src/hud.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2010-2013 blue42u, Jonathon Anderson <anderjon@umail.iu.edu>
   5 Copyright (C) 2010-2013 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU Lesser General Public License as published by
   9 the Free Software Foundation; either version 2.1 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU Lesser General Public License for more details.
  16
  17 You should have received a copy of the GNU Lesser General Public License along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20 */
  21
  22 #include "hud.h"
  23 #include "main.h"
  24 #include "settings.h"
  25 #include "util/numeric.h"
  26 #include "log.h"
  27 #include "gamedef.h"
  28 #include "itemdef.h"
  29 #include "inventory.h"
  30 #include "tile.h"
  31 #include "localplayer.h"
  32 #include "camera.h"
  33 #include "porting.h"
  34 #include <IGUIStaticText.h>
  35
  36
  37 Hud::Hud(video::IVideoDriver *driver, scene::ISceneManager* smgr,
  38                 gui::IGUIEnvironment* guienv, gui::IGUIFont *font,
  39                 u32 text_height, IGameDef *gamedef,
  40                 LocalPlayer *player, Inventory *inventory) {
  41         this->driver      = driver;
  42         this->smgr        = smgr;
  43         this->guienv      = guienv;
  44         this->font        = font;
  45         this->text_height = text_height;
  46         this->gamedef     = gamedef;
  47         this->player      = player;
  48         this->inventory   = inventory;
  49
  50         m_screensize       = v2u32(0, 0);
  51         m_displaycenter    = v2s32(0, 0);
  52         m_hotbar_imagesize = floor(HOTBAR_IMAGE_SIZE * porting::getDisplayDensity() + 0.5);
  53         m_hotbar_imagesize *= g_settings->getFloat("gui_scaling");
  54         m_padding = m_hotbar_imagesize / 12;
  55
  56         const video::SColor hbar_color(255, 255, 255, 255);
  57         for (unsigned int i=0; i < 4; i++ ){
  58                 hbar_colors[i] = hbar_color;
  59         }
  60
  61         tsrc = gamedef->getTextureSource();
  62
  63         v3f crosshair_color = g_settings->getV3F("crosshair_color");
  64         u32 cross_r = rangelim(myround(crosshair_color.X), 0, 255);
  65         u32 cross_g = rangelim(myround(crosshair_color.Y), 0, 255);
  66         u32 cross_b = rangelim(myround(crosshair_color.Z), 0, 255);
  67         u32 cross_a = rangelim(g_settings->getS32("crosshair_alpha"), 0, 255);
  68         crosshair_argb = video::SColor(cross_a, cross_r, cross_g, cross_b);
  69
  70         v3f selectionbox_color = g_settings->getV3F("selectionbox_color");
  71         u32 sbox_r = rangelim(myround(selectionbox_color.X), 0, 255);
  72         u32 sbox_g = rangelim(myround(selectionbox_color.Y), 0, 255);
  73         u32 sbox_b = rangelim(myround(selectionbox_color.Z), 0, 255);
  74         selectionbox_argb = video::SColor(255, sbox_r, sbox_g, sbox_b);
  75
  76         use_crosshair_image = tsrc->isKnownSourceImage("crosshair.png");
  77
  78         hotbar_image = "";
  79         use_hotbar_image = false;
  80         hotbar_selected_image = "";
  81         use_hotbar_selected_image = false;
  82 }
  83
  84 void Hud::drawItem(const ItemStack &item, const core::rect<s32>& rect, bool selected) {
  85
  86         if (selected) {
  87                         /* draw hihlighting around selected item */
  88                         if (use_hotbar_selected_image) {
  89                                 core::rect<s32> imgrect2 = rect;
  90                                 imgrect2.UpperLeftCorner.X  -= (m_padding*2);
  91                                 imgrect2.UpperLeftCorner.Y  -= (m_padding*2);
  92                                 imgrect2.LowerRightCorner.X += (m_padding*2);
  93                                 imgrect2.LowerRightCorner.Y += (m_padding*2);
  94                                         video::ITexture *texture = tsrc->getTexture(hotbar_selected_image);
  95                                         core::dimension2di imgsize(texture->getOriginalSize());
  96                                 driver->draw2DImage(texture, imgrect2,
  97                                                 core::rect<s32>(core::position2d<s32>(0,0), imgsize),
  98                                                 NULL, hbar_colors, true);
  99                         } else {
 100                                 video::SColor c_outside(255,255,0,0);
 101                                 //video::SColor c_outside(255,0,0,0);
 102                                 //video::SColor c_inside(255,192,192,192);
 103                                 s32 x1 = rect.UpperLeftCorner.X;
 104                                 s32 y1 = rect.UpperLeftCorner.Y;
 105                                 s32 x2 = rect.LowerRightCorner.X;
 106                                 s32 y2 = rect.LowerRightCorner.Y;
 107                                 // Black base borders
 108                                 driver->draw2DRectangle(c_outside,
 109                                         core::rect<s32>(
 110                                         v2s32(x1 - m_padding, y1 - m_padding),
 111                                         v2s32(x2 + m_padding, y1)
 112                                         ), NULL);
 113                                 driver->draw2DRectangle(c_outside,
 114                                         core::rect<s32>(
 115                                         v2s32(x1 - m_padding, y2),
 116                                         v2s32(x2 + m_padding, y2 + m_padding)
 117                                         ), NULL);
 118                                 driver->draw2DRectangle(c_outside,
 119                                         core::rect<s32>(
 120                                         v2s32(x1 - m_padding, y1),
 121                                                 v2s32(x1, y2)
 122                                         ), NULL);
 123                                 driver->draw2DRectangle(c_outside,
 124                                         core::rect<s32>(
 125                                                 v2s32(x2, y1),
 126                                         v2s32(x2 + m_padding, y2)
 127                                         ), NULL);
 128                                 /*// Light inside borders
 129                                 driver->draw2DRectangle(c_inside,
 130                                         core::rect<s32>(
 131                                                 v2s32(x1 - padding/2, y1 - padding/2),
 132                                                 v2s32(x2 + padding/2, y1)
 133                                         ), NULL);
 134                                 driver->draw2DRectangle(c_inside,
 135                                         core::rect<s32>(
 136                                                 v2s32(x1 - padding/2, y2),
 137                                                 v2s32(x2 + padding/2, y2 + padding/2)
 138                                         ), NULL);
 139                                 driver->draw2DRectangle(c_inside,
 140                                         core::rect<s32>(
 141                                                 v2s32(x1 - padding/2, y1),
 142                                                 v2s32(x1, y2)
 143                                         ), NULL);
 144                                 driver->draw2DRectangle(c_inside,
 145                                         core::rect<s32>(
 146                                                 v2s32(x2, y1),
 147                                                 v2s32(x2 + padding/2, y2)
 148                                         ), NULL);
 149                                 */
 150                         }
 151                 }
 152
 153                 video::SColor bgcolor2(128, 0, 0, 0);
 154                 if (!use_hotbar_image)
 155                         driver->draw2DRectangle(bgcolor2, rect, NULL);
 156                 drawItemStack(driver, font, item, rect, NULL, gamedef);
 157         }
 158
 159 //NOTE: selectitem = 0 -> no selected; selectitem 1-based
 160 void Hud::drawItems(v2s32 upperleftpos, s32 itemcount, s32 offset,
 161                 InventoryList *mainlist, u16 selectitem, u16 direction)
 162 {
 163         s32 height  = m_hotbar_imagesize + m_padding * 2;
 164         s32 width   = (itemcount - offset) * (m_hotbar_imagesize + m_padding * 2);
 165
 166         if (direction == HUD_DIR_TOP_BOTTOM || direction == HUD_DIR_BOTTOM_TOP) {
 167                 width  = m_hotbar_imagesize + m_padding * 2;
 168                 height = (itemcount - offset) * (m_hotbar_imagesize + m_padding * 2);
 169         }
 170
 171         // Position of upper left corner of bar
 172         v2s32 pos = upperleftpos;
 173
 174         if (hotbar_image != player->hotbar_image) {
 175                 hotbar_image = player->hotbar_image;
 176                 if (hotbar_image != "")
 177                         use_hotbar_image = tsrc->isKnownSourceImage(hotbar_image);
 178                 else
 179                         use_hotbar_image = false;
 180         }
 181
 182         if (hotbar_selected_image != player->hotbar_selected_image) {
 183                 hotbar_selected_image = player->hotbar_selected_image;
 184                 if (hotbar_selected_image != "")
 185                         use_hotbar_selected_image = tsrc->isKnownSourceImage(hotbar_selected_image);
 186                 else
 187                         use_hotbar_selected_image = false;
 188         }
 189
 190         /* draw customized item background */
 191         if (use_hotbar_image) {
 192                 core::rect<s32> imgrect2(-m_padding/2, -m_padding/2,
 193                                 width+m_padding/2, height+m_padding/2);
 194                 core::rect<s32> rect2 = imgrect2 + pos;
 195                 video::ITexture *texture = tsrc->getTexture(hotbar_image);
 196                 core::dimension2di imgsize(texture->getOriginalSize());
 197                 driver->draw2DImage(texture, rect2,
 198                         core::rect<s32>(core::position2d<s32>(0,0), imgsize),
 199                         NULL, hbar_colors, true);
 200         }
 201
 202         for (s32 i = offset; i < itemcount && (size_t)i < mainlist->getSize(); i++)
 203         {
 204                 v2s32 steppos;
 205                 s32 fullimglen = m_hotbar_imagesize + m_padding * 2;
 206
 207                 core::rect<s32> imgrect(0, 0, m_hotbar_imagesize, m_hotbar_imagesize);
 208
 209                 switch (direction) {
 210                         case HUD_DIR_RIGHT_LEFT:
 211                                 steppos = v2s32(-(m_padding + (i - offset) * fullimglen), m_padding);
 212                                 break;
 213                         case HUD_DIR_TOP_BOTTOM:
 214                                 steppos = v2s32(m_padding, m_padding + (i - offset) * fullimglen);
 215                                 break;
 216                         case HUD_DIR_BOTTOM_TOP:
 217                                 steppos = v2s32(m_padding, -(m_padding + (i - offset) * fullimglen));
 218                                 break;
 219                         default:
 220                                 steppos = v2s32(m_padding + (i - offset) * fullimglen, m_padding);
 221                                 break;
 222                 }
 223
 224                 drawItem(mainlist->getItem(i), (imgrect + pos + steppos), (i +1) == selectitem );
 225         }
 226 }
 227
 228
 229 void Hud::drawLuaElements(v3s16 camera_offset) {
 230         for (size_t i = 0; i != player->maxHudId(); i++) {
 231                 HudElement *e = player->getHud(i);
 232                 if (!e)
 233                         continue;
 234
 235                 v2s32 pos(floor(e->pos.X * (float) m_screensize.X + 0.5),
 236                                 floor(e->pos.Y * (float) m_screensize.Y + 0.5));
 237                 switch (e->type) {
 238                         case HUD_ELEM_IMAGE: {
 239                                 video::ITexture *texture = tsrc->getTexture(e->text);
 240                                 if (!texture)
 241                                         continue;
 242
 243                                 const video::SColor color(255, 255, 255, 255);
 244                                 const video::SColor colors[] = {color, color, color, color};
 245                                 core::dimension2di imgsize(texture->getOriginalSize());
 246                                 v2s32 dstsize(imgsize.Width * e->scale.X,
 247                                               imgsize.Height * e->scale.Y);
 248                                 if (e->scale.X < 0)
 249                                         dstsize.X = m_screensize.X * (e->scale.X * -0.01);
 250                                 if (e->scale.Y < 0)
 251                                         dstsize.Y = m_screensize.Y * (e->scale.Y * -0.01);
 252                                 v2s32 offset((e->align.X - 1.0) * dstsize.X / 2,
 253                                              (e->align.Y - 1.0) * dstsize.Y / 2);
 254                                 core::rect<s32> rect(0, 0, dstsize.X, dstsize.Y);
 255                                 rect += pos + offset + v2s32(e->offset.X, e->offset.Y);
 256                                 driver->draw2DImage(texture, rect,
 257                                         core::rect<s32>(core::position2d<s32>(0,0), imgsize),
 258                                         NULL, colors, true);
 259                                 break; }
 260                         case HUD_ELEM_TEXT: {
 261                                 video::SColor color(255, (e->number >> 16) & 0xFF,
 262                                                                                  (e->number >> 8)  & 0xFF,
 263                                                                                  (e->number >> 0)  & 0xFF);
 264                                 core::rect<s32> size(0, 0, e->scale.X, text_height * e->scale.Y);
 265                                 std::wstring text = narrow_to_wide(e->text);
 266                                 core::dimension2d<u32> textsize = font->getDimension(text.c_str());
 267                                 v2s32 offset((e->align.X - 1.0) * (textsize.Width / 2),
 268                                              (e->align.Y - 1.0) * (textsize.Height / 2));
 269                                 v2s32 offs(e->offset.X, e->offset.Y);
 270                                 font->draw(text.c_str(), size + pos + offset + offs, color);
 271                                 break; }
 272                         case HUD_ELEM_STATBAR: {
 273                                 v2s32 offs(e->offset.X, e->offset.Y);
 274                                 drawStatbar(pos, HUD_CORNER_UPPER, e->dir, e->text, e->number, offs, e->size);
 275                                 break; }
 276                         case HUD_ELEM_INVENTORY: {
 277                                 InventoryList *inv = inventory->getList(e->text);
 278                                 drawItems(pos, e->number, 0, inv, e->item, e->dir);
 279                                 break; }
 280                         case HUD_ELEM_WAYPOINT: {
 281                                 v3f p_pos = player->getPosition() / BS;
 282                                 v3f w_pos = e->world_pos * BS;
 283                                 float distance = floor(10 * p_pos.getDistanceFrom(e->world_pos)) / 10;
 284                                 scene::ICameraSceneNode* camera = smgr->getActiveCamera();
 285                                 w_pos -= intToFloat(camera_offset, BS);
 286                                 core::matrix4 trans = camera->getProjectionMatrix();
 287                                 trans *= camera->getViewMatrix();
 288                                 f32 transformed_pos[4] = { w_pos.X, w_pos.Y, w_pos.Z, 1.0f };
 289                                 trans.multiplyWith1x4Matrix(transformed_pos);
 290                                 if (transformed_pos[3] < 0)
 291                                         break;
 292                                 f32 zDiv = transformed_pos[3] == 0.0f ? 1.0f :
 293                                         core::reciprocal(transformed_pos[3]);
 294                                 pos.X = m_screensize.X * (0.5 * transformed_pos[0] * zDiv + 0.5);
 295                                 pos.Y = m_screensize.Y * (0.5 - transformed_pos[1] * zDiv * 0.5);
 296                                 video::SColor color(255, (e->number >> 16) & 0xFF,
 297                                                                                  (e->number >> 8)  & 0xFF,
 298                                                                                  (e->number >> 0)  & 0xFF);
 299                                 core::rect<s32> size(0, 0, 200, 2 * text_height);
 300                                 std::wstring text = narrow_to_wide(e->name);
 301                                 font->draw(text.c_str(), size + pos, color);
 302                                 std::ostringstream os;
 303                                 os<<distance<<e->text;
 304                                 text = narrow_to_wide(os.str());
 305                                 pos.Y += text_height;
 306                                 font->draw(text.c_str(), size + pos, color);
 307                                 break; }
 308                         default:
 309                                 infostream << "Hud::drawLuaElements: ignoring drawform " << e->type <<
 310                                         " of hud element ID " << i << " due to unrecognized type" << std::endl;
 311                 }
 312         }
 313 }
 314
 315
 316 void Hud::drawStatbar(v2s32 pos, u16 corner, u16 drawdir, std::string texture,
 317                 s32 count, v2s32 offset, v2s32 size)
 318 {
 319         const video::SColor color(255, 255, 255, 255);
 320         const video::SColor colors[] = {color, color, color, color};
 321
 322         video::ITexture *stat_texture = tsrc->getTexture(texture);
 323         if (!stat_texture)
 324                 return;
 325
 326         core::dimension2di srcd(stat_texture->getOriginalSize());
 327         core::dimension2di dstd;
 328         if (size == v2s32()) {
 329                 dstd = srcd;
 330         } else {
 331                 dstd.Height = size.Y * g_settings->getFloat("gui_scaling") *
 332                                 porting::getDisplayDensity();
 333                 dstd.Width  = size.X * g_settings->getFloat("gui_scaling") *
 334                                 porting::getDisplayDensity();
 335
 336                 offset.X *= g_settings->getFloat("gui_scaling") *
 337                                 porting::getDisplayDensity();
 338
 339                 offset.Y *= g_settings->getFloat("gui_scaling") *
 340                                 porting::getDisplayDensity();
 341         }
 342
 343         v2s32 p = pos;
 344         if (corner & HUD_CORNER_LOWER)
 345                 p -= dstd.Height;
 346
 347         p += offset;
 348
 349         v2s32 steppos;
 350         switch (drawdir) {
 351                 case HUD_DIR_RIGHT_LEFT:
 352                         steppos = v2s32(-1, 0);
 353                         break;
 354                 case HUD_DIR_TOP_BOTTOM:
 355                         steppos = v2s32(0, 1);
 356                         break;
 357                 case HUD_DIR_BOTTOM_TOP:
 358                         steppos = v2s32(0, -1);
 359                         break;
 360                 default:
 361                         steppos = v2s32(1, 0);
 362         }
 363         steppos.X *= dstd.Width;
 364         steppos.Y *= dstd.Height;
 365
 366         for (s32 i = 0; i < count / 2; i++)
 367         {
 368                 core::rect<s32> srcrect(0, 0, srcd.Width, srcd.Height);
 369                 core::rect<s32> dstrect(0,0, dstd.Width, dstd.Height);
 370
 371                 dstrect += p;
 372                 driver->draw2DImage(stat_texture, dstrect, srcrect, NULL, colors, true);
 373                 p += steppos;
 374         }
 375
 376         if (count % 2 == 1)
 377         {
 378                 core::rect<s32> srcrect(0, 0, srcd.Width / 2, srcd.Height);
 379                 core::rect<s32> dstrect(0,0, dstd.Width / 2, dstd.Height);
 380
 381                 dstrect += p;
 382                 driver->draw2DImage(stat_texture, dstrect, srcrect, NULL, colors, true);
 383         }
 384 }
 385
 386
 387 void Hud::drawHotbar(u16 playeritem) {
 388
 389         v2s32 centerlowerpos(m_displaycenter.X, m_screensize.Y);
 390
 391         InventoryList *mainlist = inventory->getList("main");
 392         if (mainlist == NULL) {
 393                 //silently ignore this we may not be initialized completely
 394                 return;
 395         }
 396
 397         s32 hotbar_itemcount = player->hud_hotbar_itemcount;
 398         s32 width = hotbar_itemcount * (m_hotbar_imagesize + m_padding * 2);
 399         v2s32 pos = centerlowerpos - v2s32(width / 2, m_hotbar_imagesize + m_padding * 3);
 400
 401         if ( (float) width / (float) porting::getWindowSize().X <=
 402                         g_settings->getFloat("hud_hotbar_max_width")) {
 403                 if (player->hud_flags & HUD_FLAG_HOTBAR_VISIBLE) {
 404                         drawItems(pos, hotbar_itemcount, 0, mainlist, playeritem + 1, 0);
 405                 }
 406         }
 407         else {
 408                 pos.X += width/4;
 409
 410                 v2s32 secondpos = pos;
 411                 pos = pos - v2s32(0, m_hotbar_imagesize + m_padding);
 412
 413                 if (player->hud_flags & HUD_FLAG_HOTBAR_VISIBLE) {
 414                         drawItems(pos, hotbar_itemcount/2, 0, mainlist, playeritem + 1, 0);
 415                         drawItems(secondpos, hotbar_itemcount, hotbar_itemcount/2, mainlist, playeritem + 1, 0);
 416                 }
 417         }
 418
 419         //////////////////////////// compatibility code to be removed //////////////
 420         // this is ugly as hell but there's no other way to keep compatibility to
 421         // old servers
 422         if ( player->hud_flags & HUD_FLAG_HEALTHBAR_VISIBLE)
 423                 drawStatbar(v2s32(floor(0.5 * (float) m_screensize.X + 0.5),
 424                                 floor(1 * (float) m_screensize.Y + 0.5)),
 425                                 HUD_CORNER_UPPER, 0, "heart.png",
 426                                 player->hp, v2s32((-10*24)-25,-(48+24+10)), v2s32(24,24));
 427
 428         if ((player->hud_flags & HUD_FLAG_BREATHBAR_VISIBLE) &&
 429                         (player->getBreath() < 11))
 430                 drawStatbar(v2s32(floor(0.5 * (float) m_screensize.X + 0.5),
 431                                 floor(1 * (float) m_screensize.Y + 0.5)),
 432                                 HUD_CORNER_UPPER, 0, "heart.png",
 433                                 player->getBreath(), v2s32(25,-(48+24+10)), v2s32(24,24));
 434         ////////////////////////////////////////////////////////////////////////////
 435 }
 436
 437
 438 void Hud::drawCrosshair() {
 439
 440         if (use_crosshair_image) {
 441                 video::ITexture *crosshair = tsrc->getTexture("crosshair.png");
 442                 v2u32 size  = crosshair->getOriginalSize();
 443                 v2s32 lsize = v2s32(m_displaycenter.X - (size.X / 2),
 444                                 m_displaycenter.Y - (size.Y / 2));
 445                 driver->draw2DImage(crosshair, lsize,
 446                                 core::rect<s32>(0, 0, size.X, size.Y),
 447                                 0, crosshair_argb, true);
 448         } else {
 449                 driver->draw2DLine(m_displaycenter - v2s32(10, 0),
 450                                 m_displaycenter + v2s32(10, 0), crosshair_argb);
 451                 driver->draw2DLine(m_displaycenter - v2s32(0, 10),
 452                                 m_displaycenter + v2s32(0, 10), crosshair_argb);
 453         }
 454 }
 455
 456
 457 void Hud::drawSelectionBoxes(std::vector<aabb3f> &hilightboxes) {
 458         for (std::vector<aabb3f>::const_iterator
 459                         i = hilightboxes.begin();
 460                         i != hilightboxes.end(); i++) {
 461                 driver->draw3DBox(*i, selectionbox_argb);
 462         }
 463 }
 464
 465
 466 void Hud::resizeHotbar() {
 467         if (m_screensize != porting::getWindowSize()) {
 468                 m_hotbar_imagesize = floor(HOTBAR_IMAGE_SIZE * porting::getDisplayDensity() + 0.5);
 469                 m_hotbar_imagesize *= g_settings->getFloat("gui_scaling");
 470                 m_padding = m_hotbar_imagesize / 12;
 471                 m_screensize = porting::getWindowSize();
 472                 m_displaycenter = v2s32(m_screensize.X/2,m_screensize.Y/2);
 473         }
 474 }
 475
 476 void drawItemStack(video::IVideoDriver *driver,
 477                 gui::IGUIFont *font,
 478                 const ItemStack &item,
 479                 const core::rect<s32> &rect,
 480                 const core::rect<s32> *clip,
 481                 IGameDef *gamedef)
 482 {
 483         if(item.empty())
 484                 return;
 485
 486         const ItemDefinition &def = item.getDefinition(gamedef->idef());
 487         video::ITexture *texture = gamedef->idef()->getInventoryTexture(def.name, gamedef);
 488
 489         // Draw the inventory texture
 490         if(texture != NULL)
 491         {
 492                 const video::SColor color(255,255,255,255);
 493                 const video::SColor colors[] = {color,color,color,color};
 494                 driver->draw2DImage(texture, rect,
 495                         core::rect<s32>(core::position2d<s32>(0,0),
 496                         core::dimension2di(texture->getOriginalSize())),
 497                         clip, colors, true);
 498         }
 499
 500         if(def.type == ITEM_TOOL && item.wear != 0)
 501         {
 502                 // Draw a progressbar
 503                 float barheight = rect.getHeight()/16;
 504                 float barpad_x = rect.getWidth()/16;
 505                 float barpad_y = rect.getHeight()/16;
 506                 core::rect<s32> progressrect(
 507                         rect.UpperLeftCorner.X + barpad_x,
 508                         rect.LowerRightCorner.Y - barpad_y - barheight,
 509                         rect.LowerRightCorner.X - barpad_x,
 510                         rect.LowerRightCorner.Y - barpad_y);
 511
 512                 // Shrink progressrect by amount of tool damage
 513                 float wear = item.wear / 65535.0;
 514                 int progressmid =
 515                         wear * progressrect.UpperLeftCorner.X +
 516                         (1-wear) * progressrect.LowerRightCorner.X;
 517
 518                 // Compute progressbar color
 519                 //   wear = 0.0: green
 520                 //   wear = 0.5: yellow
 521                 //   wear = 1.0: red
 522                 video::SColor color(255,255,255,255);
 523                 int wear_i = MYMIN(floor(wear * 600), 511);
 524                 wear_i = MYMIN(wear_i + 10, 511);
 525                 if(wear_i <= 255)
 526                         color.set(255, wear_i, 255, 0);
 527                 else
 528                         color.set(255, 255, 511-wear_i, 0);
 529
 530                 core::rect<s32> progressrect2 = progressrect;
 531                 progressrect2.LowerRightCorner.X = progressmid;
 532                 driver->draw2DRectangle(color, progressrect2, clip);
 533
 534                 color = video::SColor(255,0,0,0);
 535                 progressrect2 = progressrect;
 536                 progressrect2.UpperLeftCorner.X = progressmid;
 537                 driver->draw2DRectangle(color, progressrect2, clip);
 538         }
 539
 540         if(font != NULL && item.count >= 2)
 541         {
 542                 // Get the item count as a string
 543                 std::string text = itos(item.count);
 544                 v2u32 dim = font->getDimension(narrow_to_wide(text).c_str());
 545                 v2s32 sdim(dim.X,dim.Y);
 546
 547                 core::rect<s32> rect2(
 548                         /*rect.UpperLeftCorner,
 549                         core::dimension2d<u32>(rect.getWidth(), 15)*/
 550                         rect.LowerRightCorner - sdim,
 551                         sdim
 552                 );
 553
 554                 video::SColor bgcolor(128,0,0,0);
 555                 driver->draw2DRectangle(bgcolor, rect2, clip);
 556
 557                 video::SColor color(255,255,255,255);
 558                 font->draw(text.c_str(), rect2, color, false, false, clip);
 559         }
 560 }