src/drawscene.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2014 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "drawscene.h"
  21 #include "settings.h"
  22 #include "clouds.h"
  23 #include "clientmap.h"
  24 #include "util/timetaker.h"
  25 #include "fontengine.h"
  26 #include "guiscalingfilter.h"
  27 #include "filesys.h"
  28
  29 typedef enum {
  30         LEFT = -1,
  31         RIGHT = 1,
  32         EYECOUNT = 2
  33 } paralax_sign;
  34
  35 void draw_anaglyph_3d_mode(Camera& camera, bool show_hud, Hud& hud,
  36                 video::IVideoDriver* driver, scene::ISceneManager* smgr,
  37                 bool draw_wield_tool, Client& client,
  38                 gui::IGUIEnvironment* guienv )
  39 {
  40
  41         /* preserve old setup*/
  42         irr::core::vector3df oldPosition = camera.getCameraNode()->getPosition();
  43         irr::core::vector3df oldTarget   = camera.getCameraNode()->getTarget();
  44
  45         irr::core::matrix4 startMatrix =
  46                         camera.getCameraNode()->getAbsoluteTransformation();
  47         irr::core::vector3df focusPoint = (camera.getCameraNode()->getTarget()
  48                         - camera.getCameraNode()->getAbsolutePosition()).setLength(1)
  49                         + camera.getCameraNode()->getAbsolutePosition();
  50
  51
  52         //Left eye...
  53         irr::core::vector3df leftEye;
  54         irr::core::matrix4 leftMove;
  55         leftMove.setTranslation(
  56                         irr::core::vector3df(-g_settings->getFloat("3d_paralax_strength"),
  57                                         0.0f, 0.0f));
  58         leftEye = (startMatrix * leftMove).getTranslation();
  59
  60         //clear the depth buffer, and color
  61         driver->beginScene( true, true, irr::video::SColor(0, 200, 200, 255));
  62         driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_RED;
  63         driver->getOverrideMaterial().EnableFlags = irr::video::EMF_COLOR_MASK;
  64         driver->getOverrideMaterial().EnablePasses = irr::scene::ESNRP_SKY_BOX
  65                         + irr::scene::ESNRP_SOLID + irr::scene::ESNRP_TRANSPARENT
  66                         + irr::scene::ESNRP_TRANSPARENT_EFFECT + irr::scene::ESNRP_SHADOW;
  67         camera.getCameraNode()->setPosition(leftEye);
  68         camera.getCameraNode()->setTarget(focusPoint);
  69         smgr->drawAll();
  70         driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
  71         if (show_hud) {
  72                 hud.drawSelectionMesh();
  73                 if (draw_wield_tool)
  74                         camera.drawWieldedTool(&leftMove);
  75         }
  76
  77         guienv->drawAll();
  78
  79         //Right eye...
  80         irr::core::vector3df rightEye;
  81         irr::core::matrix4 rightMove;
  82         rightMove.setTranslation(
  83                         irr::core::vector3df(g_settings->getFloat("3d_paralax_strength"),
  84                                         0.0f, 0.0f));
  85         rightEye = (startMatrix * rightMove).getTranslation();
  86
  87         //clear the depth buffer
  88         driver->clearZBuffer();
  89         driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_GREEN
  90                         + irr::video::ECP_BLUE;
  91         driver->getOverrideMaterial().EnableFlags = irr::video::EMF_COLOR_MASK;
  92         driver->getOverrideMaterial().EnablePasses = irr::scene::ESNRP_SKY_BOX
  93                         + irr::scene::ESNRP_SOLID + irr::scene::ESNRP_TRANSPARENT
  94                         + irr::scene::ESNRP_TRANSPARENT_EFFECT + irr::scene::ESNRP_SHADOW;
  95         camera.getCameraNode()->setPosition(rightEye);
  96         camera.getCameraNode()->setTarget(focusPoint);
  97         smgr->drawAll();
  98         driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
  99         if (show_hud) {
 100                 hud.drawSelectionMesh();
 101                 if (draw_wield_tool)
 102                         camera.drawWieldedTool(&rightMove);
 103         }
 104
 105         guienv->drawAll();
 106
 107         driver->getOverrideMaterial().Material.ColorMask = irr::video::ECP_ALL;
 108         driver->getOverrideMaterial().EnableFlags = 0;
 109         driver->getOverrideMaterial().EnablePasses = 0;
 110         camera.getCameraNode()->setPosition(oldPosition);
 111         camera.getCameraNode()->setTarget(oldTarget);
 112 }
 113
 114 void init_texture(video::IVideoDriver* driver, const v2u32& screensize,
 115                 video::ITexture** texture, const char* name)
 116 {
 117         if (*texture != NULL)
 118         {
 119                 driver->removeTexture(*texture);
 120         }
 121         *texture = driver->addRenderTargetTexture(
 122                         core::dimension2d<u32>(screensize.X, screensize.Y), name,
 123                         irr::video::ECF_A8R8G8B8);
 124 }
 125
 126 video::ITexture* draw_image(const v2u32 &screensize,
 127                 paralax_sign psign, const irr::core::matrix4 &startMatrix,
 128                 const irr::core::vector3df &focusPoint, bool show_hud,
 129                 video::IVideoDriver *driver, Camera &camera, scene::ISceneManager *smgr,
 130                 Hud &hud, bool draw_wield_tool, Client &client,
 131                 gui::IGUIEnvironment *guienv, const video::SColor &skycolor)
 132 {
 133         static video::ITexture* images[2] = { NULL, NULL };
 134         static v2u32 last_screensize = v2u32(0, 0);
 135
 136         video::ITexture* image = NULL;
 137
 138         if (screensize != last_screensize) {
 139                 init_texture(driver, screensize, &images[1], "mt_drawimage_img1");
 140                 init_texture(driver, screensize, &images[0], "mt_drawimage_img2");
 141                 last_screensize = screensize;
 142         }
 143
 144         if (psign == RIGHT)
 145                 image = images[1];
 146         else
 147                 image = images[0];
 148
 149         driver->setRenderTarget(image, true, true,
 150                         irr::video::SColor(255,
 151                                         skycolor.getRed(), skycolor.getGreen(), skycolor.getBlue()));
 152
 153         irr::core::vector3df eye_pos;
 154         irr::core::matrix4 movement;
 155         movement.setTranslation(
 156                         irr::core::vector3df((int) psign *
 157                                         g_settings->getFloat("3d_paralax_strength"), 0.0f, 0.0f));
 158         eye_pos = (startMatrix * movement).getTranslation();
 159
 160         //clear the depth buffer
 161         driver->clearZBuffer();
 162         camera.getCameraNode()->setPosition(eye_pos);
 163         camera.getCameraNode()->setTarget(focusPoint);
 164         smgr->drawAll();
 165
 166         driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
 167
 168         if (show_hud) {
 169                 hud.drawSelectionMesh();
 170                 if (draw_wield_tool)
 171                         camera.drawWieldedTool(&movement);
 172         }
 173
 174         guienv->drawAll();
 175
 176         /* switch back to real renderer */
 177         driver->setRenderTarget(0, true, true,
 178                         irr::video::SColor(0,
 179                                         skycolor.getRed(), skycolor.getGreen(), skycolor.getBlue()));
 180
 181         return image;
 182 }
 183
 184 video::ITexture*  draw_hud(video::IVideoDriver* driver, const v2u32& screensize,
 185                 bool show_hud, Hud& hud, Client& client, bool draw_crosshair,
 186                 video::SColor skycolor, gui::IGUIEnvironment* guienv, Camera& camera )
 187 {
 188         static video::ITexture* image = NULL;
 189         init_texture(driver, screensize, &image, "mt_drawimage_hud");
 190         driver->setRenderTarget(image, true, true,
 191                         irr::video::SColor(255,0,0,0));
 192
 193         if (show_hud)
 194         {
 195                 if (draw_crosshair)
 196                         hud.drawCrosshair();
 197                 hud.drawHotbar(client.getPlayerItem());
 198                 hud.drawLuaElements(camera.getOffset());
 199                 camera.drawNametags();
 200                 guienv->drawAll();
 201         }
 202
 203         driver->setRenderTarget(0, true, true,
 204                         irr::video::SColor(0,
 205                                         skycolor.getRed(), skycolor.getGreen(), skycolor.getBlue()));
 206
 207         return image;
 208 }
 209
 210 void draw_interlaced_3d_mode(Camera& camera, bool show_hud,
 211                 Hud& hud, video::IVideoDriver* driver,
 212                 scene::ISceneManager* smgr, const v2u32& screensize,
 213                 bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
 214                 video::SColor skycolor )
 215 {
 216         /* save current info */
 217         irr::core::vector3df oldPosition = camera.getCameraNode()->getPosition();
 218         irr::core::vector3df oldTarget = camera.getCameraNode()->getTarget();
 219         irr::core::matrix4 startMatrix =
 220                         camera.getCameraNode()->getAbsoluteTransformation();
 221         irr::core::vector3df focusPoint = (camera.getCameraNode()->getTarget()
 222                         - camera.getCameraNode()->getAbsolutePosition()).setLength(1)
 223                         + camera.getCameraNode()->getAbsolutePosition();
 224
 225         /* create left view */
 226         video::ITexture* left_image = draw_image(screensize, LEFT, startMatrix,
 227                         focusPoint, show_hud, driver, camera, smgr, hud,
 228                         draw_wield_tool, client, guienv, skycolor);
 229
 230         //Right eye...
 231         irr::core::vector3df rightEye;
 232         irr::core::matrix4 rightMove;
 233         rightMove.setTranslation(
 234                         irr::core::vector3df(g_settings->getFloat("3d_paralax_strength"),
 235                                         0.0f, 0.0f));
 236         rightEye = (startMatrix * rightMove).getTranslation();
 237
 238         //clear the depth buffer
 239         driver->clearZBuffer();
 240         camera.getCameraNode()->setPosition(rightEye);
 241         camera.getCameraNode()->setTarget(focusPoint);
 242         smgr->drawAll();
 243
 244         driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
 245
 246         if (show_hud) {
 247                 hud.drawSelectionMesh();
 248                 if(draw_wield_tool)
 249                         camera.drawWieldedTool(&rightMove);
 250         }
 251         guienv->drawAll();
 252
 253         for (unsigned int i = 0; i < screensize.Y; i+=2 ) {
 254 #if (IRRLICHT_VERSION_MAJOR >= 1) && (IRRLICHT_VERSION_MINOR >= 8)
 255                 driver->draw2DImage(left_image, irr::core::position2d<s32>(0, i),
 256 #else
 257                 driver->draw2DImage(left_image, irr::core::position2d<s32>(0, screensize.Y-i),
 258 #endif
 259                                 irr::core::rect<s32>(0, i,screensize.X, i+1), 0,
 260                                 irr::video::SColor(255, 255, 255, 255),
 261                                 false);
 262         }
 263
 264         /* cleanup */
 265         camera.getCameraNode()->setPosition(oldPosition);
 266         camera.getCameraNode()->setTarget(oldTarget);
 267 }
 268
 269 void draw_sidebyside_3d_mode(Camera& camera, bool show_hud,
 270                 Hud& hud, video::IVideoDriver* driver,
 271                 scene::ISceneManager* smgr, const v2u32& screensize,
 272                 bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
 273                 video::SColor skycolor )
 274 {
 275         /* save current info */
 276         irr::core::vector3df oldPosition = camera.getCameraNode()->getPosition();
 277         irr::core::vector3df oldTarget = camera.getCameraNode()->getTarget();
 278         irr::core::matrix4 startMatrix =
 279                         camera.getCameraNode()->getAbsoluteTransformation();
 280         irr::core::vector3df focusPoint = (camera.getCameraNode()->getTarget()
 281                         - camera.getCameraNode()->getAbsolutePosition()).setLength(1)
 282                         + camera.getCameraNode()->getAbsolutePosition();
 283
 284         /* create left view */
 285         video::ITexture* left_image = draw_image(screensize, LEFT, startMatrix,
 286                         focusPoint, show_hud, driver, camera, smgr, hud,
 287                         draw_wield_tool, client, guienv, skycolor);
 288
 289         /* create right view */
 290         video::ITexture* right_image = draw_image(screensize, RIGHT, startMatrix,
 291                         focusPoint, show_hud, driver, camera, smgr, hud,
 292                         draw_wield_tool, client, guienv, skycolor);
 293
 294         /* create hud overlay */
 295         video::ITexture* hudtexture = draw_hud(driver, screensize, show_hud, hud, client,
 296                         false, skycolor, guienv, camera );
 297         driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
 298         //makeColorKeyTexture mirrors texture so we do it twice to get it right again
 299         driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
 300
 301         draw2DImageFilterScaled(driver, left_image,
 302                         irr::core::rect<s32>(0, 0, screensize.X/2, screensize.Y),
 303                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
 304
 305         draw2DImageFilterScaled(driver, hudtexture,
 306                         irr::core::rect<s32>(0, 0, screensize.X/2, screensize.Y),
 307                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
 308
 309         draw2DImageFilterScaled(driver, right_image,
 310                         irr::core::rect<s32>(screensize.X/2, 0, screensize.X, screensize.Y),
 311                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
 312
 313         draw2DImageFilterScaled(driver, hudtexture,
 314                         irr::core::rect<s32>(screensize.X/2, 0, screensize.X, screensize.Y),
 315                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
 316
 317         left_image = NULL;
 318         right_image = NULL;
 319
 320         /* cleanup */
 321         camera.getCameraNode()->setPosition(oldPosition);
 322         camera.getCameraNode()->setTarget(oldTarget);
 323 }
 324
 325 void draw_top_bottom_3d_mode(Camera& camera, bool show_hud,
 326                 Hud& hud, video::IVideoDriver* driver,
 327                 scene::ISceneManager* smgr, const v2u32& screensize,
 328                 bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
 329                 video::SColor skycolor )
 330 {
 331         /* save current info */
 332         irr::core::vector3df oldPosition = camera.getCameraNode()->getPosition();
 333         irr::core::vector3df oldTarget = camera.getCameraNode()->getTarget();
 334         irr::core::matrix4 startMatrix =
 335                         camera.getCameraNode()->getAbsoluteTransformation();
 336         irr::core::vector3df focusPoint = (camera.getCameraNode()->getTarget()
 337                         - camera.getCameraNode()->getAbsolutePosition()).setLength(1)
 338                         + camera.getCameraNode()->getAbsolutePosition();
 339
 340         /* create left view */
 341         video::ITexture* left_image = draw_image(screensize, LEFT, startMatrix,
 342                         focusPoint, show_hud, driver, camera, smgr, hud,
 343                         draw_wield_tool, client, guienv, skycolor);
 344
 345         /* create right view */
 346         video::ITexture* right_image = draw_image(screensize, RIGHT, startMatrix,
 347                         focusPoint, show_hud, driver, camera, smgr, hud,
 348                         draw_wield_tool, client, guienv, skycolor);
 349
 350         /* create hud overlay */
 351         video::ITexture* hudtexture = draw_hud(driver, screensize, show_hud, hud, client,
 352                         false, skycolor, guienv, camera );
 353         driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
 354         //makeColorKeyTexture mirrors texture so we do it twice to get it right again
 355         driver->makeColorKeyTexture(hudtexture, irr::video::SColor(255, 0, 0, 0));
 356
 357         draw2DImageFilterScaled(driver, left_image,
 358                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y/2),
 359                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
 360
 361         draw2DImageFilterScaled(driver, hudtexture,
 362                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y/2),
 363                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
 364
 365         draw2DImageFilterScaled(driver, right_image,
 366                         irr::core::rect<s32>(0, screensize.Y/2, screensize.X, screensize.Y),
 367                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, false);
 368
 369         draw2DImageFilterScaled(driver, hudtexture,
 370                         irr::core::rect<s32>(0, screensize.Y/2, screensize.X, screensize.Y),
 371                         irr::core::rect<s32>(0, 0, screensize.X, screensize.Y), 0, 0, true);
 372
 373         left_image = NULL;
 374         right_image = NULL;
 375
 376         /* cleanup */
 377         camera.getCameraNode()->setPosition(oldPosition);
 378         camera.getCameraNode()->setTarget(oldTarget);
 379 }
 380
 381 void draw_pageflip_3d_mode(Camera& camera, bool show_hud,
 382                 Hud& hud, video::IVideoDriver* driver,
 383                 scene::ISceneManager* smgr, const v2u32& screensize,
 384                 bool draw_wield_tool, Client& client, gui::IGUIEnvironment* guienv,
 385                 video::SColor skycolor)
 386 {
 387 #if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR > 8
 388         errorstream << "Pageflip 3D mode is not supported"
 389                 << " with your Irrlicht version!" << std::endl;
 390 #else
 391         /* preserve old setup*/
 392         irr::core::vector3df oldPosition = camera.getCameraNode()->getPosition();
 393         irr::core::vector3df oldTarget   = camera.getCameraNode()->getTarget();
 394
 395         irr::core::matrix4 startMatrix =
 396                         camera.getCameraNode()->getAbsoluteTransformation();
 397         irr::core::vector3df focusPoint = (camera.getCameraNode()->getTarget()
 398                         - camera.getCameraNode()->getAbsolutePosition()).setLength(1)
 399                         + camera.getCameraNode()->getAbsolutePosition();
 400
 401         //Left eye...
 402         driver->setRenderTarget(irr::video::ERT_STEREO_LEFT_BUFFER);
 403
 404         irr::core::vector3df leftEye;
 405         irr::core::matrix4 leftMove;
 406         leftMove.setTranslation(
 407                         irr::core::vector3df(-g_settings->getFloat("3d_paralax_strength"),
 408                                         0.0f, 0.0f));
 409         leftEye = (startMatrix * leftMove).getTranslation();
 410
 411         //clear the depth buffer, and color
 412         driver->beginScene(true, true, irr::video::SColor(200, 200, 200, 255));
 413         camera.getCameraNode()->setPosition(leftEye);
 414         camera.getCameraNode()->setTarget(focusPoint);
 415         smgr->drawAll();
 416         driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
 417
 418         if (show_hud) {
 419                 hud.drawSelectionMesh();
 420                 if (draw_wield_tool)
 421                         camera.drawWieldedTool(&leftMove);
 422                 hud.drawHotbar(client.getPlayerItem());
 423                 hud.drawLuaElements(camera.getOffset());
 424                 camera.drawNametags();
 425         }
 426
 427         guienv->drawAll();
 428
 429         //Right eye...
 430         driver->setRenderTarget(irr::video::ERT_STEREO_RIGHT_BUFFER);
 431
 432         irr::core::vector3df rightEye;
 433         irr::core::matrix4 rightMove;
 434         rightMove.setTranslation(
 435                         irr::core::vector3df(g_settings->getFloat("3d_paralax_strength"),
 436                                         0.0f, 0.0f));
 437         rightEye = (startMatrix * rightMove).getTranslation();
 438
 439         //clear the depth buffer, and color
 440         driver->beginScene(true, true, irr::video::SColor(200, 200, 200, 255));
 441         camera.getCameraNode()->setPosition(rightEye);
 442         camera.getCameraNode()->setTarget(focusPoint);
 443         smgr->drawAll();
 444         driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
 445
 446         if (show_hud) {
 447                 hud.drawSelectionMesh();
 448                 if (draw_wield_tool)
 449                         camera.drawWieldedTool(&rightMove);
 450                 hud.drawHotbar(client.getPlayerItem());
 451                 hud.drawLuaElements(camera.getOffset());
 452                 camera.drawNametags();
 453         }
 454
 455         guienv->drawAll();
 456
 457         camera.getCameraNode()->setPosition(oldPosition);
 458         camera.getCameraNode()->setTarget(oldTarget);
 459 #endif
 460 }
 461
 462 // returns (size / coef), rounded upwards
 463 inline int scaledown(int coef, int size)
 464 {
 465         return (size + coef - 1) / coef;
 466 }
 467
 468 void draw_plain(Camera &camera, bool show_hud,
 469                 Hud &hud, video::IVideoDriver *driver,
 470                 scene::ISceneManager *smgr, const v2u32 &screensize,
 471                 bool draw_wield_tool, Client &client, gui::IGUIEnvironment *guienv,
 472                 video::SColor skycolor)
 473 {
 474         // Undersampling-specific stuff
 475         static video::ITexture *image = NULL;
 476         static v2u32 last_pixelated_size = v2u32(0, 0);
 477         int undersampling = g_settings->getU16("undersampling");
 478         v2u32 pixelated_size;
 479         v2u32 dest_size;
 480         if (undersampling > 0) {
 481                 pixelated_size = v2u32(scaledown(undersampling, screensize.X),
 482                                 scaledown(undersampling, screensize.Y));
 483                 dest_size = v2u32(undersampling * pixelated_size.X, undersampling * pixelated_size.Y);
 484                 if (pixelated_size != last_pixelated_size) {
 485                         init_texture(driver, pixelated_size, &image, "mt_drawimage_img1");
 486                         last_pixelated_size = pixelated_size;
 487                 }
 488                 driver->setRenderTarget(image, true, true, skycolor);
 489         }
 490
 491         // Render
 492         smgr->drawAll();
 493         driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
 494         if (show_hud) {
 495                 hud.drawSelectionMesh();
 496                 if (draw_wield_tool) {
 497                         camera.drawWieldedTool();
 498                 }
 499         }
 500
 501         // Upscale lowres render
 502         if (undersampling > 0) {
 503                 driver->setRenderTarget(0, true, true);
 504                 driver->draw2DImage(image,
 505                                 irr::core::rect<s32>(0, 0, dest_size.X, dest_size.Y),
 506                                 irr::core::rect<s32>(0, 0, pixelated_size.X, pixelated_size.Y));
 507         }
 508 }
 509
 510 void draw_scene(video::IVideoDriver *driver, scene::ISceneManager *smgr,
 511                 Camera &camera, Client &client, LocalPlayer *player, Hud &hud,
 512                 Minimap &mapper, gui::IGUIEnvironment *guienv,
 513                 const v2u32 &screensize, const video::SColor &skycolor,
 514                 bool show_hud, bool show_minimap)
 515 {
 516         TimeTaker timer("smgr");
 517
 518         bool draw_wield_tool = (show_hud &&
 519                         (player->hud_flags & HUD_FLAG_WIELDITEM_VISIBLE) &&
 520                         camera.getCameraMode() < CAMERA_MODE_THIRD );
 521
 522         bool draw_crosshair = ((player->hud_flags & HUD_FLAG_CROSSHAIR_VISIBLE) &&
 523                         (camera.getCameraMode() != CAMERA_MODE_THIRD_FRONT));
 524
 525 #ifdef HAVE_TOUCHSCREENGUI
 526         try {
 527                 draw_crosshair = !g_settings->getBool("touchtarget");
 528         }
 529         catch(SettingNotFoundException) {}
 530 #endif
 531
 532         const std::string &draw_mode = g_settings->get("3d_mode");
 533
 534         if (draw_mode == "anaglyph")
 535         {
 536                 draw_anaglyph_3d_mode(camera, show_hud, hud, driver,
 537                                 smgr, draw_wield_tool, client, guienv);
 538                 draw_crosshair = false;
 539         }
 540         else if (draw_mode == "interlaced")
 541         {
 542                 draw_interlaced_3d_mode(camera, show_hud, hud, driver,
 543                                 smgr, screensize, draw_wield_tool, client, guienv, skycolor);
 544                 draw_crosshair = false;
 545         }
 546         else if (draw_mode == "sidebyside")
 547         {
 548                 draw_sidebyside_3d_mode(camera, show_hud, hud, driver,
 549                                 smgr, screensize, draw_wield_tool, client, guienv, skycolor);
 550                 show_hud = false;
 551         }
 552         else if (draw_mode == "topbottom")
 553         {
 554                 draw_top_bottom_3d_mode(camera, show_hud, hud, driver,
 555                                 smgr, screensize, draw_wield_tool, client, guienv, skycolor);
 556                 show_hud = false;
 557         }
 558         else if (draw_mode == "pageflip")
 559         {
 560                 draw_pageflip_3d_mode(camera, show_hud, hud, driver,
 561                                 smgr, screensize, draw_wield_tool, client, guienv, skycolor);
 562                 draw_crosshair = false;
 563                 show_hud = false;
 564         }
 565         else {
 566                 draw_plain(camera, show_hud, hud, driver,
 567                                 smgr, screensize, draw_wield_tool, client, guienv, skycolor);
 568         }
 569
 570         /*
 571                 Post effects
 572         */
 573         {
 574                 client.getEnv().getClientMap().renderPostFx(camera.getCameraMode());
 575         }
 576
 577         //TODO how to make those 3d too
 578         if (show_hud)
 579         {
 580                 if (draw_crosshair)
 581                         hud.drawCrosshair();
 582
 583                 hud.drawHotbar(client.getPlayerItem());
 584                 hud.drawLuaElements(camera.getOffset());
 585                 camera.drawNametags();
 586
 587                 if (show_minimap)
 588                         mapper.drawMinimap();
 589         }
 590
 591         guienv->drawAll();
 592
 593         timer.stop(true);
 594 }
 595
 596 /*
 597         Draws a screen with a single text on it.
 598         Text will be removed when the screen is drawn the next time.
 599         Additionally, a progressbar can be drawn when percent is set between 0 and 100.
 600 */
 601 void draw_load_screen(const std::wstring &text, IrrlichtDevice* device,
 602                 gui::IGUIEnvironment* guienv, ITextureSource *tsrc,
 603                 float dtime, int percent, bool clouds)
 604 {
 605         video::IVideoDriver* driver    = device->getVideoDriver();
 606         v2u32 screensize               = porting::getWindowSize();
 607
 608         v2s32 textsize(g_fontengine->getTextWidth(text), g_fontengine->getLineHeight());
 609         v2s32 center(screensize.X / 2, screensize.Y / 2);
 610         core::rect<s32> textrect(center - textsize / 2, center + textsize / 2);
 611
 612         gui::IGUIStaticText *guitext = guienv->addStaticText(
 613                         text.c_str(), textrect, false, false);
 614         guitext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 615
 616         bool cloud_menu_background = clouds && g_settings->getBool("menu_clouds");
 617         if (cloud_menu_background)
 618         {
 619                 g_menuclouds->step(dtime*3);
 620                 g_menuclouds->render();
 621                 driver->beginScene(true, true, video::SColor(255, 140, 186, 250));
 622                 g_menucloudsmgr->drawAll();
 623         }
 624         else
 625                 driver->beginScene(true, true, video::SColor(255, 0, 0, 0));
 626
 627         // draw progress bar
 628         if ((percent >= 0) && (percent <= 100)) {
 629                 video::ITexture *progress_img = tsrc->getTexture("progress_bar.png");
 630                 video::ITexture *progress_img_bg = tsrc->getTexture("progress_bar_bg.png");
 631
 632                 if (progress_img && progress_img_bg) {
 633 #ifndef __ANDROID__
 634                         const core::dimension2d<u32> &img_size = progress_img_bg->getSize();
 635                         u32 imgW = rangelim(img_size.Width, 200, 600);
 636                         u32 imgH = rangelim(img_size.Height, 24, 72);
 637 #else
 638                         const core::dimension2d<u32> img_size(256, 48);
 639                         float imgRatio = (float) img_size.Height / img_size.Width;
 640                         u32 imgW = screensize.X / 2.2f;
 641                         u32 imgH = floor(imgW * imgRatio);
 642 #endif
 643                         v2s32 img_pos((screensize.X - imgW) / 2, (screensize.Y - imgH) / 2);
 644
 645                         draw2DImageFilterScaled(
 646                                 driver, progress_img_bg,
 647                                 core::rect<s32>(img_pos.X,
 648                                                 img_pos.Y,
 649                                                 img_pos.X + imgW,
 650                                                 img_pos.Y + imgH),
 651                                 core::rect<s32>(0, 0,
 652                                                 img_size.Width,
 653                                                 img_size.Height),
 654                                 0, 0, true);
 655
 656                         draw2DImageFilterScaled(
 657                                 driver, progress_img,
 658                                 core::rect<s32>(img_pos.X,
 659                                                 img_pos.Y,
 660                                                 img_pos.X + (percent * imgW) / 100,
 661                                                 img_pos.Y + imgH),
 662                                 core::rect<s32>(0, 0,
 663                                                 (percent * img_size.Width) / 100,
 664                                                 img_size.Height),
 665                                 0, 0, true);
 666                 }
 667         }
 668
 669         guienv->drawAll();
 670         driver->endScene();
 671         guitext->remove();
 672
 673         //return guitext;
 674 }