src/guiEngine.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 sapier
   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 "guiEngine.h"
  21
  22 #include "scripting_mainmenu.h"
  23 #include "config.h"
  24 #include "version.h"
  25 #include "porting.h"
  26 #include "filesys.h"
  27 #include "main.h"
  28 #include "settings.h"
  29 #include "guiMainMenu.h"
  30 #include "sound.h"
  31 #include "sound_openal.h"
  32 #include "clouds.h"
  33 #include "httpfetch.h"
  34 #include "util/numeric.h"
  35
  36 #include <IGUIStaticText.h>
  37 #include <ICameraSceneNode.h>
  38
  39 /******************************************************************************/
  40 /** TextDestGuiEngine                                                         */
  41 /******************************************************************************/
  42 TextDestGuiEngine::TextDestGuiEngine(GUIEngine* engine)
  43 {
  44         m_engine = engine;
  45 }
  46
  47 /******************************************************************************/
  48 void TextDestGuiEngine::gotText(std::map<std::string, std::string> fields)
  49 {
  50         m_engine->getScriptIface()->handleMainMenuButtons(fields);
  51 }
  52
  53 /******************************************************************************/
  54 void TextDestGuiEngine::gotText(std::wstring text)
  55 {
  56         m_engine->getScriptIface()->handleMainMenuEvent(wide_to_narrow(text));
  57 }
  58
  59 /******************************************************************************/
  60 /** MenuTextureSource                                                         */
  61 /******************************************************************************/
  62 MenuTextureSource::MenuTextureSource(video::IVideoDriver *driver)
  63 {
  64         m_driver = driver;
  65 }
  66
  67 /******************************************************************************/
  68 MenuTextureSource::~MenuTextureSource()
  69 {
  70         for (std::set<std::string>::iterator it = m_to_delete.begin();
  71                         it != m_to_delete.end(); ++it) {
  72                 const char *tname = (*it).c_str();
  73                 video::ITexture *texture = m_driver->getTexture(tname);
  74                 m_driver->removeTexture(texture);
  75         }
  76 }
  77
  78 /******************************************************************************/
  79 video::ITexture* MenuTextureSource::getTexture(const std::string &name, u32 *id)
  80 {
  81         if(id)
  82                 *id = 0;
  83         if(name.empty())
  84                 return NULL;
  85         m_to_delete.insert(name);
  86         return m_driver->getTexture(name.c_str());
  87 }
  88
  89 /******************************************************************************/
  90 /** MenuMusicFetcher                                                          */
  91 /******************************************************************************/
  92 void MenuMusicFetcher::fetchSounds(const std::string &name,
  93                         std::set<std::string> &dst_paths,
  94                         std::set<std::string> &dst_datas)
  95 {
  96         if(m_fetched.count(name))
  97                 return;
  98         m_fetched.insert(name);
  99         std::string base;
 100         base = porting::path_share + DIR_DELIM + "sounds";
 101         dst_paths.insert(base + DIR_DELIM + name + ".ogg");
 102         int i;
 103         for(i=0; i<10; i++)
 104                 dst_paths.insert(base + DIR_DELIM + name + "."+itos(i)+".ogg");
 105         base = porting::path_user + DIR_DELIM + "sounds";
 106         dst_paths.insert(base + DIR_DELIM + name + ".ogg");
 107         for(i=0; i<10; i++)
 108                 dst_paths.insert(base + DIR_DELIM + name + "."+itos(i)+".ogg");
 109 }
 110
 111 /******************************************************************************/
 112 /** GUIEngine                                                                 */
 113 /******************************************************************************/
 114 GUIEngine::GUIEngine(   irr::IrrlichtDevice* dev,
 115                                                 gui::IGUIElement* parent,
 116                                                 IMenuManager *menumgr,
 117                                                 scene::ISceneManager* smgr,
 118                                                 MainMenuData* data,
 119                                                 bool& kill) :
 120         m_device(dev),
 121         m_parent(parent),
 122         m_menumanager(menumgr),
 123         m_smgr(smgr),
 124         m_data(data),
 125         m_texture_source(NULL),
 126         m_sound_manager(NULL),
 127         m_formspecgui(0),
 128         m_buttonhandler(0),
 129         m_menu(0),
 130         m_kill(kill),
 131         m_startgame(false),
 132         m_script(0),
 133         m_scriptdir(""),
 134         m_irr_toplefttext(0),
 135         m_clouds_enabled(true),
 136         m_cloud()
 137 {
 138         //initialize texture pointers
 139         for (unsigned int i = 0; i < TEX_LAYER_MAX; i++) {
 140                 m_textures[i].texture = NULL;
 141         }
 142         // is deleted by guiformspec!
 143         m_buttonhandler = new TextDestGuiEngine(this);
 144
 145         //create texture source
 146         m_texture_source = new MenuTextureSource(m_device->getVideoDriver());
 147
 148         //create soundmanager
 149         MenuMusicFetcher soundfetcher;
 150 #if USE_SOUND
 151         m_sound_manager = createOpenALSoundManager(&soundfetcher);
 152 #endif
 153         if(!m_sound_manager)
 154                 m_sound_manager = &dummySoundManager;
 155
 156         //create topleft header
 157         core::rect<s32> rect(0, 0, 500, 20);
 158         rect += v2s32(4, 0);
 159         std::string t = std::string("Minetest ") + minetest_version_hash;
 160
 161         m_irr_toplefttext =
 162                 m_device->getGUIEnvironment()->addStaticText(narrow_to_wide(t).c_str(),
 163                 rect,false,true,0,-1);
 164
 165         //create formspecsource
 166         m_formspecgui = new FormspecFormSource("");
 167
 168         /* Create menu */
 169         m_menu = new GUIFormSpecMenu(m_device,
 170                         m_parent,
 171                         -1,
 172                         m_menumanager,
 173                         NULL /* &client */,
 174                         NULL /* gamedef */,
 175                         m_texture_source,
 176                         m_formspecgui,
 177                         m_buttonhandler,
 178                         NULL);
 179
 180         m_menu->allowClose(false);
 181         m_menu->lockSize(true,v2u32(800,600));
 182
 183         // Initialize scripting
 184
 185         infostream << "GUIEngine: Initializing Lua" << std::endl;
 186
 187         m_script = new MainMenuScripting(this);
 188
 189         try {
 190                 if (m_data->errormessage != "") {
 191                         m_script->setMainMenuErrorMessage(m_data->errormessage);
 192                         m_data->errormessage = "";
 193                 }
 194
 195                 if (!loadMainMenuScript()) {
 196                         errorstream << "No future without mainmenu" << std::endl;
 197                         abort();
 198                 }
 199
 200                 run();
 201         }
 202         catch(LuaError &e) {
 203                 errorstream << "MAINMENU ERROR: " << e.what() << std::endl;
 204                 m_data->errormessage = e.what();
 205         }
 206
 207         m_menu->quitMenu();
 208         m_menu->drop();
 209         m_menu = 0;
 210 }
 211
 212 /******************************************************************************/
 213 bool GUIEngine::loadMainMenuScript()
 214 {
 215         // Try custom menu script (main_menu_path)
 216
 217         m_scriptdir = g_settings->get("main_menu_path");
 218         if (m_scriptdir.empty()) {
 219                 m_scriptdir = porting::path_share + DIR_DELIM "builtin" + DIR_DELIM "mainmenu";
 220         }
 221
 222         std::string script = porting::path_share + DIR_DELIM "builtin" + DIR_DELIM "init.lua";
 223         if (m_script->loadScript(script)) {
 224                 // Menu script loaded
 225                 return true;
 226         } else {
 227                 infostream
 228                         << "GUIEngine: execution of menu script in: \""
 229                         << m_scriptdir << "\" failed!" << std::endl;
 230         }
 231
 232         return false;
 233 }
 234
 235 /******************************************************************************/
 236 void GUIEngine::run()
 237 {
 238         // Always create clouds because they may or may not be
 239         // needed based on the game selected
 240         video::IVideoDriver* driver = m_device->getVideoDriver();
 241
 242         cloudInit();
 243
 244         while(m_device->run() && (!m_startgame) && (!m_kill)) {
 245                 driver->beginScene(true, true, video::SColor(255,140,186,250));
 246
 247                 if (m_clouds_enabled)
 248                 {
 249                         cloudPreProcess();
 250                         drawOverlay(driver);
 251                 }
 252                 else
 253                         drawBackground(driver);
 254
 255                 drawHeader(driver);
 256                 drawFooter(driver);
 257
 258                 m_device->getGUIEnvironment()->drawAll();
 259
 260                 driver->endScene();
 261
 262                 if (m_clouds_enabled)
 263                         cloudPostProcess();
 264                 else
 265                         sleep_ms(25);
 266
 267                 m_script->step();
 268         }
 269 }
 270
 271 /******************************************************************************/
 272 GUIEngine::~GUIEngine()
 273 {
 274         video::IVideoDriver* driver = m_device->getVideoDriver();
 275         assert(driver != 0);
 276
 277         if(m_sound_manager != &dummySoundManager){
 278                 delete m_sound_manager;
 279                 m_sound_manager = NULL;
 280         }
 281
 282         //TODO: clean up m_menu here
 283
 284         infostream<<"GUIEngine: Deinitializing scripting"<<std::endl;
 285         delete m_script;
 286
 287         m_irr_toplefttext->setText(L"");
 288
 289         //clean up texture pointers
 290         for (unsigned int i = 0; i < TEX_LAYER_MAX; i++) {
 291                 if (m_textures[i].texture != NULL)
 292                         driver->removeTexture(m_textures[i].texture);
 293         }
 294
 295         delete m_texture_source;
 296
 297         if (m_cloud.clouds)
 298                 m_cloud.clouds->drop();
 299 }
 300
 301 /******************************************************************************/
 302 void GUIEngine::cloudInit()
 303 {
 304         m_cloud.clouds = new Clouds(m_smgr->getRootSceneNode(),
 305                         m_smgr, -1, rand(), 100);
 306         m_cloud.clouds->update(v2f(0, 0), video::SColor(255,200,200,255));
 307
 308         m_cloud.camera = m_smgr->addCameraSceneNode(0,
 309                                 v3f(0,0,0), v3f(0, 60, 100));
 310         m_cloud.camera->setFarValue(10000);
 311
 312         m_cloud.lasttime = m_device->getTimer()->getTime();
 313 }
 314
 315 /******************************************************************************/
 316 void GUIEngine::cloudPreProcess()
 317 {
 318         u32 time = m_device->getTimer()->getTime();
 319
 320         if(time > m_cloud.lasttime)
 321                 m_cloud.dtime = (time - m_cloud.lasttime) / 1000.0;
 322         else
 323                 m_cloud.dtime = 0;
 324
 325         m_cloud.lasttime = time;
 326
 327         m_cloud.clouds->step(m_cloud.dtime*3);
 328         m_cloud.clouds->render();
 329         m_smgr->drawAll();
 330 }
 331
 332 /******************************************************************************/
 333 void GUIEngine::cloudPostProcess()
 334 {
 335         float fps_max = g_settings->getFloat("fps_max");
 336         // Time of frame without fps limit
 337         float busytime;
 338         u32 busytime_u32;
 339         // not using getRealTime is necessary for wine
 340         u32 time = m_device->getTimer()->getTime();
 341         if(time > m_cloud.lasttime)
 342                 busytime_u32 = time - m_cloud.lasttime;
 343         else
 344                 busytime_u32 = 0;
 345         busytime = busytime_u32 / 1000.0;
 346
 347         // FPS limiter
 348         u32 frametime_min = 1000./fps_max;
 349
 350         if(busytime_u32 < frametime_min) {
 351                 u32 sleeptime = frametime_min - busytime_u32;
 352                 m_device->sleep(sleeptime);
 353         }
 354 }
 355
 356 /******************************************************************************/
 357 void GUIEngine::drawBackground(video::IVideoDriver* driver)
 358 {
 359         v2u32 screensize = driver->getScreenSize();
 360
 361         video::ITexture* texture = m_textures[TEX_LAYER_BACKGROUND].texture;
 362
 363         /* If no texture, draw background of solid color */
 364         if(!texture){
 365                 video::SColor color(255,80,58,37);
 366                 core::rect<s32> rect(0, 0, screensize.X, screensize.Y);
 367                 driver->draw2DRectangle(color, rect, NULL);
 368                 return;
 369         }
 370
 371         v2u32 sourcesize = texture->getOriginalSize();
 372
 373         if (m_textures[TEX_LAYER_BACKGROUND].tile)
 374         {
 375                 v2u32 tilesize(
 376                                 MYMAX(sourcesize.X,m_textures[TEX_LAYER_BACKGROUND].minsize),
 377                                 MYMAX(sourcesize.Y,m_textures[TEX_LAYER_BACKGROUND].minsize));
 378                 for (unsigned int x = 0; x < screensize.X; x += tilesize.X )
 379                 {
 380                         for (unsigned int y = 0; y < screensize.Y; y += tilesize.Y )
 381                         {
 382                                 driver->draw2DImage(texture,
 383                                         core::rect<s32>(x, y, x+tilesize.X, y+tilesize.Y),
 384                                         core::rect<s32>(0, 0, sourcesize.X, sourcesize.Y),
 385                                         NULL, NULL, true);
 386                         }
 387                 }
 388                 return;
 389         }
 390
 391         /* Draw background texture */
 392         driver->draw2DImage(texture,
 393                 core::rect<s32>(0, 0, screensize.X, screensize.Y),
 394                 core::rect<s32>(0, 0, sourcesize.X, sourcesize.Y),
 395                 NULL, NULL, true);
 396 }
 397
 398 /******************************************************************************/
 399 void GUIEngine::drawOverlay(video::IVideoDriver* driver)
 400 {
 401         v2u32 screensize = driver->getScreenSize();
 402
 403         video::ITexture* texture = m_textures[TEX_LAYER_OVERLAY].texture;
 404
 405         /* If no texture, draw background of solid color */
 406         if(!texture)
 407                 return;
 408
 409         /* Draw background texture */
 410         v2u32 sourcesize = texture->getOriginalSize();
 411         driver->draw2DImage(texture,
 412                 core::rect<s32>(0, 0, screensize.X, screensize.Y),
 413                 core::rect<s32>(0, 0, sourcesize.X, sourcesize.Y),
 414                 NULL, NULL, true);
 415 }
 416
 417 /******************************************************************************/
 418 void GUIEngine::drawHeader(video::IVideoDriver* driver)
 419 {
 420         core::dimension2d<u32> screensize = driver->getScreenSize();
 421
 422         video::ITexture* texture = m_textures[TEX_LAYER_HEADER].texture;
 423
 424         /* If no texture, draw nothing */
 425         if(!texture)
 426                 return;
 427
 428         f32 mult = (((f32)screensize.Width / 2.0)) /
 429                         ((f32)texture->getOriginalSize().Width);
 430
 431         v2s32 splashsize(((f32)texture->getOriginalSize().Width) * mult,
 432                         ((f32)texture->getOriginalSize().Height) * mult);
 433
 434         // Don't draw the header is there isn't enough room
 435         s32 free_space = (((s32)screensize.Height)-320)/2;
 436
 437         if (free_space > splashsize.Y) {
 438                 core::rect<s32> splashrect(0, 0, splashsize.X, splashsize.Y);
 439                 splashrect += v2s32((screensize.Width/2)-(splashsize.X/2),
 440                                 ((free_space/2)-splashsize.Y/2)+10);
 441
 442         video::SColor bgcolor(255,50,50,50);
 443
 444         driver->draw2DImage(texture, splashrect,
 445                 core::rect<s32>(core::position2d<s32>(0,0),
 446                 core::dimension2di(texture->getOriginalSize())),
 447                 NULL, NULL, true);
 448         }
 449 }
 450
 451 /******************************************************************************/
 452 void GUIEngine::drawFooter(video::IVideoDriver* driver)
 453 {
 454         core::dimension2d<u32> screensize = driver->getScreenSize();
 455
 456         video::ITexture* texture = m_textures[TEX_LAYER_FOOTER].texture;
 457
 458         /* If no texture, draw nothing */
 459         if(!texture)
 460                 return;
 461
 462         f32 mult = (((f32)screensize.Width)) /
 463                         ((f32)texture->getOriginalSize().Width);
 464
 465         v2s32 footersize(((f32)texture->getOriginalSize().Width) * mult,
 466                         ((f32)texture->getOriginalSize().Height) * mult);
 467
 468         // Don't draw the footer if there isn't enough room
 469         s32 free_space = (((s32)screensize.Height)-320)/2;
 470
 471         if (free_space > footersize.Y) {
 472                 core::rect<s32> rect(0,0,footersize.X,footersize.Y);
 473                 rect += v2s32(screensize.Width/2,screensize.Height-footersize.Y);
 474                 rect -= v2s32(footersize.X/2, 0);
 475
 476                 driver->draw2DImage(texture, rect,
 477                         core::rect<s32>(core::position2d<s32>(0,0),
 478                         core::dimension2di(texture->getOriginalSize())),
 479                         NULL, NULL, true);
 480         }
 481 }
 482
 483 /******************************************************************************/
 484 bool GUIEngine::setTexture(texture_layer layer, std::string texturepath,
 485                 bool tile_image, unsigned int minsize)
 486 {
 487         video::IVideoDriver* driver = m_device->getVideoDriver();
 488         assert(driver != 0);
 489
 490         if (m_textures[layer].texture != NULL)
 491         {
 492                 driver->removeTexture(m_textures[layer].texture);
 493                 m_textures[layer].texture = NULL;
 494         }
 495
 496         if ((texturepath == "") || !fs::PathExists(texturepath))
 497         {
 498                 return false;
 499         }
 500
 501         m_textures[layer].texture = driver->getTexture(texturepath.c_str());
 502         m_textures[layer].tile    = tile_image;
 503         m_textures[layer].minsize = minsize;
 504
 505         if (m_textures[layer].texture == NULL)
 506         {
 507                 return false;
 508         }
 509
 510         return true;
 511 }
 512
 513 /******************************************************************************/
 514 bool GUIEngine::downloadFile(std::string url,std::string target)
 515 {
 516 #if USE_CURL
 517         std::ofstream targetfile(target.c_str(), std::ios::out | std::ios::binary);
 518
 519         if (!targetfile.good()) {
 520                 return false;
 521         }
 522
 523         HTTPFetchRequest fetchrequest;
 524         HTTPFetchResult fetchresult;
 525         fetchrequest.url = url;
 526         fetchrequest.caller = HTTPFETCH_SYNC;
 527         httpfetch_sync(fetchrequest, fetchresult);
 528
 529         if (fetchresult.succeeded) {
 530                 targetfile << fetchresult.data;
 531         } else {
 532                 return false;
 533         }
 534
 535         return true;
 536 #else
 537         return false;
 538 #endif
 539 }
 540
 541 /******************************************************************************/
 542 void GUIEngine::setTopleftText(std::string append)
 543 {
 544         std::string toset = std::string("Minetest ") + minetest_version_hash;
 545
 546         if (append != "") {
 547                 toset += " / ";
 548                 toset += append;
 549         }
 550
 551         m_irr_toplefttext->setText(narrow_to_wide(toset).c_str());
 552 }
 553
 554 /******************************************************************************/
 555 s32 GUIEngine::playSound(SimpleSoundSpec spec, bool looped)
 556 {
 557         s32 handle = m_sound_manager->playSound(spec, looped);
 558         return handle;
 559 }
 560
 561 /******************************************************************************/
 562 void GUIEngine::stopSound(s32 handle)
 563 {
 564         m_sound_manager->stopSound(handle);
 565 }
 566
 567 /******************************************************************************/
 568 unsigned int GUIEngine::queueAsync(std::string serialized_func,
 569                 std::string serialized_params)
 570 {
 571         return m_script->queueAsync(serialized_func, serialized_params);
 572 }
 573