Changeset 2850 for code/branches/gui/src

Timestamp:

Mar 25, 2009, 11:53:04 PM (16 years ago)

Author:

rgrieder

Message:

• Started working on cleaning up the GameState mess
• Cleaned out GUIManager
• Renamed GSGUI to GSMainMenu
• "—state blah" has been changed to —server, —client, —standalone, —dedicated
• —console starts the game in the console (no level loading there yet, but "loadMenu")
• adjusted run scripts

Location:

code/branches/gui/src

Files:

• core/Game.cc (modified) (6 diffs)
• core/Game.h (modified) (1 diff)
• core/GameState.cc (modified) (1 diff)
• core/GameState.h (modified) (2 diffs)
• orxonox/CameraManager.cc (modified) (1 diff)
• orxonox/GraphicsManager.cc (modified) (1 diff)
• orxonox/GraphicsManager.h (modified) (2 diffs)
• orxonox/gamestates/CMakeLists.txt (modified) (1 diff)
• orxonox/gamestates/GSGraphics.cc (modified) (3 diffs)
• orxonox/gamestates/GSIOConsole.cc (modified) (1 diff)
• orxonox/gamestates/GSIOConsole.h (modified) (1 diff)
• orxonox/gamestates/GSLevel.cc (modified) (6 diffs)
• orxonox/gamestates/GSLevel.h (modified) (2 diffs)
• orxonox/gamestates/GSMainMenu.cc (moved) (moved from code/branches/gui/src/orxonox/gamestates/GSGUI.cc) (3 diffs)
• orxonox/gamestates/GSMainMenu.h (moved) (moved from code/branches/gui/src/orxonox/gamestates/GSGUI.h) (3 diffs)
• orxonox/gamestates/GSRoot.cc (modified) (5 diffs)
• orxonox/gui/GUIManager.cc (modified) (12 diffs)
• orxonox/gui/GUIManager.h (modified) (5 diffs)

code/branches/gui/src/core/Game.cc

@@ -40 +40 @@
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/SubString.h"
 #include "Clock.h"
 #include "CommandLine.h"
@@ -247 +248 @@
         // Check parent and all its grand parents
         GameStateTreeNode* currentNode = lastRequestedNode;
-        while (requestedNode == NULL && currentNode->parent_ != NULL)
+        while (requestedNode == NULL && currentNode != NULL)
         {
             if (currentNode->state_ == state)
@@ -260 +261 @@
     }
 
+    void Game::requestStates(const std::string& names)
+    {
+        SubString tokens(names, ",;", " ");
+        for (unsigned int i = 0; i < tokens.size(); ++i)
+            this->requestState(tokens[i]);
+    }
+
     void Game::popState()
     {
@@ -270 +278 @@
     GameState* Game::getState(const std::string& name)
     {
-        std::map<std::string, GameState*>::const_iterator it = allStates_s.find(name);
+        std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(name));
         if (it != allStates_s.end())
             return it->second;
@@ -356 +364 @@
     void Game::loadState(GameState* state)
     {
+        if (!this->activeStates_.empty())
+            this->activeStates_.back()->activity_.topState = false;
         state->activate();
+        state->activity_.topState = true;
         this->activeStates_.push_back(state);
     }
@@ -362 +373 @@
     void Game::unloadState(orxonox::GameState* state)
     {
+        state->activity_.topState = false;
         state->deactivate();
         this->activeStates_.pop_back();
+        if (!this->activeStates_.empty())
+            this->activeStates_.back()->activity_.topState = true;
     }
 
     /*static*/ bool Game::addGameState(GameState* state)
     {
-        std::map<std::string, GameState*>::const_iterator it = allStates_s.find(state->getName());
+        std::map<std::string, GameState*>::const_iterator it = allStates_s.find(getLowercase(state->getName()));
         if (it == allStates_s.end())
-            allStates_s[state->getName()] = state;
+            allStates_s[getLowercase(state->getName())] = state;
         else
             ThrowException(GameState, "Cannot add two GameStates with the same name to 'Game'.");

code/branches/gui/src/core/Game.h

@@ -66 +66 @@
 
         void requestState(const std::string& name);
+        void requestStates(const std::string& names);
         void popState();
 

code/branches/gui/src/core/GameState.cc

@@ -49 +49 @@
         , parent_(0)
     {
-        State temp = {false, false, false, false, false};
-        this->activity_ = temp;
+        this->activity_.activating   = false;
+        this->activity_.active       = false;
+        this->activity_.deactivating = false;
+        this->activity_.suspended    = false;
+        this->activity_.topState     = false;
+        this->activity_.updating     = false;
     }
 

code/branches/gui/src/core/GameState.h

@@ -74 +74 @@
             unsigned updating     : 1;
             unsigned suspended    : 1;
+            unsigned topState     : 1;
         };
 
@@ -81 +82 @@
 
         const std::string& getName() const { return name_; }
-        const State getActivity() const    { return this->activity_; }
+        State getActivity() const    { return this->activity_; }
         GameState* getParent() const       { return this->parent_; }
 

code/branches/gui/src/orxonox/CameraManager.cc

@@ -142 +142 @@
 
         this->viewport_->setCamera(camera);
-        GUIManager::getInstancePtr()->setCamera(camera);
+        GUIManager::getInstance().setCamera(camera);
 
         // reactivate all visible compositors

code/branches/gui/src/orxonox/GraphicsManager.cc

@@ -216 +216 @@
     }
 
+    void GraphicsManager::setCamera(Ogre::Camera* camera)
+    {
+        this->viewport_->setCamera(camera);
+    }
+
     /**
     @brief

code/branches/gui/src/orxonox/GraphicsManager.h

@@ -66 +66 @@
             { return this->detailLevelParticle_; }
 
-        inline void setViewport(Ogre::Viewport* viewport)
-            { this->viewport_ = viewport; }
         inline Ogre::Viewport* getViewport() const
             { return this->viewport_; }
@@ -73 +71 @@
             { return this->renderWindow_; }
 
+        void setCamera(Ogre::Camera* camera);
+
         static GraphicsManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
-
 
     private:

code/branches/gui/src/orxonox/gamestates/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
+  GSClient.cc
   GSDedicated.cc
-  GSClient.cc
   GSGraphics.cc
-  GSGUI.cc
   GSIOConsole.cc
   GSLevel.cc
+  GSMainMenu.cc
   GSRoot.cc
   GSServer.cc

code/branches/gui/src/orxonox/gamestates/GSGraphics.cc

@@ -35 +35 @@
 #include "util/Debug.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Clock.h"
 #include "core/Core.h"
 #include "core/CoreIncludes.h"
@@ -146 +147 @@
         this->inputManager_->update(time);        // tick console
         this->console_->update(time);
+        this->guiManager_->update(time);
 
         uint64_t timeAfterTick = time.getRealMicroseconds();
@@ -152 +154 @@
         Game::getInstance().addTickTime(timeAfterTick - timeBeforeTick);
 
+        // Render
         this->graphicsManager_->update(time);
     }

code/branches/gui/src/orxonox/gamestates/GSIOConsole.cc

@@ -53 +53 @@
     void GSIOConsole::activate()
     {
+        {
+            FunctorMember<GSIOConsole>* functor = createFunctor(&GSIOConsole::loadMenu);
+            functor->setObject(this);
+            this->ccLoadMenu_ = createConsoleCommand(functor, "loadMenu");
+            CommandExecutor::addConsoleCommandShortcut(this->ccLoadMenu_);
+        }
     }
 
     void GSIOConsole::deactivate()
     {
+        if (this->ccLoadMenu_)
+        {
+            delete this->ccLoadMenu_;
+            this->ccLoadMenu_ = 0;
+        }
     }
 
     void GSIOConsole::update(const Clock& time)
     {
+        std::cout << ">";
         std::string command;
         std::getline(std::cin, command);
         CommandExecutor::execute(command, true);
     }
+
+    void GSIOConsole::loadMenu()
+    {
+        Game::getInstance().popState();
+        Game::getInstance().requestStates("graphics, mainMenu");
+    }
 }

code/branches/gui/src/orxonox/gamestates/GSIOConsole.h

@@ -46 +46 @@
 
     private:
+        void loadMenu();
 
+        // console commands
+        ConsoleCommand* ccLoadMenu_;
     };
 }

code/branches/gui/src/orxonox/gamestates/GSLevel.cc

@@ -49 +49 @@
 #include "LevelManager.h"
 #include "PlayerManager.h"
+#include "gui/GUIManager.h"
 
 namespace orxonox
@@ -86 +87 @@
         if (GameMode::showsGraphics())
         {
+            {
+                FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::toggleGUI);
+                functor->setObject(this);
+                this->ccToggleGUI_ = createConsoleCommand(functor, "toggleGUI");
+                CommandExecutor::addConsoleCommandShortcut(this->ccToggleGUI_);
+            }
+
             inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("game");
             keyBinder_ = new KeyBinder();
@@ -110 +118 @@
         if (GameMode::showsGraphics())
         {
-            // TODO: insert slomo console command with
-            // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
-
             // keybind console command
             FunctorMember<GSLevel>* functor1 = createFunctor(&GSLevel::keybind);
@@ -125 +130 @@
             InputManager::getInstance().setKeyDetectorCallback(std::string("keybind ") + keyDetectorCallbackCode_);
 
+            // InGame GUI test
+            GUIManager::getInstance().showGUI("inGameTest");
+
             // level is loaded: we can start capturing the input
             InputManager::getInstance().requestEnterState("game");
@@ -143 +151 @@
             this->ccTkeybind_ = 0;
         }
+        if (this->ccToggleGUI_)
+        {
+            delete this->ccToggleGUI_;
+            this->ccToggleGUI_ = 0;
+        }
+
 
         // this call will delete every BaseObject!
@@ -219 +233 @@
 
         delete this->startFile_;
+    }
+
+    void GSLevel::toggleGUI()
+    {
+        if (GameMode::showsGraphics())
+        {
+            GUIManager::getInstance().executeCode("toggleGUI()");
+        }
     }
 

code/branches/gui/src/orxonox/gamestates/GSLevel.h

@@ -47 +47 @@
         void update(const Clock& time);
 
+        void toggleGUI();
+
     protected:
         void loadLevel();
@@ -70 +72 @@
         ConsoleCommand*       ccKeybind_;
         ConsoleCommand*       ccTkeybind_;
-
+        ConsoleCommand*       ccToggleGUI_;
     };
 }

code/branches/gui/src/orxonox/gamestates/GSMainMenu.cc

@@ -28 +28 @@
 
 #include "OrxonoxStableHeaders.h"
-#include "GSGUI.h"
+#include "GSMainMenu.h"
 
-#include <OgreViewport.h>
+//#include <OgreViewport.h>
+#include <OgreSceneManager.h>
 #include "core/Clock.h"
 #include "core/ConsoleCommand.h"
@@ -37 +38 @@
 #include "core/input/SimpleInputState.h"
 #include "gui/GUIManager.h"
+#include "objects/Scene.h"
 #include "GraphicsManager.h"
 
 namespace orxonox
 {
-    AddGameState(GSGUI, "mainMenu");
+    AddGameState(GSMainMenu, "mainMenu");
 
-    GSGUI::GSGUI(const std::string& name)
+    GSMainMenu::GSMainMenu(const std::string& name)
         : GameState(name)
+        , inputState_(0)
     {
     }
 
-    GSGUI::~GSGUI()
+    GSMainMenu::~GSMainMenu()
     {
     }
 
-    void GSGUI::activate()
+    void GSMainMenu::activate()
     {
-        guiManager_ = GUIManager::getInstancePtr();
+        inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("mainMenu");
+        inputState_->setHandler(GUIManager::getInstancePtr());
+        inputState_->setJoyStickHandler(&InputManager::EMPTY_HANDLER);
+
+        // create an empty Scene
+        this->scene_ = new Scene(0);
+        // and a Camera
+        this->camera_ = this->scene_->getSceneManager()->createCamera("mainMenu/Camera");
 
         // show main menu
-        //guiManager_->loadScene("MainMenu");
-        guiManager_->showGUI("MainMenu", 0);
-        GraphicsManager::getInstance().getViewport()->setCamera(guiManager_->getCamera());
+        GUIManager::getInstance().showGUI("mainMenu");
+        GUIManager::getInstance().setCamera(this->camera_);
+        GraphicsManager::getInstance().setCamera(this->camera_);
 
         {
-            // time factor console command
-            FunctorMember<GSGUI>* functor = createFunctor(&GSGUI::startGame);
+            FunctorMember<GSMainMenu>* functor = createFunctor(&GSMainMenu::startGame);
             functor->setObject(this);
             this->ccStartGame_ = createConsoleCommand(functor, "startGame");
             CommandExecutor::addConsoleCommandShortcut(this->ccStartGame_);
         }
+        
+        InputManager::getInstance().requestEnterState("mainMenu");
     }
 
-    void GSGUI::deactivate()
+    void GSMainMenu::deactivate()
     {
+        InputManager::getInstance().requestLeaveState("game");
+        InputManager::getInstance().requestDestroyState("game");
+
         if (this->ccStartGame_)
         {
@@ -78 +92 @@
         }
 
-        guiManager_->hideGUI();
+        GUIManager::getInstance().executeCode("hideGUI()");
     }
 
-    void GSGUI::update(const Clock& time)
+    void GSMainMenu::update(const Clock& time)
     {
-        // tick CEGUI
-        guiManager_->update(time);
     }
 
-    void GSGUI::startGame()
+    void GSMainMenu::startGame()
     {
         // HACK - HACK
         Game::getInstance().popState();
-        Game::getInstance().requestState("standalone");
-        Game::getInstance().requestState("level");
+        Game::getInstance().requestStates("standalone, level");
     }
 }

code/branches/gui/src/orxonox/gamestates/GSMainMenu.h

@@ -27 +27 @@
  */
 
-#ifndef _GSGUI_H__
-#define _GSGUI_H__
+#ifndef _GSMainMenu_H__
+#define _GSMainMenu_H__
 
 #include "OrxonoxPrereqs.h"
+#include <OgrePrerequisites.h>
 #include "core/GameState.h"
 
 namespace orxonox
 {
-    class _OrxonoxExport GSGUI : public GameState
+    class _OrxonoxExport GSMainMenu : public GameState
     {
     public:
-        GSGUI(const std::string& name);
-        ~GSGUI();
+        GSMainMenu(const std::string& name);
+        ~GSMainMenu();
 
         void activate();
@@ -48 +49 @@
 
     private:
-        GUIManager* guiManager_;
+        SimpleInputState* inputState_;
+        Scene*            scene_;
+        Ogre::Camera*     camera_;
 
         // console commands
@@ -55 +58 @@
 }
 
-#endif /* _GSGUI_H__ */
+#endif /* _GSMainMenu_H__ */

code/branches/gui/src/orxonox/gamestates/GSRoot.cc

@@ -44 +44 @@
 {
     AddGameState(GSRoot, "root");
-    SetCommandLineSwitch(startWithConsole);
+    SetCommandLineSwitch(console);
+    // Shortcuts for easy direct loading
+    SetCommandLineSwitch(server);
+    SetCommandLineSwitch(client);
+    SetCommandLineSwitch(dedicated);
+    SetCommandLineSwitch(standalone);
 
     GSRoot::GSRoot(const std::string& name)
@@ -63 +68 @@
     {
         // reset game speed to normal
-        timeFactor_ = 1.0f;
+        this->timeFactor_ = 1.0f;
 
         {
@@ -81 +86 @@
         }
 
+        // Load level directly?
+        bool loadLevel = false;
+        if (CommandLine::getValue("standalone").getBool())
+        {
+            Game::getInstance().requestStates("graphics, standalone, level");
+            loadLevel = true;
+        }
+        if (CommandLine::getValue("server").getBool())
+        {
+            Game::getInstance().requestStates("graphics, server, level");
+            loadLevel = true;
+        }
+        if (CommandLine::getValue("client").getBool())
+        {
+            Game::getInstance().requestStates("graphics, standalone, level");
+            loadLevel = true;
+        }
+        if (CommandLine::getValue("dedicated").getBool())
+        {
+            Game::getInstance().requestStates("dedicated, level");
+            loadLevel = true;
+        }
+        
         // Determine where to start
-        if (CommandLine::getValue("startWithConsole").getBool())
-        {
-            // Start the game in the console
-            Game::getInstance().requestState("ioConsole");
-        }
-        else
-        {
-            // Start in GUI main menu
-            Game::getInstance().requestState("graphics");
-            Game::getInstance().requestState("mainMenu");
-        }
-
+        if (!loadLevel)
+        {
+            if (CommandLine::getValue("console").getBool())
+            {
+                // Start the game in the console without 3D graphics
+                Game::getInstance().requestState("ioConsole");
+            }
+            else
+            {
+                // Start in GUI mode
+                Game::getInstance().requestStates("graphics, mainMenu");
+            }
+        }
     }
 
@@ -113 +142 @@
     void GSRoot::update(const Clock& time)
     {
+        if (this->getActivity().topState)
+        {
+            // This state can not 'survive' on its own.
+            // Load a user interface therefore
+            Game::getInstance().requestState("ioConsole");
+        }
+
         uint64_t timeBeforeTick = time.getRealMicroseconds();
 
@@ -132 +168 @@
         uint64_t timeAfterTick = time.getRealMicroseconds();
 
-        // Also add our tick time to the list in GSRoot
+        // Also add our tick time
         Game::getInstance().addTickTime(timeAfterTick - timeBeforeTick);
     }

code/branches/gui/src/orxonox/gui/GUIManager.cc

@@ -36 +36 @@
 #include "GUIManager.h"
 
-#include <boost/filesystem.hpp>
+#include <boost/filesystem/path.hpp>
 #include <OgreRenderWindow.h>
-#include <OgreRoot.h>
 #include <CEGUI.h>
 #include <CEGUIDefaultLogger.h>
@@ -50 +49 @@
 
 #include "util/Exception.h"
-#include "core/input/InputManager.h"
-#include "core/input/SimpleInputState.h"
 #include "core/ConsoleCommand.h"
 #include "core/Core.h"
+#include "core/Clock.h"
 #include "ToluaBindCore.h"
 #include "ToluaBindOrxonox.h"
@@ -63 +61 @@
 namespace orxonox
 {
-    SetConsoleCommandShortcut(GUIManager, toggleGUI).keybindMode(KeybindMode::OnPress);
-
     GUIManager* GUIManager::singletonRef_s = 0;
 
     GUIManager::GUIManager()
-        //: emptySceneManager_(0)
-        : backgroundSceneManager_(0)
-        //, emptyCamera_(0)
-        , backgroundCamera_(0)
-        //, viewport_(0)
-        , renderWindow_(0)
+        : renderWindow_(0)
         , guiRenderer_(0)
         , resourceProvider_(0)
@@ -86 +77 @@
     GUIManager::~GUIManager()
     {
-        if (backgroundCamera_)
-            backgroundSceneManager_->destroyCamera(backgroundCamera_);
-
-        if (backgroundSceneManager_)
-        {
-            // We have to make sure the SceneManager is not anymore referenced.
-            // For the case that the target SceneManager was yet another one, it
-            // wouldn't matter anyway since this is the destructor.
-            guiRenderer_->setTargetSceneManager(0);
-            Ogre::Root::getSingleton().destroySceneManager(backgroundSceneManager_);
-        }
-
-        InputManager::getInstance().requestDestroyState("gui");
-
         if (guiSystem_)
             delete guiSystem_;
@@ -110 +87 @@
                 lua_pushnil(luaState_);
                 lua_setglobal(luaState_, "Core");
-            // TODO: deleting the script module fails an assertion.
-            // However there is not much we can do about it since it occurs too when
-            // we don't open Core or Orxonox. Might be a CEGUI issue.
-            // The memory leak is not a problem anyway..
             delete scriptModule_;
         }
@@ -134 +107 @@
                 // save the render window
                 renderWindow_ = renderWindow;
-
-                // Full screen viewport with Z order = 0 (top most). Don't yet feed a camera (so nothing gets rendered)
-                //this->viewport_ = renderWindow_->addViewport(0, 3);
-                //this->viewport_->setOverlaysEnabled(false);
-                //this->viewport_->setShadowsEnabled(false);
-                //this->viewport_->setSkiesEnabled(false);
-                //this->viewport_->setClearEveryFrame(false);
 
                 // Note: No SceneManager specified yet
@@ -166 +132 @@
                 tolua_Orxonox_open(this->scriptModule_->getLuaState());
 
-                // register us as input handler
-                SimpleInputState* state = InputManager::getInstance().createInputState<SimpleInputState>("gui");
-                state->setHandler(this);
-                state->setJoyStickHandler(&InputManager::EMPTY_HANDLER);
-
-                // load the background scene
-                loadScenes();
-                //CEGUI::KeyEventArgs e;
-                //e.codepoint
+                // initialise the basic lua code
+                loadLuaCode();
             }
             catch (CEGUI::Exception& ex)
@@ -187 +146 @@
 
             state_ = Ready;
-
         }
 
@@ -193 +151 @@
     }
 
-    void GUIManager::loadScene(const std::string& name)
-    {
-        if (name.compare("IngameMenu") == 0)
-        {
-            try
-            {
-                /*this->scriptModule_ = new LuaScriptModule();
-                this->luaState_ = this->scriptModule_->getLuaState();
-                this->guiSystem_ = new System(this->guiRenderer_, this->resourceProvider_, 0, this->scriptModule_);
-                tolua_Core_open(this->scriptModule_->getLuaState());
-                tolua_Orxonox_open(this->scriptModule_->getLuaState());
-                */
-                this->scriptModule_->executeScriptFile("loadGUI_2.lua", "GUI");
-            }
-            catch (CEGUI::Exception& ex)
-            {
-#if CEGUI_VERSION_MINOR < 6
-                throw GeneralException(ex.getMessage().c_str());
-#else
-                throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
-                                       ex.getFileName().c_str(), ex.getName().c_str());
-#endif
-            }
-        }
-        else
-        {
-            loadScenes();
-        }
-    }
-
-    void GUIManager::loadScenes()
-    {
-        // first of all, we need to have our own SceneManager for the GUI. The reason
-        // is that we might have multiple viewports when in play mode (e.g. the view of
-        // a camera fixed at the back of the ship). That forces us to create our own
-        // full screen viewport that is on top of all the others, but doesn't clear the
-        // port before rendering, so everything from the GUI gets on top eventually.
-        // But in order to realise that, we also need a SceneManager with an empty scene,
-        // because the SceneManager is responsible for the render queue.
-        //this->emptySceneManager_ = Ogre::Root::getSingleton()
-        //    .createSceneManager(Ogre::ST_GENERIC, "GUI/EmptySceneManager");
-
-        // we also need a camera or we won't see anything at all.
-        // The camera settings don't matter at all for an empty scene since the GUI
-        // gets rendered on top of the screen rather than into the scene.
-        //this->emptyCamera_ = this->emptySceneManager_->createCamera("GUI/EmptyCamera");
-
-        // Create another SceneManager that enables to display some 3D
-        // scene in the background of the main menu.
-        this->backgroundSceneManager_ = Ogre::Root::getSingleton()
-            .createSceneManager(Ogre::ST_GENERIC, "GUI/BackgroundSceneManager");
-        this->backgroundCamera_ = backgroundSceneManager_->createCamera("GUI/BackgroundCamera");
-
-        // TODO: create something 3D
+    void GUIManager::loadLuaCode()
+    {
         try
         {
@@ -264 +170 @@
     }
 
-    void GUIManager::toggleGUI()
-    {
-        //COUT(0) << "********* TOGGLE TOGGLE **********" << std::endl;
-        if (getInstance().scriptModule_->executeScriptGlobal("toggleGUI"))
-            InputManager::getInstance().requestEnterState("gui");
-        else
-            InputManager::getInstance().requestLeaveState("gui");
+    void GUIManager::update(const Clock& time)
+    {
+        assert(guiSystem_);
+        guiSystem_->injectTimePulse(time.getDeltaTime());
+    }
+
+    void GUIManager::executeCode(const std::string& str)
+    {
+        this->scriptModule_->executeString(str);
     }
 
@@ -278 +186 @@
     }
 
-    void GUIManager::showGUI(const std::string& name, Ogre::SceneManager* sceneManager)// bool showBackground)
+    void GUIManager::showGUI(const std::string& name)
     {
         if (state_ != Uninitialised)
         {
-            if (state_ == OnDisplay)
-                hideGUI();
-
             COUT(3) << "Loading GUI " << name << std::endl;
             try
             {
-                // COUT (0) << "************* sceneManager: " << sceneManager << std::endl;
-                if (!sceneManager)
-                {
-                    // currently, only an image is loaded. We could do 3D, see loadBackground.
-                    //this->viewport_->setClearEveryFrame(true);
-                    this->guiRenderer_->setTargetSceneManager(this->backgroundSceneManager_);
-                    //this->viewport_->setCamera(this->backgroundCamera_);
-
-                    lua_pushboolean(this->scriptModule_->getLuaState(), true);
-                    lua_setglobal(this->scriptModule_->getLuaState(), "showBackground");
-                }
-                else
-                {
-                    //this->viewport_->setClearEveryFrame(false);
-                    this->guiRenderer_->setTargetSceneManager(sceneManager);
-                    currentSceneManager_ = sceneManager;
-                    //this->viewport_->setCamera(this->emptyCamera_);
-
-                    lua_pushboolean(this->scriptModule_->getLuaState(), false);
-                    lua_setglobal(this->scriptModule_->getLuaState(), "showBackground");
-                }
-
-                lua_pushfstring(this->scriptModule_->getLuaState(), "mainmenu.lua");
-                lua_setglobal(this->scriptModule_->getLuaState(), "filename");
-
-                this->scriptModule_->executeScriptGlobal("showGUI");
-
-                InputManager::getInstance().requestEnterState("gui");
-
-                this->state_ = OnDisplay;
+                this->scriptModule_->executeString(std::string("showGUI(\"") + name + "\")");
             }
             catch (CEGUI::Exception& ex)
@@ -332 +208 @@
             COUT(2) << "Warning: GUI Manager not yet initialised, cannot load a GUI" << std::endl;
         }
-    }
-
-    /*void GUIManager::testFct()
-    {
-        //COUT(0) << "**** " << currentSceneManager_ << std::endl;
-        this->showGUI("IngameMenu", currentSceneManager_);
-    }
-
-    void GUIManager::testOutput(const std::string& str)
-    {
-        COUT(0) << "***" << str << "***" << std::endl;
-    }*/
-
-    void GUIManager::hideGUI()
-    {
-        if (this->state_ != OnDisplay)
-            return;
-        //this->viewport_->setCamera(0);
-        // has no effect since you cannot assign 0 as SceneManager
-        //this->guiRenderer_->setTargetSceneManager(0);
-        this->state_ = Ready;
-        InputManager::getInstance().requestLeaveState("gui");
     }
 

code/branches/gui/src/orxonox/gui/GUIManager.h

@@ -40 +40 @@
 #include <CEGUIInputEvent.h>
 #include <CEGUISystem.h>
-#include "core/Clock.h"
 #include "core/input/InputInterfaces.h"
 
@@ -71 +70 @@
 
         bool initialise(Ogre::RenderWindow* renderWindow);
-        void loadScene(const std::string& name);
-        void update(const Clock& time)
-        {
-            assert(guiSystem_);
-            guiSystem_->injectTimePulse(time.getDeltaTime());
-        }
-        void showGUI(const std::string& name, Ogre::SceneManager* sceneManager);// bool showBackground); // tolua_export
-        void hideGUI(); // tolua_export
-        //void testOutput(const std::string& str); // tolua_export
 
-        static void toggleGUI();
+        void update(const Clock& time);
+
+        void showGUI(const std::string& name);
+        void executeCode(const std::string& str);
 
         void setCamera(Ogre::Camera* camera);
-        Ogre::Camera* getCamera() { return this->backgroundCamera_; }
-
-        static void showGUI_s(const std::string& name, Ogre::SceneManager* sceneManager)//bool showBackground)
-        {
-            getInstance().showGUI(name, sceneManager);
-        }
-
-        // please remove
-        //void testFct();
 
         static GUIManager& getInstance()    { assert(singletonRef_s); return *singletonRef_s; } // tolua_export
@@ -99 +83 @@
     private:
         GUIManager(const GUIManager& instance);
+
+        void loadLuaCode();
 
         void keyPressed (const KeyEvent& evt)
@@ -120 +106 @@
         void updateMouse(float dt) { }
 
-        void loadScenes();
-
-        //Ogre::SceneManager*       emptySceneManager_;
-        Ogre::SceneManager*       backgroundSceneManager_;
-        //Ogre::Camera*             emptyCamera_;
-        Ogre::Camera*             backgroundCamera_;
-        //Ogre::Viewport*           viewport_;
         Ogre::RenderWindow*       renderWindow_;
         CEGUI::OgreCEGUIRenderer* guiRenderer_;
@@ -135 +114 @@
         CEGUI::Imageset*          backgroundImage_;
         lua_State*                luaState_;
-        Ogre::SceneManager*         currentSceneManager_;
 
         State state_;