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>
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.
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.
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.
24 #include "util/numeric.h"
27 #include "inventory.h"
28 #include "client/tile.h"
29 #include "localplayer.h"
32 #include "fontengine.h"
33 #include "guiscalingfilter.h"
35 #include "wieldmesh.h"
36 #include <IGUIStaticText.h>
38 #ifdef HAVE_TOUCHSCREENGUI
39 #include "touchscreengui.h"
42 Hud::Hud(video::IVideoDriver *driver, scene::ISceneManager* smgr,
43 gui::IGUIEnvironment* guienv, Client *client, LocalPlayer *player,
46 this->driver = driver;
48 this->guienv = guienv;
49 this->client = client;
50 this->player = player;
51 this->inventory = inventory;
53 m_hud_scaling = g_settings->getFloat("hud_scaling");
54 m_screensize = v2u32(0, 0);
55 m_displaycenter = v2s32(0, 0);
56 m_hotbar_imagesize = floor(HOTBAR_IMAGE_SIZE * porting::getDisplayDensity() + 0.5);
57 m_hotbar_imagesize *= m_hud_scaling;
58 m_padding = m_hotbar_imagesize / 12;
60 for (unsigned int i = 0; i < 4; i++)
61 hbar_colors[i] = video::SColor(255, 255, 255, 255);
63 tsrc = client->getTextureSource();
65 v3f crosshair_color = g_settings->getV3F("crosshair_color");
66 u32 cross_r = rangelim(myround(crosshair_color.X), 0, 255);
67 u32 cross_g = rangelim(myround(crosshair_color.Y), 0, 255);
68 u32 cross_b = rangelim(myround(crosshair_color.Z), 0, 255);
69 u32 cross_a = rangelim(g_settings->getS32("crosshair_alpha"), 0, 255);
70 crosshair_argb = video::SColor(cross_a, cross_r, cross_g, cross_b);
72 v3f selectionbox_color = g_settings->getV3F("selectionbox_color");
73 u32 sbox_r = rangelim(myround(selectionbox_color.X), 0, 255);
74 u32 sbox_g = rangelim(myround(selectionbox_color.Y), 0, 255);
75 u32 sbox_b = rangelim(myround(selectionbox_color.Z), 0, 255);
76 selectionbox_argb = video::SColor(255, sbox_r, sbox_g, sbox_b);
78 use_crosshair_image = tsrc->isKnownSourceImage("crosshair.png");
81 use_hotbar_image = false;
82 hotbar_selected_image = "";
83 use_hotbar_selected_image = false;
85 m_selection_mesh = NULL;
86 m_selection_boxes.clear();
89 m_selection_pos = v3f(0.0, 0.0, 0.0);
90 std::string mode_setting = g_settings->get("node_highlighting");
92 if (mode_setting == "halo") {
93 m_mode = HIGHLIGHT_HALO;
94 } else if (mode_setting == "none") {
95 m_mode = HIGHLIGHT_NONE;
97 m_mode = HIGHLIGHT_BOX;
100 m_selection_material.Lighting = false;
102 if (g_settings->getBool("enable_shaders")) {
103 IShaderSource *shdrsrc = client->getShaderSource();
104 u16 shader_id = shdrsrc->getShader(
105 m_mode == HIGHLIGHT_HALO ? "selection_shader" : "default_shader", 1, 1);
106 m_selection_material.MaterialType = shdrsrc->getShaderInfo(shader_id).material;
108 m_selection_material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
111 if (m_mode == HIGHLIGHT_BOX) {
112 m_selection_material.Thickness =
113 rangelim(g_settings->getS16("selectionbox_width"), 1, 5);
114 } else if (m_mode == HIGHLIGHT_HALO) {
115 m_selection_material.setTexture(0, tsrc->getTextureForMesh("halo.png"));
116 m_selection_material.setFlag(video::EMF_BACK_FACE_CULLING, true);
118 m_selection_material.MaterialType = video::EMT_SOLID;
124 if (m_selection_mesh)
125 m_selection_mesh->drop();
128 void Hud::drawItem(const ItemStack &item, const core::rect<s32>& rect,
132 /* draw hihlighting around selected item */
133 if (use_hotbar_selected_image) {
134 core::rect<s32> imgrect2 = rect;
135 imgrect2.UpperLeftCorner.X -= (m_padding*2);
136 imgrect2.UpperLeftCorner.Y -= (m_padding*2);
137 imgrect2.LowerRightCorner.X += (m_padding*2);
138 imgrect2.LowerRightCorner.Y += (m_padding*2);
139 video::ITexture *texture = tsrc->getTexture(hotbar_selected_image);
140 core::dimension2di imgsize(texture->getOriginalSize());
141 draw2DImageFilterScaled(driver, texture, imgrect2,
142 core::rect<s32>(core::position2d<s32>(0,0), imgsize),
143 NULL, hbar_colors, true);
145 video::SColor c_outside(255,255,0,0);
146 //video::SColor c_outside(255,0,0,0);
147 //video::SColor c_inside(255,192,192,192);
148 s32 x1 = rect.UpperLeftCorner.X;
149 s32 y1 = rect.UpperLeftCorner.Y;
150 s32 x2 = rect.LowerRightCorner.X;
151 s32 y2 = rect.LowerRightCorner.Y;
152 // Black base borders
153 driver->draw2DRectangle(c_outside,
155 v2s32(x1 - m_padding, y1 - m_padding),
156 v2s32(x2 + m_padding, y1)
158 driver->draw2DRectangle(c_outside,
160 v2s32(x1 - m_padding, y2),
161 v2s32(x2 + m_padding, y2 + m_padding)
163 driver->draw2DRectangle(c_outside,
165 v2s32(x1 - m_padding, y1),
168 driver->draw2DRectangle(c_outside,
171 v2s32(x2 + m_padding, y2)
173 /*// Light inside borders
174 driver->draw2DRectangle(c_inside,
176 v2s32(x1 - padding/2, y1 - padding/2),
177 v2s32(x2 + padding/2, y1)
179 driver->draw2DRectangle(c_inside,
181 v2s32(x1 - padding/2, y2),
182 v2s32(x2 + padding/2, y2 + padding/2)
184 driver->draw2DRectangle(c_inside,
186 v2s32(x1 - padding/2, y1),
189 driver->draw2DRectangle(c_inside,
192 v2s32(x2 + padding/2, y2)
198 video::SColor bgcolor2(128, 0, 0, 0);
199 if (!use_hotbar_image)
200 driver->draw2DRectangle(bgcolor2, rect, NULL);
201 drawItemStack(driver, g_fontengine->getFont(), item, rect, NULL,
202 client, selected ? IT_ROT_SELECTED : IT_ROT_NONE);
205 //NOTE: selectitem = 0 -> no selected; selectitem 1-based
206 void Hud::drawItems(v2s32 upperleftpos, v2s32 screen_offset, s32 itemcount,
207 s32 inv_offset, InventoryList *mainlist, u16 selectitem, u16 direction)
209 #ifdef HAVE_TOUCHSCREENGUI
210 if (g_touchscreengui && inv_offset == 0)
211 g_touchscreengui->resetHud();
214 s32 height = m_hotbar_imagesize + m_padding * 2;
215 s32 width = (itemcount - inv_offset) * (m_hotbar_imagesize + m_padding * 2);
217 if (direction == HUD_DIR_TOP_BOTTOM || direction == HUD_DIR_BOTTOM_TOP) {
223 // Position of upper left corner of bar
224 v2s32 pos = screen_offset;
225 pos.X *= m_hud_scaling * porting::getDisplayDensity();
226 pos.Y *= m_hud_scaling * porting::getDisplayDensity();
229 // Store hotbar_image in member variable, used by drawItem()
230 if (hotbar_image != player->hotbar_image) {
231 hotbar_image = player->hotbar_image;
232 if (hotbar_image != "")
233 use_hotbar_image = tsrc->isKnownSourceImage(hotbar_image);
235 use_hotbar_image = false;
238 // Store hotbar_selected_image in member variable, used by drawItem()
239 if (hotbar_selected_image != player->hotbar_selected_image) {
240 hotbar_selected_image = player->hotbar_selected_image;
241 if (hotbar_selected_image != "")
242 use_hotbar_selected_image = tsrc->isKnownSourceImage(hotbar_selected_image);
244 use_hotbar_selected_image = false;
247 // draw customized item background
248 if (use_hotbar_image) {
249 core::rect<s32> imgrect2(-m_padding/2, -m_padding/2,
250 width+m_padding/2, height+m_padding/2);
251 core::rect<s32> rect2 = imgrect2 + pos;
252 video::ITexture *texture = tsrc->getTexture(hotbar_image);
253 core::dimension2di imgsize(texture->getOriginalSize());
254 draw2DImageFilterScaled(driver, texture, rect2,
255 core::rect<s32>(core::position2d<s32>(0,0), imgsize),
256 NULL, hbar_colors, true);
260 core::rect<s32> imgrect(0, 0, m_hotbar_imagesize, m_hotbar_imagesize);
261 for (s32 i = inv_offset; i < itemcount && (size_t)i < mainlist->getSize(); i++) {
262 s32 fullimglen = m_hotbar_imagesize + m_padding * 2;
266 case HUD_DIR_RIGHT_LEFT:
267 steppos = v2s32(-(m_padding + (i - inv_offset) * fullimglen), m_padding);
269 case HUD_DIR_TOP_BOTTOM:
270 steppos = v2s32(m_padding, m_padding + (i - inv_offset) * fullimglen);
272 case HUD_DIR_BOTTOM_TOP:
273 steppos = v2s32(m_padding, -(m_padding + (i - inv_offset) * fullimglen));
276 steppos = v2s32(m_padding + (i - inv_offset) * fullimglen, m_padding);
280 drawItem(mainlist->getItem(i), (imgrect + pos + steppos), (i + 1) == selectitem);
282 #ifdef HAVE_TOUCHSCREENGUI
283 if (g_touchscreengui)
284 g_touchscreengui->registerHudItem(i, (imgrect + pos + steppos));
290 void Hud::drawLuaElements(const v3s16 &camera_offset)
292 u32 text_height = g_fontengine->getTextHeight();
293 irr::gui::IGUIFont* font = g_fontengine->getFont();
294 for (size_t i = 0; i != player->maxHudId(); i++) {
295 HudElement *e = player->getHud(i);
299 v2s32 pos(floor(e->pos.X * (float) m_screensize.X + 0.5),
300 floor(e->pos.Y * (float) m_screensize.Y + 0.5));
302 case HUD_ELEM_IMAGE: {
303 video::ITexture *texture = tsrc->getTexture(e->text);
307 const video::SColor color(255, 255, 255, 255);
308 const video::SColor colors[] = {color, color, color, color};
309 core::dimension2di imgsize(texture->getOriginalSize());
310 v2s32 dstsize(imgsize.Width * e->scale.X,
311 imgsize.Height * e->scale.Y);
313 dstsize.X = m_screensize.X * (e->scale.X * -0.01);
315 dstsize.Y = m_screensize.Y * (e->scale.Y * -0.01);
316 v2s32 offset((e->align.X - 1.0) * dstsize.X / 2,
317 (e->align.Y - 1.0) * dstsize.Y / 2);
318 core::rect<s32> rect(0, 0, dstsize.X, dstsize.Y);
319 rect += pos + offset + v2s32(e->offset.X, e->offset.Y);
320 draw2DImageFilterScaled(driver, texture, rect,
321 core::rect<s32>(core::position2d<s32>(0,0), imgsize),
324 case HUD_ELEM_TEXT: {
325 video::SColor color(255, (e->number >> 16) & 0xFF,
326 (e->number >> 8) & 0xFF,
327 (e->number >> 0) & 0xFF);
328 core::rect<s32> size(0, 0, e->scale.X, text_height * e->scale.Y);
329 std::wstring text = unescape_enriched(utf8_to_wide(e->text));
330 core::dimension2d<u32> textsize = font->getDimension(text.c_str());
331 v2s32 offset((e->align.X - 1.0) * (textsize.Width / 2),
332 (e->align.Y - 1.0) * (textsize.Height / 2));
333 v2s32 offs(e->offset.X, e->offset.Y);
334 font->draw(text.c_str(), size + pos + offset + offs, color);
336 case HUD_ELEM_STATBAR: {
337 v2s32 offs(e->offset.X, e->offset.Y);
338 drawStatbar(pos, HUD_CORNER_UPPER, e->dir, e->text, e->number, offs, e->size);
340 case HUD_ELEM_INVENTORY: {
341 InventoryList *inv = inventory->getList(e->text);
342 drawItems(pos, v2s32(e->offset.X, e->offset.Y), e->number, 0,
343 inv, e->item, e->dir);
345 case HUD_ELEM_WAYPOINT: {
346 v3f p_pos = player->getPosition() / BS;
347 v3f w_pos = e->world_pos * BS;
348 float distance = floor(10 * p_pos.getDistanceFrom(e->world_pos)) / 10;
349 scene::ICameraSceneNode* camera = smgr->getActiveCamera();
350 w_pos -= intToFloat(camera_offset, BS);
351 core::matrix4 trans = camera->getProjectionMatrix();
352 trans *= camera->getViewMatrix();
353 f32 transformed_pos[4] = { w_pos.X, w_pos.Y, w_pos.Z, 1.0f };
354 trans.multiplyWith1x4Matrix(transformed_pos);
355 if (transformed_pos[3] < 0)
357 f32 zDiv = transformed_pos[3] == 0.0f ? 1.0f :
358 core::reciprocal(transformed_pos[3]);
359 pos.X = m_screensize.X * (0.5 * transformed_pos[0] * zDiv + 0.5);
360 pos.Y = m_screensize.Y * (0.5 - transformed_pos[1] * zDiv * 0.5);
361 video::SColor color(255, (e->number >> 16) & 0xFF,
362 (e->number >> 8) & 0xFF,
363 (e->number >> 0) & 0xFF);
364 core::rect<s32> size(0, 0, 200, 2 * text_height);
365 std::wstring text = unescape_enriched(utf8_to_wide(e->name));
366 font->draw(text.c_str(), size + pos, color);
367 std::ostringstream os;
368 os << distance << e->text;
369 text = unescape_enriched(utf8_to_wide(os.str()));
370 pos.Y += text_height;
371 font->draw(text.c_str(), size + pos, color);
374 infostream << "Hud::drawLuaElements: ignoring drawform " << e->type <<
375 " of hud element ID " << i << " due to unrecognized type" << std::endl;
381 void Hud::drawStatbar(v2s32 pos, u16 corner, u16 drawdir, std::string texture,
382 s32 count, v2s32 offset, v2s32 size)
384 const video::SColor color(255, 255, 255, 255);
385 const video::SColor colors[] = {color, color, color, color};
387 video::ITexture *stat_texture = tsrc->getTexture(texture);
391 core::dimension2di srcd(stat_texture->getOriginalSize());
392 core::dimension2di dstd;
393 if (size == v2s32()) {
396 float size_factor = m_hud_scaling * porting::getDisplayDensity();
397 dstd.Height = size.Y * size_factor;
398 dstd.Width = size.X * size_factor;
399 offset.X *= size_factor;
400 offset.Y *= size_factor;
404 if (corner & HUD_CORNER_LOWER)
411 case HUD_DIR_RIGHT_LEFT:
412 steppos = v2s32(-1, 0);
414 case HUD_DIR_TOP_BOTTOM:
415 steppos = v2s32(0, 1);
417 case HUD_DIR_BOTTOM_TOP:
418 steppos = v2s32(0, -1);
421 steppos = v2s32(1, 0);
423 steppos.X *= dstd.Width;
424 steppos.Y *= dstd.Height;
426 for (s32 i = 0; i < count / 2; i++)
428 core::rect<s32> srcrect(0, 0, srcd.Width, srcd.Height);
429 core::rect<s32> dstrect(0,0, dstd.Width, dstd.Height);
432 draw2DImageFilterScaled(driver, stat_texture, dstrect, srcrect, NULL, colors, true);
438 core::rect<s32> srcrect(0, 0, srcd.Width / 2, srcd.Height);
439 core::rect<s32> dstrect(0,0, dstd.Width / 2, dstd.Height);
442 draw2DImageFilterScaled(driver, stat_texture, dstrect, srcrect, NULL, colors, true);
447 void Hud::drawHotbar(u16 playeritem) {
449 v2s32 centerlowerpos(m_displaycenter.X, m_screensize.Y);
451 InventoryList *mainlist = inventory->getList("main");
452 if (mainlist == NULL) {
453 //silently ignore this we may not be initialized completely
457 s32 hotbar_itemcount = player->hud_hotbar_itemcount;
458 s32 width = hotbar_itemcount * (m_hotbar_imagesize + m_padding * 2);
459 v2s32 pos = centerlowerpos - v2s32(width / 2, m_hotbar_imagesize + m_padding * 3);
461 if ( (float) width / (float) porting::getWindowSize().X <=
462 g_settings->getFloat("hud_hotbar_max_width")) {
463 if (player->hud_flags & HUD_FLAG_HOTBAR_VISIBLE) {
464 drawItems(pos, v2s32(0, 0), hotbar_itemcount, 0, mainlist, playeritem + 1, 0);
469 v2s32 secondpos = pos;
470 pos = pos - v2s32(0, m_hotbar_imagesize + m_padding);
472 if (player->hud_flags & HUD_FLAG_HOTBAR_VISIBLE) {
473 drawItems(pos, v2s32(0, 0), hotbar_itemcount / 2, 0,
474 mainlist, playeritem + 1, 0);
475 drawItems(secondpos, v2s32(0, 0), hotbar_itemcount,
476 hotbar_itemcount / 2, mainlist, playeritem + 1, 0);
480 //////////////////////////// compatibility code to be removed //////////////
481 // this is ugly as hell but there's no other way to keep compatibility to
483 if ((player->hud_flags & HUD_FLAG_HEALTHBAR_VISIBLE)) {
484 drawStatbar(v2s32(floor(0.5 * (float)m_screensize.X + 0.5),
485 floor(1 * (float) m_screensize.Y + 0.5)),
486 HUD_CORNER_UPPER, 0, "heart.png",
487 player->hp, v2s32((-10*24)-25,-(48+24+10)), v2s32(24,24));
490 if ((player->hud_flags & HUD_FLAG_BREATHBAR_VISIBLE) &&
491 (player->getBreath() < 11)) {
492 drawStatbar(v2s32(floor(0.5 * (float)m_screensize.X + 0.5),
493 floor(1 * (float) m_screensize.Y + 0.5)),
494 HUD_CORNER_UPPER, 0, "bubble.png",
495 player->getBreath(), v2s32(25,-(48+24+10)), v2s32(24,24));
497 ////////////////////////////////////////////////////////////////////////////
501 void Hud::drawCrosshair()
503 if (use_crosshair_image) {
504 video::ITexture *crosshair = tsrc->getTexture("crosshair.png");
505 v2u32 size = crosshair->getOriginalSize();
506 v2s32 lsize = v2s32(m_displaycenter.X - (size.X / 2),
507 m_displaycenter.Y - (size.Y / 2));
508 driver->draw2DImage(crosshair, lsize,
509 core::rect<s32>(0, 0, size.X, size.Y),
510 0, crosshair_argb, true);
512 driver->draw2DLine(m_displaycenter - v2s32(10, 0),
513 m_displaycenter + v2s32(10, 0), crosshair_argb);
514 driver->draw2DLine(m_displaycenter - v2s32(0, 10),
515 m_displaycenter + v2s32(0, 10), crosshair_argb);
519 void Hud::setSelectionPos(const v3f &pos, const v3s16 &camera_offset)
521 m_camera_offset = camera_offset;
522 m_selection_pos = pos;
523 m_selection_pos_with_offset = pos - intToFloat(camera_offset, BS);
526 void Hud::drawSelectionMesh()
528 if (m_mode == HIGHLIGHT_BOX) {
529 // Draw 3D selection boxes
530 video::SMaterial oldmaterial = driver->getMaterial2D();
531 driver->setMaterial(m_selection_material);
532 for (std::vector<aabb3f>::const_iterator
533 i = m_selection_boxes.begin();
534 i != m_selection_boxes.end(); ++i) {
536 i->MinEdge + m_selection_pos_with_offset,
537 i->MaxEdge + m_selection_pos_with_offset);
539 u32 r = (selectionbox_argb.getRed() *
540 m_selection_mesh_color.getRed() / 255);
541 u32 g = (selectionbox_argb.getGreen() *
542 m_selection_mesh_color.getGreen() / 255);
543 u32 b = (selectionbox_argb.getBlue() *
544 m_selection_mesh_color.getBlue() / 255);
545 driver->draw3DBox(box, video::SColor(255, r, g, b));
547 driver->setMaterial(oldmaterial);
548 } else if (m_mode == HIGHLIGHT_HALO && m_selection_mesh) {
549 // Draw selection mesh
550 video::SMaterial oldmaterial = driver->getMaterial2D();
551 driver->setMaterial(m_selection_material);
552 setMeshColor(m_selection_mesh, m_selection_mesh_color);
553 video::SColor face_color(0,
554 MYMIN(255, m_selection_mesh_color.getRed() * 1.5),
555 MYMIN(255, m_selection_mesh_color.getGreen() * 1.5),
556 MYMIN(255, m_selection_mesh_color.getBlue() * 1.5));
557 setMeshColorByNormal(m_selection_mesh, m_selected_face_normal,
559 scene::IMesh* mesh = cloneMesh(m_selection_mesh);
560 translateMesh(mesh, m_selection_pos_with_offset);
561 u32 mc = m_selection_mesh->getMeshBufferCount();
562 for (u32 i = 0; i < mc; i++) {
563 scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
564 driver->drawMeshBuffer(buf);
567 driver->setMaterial(oldmaterial);
571 void Hud::updateSelectionMesh(const v3s16 &camera_offset)
573 m_camera_offset = camera_offset;
574 if (m_mode != HIGHLIGHT_HALO)
577 if (m_selection_mesh) {
578 m_selection_mesh->drop();
579 m_selection_mesh = NULL;
582 if (!m_selection_boxes.size()) {
587 // New pointed object, create new mesh.
589 // Texture UV coordinates for selection boxes
590 static f32 texture_uv[24] = {
599 // Use single halo box instead of multiple overlapping boxes.
600 // Temporary solution - problem can be solved with multiple
601 // rendering targets, or some method to remove inner surfaces.
602 // Thats because of halo transparency.
604 aabb3f halo_box(100.0, 100.0, 100.0, -100.0, -100.0, -100.0);
605 m_halo_boxes.clear();
607 for (std::vector<aabb3f>::iterator
608 i = m_selection_boxes.begin();
609 i != m_selection_boxes.end(); ++i) {
610 halo_box.addInternalBox(*i);
613 m_halo_boxes.push_back(halo_box);
614 m_selection_mesh = convertNodeboxesToMesh(
615 m_halo_boxes, texture_uv, 0.5);
618 void Hud::resizeHotbar() {
619 if (m_screensize != porting::getWindowSize()) {
620 m_hotbar_imagesize = floor(HOTBAR_IMAGE_SIZE * porting::getDisplayDensity() + 0.5);
621 m_hotbar_imagesize *= m_hud_scaling;
622 m_padding = m_hotbar_imagesize / 12;
623 m_screensize = porting::getWindowSize();
624 m_displaycenter = v2s32(m_screensize.X/2,m_screensize.Y/2);
628 struct MeshTimeInfo {
633 void drawItemStack(video::IVideoDriver *driver,
635 const ItemStack &item,
636 const core::rect<s32> &rect,
637 const core::rect<s32> *clip,
639 ItemRotationKind rotation_kind)
641 static MeshTimeInfo rotation_time_infos[IT_ROT_NONE];
642 static bool enable_animations =
643 g_settings->getBool("inventory_items_animations");
646 if (rotation_kind < IT_ROT_NONE) {
647 rotation_time_infos[rotation_kind].mesh = NULL;
652 const ItemDefinition &def = item.getDefinition(client->idef());
653 ItemMesh *imesh = client->idef()->getWieldMesh(def.name, client);
655 if (imesh && imesh->mesh) {
656 scene::IMesh *mesh = imesh->mesh;
657 driver->clearZBuffer();
659 if (rotation_kind < IT_ROT_NONE) {
660 MeshTimeInfo &ti = rotation_time_infos[rotation_kind];
661 if (mesh != ti.mesh) {
663 ti.time = porting::getTimeMs();
665 delta = porting::getDeltaMs(ti.time, porting::getTimeMs()) % 100000;
668 core::rect<s32> oldViewPort = driver->getViewPort();
669 core::matrix4 oldProjMat = driver->getTransform(video::ETS_PROJECTION);
670 core::matrix4 oldViewMat = driver->getTransform(video::ETS_VIEW);
671 core::matrix4 ProjMatrix;
672 ProjMatrix.buildProjectionMatrixOrthoLH(2, 2, -1, 100);
673 driver->setTransform(video::ETS_PROJECTION, ProjMatrix);
674 driver->setTransform(video::ETS_VIEW, ProjMatrix);
675 core::matrix4 matrix;
676 matrix.makeIdentity();
678 if (enable_animations) {
679 float timer_f = (float) delta / 5000.0;
680 matrix.setRotationDegrees(core::vector3df(0, 360 * timer_f, 0));
683 driver->setTransform(video::ETS_WORLD, matrix);
684 driver->setViewPort(rect);
686 video::SColor basecolor =
687 client->idef()->getItemstackColor(item, client);
689 u32 mc = mesh->getMeshBufferCount();
690 for (u32 j = 0; j < mc; ++j) {
691 scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
692 // we can modify vertices relatively fast,
693 // because these meshes are not buffered.
694 assert(buf->getHardwareMappingHint_Vertex() == scene::EHM_NEVER);
695 video::SColor c = basecolor;
696 if (imesh->buffer_colors.size() > j) {
697 ItemPartColor *p = &imesh->buffer_colors[j];
698 if (p->override_base)
701 colorizeMeshBuffer(buf, &c);
702 video::SMaterial &material = buf->getMaterial();
703 material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
704 material.Lighting = false;
705 driver->setMaterial(material);
706 driver->drawMeshBuffer(buf);
709 driver->setTransform(video::ETS_VIEW, oldViewMat);
710 driver->setTransform(video::ETS_PROJECTION, oldProjMat);
711 driver->setViewPort(oldViewPort);
714 if(def.type == ITEM_TOOL && item.wear != 0)
716 // Draw a progressbar
717 float barheight = rect.getHeight()/16;
718 float barpad_x = rect.getWidth()/16;
719 float barpad_y = rect.getHeight()/16;
720 core::rect<s32> progressrect(
721 rect.UpperLeftCorner.X + barpad_x,
722 rect.LowerRightCorner.Y - barpad_y - barheight,
723 rect.LowerRightCorner.X - barpad_x,
724 rect.LowerRightCorner.Y - barpad_y);
726 // Shrink progressrect by amount of tool damage
727 float wear = item.wear / 65535.0;
729 wear * progressrect.UpperLeftCorner.X +
730 (1-wear) * progressrect.LowerRightCorner.X;
732 // Compute progressbar color
734 // wear = 0.5: yellow
736 video::SColor color(255,255,255,255);
737 int wear_i = MYMIN(floor(wear * 600), 511);
738 wear_i = MYMIN(wear_i + 10, 511);
740 color.set(255, wear_i, 255, 0);
742 color.set(255, 255, 511-wear_i, 0);
744 core::rect<s32> progressrect2 = progressrect;
745 progressrect2.LowerRightCorner.X = progressmid;
746 driver->draw2DRectangle(color, progressrect2, clip);
748 color = video::SColor(255,0,0,0);
749 progressrect2 = progressrect;
750 progressrect2.UpperLeftCorner.X = progressmid;
751 driver->draw2DRectangle(color, progressrect2, clip);
754 if(font != NULL && item.count >= 2)
756 // Get the item count as a string
757 std::string text = itos(item.count);
758 v2u32 dim = font->getDimension(utf8_to_wide(text).c_str());
759 v2s32 sdim(dim.X,dim.Y);
761 core::rect<s32> rect2(
762 /*rect.UpperLeftCorner,
763 core::dimension2d<u32>(rect.getWidth(), 15)*/
764 rect.LowerRightCorner - sdim,
768 video::SColor bgcolor(128,0,0,0);
769 driver->draw2DRectangle(bgcolor, rect2, clip);
771 video::SColor color(255,255,255,255);
772 font->draw(text.c_str(), rect2, color, false, false, clip);