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