Allow the gui to be updates while loading a track, and use this

to show a simple (and still stuttering) animation while loading
a track,

src/graphics/abstract_renderer.hpp

@@ -85,7 +85,7 @@ public:
     
     virtual void clearGlowingNodes() {}
 
-    virtual void render(float dt) = 0;
+    virtual void render(float dt, bool is_loading=false) = 0;
  
      // ------------------------------------------------------------------------
     const irr::core::vector2df &getCurrentScreenSize() const

src/graphics/fixed_pipeline_renderer.cpp

@@ -37,7 +37,7 @@ void FixedPipelineRenderer::onUnloadWorld()
     
 }
 
-void FixedPipelineRenderer::render(float dt)
+void FixedPipelineRenderer::render(float dt, bool is_loading)
 {    
     World *world = World::getWorld(); // Never NULL.
 
@@ -92,7 +92,7 @@ void FixedPipelineRenderer::render(float dt)
     }  // for i<getNumKarts
 
     // Either render the gui, or the global elements of the race gui.
-    GUIEngine::render(dt);
+    GUIEngine::render(dt, is_loading);
 
     // Render the profiler
     if(UserConfigParams::m_profiler_enabled)

src/graphics/fixed_pipeline_renderer.hpp

@@ -20,6 +20,8 @@
 
 #ifndef SERVER_ONLY
 #include "graphics/abstract_renderer.hpp"
+#include "utils/cpp2011.hpp"
+
 #include <map>
 
 class RenderTarget;
@@ -32,7 +34,7 @@ public:
     void onLoadWorld()  ;
     void onUnloadWorld();
     
-    void render(float dt);
+    void render(float dt, bool is_loading) OVERRIDE;
     
     std::unique_ptr<RenderTarget> createRenderTarget(const irr::core::dimension2du &dimension,
                                                      const std::string &name);

src/graphics/irr_driver.cpp

@@ -1853,8 +1853,10 @@ void IrrDriver::doScreenShot()
 // ----------------------------------------------------------------------------
 /** Update, called once per frame.
  *  \param dt Time since last update
+ *  \param is_loading True if the rendering is called during loading of world,
+ *         in which case world, physics etc must not be accessed/
  */
-void IrrDriver::update(float dt)
+void IrrDriver::update(float dt, bool is_loading)
 {
     // If the resolution should be switched, do it now. This will delete the
     // old device and create a new one.
@@ -1882,15 +1884,15 @@ void IrrDriver::update(float dt)
     if (world)
     {
 #ifndef SERVER_ONLY
-        m_renderer->render(dt);
+        m_renderer->render(dt, is_loading);
 
         GUIEngine::Screen* current_screen = GUIEngine::getCurrentScreen();
         if (current_screen != NULL && current_screen->needs3D())
         {
-            GUIEngine::render(dt);
+            GUIEngine::render(dt, is_loading);
         }
 
-        if (Physics::getInstance())
+        if (!is_loading && Physics::getInstance())
         {
             IrrDebugDrawer* debug_drawer = Physics::getInstance()->getDebugDrawer();
             if (debug_drawer != NULL && debug_drawer->debugEnabled())
@@ -1905,7 +1907,7 @@ void IrrDriver::update(float dt)
         m_video_driver->beginScene(/*backBuffer clear*/ true, /*zBuffer*/ true,
                                    video::SColor(255,100,101,140));
 
-        GUIEngine::render(dt);
+        GUIEngine::render(dt, is_loading);
 
         m_video_driver->endScene();
     }

src/graphics/irr_driver.hpp

@@ -266,7 +266,7 @@ public:
     Camera               *addCamera(unsigned int index, AbstractKart *kart);
     void                  removeCameraSceneNode(scene::ICameraSceneNode *camera);
     void                  removeCamera(Camera *camera);
-    void                  update(float dt);
+    void                  update(float dt, bool loading=false);
     /** Call to change resolution */
     void                  changeResolution(const int w, const int h, const bool fullscreen);
   /** Call this to roll back to the previous resolution if a resolution switch attempt goes bad */

src/graphics/shader_based_renderer.cpp

@@ -700,7 +700,7 @@ void ShaderBasedRenderer::addSunLight(const core::vector3df &pos)
 }
 
 // ----------------------------------------------------------------------------
-void ShaderBasedRenderer::render(float dt)
+void ShaderBasedRenderer::render(float dt, bool is_loading)
 {
     // Start the RTT for post-processing.
     // We do this before beginScene() because we want to capture the glClear()
@@ -802,7 +802,7 @@ void ShaderBasedRenderer::render(float dt)
         ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_GUI));
         PROFILER_PUSH_CPU_MARKER("GUIEngine", 0x75, 0x75, 0x75);
         // Either render the gui, or the global elements of the race gui.
-        GUIEngine::render(dt);
+        GUIEngine::render(dt, is_loading);
         PROFILER_POP_CPU_MARKER();
     }
 

src/graphics/shader_based_renderer.hpp

@@ -98,7 +98,7 @@ public:
 
     void addSunLight(const irr::core::vector3df &pos) OVERRIDE;
 
-    void render(float dt) OVERRIDE;
+    void render(float dt, bool is_loading=false) OVERRIDE;
 
     std::unique_ptr<RenderTarget> createRenderTarget(const irr::core::dimension2du &dimension,
                                                      const std::string &name) OVERRIDE;

src/guiengine/engine.cpp

@@ -1143,8 +1143,12 @@ namespace GUIEngine
     }   // reloadSkin
 
     // -----------------------------------------------------------------------
-
-    void render(float elapsed_time)
+    /** \brief called on every frame to trigger the rendering of the GUI.
+     *  \param elapsed_time Time since last rendering calls (in seconds).
+     *  \param is_loading True if the rendering is called during loading of world,
+     *         in which case world, physics etc must not be accessed.
+     */
+    void render(float elapsed_time, bool is_loading)
     {
 #ifndef SERVER_ONLY
         GUIEngine::dt = elapsed_time;
@@ -1158,9 +1162,9 @@ namespace GUIEngine
 
         const GameState gamestate = g_state_manager->getGameState();
 
-        if (gamestate == MENU &&
-            GUIEngine::getCurrentScreen() != NULL &&
-            !GUIEngine::getCurrentScreen()->needs3D())
+        if ( (gamestate == MENU &&
+              GUIEngine::getCurrentScreen() != NULL &&
+             !GUIEngine::getCurrentScreen()->needs3D()  ) || is_loading)
         {
             g_skin->drawBgImage();
         }
@@ -1181,7 +1185,7 @@ namespace GUIEngine
         g_env->drawAll();
 
         // ---- some menus may need updating
-        if (gamestate != GAME)
+        if (gamestate != GAME || is_loading)
         {
             if (ScreenKeyboard::isActive())
             {
@@ -1191,7 +1195,7 @@ namespace GUIEngine
             {
                 ModalDialog::getCurrent()->onUpdate(dt);
             }
-            else
+            else if(getCurrentScreen())
             {
                 getCurrentScreen()->onUpdate(elapsed_time);
             }

src/guiengine/engine.hpp

@@ -222,7 +222,7 @@ namespace GUIEngine
     /**
       * \brief called on every frame to trigger the rendering of the GUI
       */
-    void render(float dt);
+    void render(float dt, bool is_loading = false);
 
     /** \brief renders a "loading" screen */
     void renderLoading(bool clearIcons = true);

src/guiengine/widget.hpp

@@ -362,6 +362,7 @@ namespace GUIEngine
           * is kept)
           */
         bool isSelected(const int playerID) const { return m_selected[playerID]; }
+        void setSelected(const int playerID, bool state) { m_selected[playerID] = state;}
 
         bool isBottomBar() const { return m_bottom_bar; }
         bool isTopBar   () const { return m_top_bar;    }

src/main_loop.cpp

@@ -530,4 +530,18 @@ void MainLoop::run()
 
 }   // run
 
+// ----------------------------------------------------------------------------
+void MainLoop::renderGUI()
+{
+    uint64_t now = StkTime::getRealTimeMs();
+    float dt = (now - m_curr_time)/1000.0f;
+    m_curr_time = now;
+
+    Log::verbose("mainloop", "Rendergui t %llu dt %f",
+                 now, dt);
+
+    irr_driver->update(dt, /*is_loading*/true);
+    input_manager->update(dt);
+    GUIEngine::update(dt);
+}   // renderGUI
 /* EOF */

src/main_loop.hpp

@@ -58,6 +58,7 @@ public:
     void requestAbort() { m_request_abort = true; }
     void setThrottleFPS(bool throttle) { m_throttle_fps = throttle; }
     void setAllowLargeDt(bool enable) { m_allow_large_dt = enable; }
+    void renderGUI();
     // ------------------------------------------------------------------------
     /** Returns true if STK is to be stoppe. */
     bool isAborted() const { return m_abort; }

src/modes/world.cpp

@@ -49,6 +49,7 @@
 #include "karts/kart_model.hpp"
 #include "karts/kart_properties_manager.hpp"
 #include "karts/kart_rewinder.hpp"
+#include "main_loop.hpp"
 #include "modes/overworld.hpp"
 #include "modes/profile_world.hpp"
 #include "network/network_config.hpp"
@@ -168,9 +169,9 @@ void World::init()
     // mode class, which would not have been constructed at the time that this
     // constructor is called, so the wrong race gui would be created.
     createRaceGUI();
-
+    main_loop->renderGUI();
     RewindManager::create();
-
+    main_loop->renderGUI();
     // Grab the track file
     Track *track = track_manager->getTrack(race_manager->getTrackName());
     Scripting::ScriptEngine::getInstance<Scripting::ScriptEngine>();
@@ -184,10 +185,10 @@ void World::init()
 
     std::string script_path = track->getTrackFile("scripting.as");
     Scripting::ScriptEngine::getInstance()->loadScript(script_path, true);
-
+    main_loop->renderGUI();
     // Create the physics
     Physics::getInstance<Physics>();
-
+    main_loop->renderGUI();
     unsigned int num_karts = race_manager->getNumberOfKarts();
     //assert(num_karts > 0);
 
@@ -232,14 +233,15 @@ void World::init()
         m_karts.push_back(new_kart);
     }  // for i
 
+    main_loop->renderGUI();
     // Load other custom models if needed
     loadCustomModels();
-
+    main_loop->renderGUI();
     // Must be called after all karts are created
     m_race_gui->init();
 
     powerup_manager->computeWeightsForRace(race_manager->getNumberOfKarts());
-
+    main_loop->renderGUI();
     if (UserConfigParams::m_particles_effects > 1)
     {
         Weather::getInstance<Weather>();   // create Weather instance
@@ -258,6 +260,7 @@ void World::init()
         }   // if server with graphics of is watching replay
     } // if getNumCameras()==0
     initTeamArrows();
+    main_loop->renderGUI();
 }   // init
 
 //-----------------------------------------------------------------------------

src/network/game_setup.cpp

@@ -178,7 +178,7 @@ void GameSetup::loadWorld()
     {
         race_manager->setReverseTrack(m_reverse);
         race_manager->startSingleRace(m_tracks.back(), m_laps,
-            false/*from_overworld*/);
+                                      false/*from_overworld*/);
     }
 }   // loadWorld
 

src/network/protocols/client_lobby.cpp

@@ -280,8 +280,11 @@ void ClientLobby::addAllPlayers(Event* event)
         float time_limit = data.getFloat();
         m_game_setup->setHitCaptureTime(hit_capture_limit, time_limit);
     }
+
     configRemoteKart(players);
     loadWorld();
+    StateManager::get()->enterGameState();
+
     // Switch to assign mode in case a player hasn't chosen any karts
     input_manager->getDeviceManager()->setAssignMode(ASSIGN);
 }   // addAllPlayers

src/network/protocols/server_lobby.cpp

@@ -1942,10 +1942,7 @@ bool ServerLobby::handleAllVotes(PeerVote *winner)
     std::advance(vote, r.get(m_peers_votes.size()) );
 
     *winner = vote->second;
-
-    // DEBUG ONLY TO SHOW VOTING RESULT 
     return false;
-
     return m_peers_votes.size() == cur_players;
 }   // handleAllVotes
 

src/race/race_manager.cpp

@@ -32,6 +32,7 @@
 #include "karts/abstract_kart.hpp"
 #include "karts/controller/controller.hpp"
 #include "karts/kart_properties_manager.hpp"
+#include "main_loop.hpp"
 #include "modes/capture_the_flag.hpp"
 #include "modes/cutscene_world.hpp"
 #include "modes/demo_world.hpp"
@@ -56,6 +57,7 @@
 #include "states_screens/grand_prix_win.hpp"
 #include "states_screens/kart_selection.hpp"
 #include "states_screens/main_menu_screen.hpp"
+#include "states_screens/online/vote_overview.hpp"
 #include "states_screens/state_manager.hpp"
 #include "tracks/track_manager.hpp"
 #include "utils/ptr_vector.hpp"
@@ -470,14 +472,16 @@ void RaceManager::startNew(bool from_overworld)
  */
 void RaceManager::startNextRace()
 {
+
+    main_loop->renderGUI();
     // Uncomment to debug audio leaks
     // sfx_manager->dump();
 
     IrrlichtDevice* device = irr_driver->getDevice();
-    GUIEngine::renderLoading();
-    device->getVideoDriver()->endScene();
-    device->getVideoDriver()->beginScene(true, true,
-                                         video::SColor(255,100,101,140));
+    //GUIEngine::renderLoading();
+    //device->getVideoDriver()->endScene();
+    //device->getVideoDriver()->beginScene(true, true,
+    //                                     video::SColor(255,100,101,140));
 
     m_num_finished_karts   = 0;
     m_num_finished_players = 0;
@@ -536,6 +540,8 @@ void RaceManager::startNextRace()
         }
     }
 
+    main_loop->renderGUI();
+
     // the constructor assigns this object to the global
     // variable world. Admittedly a bit ugly, but simplifies
     // handling of objects which get created in the constructor
@@ -573,19 +579,21 @@ void RaceManager::startNextRace()
         Log::error("RaceManager", "Could not create given race mode.");
         assert(0);
     }
+    main_loop->renderGUI();
 
     // A second constructor phase is necessary in order to be able to
     // call functions which are overwritten (otherwise polymorphism
     // will fail and the results will be incorrect). Also in init() functions
     // can be called that use World::getWorld().
     World::getWorld()->init();
-
+    main_loop->renderGUI();
     // Now initialise all values that need to be reset from race to race
     // Calling this here reduces code duplication in init and restartRace()
     // functions.
     World::getWorld()->reset();
 
     irr_driver->onLoadWorld();
+    main_loop->renderGUI();
 
     // Save the current score and set last time to zero. This is necessary
     // if someone presses esc after finishing a gp, and selects restart:
@@ -597,6 +605,7 @@ void RaceManager::startNextRace()
         m_kart_status[i].m_last_score = m_kart_status[i].m_score;
         m_kart_status[i].m_last_time  = 0;
     }
+    main_loop->renderGUI();
 }   // startNextRace
 
 //-----------------------------------------------------------------------------
@@ -955,6 +964,16 @@ void RaceManager::startSingleRace(const std::string &track_ident,
 {
     assert(!m_watching_replay);
     StateManager::get()->enterGameState();
+
+    if (NetworkConfig::get()->isNetworking() &&
+        NetworkConfig::get()->isClient()        )
+    {
+        VoteOverview *overview = VoteOverview::getInstance();
+        if (GUIEngine::getCurrentScreen() != overview)
+            overview->push();
+    }
+
+
     setTrack(track_ident);
 
     if (num_laps != -1) setNumLaps( num_laps );
@@ -1011,7 +1030,7 @@ void RaceManager::startWatchingReplay(const std::string &track_ident,
 
     m_track_number = 0;
     startNextRace();
-}   // startSingleRace
+}   // startWatchingReplay
 
 //-----------------------------------------------------------------------------
 void RaceManager::configGrandPrixResultFromNetwork(NetworkString& ns)

src/states_screens/online/vote_overview.cpp

@@ -199,11 +199,14 @@ void VoteOverview::onUpdate(float dt)
     if(m_index_to_hostid.size()==0) return;
 
     static float xx = 0.0f;
-    xx += dt;
+    xx += 2*dt;
     int index = int(xx) % m_index_to_hostid.size();
-    std::string box_name = StringUtils::insertValues("rect-box%d", index);    
-    Widget *box = getWidget(box_name.c_str());
-    box->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
+    for (unsigned int i = 0; i < 8; i++)
+    {
+        std::string box_name = StringUtils::insertValues("rect-box%d", i);
+        Widget *box = getWidget(box_name.c_str());
+        box->setSelected(PLAYER_ID_GAME_MASTER, i==index);
+    }
 
     std::string s = StringUtils::insertValues("name-%d", index);
     LabelWidget *name_widget = getWidget<LabelWidget>(s.c_str());
@@ -215,29 +218,6 @@ void VoteOverview::onUpdate(float dt)
     name_widget = getWidget<LabelWidget>(s.c_str());
     name_widget->setFocusForPlayer(PLAYER_ID_GAME_MASTER);
     name_widget->setDefaultColor();
-
-#ifdef XX
-
-
-    std::string s = StringUtils::insertValues("box-%d", index);
-    LabelWidget *name_widget = getWidget<>(s.c_str());
-
-        //assert(box);
-        std::string num_laps = StringUtils::insertValues("numlaps-%d", i);
-        LabelWidget *laps_widget = getWidget<LabelWidget>(num_laps.c_str());
-        core::stringw laps = _("Laps: %d", vote->m_num_laps);
-        laps_widget->setText(laps, true);
-        std::string track_widget_name = StringUtils::insertValues("track-%d", i);
-        IconButtonWidget *track_widget =
-            getWidget<IconButtonWidget>(track_widget_name.c_str());
-
-        Track *track = track_manager->getTrack(vote->m_track_name);
-
-        track_widget->setImage(track->getScreenshotFile());
-
-    }
-    calculateLayout();
-#endif
 }   // onUpdate
 
 // -----------------------------------------------------------------------------

src/tracks/track.cpp

@@ -55,6 +55,7 @@
 #include "items/network_item_manager.hpp"
 #include "karts/abstract_kart.hpp"
 #include "karts/kart_properties.hpp"
+#include "main_loop.hpp"
 #include "modes/linear_world.hpp"
 #include "modes/easter_egg_hunt.hpp"
 #include "modes/profile_world.hpp"
@@ -1217,6 +1218,7 @@ bool Track::loadMainTrack(const XMLNode &root)
     // m_all_cached_meshes.
     m_all_cached_meshes.push_back(tangent_mesh);
     irr_driver->grabAllTextures(tangent_mesh);
+    main_loop->renderGUI();
 
 #ifdef DEBUG
     std::string debug_name=model_name+" (main track, octtree)";
@@ -1251,6 +1253,8 @@ bool Track::loadMainTrack(const XMLNode &root)
     {
         for (unsigned int i = 0; i < lod_xml_node->getNumNodes(); i++)
         {
+            main_loop->renderGUI();
+
             const XMLNode* lod_group_xml = lod_xml_node->getNode(i);
             for (unsigned int j = 0; j < lod_group_xml->getNumNodes(); j++)
             {
@@ -1258,9 +1262,12 @@ bool Track::loadMainTrack(const XMLNode &root)
             }
         }
     }
+    main_loop->renderGUI();
 
     for (unsigned int i=0; i<track_node->getNumNodes(); i++)
     {
+        main_loop->renderGUI();
+
         const XMLNode *n=track_node->getNode(i);
         // Animated textures have already been handled
         if(n->getName()=="animated-texture") continue;
@@ -1432,7 +1439,9 @@ bool Track::loadMainTrack(const XMLNode &root)
     {
         convertTrackToBullet(m_all_nodes[i]);
         uploadNodeVertexBuffer(m_all_nodes[i]);
+        main_loop->renderGUI();
     }
+
     // Free the tangent (track mesh) after converting to physics
     if (ProfileWorld::isNoGraphics())
         tangent_mesh->freeMeshVertexBuffer();
@@ -1445,6 +1454,7 @@ bool Track::loadMainTrack(const XMLNode &root)
     m_gfx_effect_mesh->createCollisionShape();
     scene_node->setMaterialFlag(video::EMF_LIGHTING, true);
     scene_node->setMaterialFlag(video::EMF_GOURAUD_SHADING, true);
+    main_loop->renderGUI();
 
     return true;
 }   // loadMainTrack
@@ -1739,6 +1749,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
     {
         reverse_track = false;
     }
+    main_loop->renderGUI();
     CheckManager::create();
     assert(m_all_cached_meshes.size()==0);
     if(UserConfigParams::logMemory())
@@ -1778,12 +1789,15 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
     // Add the track directory to the texture search path
     file_manager->pushTextureSearchPath(m_root, unique_id);
     file_manager->pushModelSearchPath(m_root);
+    main_loop->renderGUI();
+
 #ifndef SERVER_ONLY
     if (CVS->isGLSL())
     {
         SP::SPShaderManager::get()->loadSPShaders(m_root);
     }
 #endif
+    main_loop->renderGUI();
 
     // First read the temporary materials.xml file if it exists
     try
@@ -1803,6 +1817,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         // no temporary materials.xml file, ignore
         (void)e;
     }
+    main_loop->renderGUI();
 
     // Start building the scene graph
     // Soccer field with navmesh requires it
@@ -1891,6 +1906,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
                                                    sidewards_distance,
                                                    upwards_distance);
     }
+    main_loop->renderGUI();
 
     // we need to check for fog before loading the main track model
     if (const XMLNode *node = root->getNode("sun"))
@@ -1907,6 +1923,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         node->get("fog-start-height", &m_fog_height_start);
         node->get("fog-end-height",   &m_fog_height_end);
     }
+    main_loop->renderGUI();
 
 #ifndef SERVER_ONLY
     if (!ProfileWorld::isNoGraphics() && CVS->isGLSL() && m_use_fog)
@@ -1933,6 +1950,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         SP::resetEmptyFogColor();
     }
 #endif
+    main_loop->renderGUI();
 
     if (const XMLNode *node = root->getNode("lightshaft"))
     {
@@ -1943,10 +1961,12 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
     }
 
     loadMainTrack(*root);
+    main_loop->renderGUI();
 
     unsigned int main_track_count = (unsigned int)m_all_nodes.size();
 
     ModelDefinitionLoader model_def_loader(this);
+    main_loop->renderGUI();
 
     // Load LOD groups
     const XMLNode *lod_xml_node = root->getNode("lod");
@@ -1954,6 +1974,8 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
     {
         for (unsigned int i = 0; i < lod_xml_node->getNumNodes(); i++)
         {
+            main_loop->renderGUI();
+
             const XMLNode* lod_group_xml = lod_xml_node->getNode(i);
             for (unsigned int j = 0; j < lod_group_xml->getNumNodes(); j++)
             {
@@ -1963,6 +1985,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
     }
 
     loadObjects(root, path, model_def_loader, true, NULL, NULL);
+    main_loop->renderGUI();
 
     // Correct the parenting of meta library
     for (auto& p : m_meta_library)
@@ -1975,14 +1998,19 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         meta_ln->getNode()->setParent(ln->getNode());
         recursiveUpdatePosition(meta_ln->getNode());
         recursiveUpdatePhysics(p.second->getChildren());
+        main_loop->renderGUI();
+
     }
 
     model_def_loader.cleanLibraryNodesAfterLoad();
+    main_loop->renderGUI();
 
     Scripting::ScriptEngine::getInstance()->compileLoadedScripts();
+    main_loop->renderGUI();
 
     // Init all track objects
     m_track_object_manager->init();
+    main_loop->renderGUI();
 
 
     // ---- Fog
@@ -2039,6 +2067,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         irr_driver->setClearbackBufferColor(m_sky_color);
     }
 #endif
+    main_loop->renderGUI();
 
     // ---- Set ambient color
     m_ambient_color = m_default_ambient_color;
@@ -2078,8 +2107,11 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         m_sun->grab();
     }
 #endif
+    main_loop->renderGUI();
 
     createPhysicsModel(main_track_count);
+    main_loop->renderGUI();
+
     freeCachedMeshVertexBuffer();
 
     const bool arena_random_item_created =
@@ -2099,6 +2131,8 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
             }
         }   // for i<root->getNumNodes()
     }
+    main_loop->renderGUI();
+
     if (m_is_ctf &&
         race_manager->getMajorMode() == RaceManager::MAJOR_MODE_CAPTURE_THE_FLAG)
     {
@@ -2113,6 +2147,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         }   // for i<root->getNumNodes()
     }
     delete root;
+    main_loop->renderGUI();
 
     if (NetworkConfig::get()->isNetworking() &&
         NetworkConfig::get()->isClient())
@@ -2120,6 +2155,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         static_cast<NetworkItemManager*>(NetworkItemManager::get())
             ->initClientConfirmState();
     }
+    main_loop->renderGUI();
 
     if (UserConfigParams::m_track_debug && Graph::get() && !m_is_cutscene)
         Graph::get()->createDebugMesh();
@@ -2148,6 +2184,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
     {
         DriveGraph::get()->computeChecklineRequirements();
     }
+    main_loop->renderGUI();
 
     EasterEggHunt *easter_world = dynamic_cast<EasterEggHunt*>(world);
     if(easter_world)
@@ -2155,6 +2192,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
         std::string dir = StringUtils::getPath(m_filename);
         easter_world->readData(dir+"/easter_eggs.xml");
     }
+    main_loop->renderGUI();
 
     STKTexManager::getInstance()->unsetTextureErrorMessage();
 #ifndef SERVER_ONLY
@@ -2176,7 +2214,8 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
 
 //-----------------------------------------------------------------------------
 
-void Track::loadObjects(const XMLNode* root, const std::string& path, ModelDefinitionLoader& model_def_loader,
+void Track::loadObjects(const XMLNode* root, const std::string& path,
+                        ModelDefinitionLoader& model_def_loader,
                         bool create_lod_definitions, scene::ISceneNode* parent,
                         TrackObject* parent_library)
 {