Changeset 6746 for code/trunk/src

Timestamp:

Apr 16, 2010, 2:50:16 PM (15 years ago)

Author:

rgrieder

Message:

Merged gamestates2 branch back to trunk.
This brings in some heavy changes in the GUI framework.
It should also fix problems with triggered asserts in the InputManager.

Note: PickupInventory does not seem to work —> Segfault when showing because before, the owner in GUIOverlay::setGUIName is already NULL.
I haven't tested it before, so I can't tell whether it's my changes.

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/core/Core.cc (modified) (6 diffs)
• src/libraries/core/Core.h (modified) (3 diffs)
• src/libraries/core/GUIManager.cc (modified) (15 diffs)
• src/libraries/core/GUIManager.h (modified) (6 diffs)
• src/libraries/core/Game.h (modified) (1 diff)
• src/libraries/core/IOConsole.cc (modified) (1 diff)
• src/libraries/core/IOConsole.h (modified) (1 diff)
• src/libraries/core/LuaState.cc (modified) (7 diffs)
• src/libraries/core/LuaState.h (modified) (4 diffs)
• src/libraries/core/Resource.cc (modified) (2 diffs)
• src/libraries/core/Resource.h (modified) (1 diff)
• src/libraries/core/Template.cc (modified) (1 diff)
• src/libraries/core/input/InputDevice.h (modified) (3 diffs)
• src/libraries/core/input/InputHandler.h (modified) (2 diffs)
• src/libraries/core/input/InputManager.cc (modified) (18 diffs)
• src/libraries/core/input/InputManager.h (modified) (6 diffs)
• src/libraries/core/input/InputPrereqs.h (modified) (2 diffs)
• src/libraries/core/input/InputState.cc (modified) (1 diff)
• src/libraries/core/input/InputState.h (modified) (12 diffs)
• src/libraries/network/TrafficControl.h (modified) (1 diff)
• src/libraries/util/Serialise.h (modified) (1 diff)
• src/libraries/util/Singleton.h (modified) (3 diffs)
• src/libraries/util/TriBool.h (copied) (copied from code/branches/gamestates2/src/libraries/util/TriBool.h)
• src/modules/pickup/PickupManager.cc (modified) (1 diff)
• src/modules/questsystem/QuestGUI.cc (modified) (3 diffs)
• src/modules/questsystem/QuestGUINode.cc (modified) (6 diffs)
• src/orxonox/CameraManager.h (modified) (1 diff)
• src/orxonox/Level.cc (modified) (2 diffs)
• src/orxonox/LevelManager.h (modified) (1 diff)
• src/orxonox/PlayerManager.cc (modified) (2 diffs)
• src/orxonox/gamestates/GSLevel.cc (modified) (1 diff)
• src/orxonox/gamestates/GSMainMenu.cc (modified) (7 diffs)
• src/orxonox/gamestates/GSMainMenu.h (modified) (1 diff)
• src/orxonox/overlays/CMakeLists.txt (modified) (1 diff)
• src/orxonox/overlays/GUISheet.cc (copied) (copied from code/branches/gamestates2/src/orxonox/overlays/GUISheet.cc)
• src/orxonox/overlays/GUISheet.h (copied) (copied from code/branches/gamestates2/src/orxonox/overlays/GUISheet.h)

code/trunk/src/libraries/core/Core.cc

@@ -78 +78 @@
 
     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
+    SetCommandLineSwitch(noIOConsole).information("Use this if you don't want to use the IOConsole (for instance for Lua debugging)");
 #ifdef ORXONOX_PLATFORM_WINDOWS
     SetCommandLineArgument(limitToCPU, 1).information("Limits the program to one CPU/core (1, 2, 3, etc.). Default is the first core (faster than off)");
@@ -88 +89 @@
         , consoleCommandDestroyer_(CommandExecutor::destroyExternalCommands)
         , bGraphicsLoaded_(false)
+        , bStartIOConsole_(true)
     {
         // Set the hard coded fixed paths
@@ -149 +151 @@
 
         // create persistent io console
-        this->ioConsole_.reset(new IOConsole());
+        if (CommandLineParser::getValue("noIOConsole").getBool())
+        {
+            ModifyConfigValue(bStartIOConsole_, tset, false);
+        }
+        if (this->bStartIOConsole_)
+            this->ioConsole_.reset(new IOConsole());
 
         // creates the class hierarchy for all classes with factories
@@ -193 +200 @@
             .description("If true, all random actions are different each time you start the game")
             .callback(this, &Core::initRandomNumberGenerator);
+        SetConfigValue(bStartIOConsole_, true)
+            .description("Set to false if you don't want to use the IOConsole (for Lua debugging for instance)");
     }
 
@@ -225 +234 @@
 
         // Load the CEGUI interface
-        guiManager_.reset(new GUIManager(graphicsManager_->getRenderWindow(),
-            inputManager_->getMousePosition(), graphicsManager_->isFullScreen()));
+        guiManager_.reset(new GUIManager(inputManager_->getMousePosition()));
 
         bGraphicsLoaded_ = true;
@@ -328 +336 @@
         }
         // Process console events and status line
-        this->ioConsole_->preUpdate(time);
+        if (this->ioConsole_ != NULL)
+            this->ioConsole_->preUpdate(time);
         // Process thread commands
         this->tclThreadManager_->preUpdate(time);

code/trunk/src/libraries/core/Core.h

@@ -38 +38 @@
 #include "util/ScopeGuard.h"
 #include "util/Singleton.h"
-#include "core/OrxonoxClass.h"
+#include "OrxonoxClass.h"
 
 namespace orxonox
@@ -97 +97 @@
             scoped_ptr<TclBind>           tclBind_;
             scoped_ptr<TclThreadManager>  tclThreadManager_;
-            scoped_ptr<Scope<ScopeID::Root> >     rootScope_;
+            scoped_ptr<Scope<ScopeID::Root> > rootScope_;
             // graphical
             scoped_ptr<GraphicsManager>   graphicsManager_;     //!< Interface to OGRE
@@ -108 +108 @@
             std::string                   language_;                   //!< The language
             bool                          bInitRandomNumberGenerator_; //!< If true, srand(time(0)) is called
+            bool                          bStartIOConsole_;            //!< Set to false if you don't want to use the IOConsole
 
             static Core*                  singletonPtr_s;

code/trunk/src/libraries/core/GUIManager.cc

@@ -30 +30 @@
 #include "GUIManager.h"
 
+#include <boost/bind.hpp>
 #include <memory>
 extern "C" {
@@ -41 +42 @@
 #include <CEGUISystem.h>
 #include <CEGUIWindow.h>
+#include <CEGUIWindowManager.h>
 #include <ogreceguirenderer/OgreCEGUIRenderer.h>
 
@@ -57 +59 @@
 #include "ConsoleCommand.h"
 #include "Core.h"
+#include "GraphicsManager.h"
 #include "LuaState.h"
 #include "PathConfig.h"
 #include "Resource.h"
+#include "input/InputManager.h"
+#include "input/InputState.h"
+#include "input/KeyBinderManager.h"
 
 namespace orxonox
@@ -108 +114 @@
     @return true if success, otherwise false
     */
-    GUIManager::GUIManager(Ogre::RenderWindow* renderWindow, const std::pair<int, int>& mousePosition, bool bFullScreen)
-        : renderWindow_(renderWindow)
-        , resourceProvider_(0)
+    GUIManager::GUIManager(const std::pair<int, int>& mousePosition)
+        : resourceProvider_(NULL)
         , camera_(NULL)
-        , bShowIngameGUI_(false)
     {
         using namespace CEGUI;
@@ -119 +123 @@
 
         // Note: No SceneManager specified yet
-        guiRenderer_.reset(new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_OVERLAY, false, 3000));
+        guiRenderer_.reset(new OgreCEGUIRenderer(GraphicsManager::getInstance().getRenderWindow(), Ogre::RENDER_QUEUE_OVERLAY, false, 3000));
         resourceProvider_ = guiRenderer_->createResourceProvider();
         resourceProvider_->setDefaultResourceGroup("GUI");
@@ -141 +145 @@
         guiSystem_.reset(new System(guiRenderer_.get(), resourceProvider_, 0, scriptModule_.get()));
 
-        // Initialise the basic Lua code
-        this->luaState_->doFile("InitialiseGUI.lua");
-
         // Align CEGUI mouse with OIS mouse
         guiSystem_->injectMousePosition((float)mousePosition.first, (float)mousePosition.second);
 
-        // Hide the mouse cursor unless playing in full screen mode
-        if (!bFullScreen)
-            CEGUI::MouseCursor::getSingleton().hide();
+        // Initialise the Lua framework and load the schemes
+        this->luaState_->doFile("InitialiseGUI.lua");
+
+        // Create the root nodes
+        this->rootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("MenuWidgets/StaticImage", "AbsoluteRootWindow");
+        this->rootWindow_->setProperty("FrameEnabled", "False");
+        this->hudRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "HUDRootWindow");
+        this->menuRootWindow_ = CEGUI::WindowManager::getSingleton().createWindow("DefaultWindow", "MenuRootWindow");
+        // And connect them
+        CEGUI::System::getSingleton().setGUISheet(this->rootWindow_);
+        this->rootWindow_->addChildWindow(this->hudRootWindow_);
+        this->rootWindow_->addChildWindow(this->menuRootWindow_);
+
+        // Set up the sheet manager in the Lua framework
+        this->luaState_->doFile("SheetManager.lua");
     }
 
@@ -173 +186 @@
     {
         assert(guiSystem_);
-        guiSystem_->injectTimePulse(time.getDeltaTime());
+        this->protectedCall(boost::bind(&CEGUI::System::injectTimePulse, _1, time.getDeltaTime()));
     }
 
@@ -200 +213 @@
     @param str
         reference to string object holding the Lua code which is to be executed
-
-        This function gives total access to the GUI. You can execute ANY Lua code here.
     */
     void GUIManager::executeCode(const std::string& str)
     {
         this->luaState_->doString(str, rootFileInfo_);
+    }
+
+    /** Loads a GUI sheet by Lua script
+    @param name
+        The name of the GUI (like the script name, but without the extension)
+    */
+    void GUIManager::loadGUI(const std::string& name)
+    {
+        this->executeCode("loadSheet(\"" + name + "\")");
     }
 
@@ -215 +235 @@
 
         The function executes the Lua function with the same name in case the GUIManager is ready.
-        For more details check out loadGUI_2.lua where the function presides.
-    */
-    /*static*/ void GUIManager::showGUI(const std::string& name, bool hidePrevious, bool showCursor)
-    {
-        GUIManager::getInstance().executeCode("showGUI(\"" + name + "\", " + multi_cast<std::string>(hidePrevious) + ", " + multi_cast<std::string>(showCursor) + ")");
+    */
+    /*static*/ void GUIManager::showGUI(const std::string& name, bool bHidePrevious)
+    {
+        GUIManager::getInstance().executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ")");
     }
 
@@ -226 +245 @@
         Hack-ish. Needed for GUIOverlay.
     */
-    void GUIManager::showGUIExtra(const std::string& name, const std::string& ptr, bool hidePrevious, bool showCursor)
-    {
-        this->executeCode("showGUI(\"" + name + "\", " + multi_cast<std::string>(hidePrevious) + ", " + multi_cast<std::string>(showCursor) + ", " + ptr + ")");
+    void GUIManager::showGUIExtra(const std::string& name, const std::string& ptr, bool bHidePrevious)
+    {
+        this->executeCode("showMenuSheet(\"" + name + "\", " + multi_cast<std::string>(bHidePrevious) + ", " + ptr + ")");
     }
 
@@ -239 +258 @@
     /*static*/ void GUIManager::hideGUI(const std::string& name)
     {
-        GUIManager::getInstance().executeCode("hideGUI(\"" + name + "\")");
+        GUIManager::getInstance().executeCode("hideMenuSheet(\"" + name + "\")");
+    }
+
+    const std::string& GUIManager::createInputState(const std::string& name, TriBool::Value showCursor, TriBool::Value useKeyboard, bool bBlockJoyStick)
+    {
+        InputState* state = InputManager::getInstance().createInputState(name);
+
+        /* Table that maps isFullScreen() and showCursor to mouseExclusive
+        isFullscreen / showCursor | True  | False | Dontcare
+        ----------------------------------------------------
+        true                      | True  | True  | Dontcare
+        ----------------------------------------------------
+        false                     | False | True  | Dontcare
+        */
+        if (showCursor == TriBool::Dontcare)
+            state->setMouseExclusive(TriBool::Dontcare);
+        else if (GraphicsManager::getInstance().isFullScreen() || showCursor == TriBool::False)
+            state->setMouseExclusive(TriBool::True);
+        else
+            state->setMouseExclusive(TriBool::False);
+
+        if (showCursor == TriBool::True)
+            state->setMouseHandler(this);
+        else if (showCursor == TriBool::False)
+            state->setMouseHandler(&InputHandler::EMPTY);
+
+        if (useKeyboard == TriBool::True)
+            state->setKeyHandler(this);
+        else if (useKeyboard == TriBool::False)
+            state->setKeyHandler(&InputHandler::EMPTY);
+
+        if (bBlockJoyStick)
+            state->setJoyStickHandler(&InputHandler::EMPTY);
+
+        return state->getName();
     }
 
@@ -247 +300 @@
     }
 
-    void GUIManager::setBackground(const std::string& name)
-    {
-        this->executeCode("setBackground(\"" + name + "\")");
+    void GUIManager::setBackgroundImage(const std::string& imageSet, const std::string imageName)
+    {
+        if (imageSet.empty() || imageName.empty())
+            this->setBackgroundImage("");
+        else
+            this->setBackgroundImage("set: " + imageSet + " image: " + imageName);
+    }
+
+    void GUIManager::setBackgroundImage(const std::string& image)
+    {
+        if (image.empty())
+            this->rootWindow_->setProperty("Alpha", "0.0");
+        else
+            this->rootWindow_->setProperty("Alpha", "1.0");
+        this->rootWindow_->setProperty("Image", image);
     }
 
     void GUIManager::keyPressed(const KeyEvent& evt)
     {
-        guiSystem_->injectKeyDown(evt.getKeyCode());
-        guiSystem_->injectChar(evt.getText());
-    }
+        this->protectedCall(boost::bind(&CEGUI::System::injectKeyDown, _1, evt.getKeyCode()));
+        this->protectedCall(boost::bind(&CEGUI::System::injectChar, _1, evt.getText()));
+    }
+
     void GUIManager::keyReleased(const KeyEvent& evt)
     {
-        guiSystem_->injectKeyUp(evt.getKeyCode());
+        this->protectedCall(boost::bind(&CEGUI::System::injectKeyUp, _1, evt.getKeyCode()));
     }
 
@@ -273 +339 @@
     void GUIManager::buttonPressed(MouseButtonCode::ByEnum id)
     {
-        try
-        {
-            guiSystem_->injectMouseButtonDown(convertButton(id));
-        }
-        catch (CEGUI::ScriptException& ex)
-        {
-            // We simply ignore the exception and proceed
-            COUT(1) << ex.getMessage() << std::endl;
-        }
+        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonDown, _1, convertButton(id)));
     }
 
@@ -295 +353 @@
     void GUIManager::buttonReleased(MouseButtonCode::ByEnum id)
     {
-        try
-        {
-            guiSystem_->injectMouseButtonUp(convertButton(id));
-        }
-        catch (CEGUI::ScriptException& ex)
-        {
-            // We simply ignore the exception and proceed
-            COUT(1) << ex.getMessage() << std::endl;
-        }
+        this->protectedCall(boost::bind(&CEGUI::System::injectMouseButtonUp, _1, convertButton(id)));
     }
 
     void GUIManager::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
     {
-        guiSystem_->injectMousePosition(static_cast<float>(abs.x), static_cast<float>(abs.y));
-    }
+        this->protectedCall(boost::bind(&CEGUI::System::injectMousePosition, _1, (float)abs.x, (float)abs.y));
+    }
+
     void GUIManager::mouseScrolled(int abs, int rel)
     {
-        guiSystem_->injectMouseWheelChange(static_cast<float>(rel));
+        this->protectedCall(boost::bind(&CEGUI::System::injectMouseWheelChange, _1, (float)rel));
     }
 
@@ -349 +400 @@
     }
 
+    /** Executes a CEGUI function normally, but catches CEGUI::ScriptException.
+        When a ScriptException occurs, the error message will be displayed and
+        the program carries on.
+    @remarks
+        The exception behaviour may pose problems if the code is not written
+        exception-safe (and you can forget about that in Lua). The program might
+        be left in an undefined state. But otherwise one script error would
+        terminate the whole program...
+    @note
+        Your life gets easier if you use boost::bind to create the object/function.
+    @param function
+        Any callable object/function that takes this->guiSystem_ as its only parameter.
+    @return
+        True if input was handled, false otherwise. A caught exception yields true.
+    */
+    template <typename FunctionType>
+    bool GUIManager::protectedCall(FunctionType function)
+    {
+        try
+        {
+            return function(this->guiSystem_);
+        }
+        catch (CEGUI::ScriptException& ex)
+        {
+            // Display the error and proceed. See @remarks why this can be dangerous.
+            COUT(1) << ex.getMessage() << std::endl;
+            return true;
+        }
+    }
+
     void GUIManager::subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function)
     {

code/trunk/src/libraries/core/GUIManager.h

@@ -41 +41 @@
 
 #include "util/OgreForwardRefs.h"
+#include "util/TriBool.h"
 #include "util/Singleton.h"
 #include "input/InputHandler.h"
+
+// Tolua includes (have to be relative to the current directory)
+/*
+$cfile "../util/TriBool.h" // tolua_export
+*/
 
 namespace orxonox // tolua_export
@@ -54 +60 @@
 
         The GUIManager is a singleton and can be called anywhere when access on the GUI is needed.
-        Creation of the GUIManager is therefore not possible and the cunstructor is private.
 
         Since the GUI needs user input, the GUIManager implements the functions needed to act as a key and/or mouse handler.
@@ -64 +69 @@
         friend class Singleton<GUIManager>;
     public:
-        GUIManager(Ogre::RenderWindow* renderWindow, const std::pair<int, int>& mousePosition, bool bFullScreen);
+        GUIManager(const std::pair<int, int>& mousePosition);
         ~GUIManager();
 
         void preUpdate(const Clock& time);
 
-        static void showGUI(const std::string& name, bool hidePrevious=false, bool showCursor=true);
-        void showGUIExtra(const std::string& name, const std::string& ptr, bool hidePrevious=false, bool showCursor=true);
+        void loadGUI(const std::string& name);
+        static void showGUI(const std::string& name, bool bHidePrevious = false);
+        void showGUIExtra(const std::string& name, const std::string& ptr, bool bHidePrevious = false);
         static void hideGUI(const std::string& name);
         void keyESC();
-        void setBackground(const std::string& name);
+        void setBackgroundImage(const std::string& imageSet, const std::string imageName); // tolua_export
+        void setBackgroundImage(const std::string& image);
+
+        //! Creates a new InputState to be used with a GUI Sheet
+        const std::string& createInputState(const std::string& name, TriBool::Value showCursor = TriBool::True, TriBool::Value useKeyboard = TriBool::True, bool bBlockJoyStick = false); // tolua_export
+
+        //! Returns the root window for all menu sheets
+        CEGUI::Window* getMenuRootWindow() { return this->menuRootWindow_; } // tolua_export
+        //! Returns the root window for all HUD sheets
+        CEGUI::Window* getHUDRootWindow() { return this->hudRootWindow_; } // tolua_export
 
         void setCamera(Ogre::Camera* camera);
         Ogre::Camera* getCamera() { return this->camera_; }
-
-        static GUIManager* getInstancePtr() { return singletonPtr_s; }
 
         inline void setPlayer(const std::string& guiname, PlayerInfo* player)
@@ -88 +101 @@
         static void subscribeEventHelper(CEGUI::Window* window, const std::string& event, const std::string& function); //tolua_export
 
+        static GUIManager& getInstance() { return Singleton<GUIManager>::getInstance(); } // tolua_export
+
     private:
         GUIManager(const GUIManager& instance); //!< private and undefined copy c'tor (this is a singleton class)
 
         void executeCode(const std::string& str);
+
+        template <typename FunctionType>
+        bool protectedCall(FunctionType function);
 
         // keyHandler functions
@@ -102 +120 @@
         void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
         void mouseScrolled (int abs, int rel);
-
         scoped_ptr<CEGUI::OgreCEGUIRenderer> guiRenderer_;      //!< CEGUI's interface to the Ogre Engine
         scoped_ptr<LuaState>                 luaState_;         //!< LuaState, access point to the Lua engine
@@ -108 +125 @@
         scoped_ptr<CEGUI::System>            guiSystem_;        //!< CEGUI's main system
         shared_ptr<ResourceInfo>             rootFileInfo_;     //!< Resource information about the root script
-        Ogre::RenderWindow*                  renderWindow_;     //!< Ogre's render window to give CEGUI access to it
         CEGUI::ResourceProvider*             resourceProvider_; //!< CEGUI's resource provider
         CEGUI::Logger*                       ceguiLogger_;      //!< CEGUI's logger to be able to log CEGUI errors in our log
-        std::map<std::string, PlayerInfo*>   players_;          //!< Stores the player (owner) for each gui
+        CEGUI::Window*                       rootWindow_;       //!< Root node for all windows
+        CEGUI::Window*                       hudRootWindow_;    //!< Root node for the HUD sheets
+        CEGUI::Window*                       menuRootWindow_;   //!< Root node for the menu sheets (used by Lua)
+        std::map<std::string, PlayerInfo*>   players_;          //!< Stores the player (owner) for each GUI
         Ogre::Camera*                        camera_;           //!< Camera used to render the scene with the GUI
 
         static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager
-        bool                                 bShowIngameGUI_;
 
     }; // tolua_export

code/trunk/src/libraries/core/Game.h

@@ -50 +50 @@
 #include "util/ScopeGuard.h"
 #include "util/Singleton.h"
-#include "core/OrxonoxClass.h"
+#include "OrxonoxClass.h"
 
 /**

code/trunk/src/libraries/core/IOConsole.cc

@@ -35 +35 @@
 #include "util/Clock.h"
 #include "util/Math.h"
-#include "core/Game.h"
-#include "core/input/InputBuffer.h"
+#include "Game.h"
+#include "input/InputBuffer.h"
 
 // ##########################

code/trunk/src/libraries/core/IOConsole.h

@@ -37 +37 @@
 #include <vector>
 #include "util/Singleton.h"
-#include "core/Shell.h"
+#include "Shell.h"
 
 #ifdef ORXONOX_PLATFORM_UNIX

code/trunk/src/libraries/core/LuaState.cc

@@ -37 +37 @@
 
 #include "util/Debug.h"
+#include "util/Exception.h"
+#include "util/ScopeGuard.h"
+#include "IOConsole.h"
 #include "Resource.h"
 #include "ToluaBindCore.h"
@@ -54 +57 @@
         // Create new lua state and configure it
         luaState_ = lua_open();
+        Loki::ScopeGuard luaStateGuard = Loki::MakeGuard(&lua_close, luaState_);
 #if LUA_VERSION_NUM == 501
         luaL_openlibs(luaState_);
@@ -78 +82 @@
 
         // Parse init script
-        this->doFile("LuaStateInit.lua");
+        if (!this->doFile("LuaStateInit.lua"))
+            ThrowException(InitialisationFailed, "Running LuaStateInit.lua failed");
+
+        luaStateGuard.Dismiss();
     }
 
@@ -96 +103 @@
     }
 
-    void LuaState::includeFile(const std::string& filename)
+    bool LuaState::includeFile(const std::string& filename)
     {
         shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
         if (sourceInfo != NULL)
-            this->includeString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
-        else
-            COUT(2) << "LuaState: Cannot include file '" << filename << "'." << std::endl;
-    }
-
-    void LuaState::includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
+            return this->includeString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
+        else
+        {
+            COUT(2) << "LuaState: Cannot include file '" << filename << "' (not found)." << std::endl;
+            return false;
+        }
+    }
+
+    bool LuaState::includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
     {
         // Parse string with provided include parser (otherwise don't preparse at all)
@@ -114 +124 @@
             luaInput = code;
 
-        this->doString(luaInput, sourceFileInfo);
-    }
-
-    void LuaState::doFile(const std::string& filename)
+        if (sourceFileInfo != NULL)
+        {
+            // Also fill a map with the actual source code. This is just for the include* commands
+            // where the content of sourceFileInfo->filename doesn't match 'code'
+            this->sourceCodeMap_[sourceFileInfo->filename] = code;
+        }
+
+        bool returnValue = this->doString(luaInput, sourceFileInfo);
+
+        if (sourceFileInfo != NULL)
+        {
+            // Delete source code entry
+            if (sourceFileInfo != NULL)
+                this->sourceCodeMap_.erase(sourceFileInfo->filename);
+        }
+
+        return returnValue;
+    }
+
+    bool LuaState::doFile(const std::string& filename)
     {
         shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
         if (sourceInfo != NULL)
-            this->doString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
-        else
-            COUT(2) << "LuaState: Cannot do file '" << filename << "'." << std::endl;
-    }
-
-    void LuaState::doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
+            return this->doString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
+        else
+        {
+            COUT(2) << "LuaState: Cannot do file '" << filename << "' (not found)." << std::endl;
+            return false;
+        }
+    }
+
+    bool LuaState::doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo)
     {
         // Save the old source file info
@@ -134 +163 @@
             sourceFileInfo_ = sourceFileInfo;
 
-        int error = 0;
+        std::string chunkname;
+        if (sourceFileInfo != NULL)
+        {
+            // Provide lua_load with the filename for debug purposes
+            // The '@' is a Lua convention to identify the chunk name as filename
+            chunkname = '@' + sourceFileInfo->filename;
+        }
+        else
+        {
+            // Use the code string to identify the chunk
+            chunkname = code;
+        }
+
+        // Push custom error handler that uses the debugger
+        lua_getglobal(this->luaState_, "errorHandler");
+        int errorHandler = lua_gettop(luaState_);
+        if (lua_isnil(this->luaState_, -1))
+        {
+            lua_pop(this->luaState_, 1);
+            errorHandler = 0;
+        }
+
 #if LUA_VERSION_NUM != 501
         LoadS ls;
         ls.s = code.c_str();
         ls.size = code.size();
-        error = lua_load(luaState_, &orxonox::LuaState::lua_Chunkreader, &ls, code.c_str());
+        int error = lua_load(luaState_, &orxonox::LuaState::lua_Chunkreader, &ls, chunkname.c_str());
 #else
-        error = luaL_loadstring(luaState_, code.c_str());
+        int error = luaL_loadbuffer(luaState_, code.c_str(), code.size(), chunkname.c_str());
 #endif
 
-        // execute the chunk
+        switch (error)
+        {
+        case LUA_ERRSYNTAX: // Syntax error
+            COUT(1) << "Lua syntax error: " << lua_tostring(luaState_, -1) << std::endl;
+            break;
+        case LUA_ERRMEM:    // Memory allocation error
+            COUT(1) << "Lua memory allocation error: Consult your dentist immediately!" << std::endl;
+            break;
+        }
+
         if (error == 0)
-            error = lua_pcall(luaState_, 0, 1, 0);
+        {
+            // Execute the chunk in protected mode with an error handler function (stack index)
+            error = lua_pcall(luaState_, 0, 1, errorHandler);
+
+            switch (error)
+            {
+            case LUA_ERRRUN: // Runtime error
+                if (errorHandler)
+                {
+                    // Do nothing (we already display the error in the
+                    // 'errorHandler' Lua function in LuaStateInit.lua)
+                }
+                else
+                {
+                    std::string errorString = lua_tostring(this->luaState_, -1);
+                    if (errorString.find("Error propagation") == std::string::npos)
+                        COUT(1) << "Lua runtime error: " << errorString << std::endl;
+                }
+                break;
+            case LUA_ERRERR: // Error in the error handler
+                COUT(1) << "Lua error in error handler. No message available." << std::endl;
+                break;
+            case LUA_ERRMEM: // Memory allocation error
+                COUT(1) << "Lua memory allocation error: Consult your dentist immediately!" << std::endl;
+                break;
+            }
+        }
+
         if (error != 0)
         {
-            std::string origin;
-            if (sourceFileInfo != NULL)
-                origin = " originating from " + sourceFileInfo_->filename;
-            COUT(1) << "Error in Lua-script" << origin << ": " << lua_tostring(luaState_, -1) << std::endl;
-            // return value is nil
-            lua_pushnil(luaState_);
-        }
-        // push return value because it will get lost since the return value of this function is void
+            lua_pop(luaState_, 1);  // Remove error message
+            lua_pushnil(luaState_); // Push a nil return value
+        }
+
+        if (errorHandler != 0)
+            lua_remove(luaState_, errorHandler); // Remove error handler from stack
+
+        // Set return value to a global variable because we cannot return a table in this function
+        // here. It would work for numbers, pointers and strings, but certainly not for Lua tables.
         lua_setglobal(luaState_, "LuaStateReturnValue");
 
         // Load the old info again
         sourceFileInfo_ = oldSourceFileInfo;
+
+        return (error == 0);
     }
 
@@ -180 +269 @@
         else
             return true;
+    }
+
+    //! Returns the content of a file
+    std::string LuaState::getSourceCode(const std::string& filename)
+    {
+        // Try the internal map first to get the actual Lua code
+        // and not just some pseudo Lua-XML code when using include* commands
+        std::map<std::string, std::string>::const_iterator it = this->sourceCodeMap_.find(filename);
+        if (it != this->sourceCodeMap_.end())
+            return it->second;
+        shared_ptr<ResourceInfo> info = Resource::getInfo(filename);
+        if (info == NULL)
+            return "";
+        else
+            return Resource::open(info)->getAsString();
+    }
+
+    bool LuaState::usingIOConsole() const
+    {
+        return IOConsole::exists();
     }
 

code/trunk/src/libraries/core/LuaState.h

@@ -40 +40 @@
 
 #include "util/ScopeGuard.h"
-#include "core/Functor.h"
+#include "Functor.h"
 #include "ToluaInterface.h"
 
@@ -71 +71 @@
         ~LuaState();
 
-        void doFile(const std::string& filename); // tolua_export
-        void doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
+        bool doFile(const std::string& filename); // tolua_export
+        bool doString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
 
-        void includeFile(const std::string& filename); // tolua_export
-        void includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
+        bool includeFile(const std::string& filename); // tolua_export
+        bool includeString(const std::string& code, const shared_ptr<ResourceInfo>& sourceFileInfo = shared_ptr<ResourceInfo>());
 
         void luaPrint(const std::string& str); // tolua_export
         void luaLog(unsigned int level, const std::string& message); // tolua_export
         bool fileExists(const std::string& filename); // tolua_export
+        std::string getSourceCode(const std::string& filename); // tolua_export
 
         const std::stringstream& getOutput() const { return output_; }
@@ -91 +92 @@
 
         Functor* createLuaFunctor(const std::string& code) { return new LuaFunctor(code, this); } // tolua_export
+        //! Tells about whether IOConsole was activated. The Lua debugger only works with a normal console.
+        bool usingIOConsole() const; // tolua_export
 
         static bool addToluaInterface(int (*function)(lua_State*), const std::string& name);
@@ -114 +117 @@
         bool bIsRunning_;
         shared_ptr<ResourceInfo> sourceFileInfo_;
+        std::map<std::string, std::string> sourceCodeMap_;
         std::string (*includeParseFunction_)(const std::string&);
 

code/trunk/src/libraries/core/Resource.cc

@@ -29 +29 @@
 #include "Resource.h"
 
+#include <boost/filesystem/path.hpp>
 #include <OgreException.h>
+#include <OgreFileSystem.h>
 #include <OgreResourceGroupManager.h>
 
@@ -89 +91 @@
                 ptr->group = group;
                 ptr->size = it->uncompressedSize;
+                if (dynamic_cast<Ogre::FileSystemArchive*>(it->archive) != NULL)
+                {
+                    boost::filesystem::path base(it->archive->getName());
+                    base /= it->filename;
+                    ptr->fileSystemPath = base.string();
+                }
                 return ptr;
             }

code/trunk/src/libraries/core/Resource.h

@@ -57 +57 @@
         //! Uncompressed size
         size_t size;
+        //! Absolute file path ("" for files not on filesystem)
+        std::string fileSystemPath;
     };
 

code/trunk/src/libraries/core/Template.cc

@@ -33 +33 @@
 
 #include "util/Debug.h"
-#include "core/CoreIncludes.h"
-#include "core/XMLPort.h"
+#include "CoreIncludes.h"
+#include "XMLPort.h"
 
 namespace orxonox

code/trunk/src/libraries/core/input/InputDevice.h

@@ -159 +159 @@
             for (unsigned int iB = 0; iB < pressedButtons_.size(); ++iB)
                 for (unsigned int iS = 0; iS < inputStates_.size(); ++iS)
-                    inputStates_[iS]->buttonEvent<ButtonEvent::THold, Traits>(
+                    inputStates_[iS]->buttonEvent<ButtonEvent::THold, typename Traits::ButtonTypeParam>(
                         this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(pressedButtons_[iB]));
 
@@ -196 +196 @@
             // Call states
             for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->buttonEvent<ButtonEvent::TPress, Traits>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+                inputStates_[i]->buttonEvent<ButtonEvent::TPress, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 
@@ -218 +218 @@
             // Call states
             for (unsigned int i = 0; i < inputStates_.size(); ++i)
-                inputStates_[i]->buttonEvent<ButtonEvent::TRelease, Traits>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
+                inputStates_[i]->buttonEvent<ButtonEvent::TRelease, typename Traits::ButtonTypeParam>(this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(button));
         }
 

code/trunk/src/libraries/core/input/InputHandler.h

@@ -112 +112 @@
         virtual ~InputHandler() { }
 
-        template<class T> void buttonEvent(unsigned int device, const T& button, ButtonEvent::TPress)
+        template<class T> void buttonEvent(unsigned int device, T button, ButtonEvent::TPress)
             { this->buttonPressed(button); }
-        template<class T> void buttonEvent(unsigned int device, const T& button, ButtonEvent::TRelease)
+        template<class T> void buttonEvent(unsigned int device, T button, ButtonEvent::TRelease)
             { this->buttonReleased(button); }
-        template<class T> void buttonEvent(unsigned int device, const T& button, ButtonEvent::THold)
+        template<class T> void buttonEvent(unsigned int device, T button, ButtonEvent::THold)
             { this->buttonHeld(button); }
-        void buttonEvent(unsigned int device, JoyStickButtonCode::ByEnum button, ButtonEvent::TPress)
-            { this->buttonPressed(device - InputDeviceEnumerator::FirstJoyStick, button); }
-        void buttonEvent(unsigned int device, JoyStickButtonCode::ByEnum button, ButtonEvent::TRelease)
-            { this->buttonReleased(device - InputDeviceEnumerator::FirstJoyStick, button); }
-        void buttonEvent(unsigned int device, JoyStickButtonCode::ByEnum button, ButtonEvent::THold)
-            { this->buttonHeld(device - InputDeviceEnumerator::FirstJoyStick, button); }
 
         virtual void buttonPressed (const KeyEvent& evt) { }
@@ -149 +143 @@
         static InputHandler EMPTY;
     };
+
+    template<> inline void InputHandler::buttonEvent<JoyStickButtonCode::ByEnum>(unsigned int device, JoyStickButtonCode::ByEnum button, ButtonEvent::TPress)
+        { this->buttonPressed(device - InputDeviceEnumerator::FirstJoyStick, button); }
+    template<> inline void InputHandler::buttonEvent<JoyStickButtonCode::ByEnum>(unsigned int device, JoyStickButtonCode::ByEnum button, ButtonEvent::TRelease)
+        { this->buttonReleased(device - InputDeviceEnumerator::FirstJoyStick, button); }
+    template<> inline void InputHandler::buttonEvent<JoyStickButtonCode::ByEnum>(unsigned int device, JoyStickButtonCode::ByEnum button, ButtonEvent::THold)
+        { this->buttonHeld(device - InputDeviceEnumerator::FirstJoyStick, button); }
 }
 

code/trunk/src/libraries/core/input/InputManager.cc

@@ -87 +87 @@
         , oisInputManager_(0)
         , devices_(2)
-        , mouseMode_(MouseMode::Nonexclusive)
+        , exclusiveMouse_(TriBool::False)
         , emptyState_(0)
         , calibratorCallbackHandler_(0)
@@ -95 +95 @@
         CCOUT(4) << "Constructing..." << std::endl;
 
+        // Allocate space for the function call buffer
+        this->callBuffer_.reserve(16);
+
         this->setConfigValues();
 
         if (GraphicsManager::getInstance().isFullScreen())
-            mouseMode_ = MouseMode::Exclusive;
+            exclusiveMouse_ = TriBool::True;
         this->loadDevices();
 
@@ -155 +158 @@
         paramList.insert(std::make_pair("w32_keyboard", "DISCL_FOREGROUND"));
         paramList.insert(std::make_pair("w32_mouse", "DISCL_FOREGROUND"));
-        if (mouseMode_ == MouseMode::Exclusive || GraphicsManager::getInstance().isFullScreen())
+        if (exclusiveMouse_ == TriBool::True || GraphicsManager::getInstance().isFullScreen())
         {
             // Disable Windows key plus special keys (like play, stop, next, etc.)
@@ -168 +171 @@
         paramList.insert(std::make_pair("XAutoRepeatOn", "true"));
 
-        if (mouseMode_ == MouseMode::Exclusive || GraphicsManager::getInstance().isFullScreen())
+        if (exclusiveMouse_ == TriBool::True || GraphicsManager::getInstance().isFullScreen())
         {
             if (CommandLineParser::getValue("keyboard_no_grab").getBool())
@@ -266 +269 @@
         CCOUT(3) << "Destroying..." << std::endl;
 
+        // Leave all active InputStates (except "empty")
+        while (this->activeStates_.size() > 1)
+            this->leaveState(this->activeStates_.rbegin()->second->getName());
+        this->activeStates_.clear();
+
         // Destroy calibrator helper handler and state
         this->destroyState("calibrator");
         // Destroy KeyDetector and state
         calibratorCallbackHandler_->destroy();
-        // destroy the empty InputState
+        // Destroy the empty InputState
         this->destroyStateInternal(this->emptyState_);
 
-        // destroy all user InputStates
+        // Destroy all user InputStates
         while (statesByName_.size() > 0)
             this->destroyStateInternal(statesByName_.rbegin()->second);
@@ -335 +343 @@
     void InputManager::reload()
     {
-        if (internalState_ & Ticking)
-        {
-            // We cannot destroy OIS right now, because reload was probably
-            // caused by a user clicking on a GUI item. The stack trace would then
-            // include an OIS method. So it would be a very bad thing to destroy it..
-            internalState_ |= ReloadRequest;
-        }
-        else if (internalState_ & Calibrating)
+        if (internalState_ & Calibrating)
             CCOUT(2) << "Warning: Cannot reload input system. Joy sticks are currently being calibrated." << std::endl;
         else
@@ -351 +352 @@
     void InputManager::reloadInternal()
     {
-        CCOUT(3) << "Reloading ..." << std::endl;
+        CCOUT(4) << "Reloading ..." << std::endl;
 
         this->destroyDevices();
@@ -357 +358 @@
 
         internalState_ &= ~Bad;
-        internalState_ &= ~ReloadRequest;
         CCOUT(4) << "Reloading complete." << std::endl;
     }
@@ -370 +370 @@
         if (internalState_ & Bad)
             ThrowException(General, "InputManager was not correctly reloaded.");
-
-        else if (internalState_ & ReloadRequest)
-            reloadInternal();
-
-        // check for states to leave
-        if (!stateLeaveRequests_.empty())
-        {
-            for (std::set<InputState*>::iterator it = stateLeaveRequests_.begin();
-                it != stateLeaveRequests_.end(); ++it)
-            {
-                (*it)->left();
-                // just to be sure that the state actually is registered
-                assert(statesByName_.find((*it)->getName()) != statesByName_.end());
-
-                activeStates_.erase((*it)->getPriority());
-                if ((*it)->getPriority() < InputStatePriority::HighPriority)
-                    (*it)->setPriority(0);
-                updateActiveStates();
-            }
-            stateLeaveRequests_.clear();
-        }
-
-        // check for states to enter
-        if (!stateEnterRequests_.empty())
-        {
-            for (std::set<InputState*>::const_iterator it = stateEnterRequests_.begin();
-                it != stateEnterRequests_.end(); ++it)
-            {
-                // just to be sure that the state actually is registered
-                assert(statesByName_.find((*it)->getName()) != statesByName_.end());
-
-                if ((*it)->getPriority() == 0)
-                {
-                    // Get smallest possible priority between 1 and maxStateStackSize_s
-                    for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
-                        rit != activeStates_.rend(); ++rit)
-                    {
-                        if (rit->first < InputStatePriority::HighPriority)
-                        {
-                            (*it)->setPriority(rit->first + 1);
-                            break;
-                        }
-                    }
-                    // In case no normal handler was on the stack
-                    if ((*it)->getPriority() == 0)
-                        (*it)->setPriority(1);
-                }
-                activeStates_[(*it)->getPriority()] = (*it);
-                updateActiveStates();
-                (*it)->entered();
-            }
-            stateEnterRequests_.clear();
-        }
-
-        // check for states to destroy
-        if (!stateDestroyRequests_.empty())
-        {
-            for (std::set<InputState*>::iterator it = stateDestroyRequests_.begin();
-                it != stateDestroyRequests_.end(); ++it)
-            {
-                destroyStateInternal((*it));
-            }
-            stateDestroyRequests_.clear();
-        }
 
         // check whether a state has changed its EMPTY situation
@@ -448 +384 @@
             updateActiveStates();
 
-        // mark that we now start capturing and distributing input
-        internalState_ |= Ticking;
-
-        // Capture all the input and handle it
+        // Capture all the input and collect the function calls
+        // No event gets triggered here yet!
         BOOST_FOREACH(InputDevice* device, devices_)
             if (device != NULL)
                 device->update(time);
 
-        // Update the states
+        // Collect function calls for the update
         for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
             activeStatesTicked_[i]->update(time.getDeltaTime());
 
-        internalState_ &= ~Ticking;
+        // Execute all cached function calls in order
+        // Why so complicated? The problem is that an InputHandler could trigger
+        // a reload that would destroy the OIS devices or it could even leave and
+        // then destroy its own InputState. That would of course lead to access
+        // violations.
+        // If we delay the calls, then OIS and and the InputStates are not anymore
+        // in the call stack and can therefore be edited.
+        for (size_t i = 0; i < this->callBuffer_.size(); ++i)
+            this->callBuffer_[i]();
+
+        this->callBuffer_.clear();
     }
 
@@ -470 +414 @@
     void InputManager::updateActiveStates()
     {
-        assert((internalState_ & InputManager::Ticking) == 0);
-        // temporary resize
+        // Calculate the stack of input states
+        // and assign it to the corresponding device
         for (unsigned int i = 0; i < devices_.size(); ++i)
         {
@@ -490 +434 @@
         }
 
-        // update tickables (every state will only appear once)
-        // Using a std::set to avoid duplicates
+        // See that we only update each InputState once for each device
+        // Using an std::set to avoid duplicates
         std::set<InputState*> tempSet;
         for (unsigned int i = 0; i < devices_.size(); ++i)
@@ -498 +442 @@
                     tempSet.insert(devices_[i]->getStateListRef()[iState]);
 
-        // copy the content of the std::set back to the actual vector
+        // Copy the content of the std::set back to the actual vector
         activeStatesTicked_.clear();
         for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
@@ -504 +448 @@
 
         // Check whether we have to change the mouse mode
-        MouseMode::Value requestedMode = MouseMode::Dontcare;
+        TriBool::Value requestedMode = TriBool::Dontcare;
         std::vector<InputState*>& mouseStates = devices_[InputDeviceEnumerator::Mouse]->getStateListRef();
         if (mouseStates.empty())
-            requestedMode = MouseMode::Nonexclusive;
-        else
-            requestedMode = mouseStates.front()->getMouseMode();
-        if (requestedMode != MouseMode::Dontcare && mouseMode_ != requestedMode)
-        {
-            mouseMode_ = requestedMode;
+            requestedMode = TriBool::False;
+        else
+            requestedMode = mouseStates.front()->getMouseExclusive();
+        if (requestedMode != TriBool::Dontcare && exclusiveMouse_ != requestedMode)
+        {
+            exclusiveMouse_ = requestedMode;
             if (!GraphicsManager::getInstance().isFullScreen())
                 this->reloadInternal();
@@ -622 +566 @@
         // get pointer from the map with all stored handlers
         std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
-        if (it != statesByName_.end())
-        {
-            // exists
-            if (activeStates_.find(it->second->getPriority()) == activeStates_.end())
-            {
-                // not active
-                if (stateDestroyRequests_.find(it->second) == stateDestroyRequests_.end())
+        if (it != statesByName_.end() && activeStates_.find(it->second->getPriority()) == activeStates_.end())
+        {
+            // exists and not active
+            if (it->second->getPriority() == 0)
+            {
+                // Get smallest possible priority between 1 and maxStateStackSize_s
+                for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
+                    rit != activeStates_.rend(); ++rit)
                 {
-                    // not scheduled for destruction
-                    // prevents a state from being added multiple times
-                    stateEnterRequests_.insert(it->second);
-                    return true;
+                    if (rit->first < InputStatePriority::HighPriority)
+                    {
+                        it->second->setPriority(rit->first + 1);
+                        break;
+                    }
                 }
-            }
-            else if (this->stateLeaveRequests_.find(it->second) != this->stateLeaveRequests_.end())
-            {
-                // State already scheduled for leaving --> cancel
-                this->stateLeaveRequests_.erase(this->stateLeaveRequests_.find(it->second));
-            }
+                // In case no normal handler was on the stack
+                if (it->second->getPriority() == 0)
+                    it->second->setPriority(1);
+            }
+            activeStates_[it->second->getPriority()] = it->second;
+            updateActiveStates();
+            it->second->entered();
+
+            return true;
         }
         return false;
@@ -654 +603 @@
         // get pointer from the map with all stored handlers
         std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
-        if (it != statesByName_.end())
-        {
-            // exists
-            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
-            {
-                // active
-                stateLeaveRequests_.insert(it->second);
-                return true;
-            }
-            else if (this->stateEnterRequests_.find(it->second) != this->stateEnterRequests_.end())
-            {
-                // State already scheduled for entering --> cancel
-                this->stateEnterRequests_.erase(this->stateEnterRequests_.find(it->second));
-            }
+        if (it != statesByName_.end() && activeStates_.find(it->second->getPriority()) != activeStates_.end())
+        {
+            // exists and active
+
+            it->second->left();
+
+            activeStates_.erase(it->second->getPriority());
+            if (it->second->getPriority() < InputStatePriority::HighPriority)
+                it->second->setPriority(0);
+            updateActiveStates();
+
+            return true;
         }
         return false;
@@ -682 +629 @@
         if (it != statesByName_.end())
         {
-            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
-            {
-                // The state is still active. We have to postpone
-                stateLeaveRequests_.insert(it->second);
-                stateDestroyRequests_.insert(it->second);
-            }
-            else if (this->internalState_ & Ticking)
-            {
-                // cannot remove state while ticking
-                stateDestroyRequests_.insert(it->second);
-            }
-            else
-                destroyStateInternal(it->second);
+            this->leaveState(name);
+            destroyStateInternal(it->second);
 
             return true;
@@ -704 +640 @@
     void InputManager::destroyStateInternal(InputState* state)
     {
-        assert(state && !(this->internalState_ & Ticking));
-        std::map<int, InputState*>::iterator it = this->activeStates_.find(state->getPriority());
-        if (it != this->activeStates_.end())
-        {
-            this->activeStates_.erase(it);
-            updateActiveStates();
-        }
+        assert(state && this->activeStates_.find(state->getPriority()) == this->activeStates_.end());
         statesByName_.erase(state->getName());
         state->destroy();

code/trunk/src/libraries/core/input/InputManager.h

@@ -36 +36 @@
 #include <string>
 #include <vector>
+#include <boost/function.hpp>
 
 #include "util/Singleton.h"
+#include "util/TriBool.h"
 #include "core/WindowEventListener.h"
-#include "InputState.h"
 
 // tolua_begin
@@ -75 +76 @@
             Nothing       = 0x00,
             Bad           = 0x02,
-            Ticking       = 0x04,
-            Calibrating   = 0x08,
-            ReloadRequest = 0x10,
+            Calibrating   = 0x04,
         };
 
@@ -159 +158 @@
             - The removal process is being postponed if InputManager::preUpdate() is currently running.
         */
-        bool destroyState(const std::string& name);
+        bool destroyState(const std::string& name); // tolua_export
 
         //-------------------------------
@@ -169 +168 @@
         //! Returns a pointer to the OIS InputManager. Only you if you know what you're doing!
         OIS::InputManager* getOISInputManager() { return this->oisInputManager_; }
+        //! Returns the position of the cursor as std::pair of ints
         std::pair<int, int> getMousePosition() const;
+        //! Tells whether the mouse is used exclusively to the game
+        bool isMouseExclusive() const { return this->exclusiveMouse_; } // tolua_export
+
+        //-------------------------------
+        // Function call caching
+        //-------------------------------
+        void pushCall(const boost::function<void ()>& function)
+            { this->callBuffer_.push_back(function); }
 
         static InputManager& getInstance() { return Singleton<InputManager>::getInstance(); } // tolua_export
@@ -196 +204 @@
         OIS::InputManager*                  oisInputManager_;      //!< OIS input manager
         std::vector<InputDevice*>           devices_;              //!< List of all input devices (keyboard, mouse, joy sticks)
-        MouseMode::Value                    mouseMode_;            //!< Currently applied mouse mode
+        TriBool::Value                      exclusiveMouse_;       //!< Currently applied mouse mode
 
         // some internally handled states and handlers
@@ -207 +215 @@
         std::vector<InputState*>            activeStatesTicked_;   //!< Like activeStates_, but only contains the ones that currently receive events
 
-        std::set<InputState*>               stateEnterRequests_;   //!< Requests to enter a new state
-        std::set<InputState*>               stateLeaveRequests_;   //!< Requests to leave a running state
-        std::set<InputState*>               stateDestroyRequests_; //!< Requests to destroy a state
+        std::vector<boost::function<void ()> > callBuffer_;        //!< Caches all calls from InputStates to be executed afterwards (see preUpdate)
 
         static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton

code/trunk/src/libraries/core/input/InputPrereqs.h

@@ -42 +42 @@
 #include <ois/OISMouse.h>
 #include <ois/OISJoyStick.h>
+#include "util/OrxEnum.h"
 
 namespace orxonox
@@ -448 +449 @@
         };
     }
+
+    //! Enumeration wrapper for input state priorities
+    struct InputStatePriority : OrxEnum<InputStatePriority>
+    {
+        OrxEnumConstructors(InputStatePriority);
+
+        static const int Empty        = -1;
+        static const int Dynamic      = 0;
+
+        static const int HighPriority = 1000;
+        static const int Console      = HighPriority + 0;
+        static const int Calibrator   = HighPriority + 1;
+        static const int Detector     = HighPriority + 2;
+    };
 }
 

code/trunk/src/libraries/core/input/InputState.cc

@@ -37 +37 @@
         , bAlwaysGetsInput_(bAlwaysGetsInput)
         , bTransparent_(bTransparent)
-        , mouseMode_(MouseMode::Dontcare)
+        , exclusiveMouse_(TriBool::Dontcare)
         , bExpired_(true)
         , handlers_(2)

code/trunk/src/libraries/core/input/InputState.h

@@ -35 +35 @@
 #include <string>
 #include <vector>
-
-#include "util/OrxEnum.h"
+#include <boost/function.hpp>
+#include <boost/bind.hpp>
+
+#include "util/TriBool.h"
 #include "InputHandler.h"
+#include "InputManager.h"
 #include "JoyStickQuantityListener.h"
+
+#define INPUT_STATE_PUSH_CALL(deviceIndex, functionName, ...) \
+    InputManager::getInstance().pushCall(boost::function<void ()>(boost::bind(&InputHandler::functionName, handlers_[deviceIndex], __VA_ARGS__)))
 
 namespace orxonox
 {
-    //! Enumeration wrapper for input state priorities
-    struct InputStatePriority : OrxEnum<InputStatePriority>
-    {
-        OrxEnumConstructors(InputStatePriority);
-
-        static const int Empty        = -1;
-        static const int Dynamic      = 0;
-
-        static const int HighPriority = 1000;
-        static const int Console      = HighPriority + 0;
-        static const int Calibrator   = HighPriority + 1;
-        static const int Detector     = HighPriority + 2;
-    };
-
-    namespace MouseMode
-    {
-        enum Value
-        {
-            Exclusive,
-            Nonexclusive,
-            Dontcare
-        };
-    }
-
     /**
     @brief
@@ -73 +55 @@
         that stack and only the top one gets the input events. This is done for
         every device (keyboard, mouse, all joy sticks) separately to allow
-        for intance keyboard input capturing for the console while you can still
+        for instance keyboard input capturing for the console while you can still
         steer a ship with the mouse.
         There are two exceptions to this behaviour though:
@@ -83 +65 @@
           the state will always receive input as long as it is activated.
         - Note: If you mark an InputState with both parameters on, then it will
-          not influence ony other InputState at all.
+          not influence only other InputState at all.
 
     @par Priorities
@@ -95 +77 @@
     @par Exclusive/Non-Exclusive mouse Mode
         You can select a specific mouse mode that tells whether the application
-        should have exclusive accessto it or not.
+        should have exclusive access to it or not.
         When in non-exclusive mode, you can move the mouse out of the window
         like with any other normal window (only for windowed mode!).
@@ -130 +112 @@
         void setHandler        (InputHandler* handler);
 
-        void setMouseMode(MouseMode::Value value) { mouseMode_ = value; this->bExpired_ = true; }
-        MouseMode::Value getMouseMode() const { return mouseMode_; }
+        void setMouseExclusive(TriBool::Value value) { exclusiveMouse_ = value; this->bExpired_ = true; }
+        TriBool::Value getMouseExclusive() const { return exclusiveMouse_; }
 
         //! Returns the name of the state (which is unique!)
@@ -152 +134 @@
 
         //! Generic function that distributes all 9 button events
-        template <typename EventType, class Traits>
-        void buttonEvent(unsigned int device, const typename Traits::ButtonTypeParam button);
+        template <typename EventType, class ButtonTypeParam>
+        void buttonEvent(unsigned int device, ButtonTypeParam button);
 
         //! Event handler
@@ -184 +166 @@
         const bool                  bAlwaysGetsInput_;      //!< See class declaration for explanation
         const bool                  bTransparent_;          //!< See class declaration for explanation
-        MouseMode::Value            mouseMode_;             //!< See class declaration for explanation
+        TriBool::Value              exclusiveMouse_;        //!< See class declaration for explanation
         int                         priority_;              //!< Current priority (might change)
         bool                        bExpired_;              //!< See hasExpired()
@@ -198 +180 @@
         for (unsigned int i = 0; i < handlers_.size(); ++i)
             if (handlers_[i] != NULL)
-                handlers_[i]->allDevicesUpdated(dt);
+                INPUT_STATE_PUSH_CALL(i, allDevicesUpdated, dt);
     }
 
@@ -207 +189 @@
         case InputDeviceEnumerator::Keyboard:
             if (handlers_[keyboardIndex_s] != NULL)
-                handlers_[keyboardIndex_s]->keyboardUpdated(dt);
+                INPUT_STATE_PUSH_CALL(keyboardIndex_s, keyboardUpdated, dt);
             break;
 
         case InputDeviceEnumerator::Mouse:
             if (handlers_[mouseIndex_s] != NULL)
-                handlers_[mouseIndex_s]->mouseUpdated(dt);
+                INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseUpdated, dt);
             break;
 
         default: // joy sticks
             if (handlers_[device] != NULL)
-                handlers_[device]->joyStickUpdated(device - firstJoyStickIndex_s, dt);
+                INPUT_STATE_PUSH_CALL(device, joyStickUpdated, device - firstJoyStickIndex_s, dt);
             break;
         }
     }
 
-    template <typename EventType, class Traits>
-    FORCEINLINE void InputState::buttonEvent(unsigned int device, const typename Traits::ButtonTypeParam button)
+    template <typename EventType, class ButtonTypeParam>
+    FORCEINLINE void InputState::buttonEvent(unsigned int device, ButtonTypeParam button)
     {
         assert(device < handlers_.size());
         if (handlers_[device] != NULL)
-            handlers_[device]->buttonEvent(device, button, EventType());
+        {
+            // We have to store the function pointer to tell the compiler about its actual type because of overloading
+            void (InputHandler::*function)(unsigned int, ButtonTypeParam, EventType) = &InputHandler::buttonEvent<ButtonTypeParam>;
+            InputManager::getInstance().pushCall(boost::function<void ()>(boost::bind(function, handlers_[device], device, button, EventType())));
+        }
     }
 
@@ -233 +219 @@
     {
         if (handlers_[mouseIndex_s] != NULL)
-            handlers_[mouseIndex_s]->mouseMoved(abs, rel, clippingSize);
+            INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseMoved, abs, rel, clippingSize);
     }
 
@@ -239 +225 @@
     {
         if (handlers_[mouseIndex_s] != NULL)
-            handlers_[mouseIndex_s]->mouseScrolled(abs, rel);
+            INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseScrolled, abs, rel);
     }
 
@@ -246 +232 @@
         assert(device < handlers_.size());
         if (handlers_[device] != NULL)
-            handlers_[device]->axisMoved(device - firstJoyStickIndex_s, axis, value);
+            INPUT_STATE_PUSH_CALL(device, axisMoved, device - firstJoyStickIndex_s, axis, value);
     }
 }

code/trunk/src/libraries/network/TrafficControl.h

@@ -34 +34 @@
 #include <list>
 #include <map>
-#include "network/ClientConnectionListener.h"
+#include "ClientConnectionListener.h"
 
 namespace orxonox {

code/trunk/src/libraries/util/Serialise.h

@@ -35 +35 @@
 #define _Serialise_H__
 
+#include "UtilPrereqs.h"
+
 #include <cstring>
-#include "util/Math.h"
-#include "util/mbool.h"
+#include "Math.h"
+#include "mbool.h"
 
 namespace orxonox{

code/trunk/src/libraries/util/Singleton.h

@@ -49 +49 @@
     public:
         //! Returns a reference to the singleton instance
-        static T& getInstance()
+        FORCEINLINE static T& getInstance()
         {
             assert(T::singletonPtr_s != NULL);
@@ -56 +56 @@
 
         //! Tells whether the singleton has been created
-        static bool exists()
+        FORCEINLINE static bool exists()
         {
             return (T::singletonPtr_s != NULL);
@@ -62 +62 @@
 
         //! Update method called by ClassSingletonManager (if used)
-        void preUpdateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->preUpdate(time); }
+        FORCEINLINE void preUpdateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->preUpdate(time); }
         //! Empty update method for the static polymorphism
-        void preUpdate(const Clock& time) { }
+        FORCEINLINE void preUpdate(const Clock& time) { }
         //! Update method called by ClassSingletonManager (if used)
-        void postUpdateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->postUpdate(time); }
+        FORCEINLINE void postUpdateSingleton(const Clock& time) { static_cast<T*>(T::singletonPtr_s)->postUpdate(time); }
         //! Empty update method for the static polymorphism
-        void postUpdate(const Clock& time) { }
+        FORCEINLINE void postUpdate(const Clock& time) { }
 
     protected:

code/trunk/src/modules/pickup/PickupManager.cc

@@ -152 +152 @@
     PickupCarrier* PickupManager::getPawn(void)
     {
-        Pawn* pawn = dynamic_cast<Pawn*>(GUIManager::getInstancePtr()->getPlayer(PickupManager::guiName_s)->getControllableEntity());
+        Pawn* pawn = dynamic_cast<Pawn*>(GUIManager::getInstance().getPlayer(PickupManager::guiName_s)->getControllableEntity());
         if(pawn == NULL)
             return NULL;

code/trunk/src/modules/questsystem/QuestGUI.cc

@@ -109 +109 @@
 
         //! Create root window.
-        this->rootWindow_ = this->windowManager_->createWindow("TaharezLook/ScrollablePane", "QuestGUI/Quests");
+        this->rootWindow_ = this->windowManager_->createWindow("MenuWidgets/ScrollablePane", "QuestGUI/Quests");
         this->rootWindow_->setSize(CEGUI::UVector2(CEGUI::UDim(1, 0),CEGUI::UDim(1, 0)));
 
@@ -161 +161 @@
         Get a CEGUI Window to use.
         Windows that are no longer used are collected with giveWindow, and are given out again with getWindow, so save some time recreating new windows everytime.
-        The retreived window is of type "TaharezLook/TabButton".
-    @return
-        Returns a CEGUI Window of type "TaharezLook/TabButton".
+        The retreived window is of type "MenuWidgets/TabButton".
+    @return
+        Returns a CEGUI Window of type "MenuWidgets/TabButton".
     */
     CEGUI::Window* QuestGUI::getWindow(void)
@@ -177 +177 @@
         std::ostringstream stream;
         stream << "QuestGUI/Quests/EmptyWindows/" << this->windows_.size()+1;
-        return this->windowManager_->createWindow("TaharezLook/TabButton", stream.str());
+        return this->windowManager_->createWindow("MenuWidgets/TabButton", stream.str());
     }
 

code/trunk/src/modules/questsystem/QuestGUINode.cc

@@ -160 +160 @@
             stream << this->window_->getName() << "/Details";
             const QuestDescription* description = this->item_->getDescription();
-            this->details_ = this->gui_->getWindowManager()->createWindow("TaharezLook/FrameWindow", stream.str());
+            this->details_ = this->gui_->getWindowManager()->createWindow("MenuWidgets/FrameWindow", stream.str());
             this->details_->setSize(CEGUI::UVector2(CEGUI::UDim(0.7f, 0),CEGUI::UDim(0.7f, 0)));
             this->details_->setPosition(CEGUI::UVector2(CEGUI::UDim(0.1f, 0),CEGUI::UDim(0.1f, 0)));
@@ -171 +171 @@
             //! Create a ScrollablePane.
             stream << "/Scrollable";
-            CEGUI::Window* window = this->gui_->getWindowManager()->createWindow("TaharezLook/ScrollablePane", stream.str());
+            CEGUI::Window* window = this->gui_->getWindowManager()->createWindow("MenuWidgets/ScrollablePane", stream.str());
             window->setSize(CEGUI::UVector2(CEGUI::UDim(1.0, -2*QuestGUINode::BORDER_WIDTH),CEGUI::UDim(1.0, -QuestGUINode::TITLE_HEIGHT)));
             window->setPosition(CEGUI::UVector2(CEGUI::UDim(0, (float)QuestGUINode::BORDER_WIDTH),CEGUI::UDim(0, (float)QuestGUINode::TITLE_HEIGHT)));
@@ -185 +185 @@
                 stream.str("");
                 stream << this->details_->getName() << "/Status";
-                CEGUI::Window* statusWindow = this->gui_->getWindowManager()->createWindow("TaharezLook/StaticText", stream.str());
+                CEGUI::Window* statusWindow = this->gui_->getWindowManager()->createWindow("MenuWidgets/StaticText", stream.str());
                 window->addChildWindow(statusWindow);
                 std::string status;
@@ -214 +214 @@
             stream << this->details_->getName() << "/Description";
             stream << "/Title";
-            CEGUI::Window* descriptionWindowTitle = this->gui_->getWindowManager()->createWindow("TaharezLook/StaticText", stream.str());
+            CEGUI::Window* descriptionWindowTitle = this->gui_->getWindowManager()->createWindow("MenuWidgets/StaticText", stream.str());
             window->addChildWindow(descriptionWindowTitle);
             descriptionWindowTitle->setProperty("HorzFormatting", "HorzCentred");
@@ -227 +227 @@
             stream.str("");
             stream << this->details_->getName() << "/Description";
-            CEGUI::Window* descriptionWindow = this->gui_->getWindowManager()->createWindow("TaharezLook/StaticText", stream.str());
+            CEGUI::Window* descriptionWindow = this->gui_->getWindowManager()->createWindow("MenuWidgets/StaticText", stream.str());
             window->addChildWindow(descriptionWindow);
             descriptionWindow->setProperty("HorzFormatting", "WordWrapLeftAligned");
@@ -250 +250 @@
                             stream.str("");
                             stream << this->details_->getName() << "/Hints/Title";
-                            CEGUI::Window* hintsTitle = this->gui_->getWindowManager()->createWindow("TaharezLook/StaticText", stream.str());
+                            CEGUI::Window* hintsTitle = this->gui_->getWindowManager()->createWindow("MenuWidgets/StaticText", stream.str());
                             window->addChildWindow(hintsTitle);
                             hintsTitle->setProperty("HorzFormatting", "HorzCentred");

code/trunk/src/orxonox/CameraManager.h

@@ -61 +61 @@
             void useCamera(Ogre::Camera* camera);
 
-            static CameraManager* getInstancePtr() { return singletonPtr_s; }
-
         private:
             CameraManager(const CameraManager&); // don't use

code/trunk/src/orxonox/Level.cc

@@ -58 +58 @@
         if (this->isInitialized())
         {
-            if (LevelManager::getInstancePtr())
+            if (LevelManager::exists())
                 LevelManager::getInstance().releaseActivity(this);
 
@@ -116 +116 @@
             (*it)->setGametype(rootgametype);
 
-        if (LevelManager::getInstancePtr())
+        if (LevelManager::exists())
             LevelManager::getInstance().requestActivity(this);
     }

code/trunk/src/orxonox/LevelManager.h

@@ -62 +62 @@
             const std::string& getAvailableLevelListItem(unsigned int index) const; //tolua_export
 
-            static LevelManager* getInstancePtr() { return singletonPtr_s; }
             static LevelManager& getInstance()    { return Singleton<LevelManager>::getInstance(); } // tolua_export
 

code/trunk/src/orxonox/PlayerManager.cc

@@ -66 +66 @@
             this->clients_[clientID] = player;
 
-            if (LevelManager::getInstancePtr() && LevelManager::getInstance().getActiveLevel())
+            if (LevelManager::exists() && LevelManager::getInstance().getActiveLevel())
                 LevelManager::getInstance().getActiveLevel()->playerEntered(player);
         }
@@ -82 +82 @@
             this->clients_.erase(clientID);
 
-            if (LevelManager::getInstancePtr() && LevelManager::getInstance().getActiveLevel())
+            if (LevelManager::exists() && LevelManager::getInstance().getActiveLevel())
                 LevelManager::getInstance().getActiveLevel()->playerLeft(player);
 

code/trunk/src/orxonox/gamestates/GSLevel.cc

@@ -69 +69 @@
         {
             gameInputState_ = InputManager::getInstance().createInputState("game");
-            gameInputState_->setMouseMode(MouseMode::Exclusive);
+            gameInputState_->setMouseExclusive(TriBool::True);
             gameInputState_->setHandler(KeyBinderManager::getInstance().getDefaultAsHandler());
             KeyBinderManager::getInstance().setToDefault();
 
             guiMouseOnlyInputState_ = InputManager::getInstance().createInputState("guiMouseOnly");
-            guiMouseOnlyInputState_->setMouseMode(MouseMode::Exclusive);
-            guiMouseOnlyInputState_->setMouseHandler(GUIManager::getInstancePtr());
+            guiMouseOnlyInputState_->setMouseExclusive(TriBool::True);
+            guiMouseOnlyInputState_->setMouseHandler(&GUIManager::getInstance());
 
             guiKeysOnlyInputState_ = InputManager::getInstance().createInputState("guiKeysOnly");
-            guiKeysOnlyInputState_->setKeyHandler(GUIManager::getInstancePtr());
+            guiKeysOnlyInputState_->setKeyHandler(&GUIManager::getInstance());
         }
 

code/trunk/src/orxonox/gamestates/GSMainMenu.cc

@@ -31 +31 @@
 #include <OgreSceneManager.h>
 
-#include "core/input/InputManager.h"
-#include "core/input/InputState.h"
 #include "core/input/KeyBinderManager.h"
 #include "core/Game.h"
@@ -42 +40 @@
 #include "Scene.h"
 #include "sound/AmbientSound.h"
+// HACK
+#include "core/input/InputManager.h"
+#include "core/input/InputState.h"
 
 namespace orxonox
@@ -49 +50 @@
     GSMainMenu::GSMainMenu(const GameStateInfo& info)
         : GameState(info)
-        , inputState_(0)
     {
         RegisterRootObject(GSMainMenu);
-        inputState_ = InputManager::getInstance().createInputState("mainMenu");
-        inputState_->setMouseMode(MouseMode::Nonexclusive);
-        inputState_->setHandler(GUIManager::getInstancePtr());
-        inputState_->setKeyHandler(KeyBinderManager::getInstance().getDefaultAsHandler());
-        inputState_->setJoyStickHandler(&InputHandler::EMPTY);
+
+        InputManager::getInstance().createInputState("MainMenuHackery")->setKeyHandler(KeyBinderManager::getInstance().getDefaultAsHandler());
 
         // create an empty Scene
@@ -76 +73 @@
             this->ambient_->destroy();
 
-        InputManager::getInstance().destroyState("mainMenu");
+        InputManager::getInstance().destroyState("MainMenuHackery");
 
         this->scene_->getSceneManager()->destroyCamera(this->camera_);
@@ -85 +82 @@
     {
         // show main menu
-        GUIManager::getInstance().showGUI("MainMenu", true, GraphicsManager::getInstance().isFullScreen());
+        GUIManager::getInstance().showGUI("MainMenu", true);
         GUIManager::getInstance().setCamera(this->camera_);
-        GUIManager::getInstance().setBackground("MainMenuBackground");
-//         GUIManager::getInstance().setBackground("");
+        GUIManager::getInstance().setBackgroundImage("MainMenuBackground", "Background");
         GraphicsManager::getInstance().setCamera(this->camera_);
+
+        InputManager::getInstance().enterState("MainMenuHackery");
 
         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&GSMainMenu::startStandalone), "startGame"));
@@ -101 +99 @@
 
         KeyBinderManager::getInstance().setToDefault();
-        InputManager::getInstance().enterState("mainMenu");
 
         this->setConfigValues();
@@ -119 +116 @@
         }
 
-        InputManager::getInstance().leaveState("mainMenu");
+        InputManager::getInstance().leaveState("MainMenuHackery");
 
         GUIManager::getInstance().setCamera(0);
-        GUIManager::getInstance().setBackground("");
+        GUIManager::getInstance().setBackgroundImage("");
         GUIManager::hideGUI("MainMenu");
         GraphicsManager::getInstance().setCamera(0);

code/trunk/src/orxonox/gamestates/GSMainMenu.h

@@ -61 +61 @@
 
     private:
-        InputState*       inputState_;
         Scene*            scene_;
         Ogre::Camera*     camera_;

code/trunk/src/orxonox/overlays/CMakeLists.txt

@@ -1 +1 @@
 ADD_SOURCE_FILES(ORXONOX_SRC_FILES
+  GUISheet.cc
   OrxonoxOverlay.cc
   OverlayGroup.cc