src/client/renderingengine.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2017 nerzhul, Loic Blot <loic.blot@unix-experience.fr>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include <IrrlichtDevice.h>
  22 #include <irrlicht.h>
  23 #include "fontengine.h"
  24 #include "client.h"
  25 #include "clouds.h"
  26 #include "util/numeric.h"
  27 #include "guiscalingfilter.h"
  28 #include "localplayer.h"
  29 #include "client/hud.h"
  30 #include "camera.h"
  31 #include "minimap.h"
  32 #include "clientmap.h"
  33 #include "renderingengine.h"
  34 #include "render/core.h"
  35 #include "render/factory.h"
  36 #include "inputhandler.h"
  37 #include "gettext.h"
  38 #include "../gui/guiSkin.h"
  39
  40 #if !defined(_WIN32) && !defined(__APPLE__) && !defined(__ANDROID__) && \
  41                 !defined(SERVER) && !defined(__HAIKU__)
  42 #define XORG_USED
  43 #endif
  44 #ifdef XORG_USED
  45 #include <X11/Xlib.h>
  46 #include <X11/Xutil.h>
  47 #include <X11/Xatom.h>
  48 #endif
  49
  50 #ifdef _WIN32
  51 #include <windows.h>
  52 #include <winuser.h>
  53 #endif
  54
  55 #if ENABLE_GLES
  56 #include "filesys.h"
  57 #endif
  58
  59 RenderingEngine *RenderingEngine::s_singleton = nullptr;
  60
  61
  62 static gui::GUISkin *createSkin(gui::IGUIEnvironment *environment,
  63                 gui::EGUI_SKIN_TYPE type, video::IVideoDriver *driver)
  64 {
  65         gui::GUISkin *skin = new gui::GUISkin(type, driver);
  66
  67         gui::IGUIFont *builtinfont = environment->getBuiltInFont();
  68         gui::IGUIFontBitmap *bitfont = nullptr;
  69         if (builtinfont && builtinfont->getType() == gui::EGFT_BITMAP)
  70                 bitfont = (gui::IGUIFontBitmap*)builtinfont;
  71
  72         gui::IGUISpriteBank *bank = 0;
  73         skin->setFont(builtinfont);
  74
  75         if (bitfont)
  76                 bank = bitfont->getSpriteBank();
  77
  78         skin->setSpriteBank(bank);
  79
  80         return skin;
  81 }
  82
  83
  84 RenderingEngine::RenderingEngine(IEventReceiver *receiver)
  85 {
  86         sanity_check(!s_singleton);
  87
  88         // Resolution selection
  89         bool fullscreen = g_settings->getBool("fullscreen");
  90         u16 screen_w = g_settings->getU16("screen_w");
  91         u16 screen_h = g_settings->getU16("screen_h");
  92
  93         // bpp, fsaa, vsync
  94         bool vsync = g_settings->getBool("vsync");
  95         u16 bits = g_settings->getU16("fullscreen_bpp");
  96         u16 fsaa = g_settings->getU16("fsaa");
  97
  98         // stereo buffer required for pageflip stereo
  99         bool stereo_buffer = g_settings->get("3d_mode") == "pageflip";
 100
 101         // Determine driver
 102         video::E_DRIVER_TYPE driverType = video::EDT_OPENGL;
 103         const std::string &driverstring = g_settings->get("video_driver");
 104         std::vector<video::E_DRIVER_TYPE> drivers =
 105                         RenderingEngine::getSupportedVideoDrivers();
 106         u32 i;
 107         for (i = 0; i != drivers.size(); i++) {
 108                 if (!strcasecmp(driverstring.c_str(),
 109                                 RenderingEngine::getVideoDriverName(drivers[i]))) {
 110                         driverType = drivers[i];
 111                         break;
 112                 }
 113         }
 114         if (i == drivers.size()) {
 115                 errorstream << "Invalid video_driver specified; "
 116                                "defaulting to opengl"
 117                             << std::endl;
 118         }
 119
 120         SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
 121         if (g_logger.getTraceEnabled())
 122                 params.LoggingLevel = irr::ELL_DEBUG;
 123         params.DriverType = driverType;
 124         params.WindowSize = core::dimension2d<u32>(screen_w, screen_h);
 125         params.Bits = bits;
 126         params.AntiAlias = fsaa;
 127         params.Fullscreen = fullscreen;
 128         params.Stencilbuffer = false;
 129         params.Stereobuffer = stereo_buffer;
 130         params.Vsync = vsync;
 131         params.EventReceiver = receiver;
 132         params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
 133         params.ZBufferBits = 24;
 134 #ifdef __ANDROID__
 135         params.PrivateData = porting::app_global;
 136 #endif
 137 #if ENABLE_GLES
 138         // there is no standardized path for these on desktop
 139         std::string rel_path = std::string("client") + DIR_DELIM
 140                         + "shaders" + DIR_DELIM + "Irrlicht";
 141         params.OGLES2ShaderPath = (porting::path_share + DIR_DELIM + rel_path + DIR_DELIM).c_str();
 142 #endif
 143
 144         m_device = createDeviceEx(params);
 145         driver = m_device->getVideoDriver();
 146
 147         s_singleton = this;
 148
 149         auto skin = createSkin(m_device->getGUIEnvironment(),
 150                         gui::EGST_WINDOWS_METALLIC, driver);
 151         m_device->getGUIEnvironment()->setSkin(skin);
 152         skin->drop();
 153 }
 154
 155 RenderingEngine::~RenderingEngine()
 156 {
 157         core.reset();
 158         m_device->closeDevice();
 159         s_singleton = nullptr;
 160 }
 161
 162 v2u32 RenderingEngine::getWindowSize() const
 163 {
 164         if (core)
 165                 return core->getVirtualSize();
 166         return m_device->getVideoDriver()->getScreenSize();
 167 }
 168
 169 void RenderingEngine::setResizable(bool resize)
 170 {
 171         m_device->setResizable(resize);
 172 }
 173
 174 bool RenderingEngine::print_video_modes()
 175 {
 176         IrrlichtDevice *nulldevice;
 177
 178         bool vsync = g_settings->getBool("vsync");
 179         u16 fsaa = g_settings->getU16("fsaa");
 180         MyEventReceiver *receiver = new MyEventReceiver();
 181
 182         SIrrlichtCreationParameters params = SIrrlichtCreationParameters();
 183         params.DriverType = video::EDT_NULL;
 184         params.WindowSize = core::dimension2d<u32>(640, 480);
 185         params.Bits = 24;
 186         params.AntiAlias = fsaa;
 187         params.Fullscreen = false;
 188         params.Stencilbuffer = false;
 189         params.Vsync = vsync;
 190         params.EventReceiver = receiver;
 191         params.HighPrecisionFPU = g_settings->getBool("high_precision_fpu");
 192
 193         nulldevice = createDeviceEx(params);
 194
 195         if (!nulldevice) {
 196                 delete receiver;
 197                 return false;
 198         }
 199
 200         std::cout << _("Available video modes (WxHxD):") << std::endl;
 201
 202         video::IVideoModeList *videomode_list = nulldevice->getVideoModeList();
 203
 204         if (videomode_list != NULL) {
 205                 s32 videomode_count = videomode_list->getVideoModeCount();
 206                 core::dimension2d<u32> videomode_res;
 207                 s32 videomode_depth;
 208                 for (s32 i = 0; i < videomode_count; ++i) {
 209                         videomode_res = videomode_list->getVideoModeResolution(i);
 210                         videomode_depth = videomode_list->getVideoModeDepth(i);
 211                         std::cout << videomode_res.Width << "x" << videomode_res.Height
 212                                   << "x" << videomode_depth << std::endl;
 213                 }
 214
 215                 std::cout << _("Active video mode (WxHxD):") << std::endl;
 216                 videomode_res = videomode_list->getDesktopResolution();
 217                 videomode_depth = videomode_list->getDesktopDepth();
 218                 std::cout << videomode_res.Width << "x" << videomode_res.Height << "x"
 219                           << videomode_depth << std::endl;
 220         }
 221
 222         nulldevice->drop();
 223         delete receiver;
 224
 225         return videomode_list != NULL;
 226 }
 227
 228 void RenderingEngine::cleanupMeshCache()
 229 {
 230         auto mesh_cache = m_device->getSceneManager()->getMeshCache();
 231         while (mesh_cache->getMeshCount() != 0) {
 232                 if (scene::IAnimatedMesh *mesh = mesh_cache->getMeshByIndex(0))
 233                         m_rendering_engine->get_mesh_cache()->removeMesh(mesh);
 234         }
 235 }
 236
 237 bool RenderingEngine::setupTopLevelWindow(const std::string &name)
 238 {
 239         // FIXME: It would make more sense for there to be a switch of some
 240         // sort here that would call the correct toplevel setup methods for
 241         // the environment Minetest is running in.
 242
 243         /* Setting Xorg properties for the top level window */
 244         setupTopLevelXorgWindow(name);
 245
 246         /* Setting general properties for the top level window */
 247         verbosestream << "Client: Configuring general top level"
 248                 << " window properties"
 249                 << std::endl;
 250         bool result = setWindowIcon();
 251
 252         return result;
 253 }
 254
 255 void RenderingEngine::setupTopLevelXorgWindow(const std::string &name)
 256 {
 257 #ifdef XORG_USED
 258         const video::SExposedVideoData exposedData = driver->getExposedVideoData();
 259
 260         Display *x11_dpl = reinterpret_cast<Display *>(exposedData.OpenGLLinux.X11Display);
 261         if (x11_dpl == NULL) {
 262                 warningstream << "Client: Could not find X11 Display in ExposedVideoData"
 263                         << std::endl;
 264                 return;
 265         }
 266
 267         verbosestream << "Client: Configuring X11-specific top level"
 268                 << " window properties"
 269                 << std::endl;
 270
 271
 272         Window x11_win = reinterpret_cast<Window>(exposedData.OpenGLLinux.X11Window);
 273
 274         // Set application name and class hints. For now name and class are the same.
 275         XClassHint *classhint = XAllocClassHint();
 276         classhint->res_name = const_cast<char *>(name.c_str());
 277         classhint->res_class = const_cast<char *>(name.c_str());
 278
 279         XSetClassHint(x11_dpl, x11_win, classhint);
 280         XFree(classhint);
 281
 282         // FIXME: In the future WMNormalHints should be set ... e.g see the
 283         // gtk/gdk code (gdk/x11/gdksurface-x11.c) for the setup_top_level
 284         // method. But for now (as it would require some significant changes)
 285         // leave the code as is.
 286
 287         // The following is borrowed from the above gdk source for setting top
 288         // level windows. The source indicates and the Xlib docs suggest that
 289         // this will set the WM_CLIENT_MACHINE and WM_LOCAL_NAME. This will not
 290         // set the WM_CLIENT_MACHINE to a Fully Qualified Domain Name (FQDN) which is
 291         // required by the Extended Window Manager Hints (EWMH) spec when setting
 292         // the _NET_WM_PID (see further down) but running Minetest in an env
 293         // where the window manager is on another machine from Minetest (therefore
 294         // making the PID useless) is not expected to be a problem. Further
 295         // more, using gtk/gdk as the model it would seem that not using a FQDN is
 296         // not an issue for modern Xorg window managers.
 297
 298         verbosestream << "Client: Setting Xorg window manager Properties"
 299                 << std::endl;
 300
 301         XSetWMProperties (x11_dpl, x11_win, NULL, NULL, NULL, 0, NULL, NULL, NULL);
 302
 303         // Set the _NET_WM_PID window property according to the EWMH spec. _NET_WM_PID
 304         // (in conjunction with WM_CLIENT_MACHINE) can be used by window managers to
 305         // force a shutdown of an application if it doesn't respond to the destroy
 306         // window message.
 307
 308         verbosestream << "Client: Setting Xorg _NET_WM_PID extened window manager property"
 309                 << std::endl;
 310
 311         Atom NET_WM_PID = XInternAtom(x11_dpl, "_NET_WM_PID", false);
 312
 313         pid_t pid = getpid();
 314
 315         XChangeProperty(x11_dpl, x11_win, NET_WM_PID,
 316                         XA_CARDINAL, 32, PropModeReplace,
 317                         reinterpret_cast<unsigned char *>(&pid),1);
 318
 319         // Set the WM_CLIENT_LEADER window property here. Minetest has only one
 320         // window and that window will always be the leader.
 321
 322         verbosestream << "Client: Setting Xorg WM_CLIENT_LEADER property"
 323                 << std::endl;
 324
 325         Atom WM_CLIENT_LEADER = XInternAtom(x11_dpl, "WM_CLIENT_LEADER", false);
 326
 327         XChangeProperty (x11_dpl, x11_win, WM_CLIENT_LEADER,
 328                 XA_WINDOW, 32, PropModeReplace,
 329                 reinterpret_cast<unsigned char *>(&x11_win), 1);
 330 #endif
 331 }
 332
 333 #ifdef _WIN32
 334 static bool getWindowHandle(irr::video::IVideoDriver *driver, HWND &hWnd)
 335 {
 336         const video::SExposedVideoData exposedData = driver->getExposedVideoData();
 337
 338         switch (driver->getDriverType()) {
 339 #if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR < 9
 340         case video::EDT_DIRECT3D8:
 341                 hWnd = reinterpret_cast<HWND>(exposedData.D3D8.HWnd);
 342                 break;
 343 #endif
 344         case video::EDT_DIRECT3D9:
 345                 hWnd = reinterpret_cast<HWND>(exposedData.D3D9.HWnd);
 346                 break;
 347 #if ENABLE_GLES
 348         case video::EDT_OGLES1:
 349         case video::EDT_OGLES2:
 350 #endif
 351         case video::EDT_OPENGL:
 352                 hWnd = reinterpret_cast<HWND>(exposedData.OpenGLWin32.HWnd);
 353                 break;
 354         default:
 355                 return false;
 356         }
 357
 358         return true;
 359 }
 360 #endif
 361
 362 bool RenderingEngine::setWindowIcon()
 363 {
 364 #if defined(XORG_USED)
 365 #if RUN_IN_PLACE
 366         return setXorgWindowIconFromPath(
 367                         porting::path_share + "/misc/" PROJECT_NAME "-xorg-icon-128.png");
 368 #else
 369         // We have semi-support for reading in-place data if we are
 370         // compiled with RUN_IN_PLACE. Don't break with this and
 371         // also try the path_share location.
 372         return setXorgWindowIconFromPath(
 373                                ICON_DIR "/hicolor/128x128/apps/" PROJECT_NAME ".png") ||
 374                setXorgWindowIconFromPath(porting::path_share + "/misc/" PROJECT_NAME
 375                                                                "-xorg-icon-128.png");
 376 #endif
 377 #elif defined(_WIN32)
 378         HWND hWnd; // Window handle
 379         if (!getWindowHandle(driver, hWnd))
 380                 return false;
 381
 382         // Load the ICON from resource file
 383         const HICON hicon = LoadIcon(GetModuleHandle(NULL),
 384                         MAKEINTRESOURCE(130) // The ID of the ICON defined in
 385                                              // winresource.rc
 386         );
 387
 388         if (hicon) {
 389                 SendMessage(hWnd, WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(hicon));
 390                 SendMessage(hWnd, WM_SETICON, ICON_SMALL,
 391                                 reinterpret_cast<LPARAM>(hicon));
 392                 return true;
 393         }
 394         return false;
 395 #else
 396         return false;
 397 #endif
 398 }
 399
 400 bool RenderingEngine::setXorgWindowIconFromPath(const std::string &icon_file)
 401 {
 402 #ifdef XORG_USED
 403
 404         video::IImageLoader *image_loader = NULL;
 405         u32 cnt = driver->getImageLoaderCount();
 406         for (u32 i = 0; i < cnt; i++) {
 407                 if (driver->getImageLoader(i)->isALoadableFileExtension(
 408                                     icon_file.c_str())) {
 409                         image_loader = driver->getImageLoader(i);
 410                         break;
 411                 }
 412         }
 413
 414         if (!image_loader) {
 415                 warningstream << "Could not find image loader for file '" << icon_file
 416                               << "'" << std::endl;
 417                 return false;
 418         }
 419
 420         io::IReadFile *icon_f =
 421                         m_device->getFileSystem()->createAndOpenFile(icon_file.c_str());
 422
 423         if (!icon_f) {
 424                 warningstream << "Could not load icon file '" << icon_file << "'"
 425                               << std::endl;
 426                 return false;
 427         }
 428
 429         video::IImage *img = image_loader->loadImage(icon_f);
 430
 431         if (!img) {
 432                 warningstream << "Could not load icon file '" << icon_file << "'"
 433                               << std::endl;
 434                 icon_f->drop();
 435                 return false;
 436         }
 437
 438         u32 height = img->getDimension().Height;
 439         u32 width = img->getDimension().Width;
 440
 441         size_t icon_buffer_len = 2 + height * width;
 442         long *icon_buffer = new long[icon_buffer_len];
 443
 444         icon_buffer[0] = width;
 445         icon_buffer[1] = height;
 446
 447         for (u32 x = 0; x < width; x++) {
 448                 for (u32 y = 0; y < height; y++) {
 449                         video::SColor col = img->getPixel(x, y);
 450                         long pixel_val = 0;
 451                         pixel_val |= (u8)col.getAlpha() << 24;
 452                         pixel_val |= (u8)col.getRed() << 16;
 453                         pixel_val |= (u8)col.getGreen() << 8;
 454                         pixel_val |= (u8)col.getBlue();
 455                         icon_buffer[2 + x + y * width] = pixel_val;
 456                 }
 457         }
 458
 459         img->drop();
 460         icon_f->drop();
 461
 462         const video::SExposedVideoData &video_data = driver->getExposedVideoData();
 463
 464         Display *x11_dpl = (Display *)video_data.OpenGLLinux.X11Display;
 465
 466         if (x11_dpl == NULL) {
 467                 warningstream << "Could not find x11 display for setting its icon."
 468                               << std::endl;
 469                 delete[] icon_buffer;
 470                 return false;
 471         }
 472
 473         Window x11_win = (Window)video_data.OpenGLLinux.X11Window;
 474
 475         Atom net_wm_icon = XInternAtom(x11_dpl, "_NET_WM_ICON", False);
 476         Atom cardinal = XInternAtom(x11_dpl, "CARDINAL", False);
 477         XChangeProperty(x11_dpl, x11_win, net_wm_icon, cardinal, 32, PropModeReplace,
 478                         (const unsigned char *)icon_buffer, icon_buffer_len);
 479
 480         delete[] icon_buffer;
 481
 482 #endif
 483         return true;
 484 }
 485
 486 /*
 487         Draws a screen with a single text on it.
 488         Text will be removed when the screen is drawn the next time.
 489         Additionally, a progressbar can be drawn when percent is set between 0 and 100.
 490 */
 491 void RenderingEngine::_draw_load_screen(const std::wstring &text,
 492                 gui::IGUIEnvironment *guienv, ITextureSource *tsrc, float dtime,
 493                 int percent, bool clouds)
 494 {
 495         v2u32 screensize = RenderingEngine::get_instance()->getWindowSize();
 496
 497         v2s32 textsize(g_fontengine->getTextWidth(text), g_fontengine->getLineHeight());
 498         v2s32 center(screensize.X / 2, screensize.Y / 2);
 499         core::rect<s32> textrect(center - textsize / 2, center + textsize / 2);
 500
 501         gui::IGUIStaticText *guitext =
 502                         guienv->addStaticText(text.c_str(), textrect, false, false);
 503         guitext->setTextAlignment(gui::EGUIA_CENTER, gui::EGUIA_UPPERLEFT);
 504
 505         bool cloud_menu_background = clouds && g_settings->getBool("menu_clouds");
 506         if (cloud_menu_background) {
 507                 g_menuclouds->step(dtime * 3);
 508                 g_menuclouds->render();
 509                 get_video_driver()->beginScene(
 510                                 true, true, video::SColor(255, 140, 186, 250));
 511                 g_menucloudsmgr->drawAll();
 512         } else
 513                 get_video_driver()->beginScene(true, true, video::SColor(255, 0, 0, 0));
 514
 515         // draw progress bar
 516         if ((percent >= 0) && (percent <= 100)) {
 517                 video::ITexture *progress_img = tsrc->getTexture("progress_bar.png");
 518                 video::ITexture *progress_img_bg =
 519                                 tsrc->getTexture("progress_bar_bg.png");
 520
 521                 if (progress_img && progress_img_bg) {
 522 #ifndef __ANDROID__
 523                         const core::dimension2d<u32> &img_size =
 524                                         progress_img_bg->getSize();
 525                         u32 imgW = rangelim(img_size.Width, 200, 600);
 526                         u32 imgH = rangelim(img_size.Height, 24, 72);
 527 #else
 528                         const core::dimension2d<u32> img_size(256, 48);
 529                         float imgRatio = (float)img_size.Height / img_size.Width;
 530                         u32 imgW = screensize.X / 2.2f;
 531                         u32 imgH = floor(imgW * imgRatio);
 532 #endif
 533                         v2s32 img_pos((screensize.X - imgW) / 2,
 534                                         (screensize.Y - imgH) / 2);
 535
 536                         draw2DImageFilterScaled(get_video_driver(), progress_img_bg,
 537                                         core::rect<s32>(img_pos.X, img_pos.Y,
 538                                                         img_pos.X + imgW,
 539                                                         img_pos.Y + imgH),
 540                                         core::rect<s32>(0, 0, img_size.Width,
 541                                                         img_size.Height),
 542                                         0, 0, true);
 543
 544                         draw2DImageFilterScaled(get_video_driver(), progress_img,
 545                                         core::rect<s32>(img_pos.X, img_pos.Y,
 546                                                         img_pos.X + (percent * imgW) / 100,
 547                                                         img_pos.Y + imgH),
 548                                         core::rect<s32>(0, 0,
 549                                                         (percent * img_size.Width) / 100,
 550                                                         img_size.Height),
 551                                         0, 0, true);
 552                 }
 553         }
 554
 555         guienv->drawAll();
 556         get_video_driver()->endScene();
 557         guitext->remove();
 558 }
 559
 560 /*
 561         Draws the menu scene including (optional) cloud background.
 562 */
 563 void RenderingEngine::_draw_menu_scene(gui::IGUIEnvironment *guienv,
 564                 float dtime, bool clouds)
 565 {
 566         bool cloud_menu_background = clouds && g_settings->getBool("menu_clouds");
 567         if (cloud_menu_background) {
 568                 g_menuclouds->step(dtime * 3);
 569                 g_menuclouds->render();
 570                 get_video_driver()->beginScene(
 571                                 true, true, video::SColor(255, 140, 186, 250));
 572                 g_menucloudsmgr->drawAll();
 573         } else
 574                 get_video_driver()->beginScene(true, true, video::SColor(255, 0, 0, 0));
 575
 576         guienv->drawAll();
 577         get_video_driver()->endScene();
 578 }
 579
 580 std::vector<core::vector3d<u32>> RenderingEngine::getSupportedVideoModes()
 581 {
 582         IrrlichtDevice *nulldevice = createDevice(video::EDT_NULL);
 583         sanity_check(nulldevice);
 584
 585         std::vector<core::vector3d<u32>> mlist;
 586         video::IVideoModeList *modelist = nulldevice->getVideoModeList();
 587
 588         s32 num_modes = modelist->getVideoModeCount();
 589         for (s32 i = 0; i != num_modes; i++) {
 590                 core::dimension2d<u32> mode_res = modelist->getVideoModeResolution(i);
 591                 u32 mode_depth = (u32)modelist->getVideoModeDepth(i);
 592                 mlist.emplace_back(mode_res.Width, mode_res.Height, mode_depth);
 593         }
 594
 595         nulldevice->drop();
 596         return mlist;
 597 }
 598
 599 std::vector<irr::video::E_DRIVER_TYPE> RenderingEngine::getSupportedVideoDrivers()
 600 {
 601         std::vector<irr::video::E_DRIVER_TYPE> drivers;
 602
 603         for (int i = 0; i != irr::video::EDT_COUNT; i++) {
 604                 if (irr::IrrlichtDevice::isDriverSupported((irr::video::E_DRIVER_TYPE)i))
 605                         drivers.push_back((irr::video::E_DRIVER_TYPE)i);
 606         }
 607
 608         return drivers;
 609 }
 610
 611 void RenderingEngine::_initialize(Client *client, Hud *hud)
 612 {
 613         const std::string &draw_mode = g_settings->get("3d_mode");
 614         core.reset(createRenderingCore(draw_mode, m_device, client, hud));
 615         core->initialize();
 616 }
 617
 618 void RenderingEngine::_finalize()
 619 {
 620         core.reset();
 621 }
 622
 623 void RenderingEngine::_draw_scene(video::SColor skycolor, bool show_hud,
 624                 bool show_minimap, bool draw_wield_tool, bool draw_crosshair)
 625 {
 626         core->draw(skycolor, show_hud, show_minimap, draw_wield_tool, draw_crosshair);
 627 }
 628
 629 const char *RenderingEngine::getVideoDriverName(irr::video::E_DRIVER_TYPE type)
 630 {
 631         static const char *driver_ids[] = {
 632                         "null",
 633                         "software",
 634                         "burningsvideo",
 635                         "direct3d8",
 636                         "direct3d9",
 637                         "opengl",
 638                         "ogles1",
 639                         "ogles2",
 640         };
 641
 642         return driver_ids[type];
 643 }
 644
 645 const char *RenderingEngine::getVideoDriverFriendlyName(irr::video::E_DRIVER_TYPE type)
 646 {
 647         static const char *driver_names[] = {
 648                         "NULL Driver",
 649                         "Software Renderer",
 650                         "Burning's Video",
 651                         "Direct3D 8",
 652                         "Direct3D 9",
 653                         "OpenGL",
 654                         "OpenGL ES1",
 655                         "OpenGL ES2",
 656         };
 657
 658         return driver_names[type];
 659 }
 660
 661 #ifndef __ANDROID__
 662 #if defined(XORG_USED)
 663
 664 static float calcDisplayDensity()
 665 {
 666         const char *current_display = getenv("DISPLAY");
 667
 668         if (current_display != NULL) {
 669                 Display *x11display = XOpenDisplay(current_display);
 670
 671                 if (x11display != NULL) {
 672                         /* try x direct */
 673                         int dh = DisplayHeight(x11display, 0);
 674                         int dw = DisplayWidth(x11display, 0);
 675                         int dh_mm = DisplayHeightMM(x11display, 0);
 676                         int dw_mm = DisplayWidthMM(x11display, 0);
 677                         XCloseDisplay(x11display);
 678
 679                         if (dh_mm != 0 && dw_mm != 0) {
 680                                 float dpi_height = floor(dh / (dh_mm * 0.039370) + 0.5);
 681                                 float dpi_width = floor(dw / (dw_mm * 0.039370) + 0.5);
 682                                 return std::max(dpi_height, dpi_width) / 96.0;
 683                         }
 684                 }
 685         }
 686
 687         /* return manually specified dpi */
 688         return g_settings->getFloat("screen_dpi") / 96.0;
 689 }
 690
 691 float RenderingEngine::getDisplayDensity()
 692 {
 693         static float cached_display_density = calcDisplayDensity();
 694         return cached_display_density;
 695 }
 696
 697 #elif defined(_WIN32)
 698
 699
 700 static float calcDisplayDensity(irr::video::IVideoDriver *driver)
 701 {
 702         HWND hWnd;
 703         if (getWindowHandle(driver, hWnd)) {
 704                 HDC hdc = GetDC(hWnd);
 705                 float dpi = GetDeviceCaps(hdc, LOGPIXELSX);
 706                 ReleaseDC(hWnd, hdc);
 707                 return dpi / 96.0f;
 708         }
 709
 710         /* return manually specified dpi */
 711         return g_settings->getFloat("screen_dpi") / 96.0f;
 712 }
 713
 714 float RenderingEngine::getDisplayDensity()
 715 {
 716         static bool cached = false;
 717         static float display_density;
 718         if (!cached) {
 719                 display_density = calcDisplayDensity(get_video_driver());
 720                 cached = true;
 721         }
 722         return display_density;
 723 }
 724
 725 #else
 726
 727 float RenderingEngine::getDisplayDensity()
 728 {
 729         return g_settings->getFloat("screen_dpi") / 96.0;
 730 }
 731
 732 #endif
 733
 734 v2u32 RenderingEngine::getDisplaySize()
 735 {
 736         IrrlichtDevice *nulldevice = createDevice(video::EDT_NULL);
 737
 738         core::dimension2d<u32> deskres =
 739                         nulldevice->getVideoModeList()->getDesktopResolution();
 740         nulldevice->drop();
 741
 742         return deskres;
 743 }
 744
 745 #else // __ANDROID__
 746 float RenderingEngine::getDisplayDensity()
 747 {
 748         return porting::getDisplayDensity();
 749 }
 750
 751 v2u32 RenderingEngine::getDisplaySize()
 752 {
 753         return porting::getDisplaySize();
 754 }
 755 #endif // __ANDROID__