Index: code/branches/gui/src/orxonox/GraphicsEngine.cc
===================================================================
--- code/branches/gui/src/orxonox/GraphicsEngine.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/GraphicsEngine.cc	(revision 1638)
@@ -27,8 +27,9 @@
  */
 
- /**
-    @file orxonox.cc
-    @brief Orxonox class
-  */
+/**
+@file
+@brief
+    Implementation of an partial interface to Ogre.
+*/
 
 #include "OrxonoxStableHeaders.h"
@@ -50,4 +51,5 @@
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
+#include "core/Exception.h"
 
 #include "overlays/console/InGameConsole.h"
@@ -57,423 +59,444 @@
 #include "tools/WindowEventListener.h"
 
+#include "objects/CameraHandler.h"
 
 namespace orxonox
 {
-  /**
-    @brief Returns the singleton instance and creates it the first time.
-    @return The only instance of GraphicsEngine.
-  */
-  /*static*/ GraphicsEngine& GraphicsEngine::getSingleton()
-  {
-    static GraphicsEngine theOnlyInstance;
-    return theOnlyInstance;
-  }
-
-  /**
-    @brief Only use constructor to initialise variables and pointers!
-  */
-  GraphicsEngine::GraphicsEngine() :
-    root_(0),
-    scene_(0),
-    renderWindow_(0)
-  {
-    RegisterObject(GraphicsEngine);
-
-    this->detailLevelParticle_ = 0;
-
-    this->setConfigValues();
-    CCOUT(4) << "Constructed" << std::endl;
-  }
-
-  void GraphicsEngine::setConfigValues()
-  {
-    SetConfigValue(resourceFile_,    "resources.cfg").description("Location of the resources file in the data path.");
-    SetConfigValue(ogreConfigFile_,  "ogre.cfg").description("Location of the Ogre config file");
-    SetConfigValue(ogrePluginsFile_, "plugins.cfg").description("Location of the Ogre plugins file");
-    SetConfigValue(ogreLogFile_,     "ogre.log").description("Logfile for messages from Ogre. \
-                                                             Use \"\" to suppress log file creation.");
-    SetConfigValue(ogreLogLevelTrivial_ , 5).description("Corresponding orxonox debug level for ogre Trivial");
-    SetConfigValue(ogreLogLevelNormal_  , 4).description("Corresponding orxonox debug level for ogre Normal");
-    SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
-
-    unsigned int old = this->detailLevelParticle_;
-    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high");
-
-    if (this->detailLevelParticle_ != old)
-      for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
-        it->detailLevelChanged(this->detailLevelParticle_);
-  }
-
-  /**
-    @brief Called after main() --> call destroyObjects()!
-  */
-  GraphicsEngine::~GraphicsEngine()
-  {
-    this->destroy();
-  }
-
-  /**
-    @brief Destroys all the internal objects. Call this method when you
-           normally would call the destructor.
-  */
-  void GraphicsEngine::destroy()
-  {
-    CCOUT(4) << "Destroying objects..." << std::endl;
-    Ogre::WindowEventUtilities::removeWindowEventListener(this->renderWindow_, this);
-    if (this->root_)
-      delete this->root_;
-    this->root_ = 0;
-    this->scene_ = 0;
-    this->renderWindow_ = 0;
-    // delete the ogre log and the logManager (since we have created it).
-    if (Ogre::LogManager::getSingletonPtr() != 0)
-    {
-      Ogre::LogManager::getSingleton().getDefaultLog()->removeListener(this);
-      Ogre::LogManager::getSingleton().destroyLog(Ogre::LogManager::getSingleton().getDefaultLog());
-      delete Ogre::LogManager::getSingletonPtr();
-    }
-    CCOUT(4) << "Destroying objects done" << std::endl;
-  }
-
-  /**
-    @brief Creates the Ogre Root object and sets up the ogre log.
-  */
-  bool GraphicsEngine::setup()
-  {
-    CCOUT(3) << "Setting up..." << std::endl;
-    // temporary overwrite of dataPath, change ini file for permanent change
-
-// TODO: LogManager doesn't work on specific systems. The why is unknown yet.
+    GraphicsEngine* GraphicsEngine::singletonRef_s = 0;
+
+    /**
+    @brief
+        Returns the singleton instance.
+    @return
+        The only instance of GraphicsEngine.
+    */
+    /*static*/ GraphicsEngine& GraphicsEngine::getSingleton()
+    {
+        assert(singletonRef_s);
+        return *singletonRef_s;
+    }
+
+    /**
+    @brief
+        Non-initialising constructor.
+    */
+    GraphicsEngine::GraphicsEngine()
+        : root_(0)
+        , renderWindow_(0)
+        , levelSceneManager_(0)
+        , levelViewport_(0)
+    {
+        RegisterObject(GraphicsEngine);
+
+        singletonRef_s = this;
+
+        this->detailLevelParticle_ = 0;
+
+        this->setConfigValues();
+        CCOUT(4) << "Constructed" << std::endl;
+    }
+
+    void GraphicsEngine::setConfigValues()
+    {
+        SetConfigValue(resourceFile_,    "resources.cfg").description("Location of the resources file in the data path.");
+        SetConfigValue(ogreConfigFile_,  "ogre.cfg").description("Location of the Ogre config file");
+        SetConfigValue(ogrePluginsFile_, "plugins.cfg").description("Location of the Ogre plugins file");
+        SetConfigValue(ogreLogFile_,     "ogre.log").description("Logfile for messages from Ogre. \
+                                                                 Use \"\" to suppress log file creation.");
+        SetConfigValue(ogreLogLevelTrivial_ , 5).description("Corresponding orxonox debug level for ogre Trivial");
+        SetConfigValue(ogreLogLevelNormal_  , 4).description("Corresponding orxonox debug level for ogre Normal");
+        SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
+
+        unsigned int old = this->detailLevelParticle_;
+        SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high");
+
+        if (this->detailLevelParticle_ != old)
+            for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+                it->detailLevelChanged(this->detailLevelParticle_);
+    }
+
+    /**
+    @brief
+        Destroys all the Ogre related objects
+    */
+    GraphicsEngine::~GraphicsEngine()
+    {
+        CCOUT(4) << "Destroying objects..." << std::endl;
+        Ogre::WindowEventUtilities::removeWindowEventListener(this->renderWindow_, this);
+        if (this->root_)
+            delete this->root_;
+        this->root_ = 0;
+        this->levelSceneManager_ = 0;
+        this->renderWindow_ = 0;
+
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
-    // create a logManager
-    // note: If there's already a logManager, Ogre will complain by a failed assertation.
-    // but that shouldn't happen, since this is the first time to create a logManager..
-    Ogre::LogManager* logger = new Ogre::LogManager();
-    CCOUT(4) << "Ogre LogManager created" << std::endl;
-
-    // create our own log that we can listen to
-    Ogre::Log *myLog;
-    if (this->ogreLogFile_ == "")
-      myLog = logger->createLog("ogre.log", true, false, true);
-    else
-      myLog = logger->createLog(this->ogreLogFile_, true, false, false);
-    CCOUT(4) << "Ogre Log created" << std::endl;
-
-    myLog->setLogDetail(Ogre::LL_BOREME);
-    myLog->addListener(this);
+        // delete the ogre log and the logManager (since we have created it).
+        if (Ogre::LogManager::getSingletonPtr() != 0)
+        {
+            Ogre::LogManager::getSingleton().getDefaultLog()->removeListener(this);
+            Ogre::LogManager::getSingleton().destroyLog(Ogre::LogManager::getSingleton().getDefaultLog());
+            delete Ogre::LogManager::getSingletonPtr();
+        }
+        CCOUT(4) << "Destroying objects done" << std::endl;
 #endif
 
-    // Root will detect that we've already created a Log
-    CCOUT(4) << "Creating Ogre Root..." << std::endl;
-
-    if (ogrePluginsFile_ == "")
-    {
-      COUT(1) << "Error: Ogre plugins file set to \"\". Cannot load." << std::endl;
-      return false;
-    }
-    if (ogreConfigFile_ == "")
-    {
-      COUT(1) << "Error: Ogre config file set to \"\". Cannot load." << std::endl;
-      return false;
-    }
-    if (ogreLogFile_ == "")
-    {
-      COUT(1) << "Error: Ogre log file set to \"\". Cannot load." << std::endl;
-      return false;
-    }
-
-    try
-    {
-      root_ = new Ogre::Root(ogrePluginsFile_, ogreConfigFile_, ogreLogFile_);
-    }
-    catch (Ogre::Exception ex)
-    {
-      COUT(2) << "Error: There was an exception when creating Ogre Root." << std::endl;
-      return false;
-    }
-
-    if (!root_->getInstalledPlugins().size())
-    {
-      COUT(1) << "Error: No plugins declared. Cannot load Ogre." << std::endl;
-      COUT(0) << "Is the plugins file correctly declared?" << std::endl;
-      return false;
-    }
-
-#if 0
-    // tame the ogre ouput so we don't get all the mess in the console
-    Ogre::Log* defaultLog = Ogre::LogManager::getSingleton().getDefaultLog();
-    defaultLog->setDebugOutputEnabled(false);
-    defaultLog->setLogDetail(Ogre::LL_BOREME);
-    defaultLog->addListener(this);
+        singletonRef_s = 0;
+    }
+
+    /**
+    @brief
+        Creates the Ogre Root object and sets up the ogre log.
+    */
+    void GraphicsEngine::setup()
+    {
+        CCOUT(3) << "Setting up..." << std::endl;
+
+        // TODO: LogManager doesn't work on linux platform. The why is yet unknown.
+#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+        // create a new logManager
+        Ogre::LogManager* logger = new Ogre::LogManager();
+        CCOUT(4) << "Ogre LogManager created" << std::endl;
+
+        // create our own log that we can listen to
+        Ogre::Log *myLog;
+        if (this->ogreLogFile_ == "")
+            myLog = logger->createLog("ogre.log", true, false, true);
+        else
+            myLog = logger->createLog(this->ogreLogFile_, true, false, false);
+        CCOUT(4) << "Ogre Log created" << std::endl;
+
+        myLog->setLogDetail(Ogre::LL_BOREME);
+        myLog->addListener(this);
 #endif
 
-    CCOUT(4) << "Creating Ogre Root done" << std::endl;
-
-    // specify where Ogre has to look for resources. This call doesn't parse anything yet!
-    if (!declareRessourceLocations())
-      return false;
-
-    CCOUT(3) << "Set up done." << std::endl;
-    return true;
-  }
-
-  bool GraphicsEngine::declareRessourceLocations()
-  {
-    CCOUT(4) << "Declaring Resources" << std::endl;
-    //TODO: Specify layout of data file and maybe use xml-loader
-    //TODO: Work with ressource groups (should be generated by a special loader)
-
-    if (resourceFile_ == "")
-    {
-      COUT(1) << "Error: Resource file set to \"\". Cannot load." << std::endl;
-      return false;
-    }
-
-    // Load resource paths from data file using configfile ressource type
-    Ogre::ConfigFile cf;
-    try
-    {
-      cf.load(Settings::getDataPath() + resourceFile_);
-    }
-    catch (Ogre::Exception ex)
-    {
-      COUT(1) << "Error: Could not load resources.cfg in path " << Settings::getDataPath() << std::endl;
-      COUT(0) << "Have you forgotten to set the data path in orxnox.ini?" << std::endl;
-      return false;
-    }
-
-    // Go through all sections & settings in the file
-    Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
-
-    std::string secName, typeName, archName;
-    while (seci.hasMoreElements())
-    {
-      try
-      {
-        secName = seci.peekNextKey();
-        Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
-        Ogre::ConfigFile::SettingsMultiMap::iterator i;
-        for (i = settings->begin(); i != settings->end(); ++i)
-        {
-          typeName = i->first; // for instance "FileSystem" or "Zip"
-          archName = i->second; // name (and location) of archive
-
-          Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
-              std::string(Settings::getDataPath() + archName), typeName, secName);
-        }
-      }
-      catch (Ogre::Exception ex)
-      {
-        COUT(2) << "Exception while reading resources.cfg. Proceeding.." << ex.getDescription() << std::endl;
-      }
-    }
-    return true;
-  }
-
-  bool GraphicsEngine::loadRenderer()
-  {
-    CCOUT(4) << "Configuring Renderer" << std::endl;
-
-    // check for file existence because Ogre displays exceptions if not
-    std::ifstream probe;
-    probe.open(ogreConfigFile_.c_str());
-    if (!probe)
-    {
-      // create a zero sized file
-      std::ofstream creator;
-      creator.open(ogreConfigFile_.c_str());
-      creator.close();
-    }
-    else
-      probe.close();
-
-    if (!root_->restoreConfig())
-      if (!root_->showConfigDialog())
-        return false;
-
-    CCOUT(4) << "Creating render window" << std::endl;
-    try
-    {
-      this->renderWindow_ = root_->initialise(true, "OrxonoxV2");
-    }
-    catch (Ogre::Exception ex)
-    {
-      COUT(2) << "Error: There was an exception when initialising Ogre Root." << std::endl;
-      return false;
-    }
-
-    if (!root_->isInitialised())
-    {
-      CCOUT(2) << "Error: Initialising Ogre root object failed." << std::endl;
-      return false;
-    }
-    Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, this);
-    Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
-    return true;
-  }
-
-  bool GraphicsEngine::initialiseResources()
-  {
-    CCOUT(4) << "Initialising resources" << std::endl;
-    //TODO: Do NOT load all the groups, why are we doing that? And do we really do that? initialise != load...
-    try
-    {
-      Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
-      /*Ogre::StringVector str = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-      for (unsigned int i = 0; i < str.size(); i++)
-      {
-        Ogre::ResourceGroupManager::getSingleton().loadResourceGroup(str[i]);
-      }*/
-    }
-    catch (Ogre::Exception e)
-    {
-      CCOUT(2) << "Error: There was an Error when initialising the resources." << std::endl;
-      CCOUT(2) << "ErrorMessage: " << e.getFullDescription() << std::endl;
-      return false;
-    }
-    return true;
-  }
-
-  /**
-   * @brief Creates the SceneManager
-   */
-  bool GraphicsEngine::createNewScene()
-  {
-    CCOUT(4) << "Creating new SceneManager..." << std::endl;
-    if (scene_)
-    {
-      CCOUT(2) << "SceneManager already exists! Skipping." << std::endl;
-      return false;
-    }
-    scene_ = root_->createSceneManager(Ogre::ST_GENERIC, "Default SceneManager");
-    CCOUT(3) << "Created SceneManager: " << scene_ << std::endl;
-    return true;
-  }
-
-  /**
-    Returns the window handle of the render window.
-    At least the InputHandler uses this to create the OIS::InputManager
-    @return The window handle of the render window
-  */
-  size_t GraphicsEngine::getWindowHandle()
-  {
-    if (this->renderWindow_)
-    {
-      size_t windowHnd = 0;
-      this->renderWindow_->getCustomAttribute("WINDOW", &windowHnd);
-      return windowHnd;
-    }
-    else
-      return 0;
-  }
-
-  /**
-    Get the width of the current render window
-    @return The width of the current render window
-  */
-  int GraphicsEngine::getWindowWidth() const
-  {
-    if (this->renderWindow_)
-      return this->renderWindow_->getWidth();
-    else
-      return 0;
-  }
-
-  /**
-    Get the height of the current render window
-    @return The height of the current render window
-  */
-  int GraphicsEngine::getWindowHeight() const
-  {
-    if (this->renderWindow_)
-      return this->renderWindow_->getHeight();
-    else
-      return 0;
-  }
-
-  /**
-    @brief Returns the window aspect ratio height/width.
-    @return The ratio
-  */
-  float GraphicsEngine::getWindowAspectRatio() const
-  {
-    if (this->renderWindow_)
-        return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
-    else
-        return 1.0f;
-  }
-
-  /**
-    @brief Method called by the LogListener interface from Ogre.
-    We use it to capture Ogre log messages and handle it ourselves.
-    @param message The message to be logged
-    @param lml The message level the log is using
-    @param maskDebug If we are printing to the console or not
-    @param logName the name of this log (so you can have several listeners
-                   for different logs, and identify them)
-  */
-  void GraphicsEngine::messageLogged(const std::string& message,
-    Ogre::LogMessageLevel lml, bool maskDebug, const std::string &logName)
-  {
-    int orxonoxLevel;
-    switch (lml)
-    {
-      case Ogre::LML_TRIVIAL:
-        orxonoxLevel = this->ogreLogLevelTrivial_;
-        break;
-      case Ogre::LML_NORMAL:
-        orxonoxLevel = this->ogreLogLevelNormal_;
-        break;
-      case Ogre::LML_CRITICAL:
-        orxonoxLevel = this->ogreLogLevelCritical_;
-        break;
-      default:
-        orxonoxLevel = 0;
-    }
-    OutputHandler::getOutStream().setOutputLevel(orxonoxLevel)
-        << "Ogre: " << message << std::endl;
-  }
-
-  /**
-  * Window has moved.
-  * @param rw The render window it occured in
-  */
-  void GraphicsEngine::windowMoved(Ogre::RenderWindow *rw)
-  {
-    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
-      it->windowMoved();
-  }
-
-  /**
-  * Window has resized.
-  * @param rw The render window it occured in
-  * @note GraphicsEngine has a render window stored itself. This is the same
-  *       as rw. But we have to be careful when using multiple render windows!
-  */
-  void GraphicsEngine::windowResized(Ogre::RenderWindow *rw)
-  {
-    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
-      it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
-  }
-
-  /**
-  * Window has changed Focus.
-  * @param rw The render window it occured in
-  */
-  void GraphicsEngine::windowFocusChanged(Ogre::RenderWindow *rw)
-  {
-    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
-      it->windowFocusChanged();
-  }
-
-  /**
-  * Window was closed.
-  * @param rw The render window it occured in
-  */
-  void GraphicsEngine::windowClosed(Ogre::RenderWindow *rw)
-  {
-    // using CommandExecutor in order to avoid depending on Orxonox.h.
-    CommandExecutor::execute("exit", false);
-  }
+        // Root will detect that we've already created a Log
+        CCOUT(4) << "Creating Ogre Root..." << std::endl;
+
+        if (ogrePluginsFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre plugins file set to \"\". Defaulting to plugins.cfg" << std::endl;
+            ModifyConfigValue(ogrePluginsFile_, tset, "plugins.cfg");
+        }
+        if (ogreConfigFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre config file set to \"\". Defaulting to config.cfg" << std::endl;
+            ModifyConfigValue(ogreConfigFile_, tset, "config.cfg");
+        }
+        if (ogreLogFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre log file set to \"\". Defaulting to ogre.log" << std::endl;
+            ModifyConfigValue(ogreLogFile_, tset, "ogre.log");
+        }
+
+        root_ = new Ogre::Root(ogrePluginsFile_, ogreConfigFile_, ogreLogFile_);
+
+        if (!root_->getInstalledPlugins().size())
+        {
+            ThrowException(PluginsNotFound, "No Ogre plugins declared. Cannot load Ogre.");
+        }
+
+#if 0 // Ogre 1.4.3 doesn't support setDebugOutputEnabled(.)
+//#if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
+        // tame the ogre ouput so we don't get all the mess in the console
+        Ogre::Log* defaultLog = Ogre::LogManager::getSingleton().getDefaultLog();
+        defaultLog->setDebugOutputEnabled(false);
+        defaultLog->setLogDetail(Ogre::LL_BOREME);
+        defaultLog->addListener(this);
+#endif
+
+        CCOUT(4) << "Creating Ogre Root done" << std::endl;
+
+        // specify where Ogre has to look for resources. This call doesn't parse anything yet!
+        declareRessourceLocations();
+
+        CCOUT(3) << "Set up done." << std::endl;
+    }
+
+    void GraphicsEngine::declareRessourceLocations()
+    {
+        CCOUT(4) << "Declaring Resources" << std::endl;
+        //TODO: Specify layout of data file and maybe use xml-loader
+        //TODO: Work with ressource groups (should be generated by a special loader)
+
+        if (resourceFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre resource file set to \"\". Defaulting to resources.cfg" << std::endl;
+            ModifyConfigValue(resourceFile_, tset, "resources.cfg");
+        }
+
+        // Load resource paths from data file using configfile ressource type
+        Ogre::ConfigFile cf;
+        try
+        {
+            cf.load(Settings::getDataPath() + resourceFile_);
+        }
+        catch (Ogre::Exception& ex)
+        {
+            COUT(1) << ex.getFullDescription() << std::endl;
+            COUT(0) << "Have you forgotten to set the data path in orxnox.ini?" << std::endl;
+            throw;
+        }
+
+        // Go through all sections & settings in the file
+        Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
+
+        std::string secName, typeName, archName;
+        while (seci.hasMoreElements())
+        {
+            try
+            {
+                secName = seci.peekNextKey();
+                Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
+                Ogre::ConfigFile::SettingsMultiMap::iterator i;
+                for (i = settings->begin(); i != settings->end(); ++i)
+                {
+                    typeName = i->first; // for instance "FileSystem" or "Zip"
+                    archName = i->second; // name (and location) of archive
+
+                    Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
+                        std::string(Settings::getDataPath() + archName), typeName, secName);
+                }
+            }
+            catch (Ogre::Exception& ex)
+            {
+                COUT(1) << ex.getFullDescription() << std::endl;
+            }
+        }
+    }
+
+    bool GraphicsEngine::loadRenderer()
+    {
+        CCOUT(4) << "Configuring Renderer" << std::endl;
+
+        // check for file existence because Ogre displays exceptions if not
+        std::ifstream probe;
+        probe.open(ogreConfigFile_.c_str());
+        if (!probe)
+        {
+            // create a zero sized file
+            std::ofstream creator;
+            creator.open(ogreConfigFile_.c_str());
+            creator.close();
+        }
+        else
+            probe.close();
+
+        if (!root_->restoreConfig())
+            if (!root_->showConfigDialog())
+                return false;
+
+        CCOUT(4) << "Creating render window" << std::endl;
+        try
+        {
+            this->renderWindow_ = root_->initialise(true, "OrxonoxV2");
+        }
+        catch (...)
+        {
+            COUT(2) << "Error: There was an exception when initialising Ogre Root." << std::endl;
+            return false;
+        }
+
+        if (!root_->isInitialised())
+        {
+            CCOUT(2) << "Error: Initialising Ogre root object failed." << std::endl;
+            return false;
+        }
+        Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, this);
+        //Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
+
+        // create a full screen viewport in which to render the scene and the loading screen
+        // The GUI uses its own one to be able to render on top of everything.
+        // That explains why the Z order here is only 1 and not 0 (top most)
+        this->levelViewport_ = this->renderWindow_->addViewport(0, 1);
+
+        return true;
+    }
+
+    bool GraphicsEngine::initialiseResources()
+    {
+        CCOUT(4) << "Initialising resources" << std::endl;
+        //TODO: Do NOT load all the groups, why are we doing that? And do we really do that? initialise != load...
+        try
+        {
+            Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+            /*Ogre::StringVector str = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
+            for (unsigned int i = 0; i < str.size(); i++)
+            {
+            Ogre::ResourceGroupManager::getSingleton().loadResourceGroup(str[i]);
+            }*/
+        }
+        catch (Ogre::Exception& e)
+        {
+            CCOUT(2) << "Error: There was an Error when initialising the resources." << std::endl;
+            CCOUT(2) << "ErrorMessage: " << e.getFullDescription() << std::endl;
+            return false;
+        }
+        return true;
+    }
+
+    /**
+    @brief
+        Creates the SceneManager
+    */
+    bool GraphicsEngine::createNewScene()
+    {
+        CCOUT(4) << "Creating new SceneManager..." << std::endl;
+        if (levelSceneManager_)
+        {
+            CCOUT(2) << "SceneManager already exists! Skipping." << std::endl;
+            return false;
+        }
+        this->levelSceneManager_ = this->root_->createSceneManager(Ogre::ST_GENERIC, "LevelSceneManager");
+        CCOUT(3) << "Created SceneManager: " << levelSceneManager_ << std::endl;
+        return true;
+    }
+
+    /**
+    @brief
+        Returns the window handle of the render window.
+        At least the InputHandler uses this to create the OIS::InputManager
+    @return
+        The window handle of the render window
+    */
+    size_t GraphicsEngine::getWindowHandle()
+    {
+        if (this->renderWindow_)
+        {
+            size_t windowHnd = 0;
+            this->renderWindow_->getCustomAttribute("WINDOW", &windowHnd);
+            return windowHnd;
+        }
+        else
+            return 0;
+    }
+
+    /**
+    @brief
+        Get the width of the render window
+    @return
+        The width of the render window
+    */
+    int GraphicsEngine::getWindowWidth() const
+    {
+        if (this->renderWindow_)
+            return this->renderWindow_->getWidth();
+        else
+            return 0;
+    }
+
+    /**
+    @brief
+        Get the height of the render window
+    @return
+        The height of the render window
+    */
+    int GraphicsEngine::getWindowHeight() const
+    {
+        if (this->renderWindow_)
+            return this->renderWindow_->getHeight();
+        else
+            return 0;
+    }
+
+    /**
+    @brief
+        Returns the window aspect ratio height/width.
+    @return
+        The window aspect ratio
+    */
+    float GraphicsEngine::getWindowAspectRatio() const
+    {
+        if (this->renderWindow_)
+            return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
+        else
+            return 1.0f;
+    }
+
+    /**
+    @brief
+        Method called by the LogListener interface from Ogre.
+        We use it to capture Ogre log messages and handle it ourselves.
+    @param message
+        The message to be logged
+    @param lml
+        The message level the log is using
+    @param maskDebug
+        If we are printing to the console or not
+    @param logName
+        The name of this log (so you can have several listeners
+        for different logs, and identify them)
+    */
+    void GraphicsEngine::messageLogged(const std::string& message,
+        Ogre::LogMessageLevel lml, bool maskDebug, const std::string &logName)
+    {
+        int orxonoxLevel;
+        switch (lml)
+        {
+        case Ogre::LML_TRIVIAL:
+            orxonoxLevel = this->ogreLogLevelTrivial_;
+            break;
+        case Ogre::LML_NORMAL:
+            orxonoxLevel = this->ogreLogLevelNormal_;
+            break;
+        case Ogre::LML_CRITICAL:
+            orxonoxLevel = this->ogreLogLevelCritical_;
+            break;
+        default:
+            orxonoxLevel = 0;
+        }
+        OutputHandler::getOutStream().setOutputLevel(orxonoxLevel)
+            << "Ogre: " << message << std::endl;
+    }
+
+    /**
+    @brief
+        Window has moved.
+    @param rw
+        The render window it occured in
+    */
+    void GraphicsEngine::windowMoved(Ogre::RenderWindow *rw)
+    {
+        for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+            it->windowMoved();
+    }
+
+    /**
+    @brief
+        Window has resized.
+    @param rw
+        The render window it occured in
+    @note
+        GraphicsEngine has a render window stored itself. This is the same
+        as rw. But we have to be careful when using multiple render windows!
+    */
+    void GraphicsEngine::windowResized(Ogre::RenderWindow *rw)
+    {
+        for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+            it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
+    }
+
+    /**
+    @brief
+        Window focus has changed.
+    @param rw
+        The render window it occured in
+    */
+    void GraphicsEngine::windowFocusChanged(Ogre::RenderWindow *rw)
+    {
+        for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+            it->windowFocusChanged();
+    }
+
+    /**
+    @brief
+        Window was closed.
+    @param rw
+        The render window it occured in
+    */
+    void GraphicsEngine::windowClosed(Ogre::RenderWindow *rw)
+    {
+        // using CommandExecutor in order to avoid depending on Orxonox.h.
+        CommandExecutor::execute("exit", false);
+    }
 
 }
Index: code/branches/gui/src/orxonox/GraphicsEngine.h
===================================================================
--- code/branches/gui/src/orxonox/GraphicsEngine.h	(revision 1636)
+++ code/branches/gui/src/orxonox/GraphicsEngine.h	(revision 1638)
@@ -54,65 +54,74 @@
     class _OrxonoxExport GraphicsEngine : public Ogre::WindowEventListener, public Ogre::LogListener, public OrxonoxClass
     {
-        public:
-            void setConfigValues();
-            bool setup();
-            bool declareRessourceLocations();
-            bool loadRenderer();
-            bool initialiseResources();
-            bool createNewScene();
+    public:
+        GraphicsEngine();
+        ~GraphicsEngine();
 
-            void destroy();
+        void setConfigValues();
+        void setup();
+        void declareRessourceLocations();
+        bool loadRenderer();
+        bool initialiseResources();
+        bool createNewScene();
 
-            Ogre::SceneManager* getSceneManager() { return scene_; }
+        void setLevelSceneManager(Ogre::SceneManager* sceneMgr) { this->levelSceneManager_ = sceneMgr; }
+        Ogre::SceneManager* getLevelSceneManager() { return levelSceneManager_; }
 
-            // several window properties
-            Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
-            size_t getWindowHandle();
-            int getWindowWidth() const;
-            int getWindowHeight() const;
-            float getWindowAspectRatio() const;
-            float getAverageFramesPerSecond() const { return this->avgFramesPerSecond_; }
-            float getAverageTickTime() const { return this->avgTickTime_; }
-            void setAverageTickTime(float tickTime) { this->avgTickTime_ = tickTime; }
-            void setAverageFramesPerSecond(float fps) { this->avgFramesPerSecond_ = fps; }
+        Ogre::Viewport* getLevelViewport() { return this->levelViewport_; }
 
-            void setWindowActivity(bool activity)
-            { if (this->renderWindow_) this->renderWindow_->setActive(activity); }
+        // several window properties
+        Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
+        size_t getWindowHandle();
+        int getWindowWidth() const;
+        int getWindowHeight() const;
+        float getWindowAspectRatio() const;
+        float getAverageFramesPerSecond() const   { return this->avgFramesPerSecond_; }
+        float getAverageTickTime() const          { return this->avgTickTime_; }
+        void setAverageTickTime(float tickTime)   { this->avgTickTime_ = tickTime; }
+        void setAverageFramesPerSecond(float fps) { this->avgFramesPerSecond_ = fps; }
 
-            void windowMoved       (Ogre::RenderWindow* rw);
-            void windowResized     (Ogre::RenderWindow* rw);
-            void windowFocusChanged(Ogre::RenderWindow* rw);
-            void windowClosed      (Ogre::RenderWindow* rw);
+        void setWindowActivity(bool activity)
+        { if (this->renderWindow_) this->renderWindow_->setActive(activity); }
 
-            inline unsigned int getDetailLevelParticle() const
-              { return this->detailLevelParticle_; }
+        inline unsigned int getDetailLevelParticle() const
+        { return this->detailLevelParticle_; }
 
-            static GraphicsEngine& getSingleton();
-            static GraphicsEngine* getSingletonPtr() { return &getSingleton(); }
+        static GraphicsEngine& getSingleton();
+        static GraphicsEngine* getSingletonPtr() { return &getSingleton(); }
 
+    private:
+        // don't mess with singletons
+        GraphicsEngine(GraphicsEngine&) { }
 
-        private:
-            // don't mess with singletons
-            GraphicsEngine();
-            ~GraphicsEngine();
-            GraphicsEngine(GraphicsEngine&) { }
+        //! Method called by the LogListener from Ogre
+        void messageLogged(const std::string&, Ogre::LogMessageLevel,
+            bool, const std::string&);
 
-            //! Method called by the LogListener from Ogre
-            void messageLogged(const std::string&, Ogre::LogMessageLevel,
-                             bool, const std::string&);
+        // window events from Ogre::WindowEventListener
+        void windowMoved       (Ogre::RenderWindow* rw);
+        void windowResized     (Ogre::RenderWindow* rw);
+        void windowFocusChanged(Ogre::RenderWindow* rw);
+        void windowClosed      (Ogre::RenderWindow* rw);
 
-            Ogre::Root*         root_;                  //!< Ogre's root
-            Ogre::SceneManager* scene_;                 //!< scene manager of the game
-            Ogre::RenderWindow* renderWindow_;          //!< the current render window
-            std::string         resourceFile_;          //!< resources file name
-            std::string         ogreConfigFile_;        //!< ogre config file name
-            std::string         ogrePluginsFile_;       //!< ogre plugins file name
-            std::string         ogreLogFile_;           //!< log file name for Ogre log messages
-            int                 ogreLogLevelTrivial_;   //!< Corresponding Orxonx debug level for LL_TRIVIAL
-            int                 ogreLogLevelNormal_;    //!< Corresponding Orxonx debug level for LL_NORMAL
-            int                 ogreLogLevelCritical_;  //!< Corresponding Orxonx debug level for LL_CRITICAL
-            unsigned int        detailLevelParticle_;   //!< Detail level of particle effects (0: off, 1: low, 2: normal, 3: high)
-            float               avgTickTime_;           //!< time in ms to tick() one frame
-            float               avgFramesPerSecond_;    //!< number of frames processed in one second
+        Ogre::Root*         root_;                  //!< Ogre's root
+        Ogre::RenderWindow* renderWindow_;          //!< the current render window
+        Ogre::SceneManager* levelSceneManager_;     //!< scene manager of the game
+        Ogre::Viewport*     levelViewport_;         //!< default full size viewport for the level
+
+        // stats
+        float               avgTickTime_;           //!< time in ms to tick() one frame
+        float               avgFramesPerSecond_;    //!< number of frames processed in one second
+
+        // config values
+        std::string         resourceFile_;          //!< resources file name
+        std::string         ogreConfigFile_;        //!< ogre config file name
+        std::string         ogrePluginsFile_;       //!< ogre plugins file name
+        std::string         ogreLogFile_;           //!< log file name for Ogre log messages
+        int                 ogreLogLevelTrivial_;   //!< Corresponding Orxonx debug level for LL_TRIVIAL
+        int                 ogreLogLevelNormal_;    //!< Corresponding Orxonx debug level for LL_NORMAL
+        int                 ogreLogLevelCritical_;  //!< Corresponding Orxonx debug level for LL_CRITICAL
+        unsigned int        detailLevelParticle_;   //!< Detail level of particle effects (0: off, 1: low, 2: normal, 3: high)
+
+        static GraphicsEngine* singletonRef_s;      //!< Pointer to the Singleton
     };
 }
Index: code/branches/gui/src/orxonox/Main.cc
===================================================================
--- code/branches/gui/src/orxonox/Main.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/Main.cc	(revision 1638)
@@ -22,4 +22,5 @@
  *   Author:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      Reto Grieder
  *   Co-authors:
  *      ...
@@ -35,10 +36,16 @@
 
 #include <exception>
+#include <cassert>
 
 #include "util/OrxonoxPlatform.h"
+#include "util/ArgReader.h"
 #include "core/SignalHandler.h"
+#include "core/Debug.h"
+#include "network/ClientConnection.h"
+#include "Settings.h"
 #include "Orxonox.h"
 
 using namespace orxonox;
+
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
 #include <CoreFoundation/CoreFoundation.h>
@@ -49,22 +56,57 @@
              std::string macBundlePath()
 {
-  char path[1024];
-  CFBundleRef mainBundle = CFBundleGetMainBundle();
-  assert(mainBundle);
+    char path[1024];
+    CFBundleRef mainBundle = CFBundleGetMainBundle();
+    assert(mainBundle);
 
-  CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
-  assert(mainBundleURL);
+    CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
+    assert(mainBundleURL);
 
-  CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);
-  assert(cfStringRef);
+    CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);
+    assert(cfStringRef);
 
-  CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);
+    CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);
 
-  CFRelease(mainBundleURL);
-  CFRelease(cfStringRef);
+    CFRelease(mainBundleURL);
+    CFRelease(cfStringRef);
 
-  return std::string(path);
+    return std::string(path);
 }
 #endif
+
+bool parseCommandLine(int argc, char** argv)
+{
+    ArgReader args;
+    std::string errorStr = args.parse(argc, argv);
+    if (errorStr != "")
+    {
+        COUT(1) << "Command Line: Parsing failed.\n" << errorStr << std::endl;
+        return false;
+    }
+
+    // Argument reader parses the command line to check syntax.
+    // Settings Singleton then stores the arguments. It always
+    // expects a default value.
+    bool success = true;
+    success &= Settings::addCommandLineArgument<std::string>
+        ("mode",     args.getArgument("mode"),     "standalone");
+    success &= Settings::addCommandLineArgument<std::string>
+        ("dataPath", args.getArgument("dataPath"), "./");
+    success &= Settings::addCommandLineArgument<std::string>
+        ("ip",       args.getArgument("ip"),       "127.0.0.0");
+    success &= Settings::addCommandLineArgument<int>
+        ("port",     args.getArgument("port"),     NETWORK_PORT);
+
+    if (!success)
+        return false;
+
+    if (!args.allChecked())
+    {
+        COUT(1) << "Command Line: Parsing failed.\nNot all arguments were matched." << std::endl;
+        return false;
+    }
+
+    return true;
+}
 
 #ifdef __cplusplus
@@ -72,29 +114,33 @@
 #endif
 
-int main(int argc, char **argv)
+int main(int argc, char** argv)
 {
-  //try {
+    // create a signal handler (only works for linux)
     SignalHandler::getInstance()->doCatch(argv[0], "orxonox.log");
-    Orxonox* orx = Orxonox::getSingleton();
 
-    bool res = false;
+    if (!parseCommandLine(argc, argv))
+    {
+        COUT(0) << "Usage:" << std::endl << "orxonox [--mode client|server|dedicated|standalone] "
+                << "[--data PATH] [--ip IP] [--port PORT]" << std::endl;
+        return 0;
+    }
+
+    Orxonox orxonoxInstance;
+
+    try
+    {
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
-    res = orx->init(argc, argv, macBundlePath());
+        orxonoxInstance.start(macBundlePath());
 #else
-    res = orx->init(argc, argv);
+        orxonoxInstance.start();
 #endif
+    }
+    catch (std::exception& ex)
+    {
+        COUT(1) << ex.what() << std::endl;
+        COUT(1) << "Abort." << std::endl;
+    }
 
-    if (res)
-      orx->start();
-    orx->destroySingleton();
-  /*}
-  catch (std::exception &ex)
-  {
-    std::cerr << "Exception:\n";
-    std::cerr << ex.what() << "\n";
-    return 1;
-  }*/
-
-  return 0;
+    return 0;
 }
 
Index: code/branches/gui/src/orxonox/Orxonox.cc
===================================================================
--- code/branches/gui/src/orxonox/Orxonox.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/Orxonox.cc	(revision 1638)
@@ -22,6 +22,7 @@
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
- *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      ...
  *
  */
@@ -38,4 +39,5 @@
 //****** STD *******
 #include <deque>
+#include <cassert>
 
 //****** OGRE ******
@@ -50,12 +52,15 @@
 // util
 //#include "util/Sleep.h"
-#include "util/ArgReader.h"
 
 // core
 #include "core/ConfigFileManager.h"
+#include "core/ConfigValueIncludes.h"
 #include "core/ConsoleCommand.h"
 #include "core/Debug.h"
 #include "core/Loader.h"
+#include "core/Exception.h"
 #include "core/input/InputManager.h"
+#include "core/input/SimpleInputState.h"
+#include "core/input/KeyBinder.h"
 #include "core/TclBind.h"
 #include "core/Core.h"
@@ -69,9 +74,9 @@
 
 // objects and tools
-#include "overlays/OverlayGroup.h"
 #include "overlays/console/InGameConsole.h"
 #include "objects/Tickable.h"
 #include "objects/Backlight.h"
 #include "tools/ParticleInterface.h"
+#include "gui/GUIManager.h"
 
 #include "GraphicsEngine.h"
@@ -85,7 +90,8 @@
 namespace orxonox
 {
-  SetConsoleCommandShortcut(Orxonox, exit).setKeybindMode(KeybindMode::OnPress);
-  SetConsoleCommandShortcut(Orxonox, slomo).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
-  SetConsoleCommandShortcut(Orxonox, setTimeFactor).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
+  SetConsoleCommand(Orxonox, exit, true).setKeybindMode(KeybindMode::OnPress);
+  SetConsoleCommand(Orxonox, slomo, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
+  SetConsoleCommand(Orxonox, setTimeFactor, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
+  SetConsoleCommand(Orxonox, loadGame, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, "standalone");
 
   /**
@@ -106,8 +112,11 @@
     , bAbort_(false)
     , timefactor_(1.0f)
-    , mode_(STANDALONE)
-    , serverIp_("")
-    , serverPort_(NETWORK_PORT)
-  {
+    , mode_(GameMode::GM_Unspecified)
+    , debugRefreshTime_(0.0f)
+  {
+    RegisterRootObject(Orxonox);
+
+    assert(singletonRef_s == 0);
+    singletonRef_s = this;
   }
 
@@ -118,5 +127,5 @@
   {
     // keep in mind: the order of deletion is very important!
-    Loader::unload(startLevel_);
+    Loader::unload();
     if (this->startLevel_)
       delete this->startLevel_;
@@ -136,5 +145,7 @@
       delete this->timer_;
     InputManager::destroy();
-    GraphicsEngine::getSingleton().destroy();
+
+    if (this->ogre_)
+      delete ogre_;
 
     if (network::Client::getSingleton())
@@ -142,4 +153,11 @@
     if (server_g)
       delete network::Server::getSingleton();
+
+    singletonRef_s = 0;
+  }
+
+  void Orxonox::setConfigValues()
+  {
+    SetConfigValue(debugRefreshTime_, 0.2).description("Sets the time interval at which average fps, etc. get updated.");
   }
 
@@ -157,19 +175,8 @@
    * @return singleton reference
    */
-  Orxonox* Orxonox::getSingleton()
-  {
-    if (!singletonRef_s)
-      singletonRef_s = new Orxonox();
-    return singletonRef_s;
-  }
-
-  /**
-    @brief Destroys the Orxonox singleton.
-  */
-  void Orxonox::destroySingleton()
-  {
-    if (singletonRef_s)
-      delete singletonRef_s;
-    singletonRef_s = 0;
+  Orxonox& Orxonox::getSingleton()
+  {
+    assert(singletonRef_s);
+    return *singletonRef_s;
   }
 
@@ -179,20 +186,19 @@
   void Orxonox::setTimeFactor(float factor)
   {
-    float change = factor / Orxonox::getSingleton()->getTimeFactor();
-    Orxonox::getSingleton()->timefactor_ = factor;
+    float change = factor / Orxonox::getSingleton().getTimeFactor();
+    Orxonox::getSingleton().timefactor_ = factor;
     for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
         it->setSpeedFactor(it->getSpeedFactor() * change);
 
     for (Iterator<Backlight> it = ObjectList<Backlight>::begin(); it; ++it)
-        it->setTimeFactor(Orxonox::getSingleton()->getTimeFactor());
-  }
-
-  /**
-   * initialization of Orxonox object
-   * @param argc argument counter
-   * @param argv list of argumenst
+        it->setTimeFactor(Orxonox::getSingleton().getTimeFactor());
+  }
+
+
+  /**
+   * Starts the whole Game.
    * @param path path to config (in home dir or something)
    */
-  bool Orxonox::init(int argc, char **argv)
+  void Orxonox::start()
   {
 #ifdef _DEBUG
@@ -203,130 +209,138 @@
     Factory::createClassHierarchy();
 
-    std::string mode;
-    std::string tempDataPath;
-
-    ArgReader ar(argc, argv);
-    ar.checkArgument("mode", &mode, false);
-    ar.checkArgument("data", &tempDataPath, false);
-    ar.checkArgument("ip",   &serverIp_, false);
-    ar.checkArgument("port", &serverPort_, false);
-    if(ar.errorHandling())
-    {
-      COUT(1) << "Error while parsing command line arguments" << std::endl;
-      COUT(1) << ar.getErrorString();
-      COUT(0) << "Usage:" << std::endl << "orxonox [mode client|server|dedicated|standalone] "
-        << "[--data PATH] [--ip IP] [--port PORT]" << std::endl;
-      return false;
-    }
-
-    if (mode == "client")
-      mode_ = CLIENT;
-    else if (mode == "server")
-      mode_ = SERVER;
-    else if (mode == "dedicated")
-      mode_ = DEDICATED;
-    else
-    {
-      if (mode == "")
-        mode = "standalone";
-      if (mode != "standalone")
+    setConfigValues();
+
+    const Settings::CommandLineArgument* mode = Settings::getCommandLineArgument("mode");
+    assert(mode);
+    if (!mode->bHasDefaultValue_)
+    {
+      Settings::setGameMode(mode->value_);
+      this->mode_ = Settings::getGameMode();
+    }
+    COUT(3) << "Orxonox: Game mode is " << mode_.name << "." << std::endl;
+
+    const Settings::CommandLineArgument* dataPath = Settings::getCommandLineArgument("dataPath");
+    assert(dataPath);
+    if (!dataPath->bHasDefaultValue_)
+    {
+      if (*dataPath->value_.getString().end() != '/' && *dataPath->value_.getString().end() != '\\')
+        Settings::tsetDataPath(dataPath->value_.getString() + "/");
+      else
+        Settings::tsetDataPath(dataPath->value_.getString());
+    }
+
+    try
+    {
+        // initialise TCL
+        TclBind::getInstance().setDataPath(Settings::getDataPath());
+
+        ogre_ = new GraphicsEngine();
+        ogre_->setup();       // creates ogre root and other essentials
+
+        if (mode_.showsGraphics)
+        {
+          ogre_->loadRenderer();    // creates the render window
+
+          // TODO: Spread this so that this call only initialises things needed for the Console and GUI
+          ogre_->initialiseResources();
+
+          // Calls the InputManager which sets up the input devices.
+          // The render window width and height are used to set up the mouse movement.
+          InputManager::initialise(ogre_->getWindowHandle(),
+                ogre_->getWindowWidth(), ogre_->getWindowHeight(), true, true, true);
+          KeyBinder* keyBinder = new KeyBinder();
+          InputManager::createSimpleInputState("game", 20)->setHandler(keyBinder);
+
+          // Load the InGameConsole
+          InGameConsole::getInstance().initialise();
+
+          // load the CEGUI interface
+          GUIManager::getInstance().initialise();
+        }
+
+        bool showGUI = true;
+        if (mode_.mode != GameMode::Unspecified)
+        {
+          showGUI = false;
+          // a game mode was specified with the command line
+          // we therefore load the game and level directly
+
+          if (!loadLevel(this->mode_))
+          {
+            COUT(1) << "Loading with predefined mode failed. Showing main menu." << std::endl;
+            showGUI = true;
+            mode_ = GameMode::GM_Unspecified;
+          }
+        }
+        
+        if (showGUI)
+        {
+          // show main menu
+          //GraphicsEngine::getSingleton().createNewScene();
+          GUIManager::getInstance().showGUI("MainMenu", true);
+        }
+    }
+    catch (std::exception& ex)
+    {
+      COUT(1) << ex.what() << std::endl;
+      COUT(1) << "Loading sequence aborted." << std::endl;
+      return;
+    }
+
+    modeRequest_ = mode_;
+    // here happens the game
+    startRenderLoop();
+
+    if (mode_.mode == GameMode::Client)
+      network::Client::getSingleton()->closeConnection();
+
+    if (mode_.hasServer)
+      server_g->close();
+  }
+
+  void Orxonox::loadGame(const std::string& name)
+  {
+      const GameMode& mode = Settings::getGameMode(name);
+      if (mode.mode == GameMode::None)
+          return;
+
+      getSingleton().modeRequest_ = mode;
+  }
+
+  bool Orxonox::loadLevel(const GameMode& mode)
+  {
+      bool success = true;
+
+      if (mode.showsGraphics)
       {
-        COUT(2) << "Warning: mode \"" << mode << "\" doesn't exist. "
-          << "Defaulting to standalone" << std::endl;
-        mode = "standalone";
+        // create Ogre SceneManager for the level
+        ogre_->createNewScene();
+
+        if (!loadPlayground())
+            return false;
       }
-      mode_ = STANDALONE;
-    }
-    COUT(3) << "Orxonox: Mode is " << mode << "." << std::endl;
-
-    if (tempDataPath != "")
-    {
-      if (tempDataPath[tempDataPath.size() - 1] != '/')
-        tempDataPath += "/";
-      Settings::tsetDataPath(tempDataPath);
-    }
-
-    // initialise TCL
-    TclBind::getInstance().setDataPath(Settings::getDataPath());
-
-    //if (mode_ == DEDICATED)
-      // TODO: decide what to do here
-    //else
-
-    // for playable server, client and standalone, the startup
-    // procedure until the GUI is identical
-
-    ogre_ = &GraphicsEngine::getSingleton();
-    if (!ogre_->setup())       // creates ogre root and other essentials
-      return false;
-
-    return true;
-  }
-
-  /**
-   * start modules
-   */
-  bool Orxonox::start()
-  {
-    if (mode_ == DEDICATED)
-    {
-      // do something else
-    }
-    else
-    { // not dedicated server
-      if (!ogre_->loadRenderer())    // creates the render window
-        return false;
-
-      // TODO: Spread this so that this call only initialises things needed for the Console
-      if (!ogre_->initialiseResources())
-        return false;
-
-      // Load the InGameConsole
-      InGameConsole::getInstance().initialise();
-
-      // Calls the InputManager which sets up the input devices.
-      // The render window width and height are used to set up the mouse movement.
-      if (!InputManager::initialise(ogre_->getWindowHandle(),
-            ogre_->getWindowWidth(), ogre_->getWindowHeight(), true, true, true))
-        return false;
-
-      // TOOD: load the GUI here
-      // set InputManager to GUI mode
-      InputManager::setInputState(InputManager::IS_GUI);
-      // TODO: run GUI here
-
-      // The following lines depend very much on the GUI output, so they're probably misplaced here..
-
-      InputManager::setInputState(InputManager::IS_NONE);
-
-      // create Ogre SceneManager
-      ogre_->createNewScene();
-
-      if (!loadPlayground())
-        return false;
-    }
-
-    switch (mode_)
-    {
-    case SERVER:
-      if (!serverLoad())
-        return false;
-      break;
-    case CLIENT:
-      if (!clientLoad())
-        return false;
-      break;
-    case DEDICATED:
-      if (!serverLoad())
-        return false;
-      break;
-    default:
-      if (!standaloneLoad())
-        return false;
-    }
-
-    InputManager::setInputState(InputManager::IS_NORMAL);
-
-    return startRenderLoop();
+
+      switch (mode.mode)
+      {
+      case GameMode::Server:
+        success &= serverLoad();
+        break;
+      case GameMode::Client:
+        success &= clientLoad();
+        break;
+      case GameMode::Dedicated:
+        success &= serverLoad();
+        break;
+      case GameMode::Standalone:
+        success &= standaloneLoad();
+        break;
+      default: // never happens
+          assert(false);
+      }
+      
+      if (success)
+        InputManager::requestEnterState("game");
+
+      return success;
   }
 
@@ -337,21 +351,21 @@
   bool Orxonox::loadPlayground()
   {
-    // Init audio
-    //auMan_ = new audio::AudioManager();
-    //auMan_->ambientAdd("a1");
-    //auMan_->ambientAdd("a2");
-    //auMan_->ambientAdd("a3");
-    //auMan->ambientAdd("ambient1");
-    //auMan_->ambientStart();
+    // Start the Radar
+    this->radar_ = new Radar();
 
     // Load the HUD
     COUT(3) << "Orxonox: Loading HUD" << std::endl;
     hud_ = new Level(Settings::getDataPath() + "overlay/hud.oxo");
-    Loader::load(hud_);
-
-    // Start the Radar
-    this->radar_ = new Radar();
-
-    return true;
+    return Loader::load(hud_);
+  }
+
+  /**
+   * Helper method to load a level.
+   */
+  bool Orxonox::loadScene()
+  {
+    COUT(0) << "Loading level..." << std::endl;
+    startLevel_ = new Level(Settings::getDataPath() + "levels/sample.oxw");
+    return Loader::open(startLevel_);
   }
 
@@ -363,6 +377,8 @@
     COUT(0) << "Loading level in server mode" << std::endl;
 
+    assert(Settings::getCommandLineArgument("port"));
+    int serverPort = Settings::getCommandLineArgument("port")->value_;
     //server_g = new network::Server(serverPort_);
-    server_g = network::Server::createSingleton(serverPort_);
+    server_g = network::Server::createSingleton(serverPort);
 
     if (!loadScene())
@@ -381,9 +397,13 @@
     COUT(0) << "Loading level in client mode" << std::endl;\
 
-    if (serverIp_.compare("") == 0)
+    assert(Settings::getCommandLineArgument("port"));
+    assert(Settings::getCommandLineArgument("ip"));
+    int serverPort = Settings::getCommandLineArgument("port")->value_;
+    std::string serverIP = Settings::getCommandLineArgument("ip")->value_;
+
+    if (serverIP.compare("") == 0)
       client_g = network::Client::createSingleton();
     else
-
-      client_g = network::Client::createSingleton(serverIp_, serverPort_);
+      client_g = network::Client::createSingleton(serverIP, serverPort);
 
     if(!client_g->establishConnection())
@@ -408,33 +428,19 @@
 
   /**
-   * Helper method to load a level.
-   */
-  bool Orxonox::loadScene()
-  {
-    startLevel_ = new Level("levels/sample.oxw");
-    Loader::open(startLevel_);
-
-    return true;
-  }
-
-
-  /**
     Main loop of the orxonox game.
-    About the loop: The design is almost exactly like the one in ogre, so that
-    if any part of ogre registers a framelisteners, it will still behave
-    correctly. Furthermore the time smoothing feature from ogre has been
-    implemented too. If turned on (see orxonox constructor), it will calculate
-    the dt_n by means of the recent most dt_n-1, dt_n-2, etc.
+    We use the Ogre::Timer to measure time since it uses the most precise
+    method an a platform (however the windows timer lacks time when under
+    heavy kernel load!).
+    There is a simple mechanism to measure the average time spent in our
+    ticks as it may indicate performance issues.
+    A note about the Ogre::FrameListener: Even though we don't use them,
+    they still get called. However, the delta times are not correct (except
+    for timeSinceLastFrame, which is the most important). A little research
+    as shown that there is probably only one FrameListener that doesn't even
+    need the time. So we shouldn't run into problems.
   */
-  bool Orxonox::startRenderLoop()
-  {
-    // first check whether ogre root object has been created
-    if (Ogre::Root::getSingletonPtr() == 0)
-    {
-      COUT(2) << "Orxonox Error: Could not start rendering. No Ogre root object found" << std::endl;
-      return false;
-    }
+  void Orxonox::startRenderLoop()
+  {
     Ogre::Root& ogreRoot = Ogre::Root::getSingleton();
-
 
     // use the ogre timer class to measure time.
@@ -444,6 +450,5 @@
     unsigned long frameCount = 0;
     
-    // TODO: this would very well fit into a configValue
-    const unsigned long refreshTime = 200000;
+    const unsigned long refreshTime = debugRefreshTime_ * 1000000.0f;
     unsigned long refreshStartTime = 0;
     unsigned long tickTime = 0;
@@ -454,80 +459,108 @@
     unsigned long timeAfterTick = 0;
 
+    int sleepTime = 0;
+
+    // TODO: Update time in seconds every 7 seconds to avoid any overflow (7 secs is very tight)
+
     COUT(3) << "Orxonox: Starting the main loop." << std::endl;
 
+    try
+    {
     timer_->reset();
     while (!bAbort_)
     {
-      // get current time
-      timeBeforeTickOld = timeBeforeTick;
-      timeBeforeTick    = timer_->getMicroseconds();
-      float dt = (timeBeforeTick - timeBeforeTickOld) / 1000000.0;
-
-
-      // tick the core (needs real time for input and tcl thread management)
-      Core::tick(dt);
-
-      // Call those objects that need the real time
-      for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
-        it->tick(dt);
-      // Call the scene objects
-      for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
-        it->tick(dt * this->timefactor_);
-
-      // call server/client with normal dt
-      if (client_g)
-        client_g->tick(dt * this->timefactor_);
-      if (server_g)
-        server_g->tick(dt * this->timefactor_);
-
-
-      // get current time once again
-      timeAfterTick = timer_->getMicroseconds();
-
-      tickTime += timeAfterTick - timeBeforeTick;
-      if (timeAfterTick > refreshStartTime + refreshTime)
-      {
-        GraphicsEngine::getSingleton().setAverageTickTime(
-            (float)tickTime * 0.001 / (frameCount - oldFrameCount));
-        GraphicsEngine::getSingleton().setAverageFramesPerSecond(
-            (float)(frameCount - oldFrameCount) / (timeAfterTick - refreshStartTime) * 1000000.0);
-        oldFrameCount = frameCount;
-        tickTime = 0;
-        refreshStartTime = timeAfterTick;
-      }
-
-
-      // don't forget to call _fireFrameStarted in ogre to make sure
-      // everything goes smoothly
-      Ogre::FrameEvent evt;
-      evt.timeSinceLastFrame = dt;
-      evt.timeSinceLastEvent = dt; // note: same time, but shouldn't matter anyway
-      ogreRoot._fireFrameStarted(evt);
-
-      if (mode_ != DEDICATED)
-      {
-        // Pump messages in all registered RenderWindows
-        // This calls the WindowEventListener objects.
-        Ogre::WindowEventUtilities::messagePump();
-        // make sure the window stays active even when not focused
-        // (probably only necessary on windows)
-        GraphicsEngine::getSingleton().setWindowActivity(true);
-
-        // render
-        ogreRoot._updateAllRenderTargets();
-      }
-
-      // again, just to be sure ogre works fine
-      ogreRoot._fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
-
-      ++frameCount;
-    }
-
-    if (mode_ == CLIENT)
-      network::Client::getSingleton()->closeConnection();
-    else if (mode_ == SERVER)
-      server_g->close();
-
-    return true;
+        // get current time
+        timeBeforeTickOld = timeBeforeTick;
+        timeBeforeTick    = timer_->getMicroseconds();
+        float dt = (timeBeforeTick - timeBeforeTickOld) / 1000000.0;
+
+        // check whether we have to load a game
+        if (mode_.mode != modeRequest_.mode && mode_.mode == GameMode::Unspecified)
+        {
+            this->loadLevel(modeRequest_);
+            this->modeRequest_ = GameMode::GM_None;
+        }
+
+
+        // tick the core (needs real time for input and tcl thread management)
+        Core::tick(dt);
+
+        // Call those objects that need the real time
+        for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+          it->tick(dt);
+        // Call the scene objects
+        for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+          it->tick(dt * this->timefactor_);
+
+        // call server/client with normal dt
+        if (client_g)
+          client_g->tick(dt * this->timefactor_);
+        if (server_g)
+          server_g->tick(dt * this->timefactor_);
+
+
+        // get current time once again
+        timeAfterTick = timer_->getMicroseconds();
+
+        tickTime += timeAfterTick - timeBeforeTick;
+        if (timeAfterTick > refreshStartTime + refreshTime)
+        {
+          GraphicsEngine::getSingleton().setAverageTickTime(
+              (float)tickTime * 0.001 / (frameCount - oldFrameCount));
+          float avgFPS = (float)(frameCount - oldFrameCount) / (timeAfterTick - refreshStartTime) * 1000000.0;
+          GraphicsEngine::getSingleton().setAverageFramesPerSecond(avgFPS);
+
+          if (avgFPS > 60.0)
+            sleepTime++;
+          else
+            sleepTime--;
+          if (sleepTime < 0)
+              sleepTime = 0;
+
+          oldFrameCount = frameCount;
+          tickTime = 0;
+          refreshStartTime = timeAfterTick;
+        }
+
+        // do some sleeping when the frameRate is over 60
+        if (sleepTime > 0)
+          msleep(sleepTime);
+
+
+        // don't forget to call _fireFrameStarted in ogre to make sure
+        // everything goes smoothly
+        Ogre::FrameEvent evt;
+        evt.timeSinceLastFrame = dt;
+        evt.timeSinceLastEvent = dt; // note: same time, but shouldn't matter anyway
+        ogreRoot._fireFrameStarted(evt);
+
+        if (mode_.showsGraphics)
+        {
+          // Pump messages in all registered RenderWindows
+          // This calls the WindowEventListener objects.
+          Ogre::WindowEventUtilities::messagePump();
+          // make sure the window stays active even when not focused
+          // (probably only necessary on windows)
+          GraphicsEngine::getSingleton().setWindowActivity(true);
+
+          // tick CEGUI
+          GUIManager::getInstance().tick(dt);
+
+          // render
+          ogreRoot._updateAllRenderTargets();
+        }
+
+        // again, just to be sure ogre works fine
+        ogreRoot._fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
+
+        ++frameCount;
+    }
+    }
+    catch (std::exception& ex)
+    {
+      // something went wrong.
+      COUT(1) << ex.what() << std::endl;
+      COUT(1) << "Main loop was stopped by an unhandled exception. Shutting down." << std::endl;
+    }
   }
 }
Index: code/branches/gui/src/orxonox/Orxonox.h
===================================================================
--- code/branches/gui/src/orxonox/Orxonox.h	(revision 1636)
+++ code/branches/gui/src/orxonox/Orxonox.h	(revision 1638)
@@ -22,6 +22,7 @@
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
- *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      ...
  *
  */
@@ -41,52 +42,44 @@
 
 #include <OgrePrerequisites.h>
+
+#include "core/OrxonoxClass.h"
 #include "audio/AudioPrereqs.h"
+#include "GraphicsEngine.h"
+#include "Settings.h"
 
-#include "GraphicsEngine.h"
-
-namespace orxonox {
-
-  enum gameMode{
-    SERVER,
-    CLIENT,
-    STANDALONE,
-    DEDICATED
-  };
-
+namespace orxonox
+{
   //! Orxonox singleton class
-  class _OrxonoxExport Orxonox
+    class _OrxonoxExport Orxonox : public OrxonoxClass
   {
     public:
-      bool init(int argc, char **argv);
-      bool start();
+      Orxonox();
+      ~Orxonox();
+
+      void start();
+      void setConfigValues();
 
       void abortRequest();
 
-      static Orxonox* getSingleton();
-      static void destroySingleton();
+      static Orxonox& getSingleton();
 
-      static inline void slomo(float factor) { Orxonox::setTimeFactor(factor); }
+      static void slomo(float factor) { Orxonox::setTimeFactor(factor); }
+      static float getTimeFactor()    { return Orxonox::getSingleton().timefactor_; }
+      static void loadGame(const std::string& name);
+      static void exit()              { Orxonox::getSingleton().abortRequest(); }
       static void setTimeFactor(float factor = 1.0);
-      static inline float getTimeFactor() { return Orxonox::getSingleton()->timefactor_; }
-      static inline void exit() { Orxonox::getSingleton()->abortRequest(); }
 
    private:
       // don't mess with singletons
-      Orxonox();
       Orxonox(Orxonox& instance);
-      Orxonox& operator=(const Orxonox& instance);
-      ~Orxonox();
 
-      bool loadPlayground();
-
+      bool loadLevel(const GameMode& mode);
       bool serverLoad();
       bool clientLoad();
       bool standaloneLoad();
 
+      bool loadPlayground();
       bool loadScene();
-
-      bool startRenderLoop();
-
-      float calculateEventTime(unsigned long, std::deque<unsigned long>&);
+      void startRenderLoop();
 
     private:
@@ -101,7 +94,9 @@
 
       // this is used to identify the mode (server/client/...) we're in
-      gameMode              mode_;
-      std::string           serverIp_;
-      int                   serverPort_;
+      GameMode              mode_;
+      GameMode              modeRequest_;
+
+      // config values
+      float                 debugRefreshTime_;
 
       static Orxonox *singletonRef_s;
Index: code/branches/gui/src/orxonox/OrxonoxStableHeaders.h
===================================================================
--- code/branches/gui/src/orxonox/OrxonoxStableHeaders.h	(revision 1636)
+++ code/branches/gui/src/orxonox/OrxonoxStableHeaders.h	(revision 1638)
@@ -45,40 +45,8 @@
 #  define WIN32_LEAN_AND_MEAN
 #endif
-// not including the entire Ogre.h doesn't exceed the default heap size for pch
-//#include <Ogre.h>
-#include <OgreBillboardSet.h>
-#include <OgreCamera.h>
-#include <OgreColourValue.h>
-#include <OgreConfigFile.h>
-#include <OgreEntity.h>
-#include <OgreException.h>
-#include <OgreFrameListener.h>
-#include <OgreLight.h>
-#include <OgreLog.h>
-#include <OgreLogManager.h>
-#include <OgreMath.h>
-#include <OgreMatrix3.h>
-#include <OgreMatrix4.h>
-#include <OgreMesh.h>
-#include <OgreOverlay.h>
-#include <OgreOverlayElement.h>
-#include <OgreOverlayManager.h>
-#include <OgreParticleEmitter.h>
-#include <OgreParticleSystem.h>
-#include <OgreQuaternion.h>
-#include <OgreResourceGroupManager.h>
-#include <OgreRenderWindow.h>
-#include <OgreRoot.h>
-#include <OgreSceneManager.h>
-#include <OgreSceneNode.h>
-#include <OgreString.h>
-#include <OgreStringConverter.h>
-#include <OgreTextureManager.h>
-#include <OgreTimer.h>
-#include <OgreVector2.h>
-#include <OgreVector3.h>
-#include <OgreVector3.h>
-#include <OgreViewport.h>
-#include <OgreWindowEventUtilities.h>
+
+#include <Ogre.h>
+#include <CEGUI.h>
+#include <boost/thread/recursive_mutex.hpp>
 
 //-----------------------------------------------------------------------
@@ -86,6 +54,4 @@
 //-----------------------------------------------------------------------
 
-#include "ois/OIS.h"
-#include "cpptcl/CppTcl.h"
 #include "tinyxml/ticpp.h"
 #include "tinyxml/tinyxml.h"
@@ -104,8 +70,9 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/CommandExecutor.h"
 #include "core/Debug.h"
+#include "core/Executor.h"
 #include "core/OutputBuffer.h"
 #include "core/OutputHandler.h"
-#include "core/Executor.h"
 #include "core/XMLPort.h"
 
Index: code/branches/gui/src/orxonox/Radar.cc
===================================================================
--- code/branches/gui/src/orxonox/Radar.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/Radar.cc	(revision 1638)
@@ -34,5 +34,6 @@
 #include "OrxonoxStableHeaders.h"
 #include "Radar.h"
-#include <float.h>
+#include <cfloat>
+#include <cassert>
 #include "objects/WorldEntity.h"
 #include "objects/SpaceShip.h"
Index: code/branches/gui/src/orxonox/RadarViewable.h
===================================================================
--- code/branches/gui/src/orxonox/RadarViewable.h	(revision 1636)
+++ code/branches/gui/src/orxonox/RadarViewable.h	(revision 1638)
@@ -32,4 +32,5 @@
 #include "OrxonoxPrereqs.h"
 #include <string>
+#include <cassert>
 #include "util/Math.h"
 #include "core/Debug.h"
Index: code/branches/gui/src/orxonox/Settings.cc
===================================================================
--- code/branches/gui/src/orxonox/Settings.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/Settings.cc	(revision 1638)
@@ -28,6 +28,7 @@
 
 /**
-    @file
-    @brief Implementation of the Settings class.
+@file
+@brief
+    Implementation of the Settings class.
 */
 
@@ -35,4 +36,5 @@
 #include "Settings.h"
 
+#include "util/String.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
@@ -40,66 +42,113 @@
 namespace orxonox
 {
-  /**
-    @brief Constructor: Registers the object and sets the config-values.
-  */
-  Settings::Settings()
-  {
-    RegisterRootObject(Settings);
-    setConfigValues();
-  }
 
-  Settings::~Settings()
-  {
-  }
+// Using a macro makes the above list much more readable.
+// Settings::addGameMode adds the mode in a map, so we can access game modes by string.
+#define CreateGameMode(name, showsGraphics, isMaster, hasServer)                                        \
+    const GameMode GameMode::GM_##name = { GameMode::name, showsGraphics, isMaster, hasServer, #name }; \
+    bool temporaryVariable##name = Settings::addGameMode(&GameMode::GM_##name)
 
-  /**
-    @brief Returns a unique instance of Core.
-    @return The instance
-  */
-  Settings& Settings::getSingleton()
-  {
-    static Settings instance;
-    return instance;
-  }
+    //                          showsGraphics  isMaster  hasServer
+    CreateGameMode(None,        false,         false,    false);
+    CreateGameMode(Unspecified, true,          false,    false);
+    CreateGameMode(Server,      true,          true,     true );
+    CreateGameMode(Client,      true,          false,    false);
+    CreateGameMode(Standalone,  true,          true,     false);
+    CreateGameMode(Dedicated,   false,         true,     true );
 
-  /**
-    @brief Function to collect the SetConfigValue-macro calls.
-  */
-  void Settings::setConfigValues()
-  {
-    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.");
-    if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+    /**
+    @brief
+        Constructor: Registers the object and sets the config-values.
+    */
+    Settings::Settings()
     {
-      ModifyConfigValue(dataPath_, set, dataPath_ + "/");
+        RegisterRootObject(Settings);
+        gameMode_ = GameMode::GM_Unspecified;
+        setConfigValues();
     }
 
-    if (dataPath_ == "")
+    /**
+    @brief
+        Returns a unique instance of Core.
+    @return
+        The instance
+    */
+    Settings& Settings::getInstance()
     {
-      ModifyConfigValue(dataPath_, set, "/");
-      COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
+        static Settings instance;
+        return instance;
     }
-  }
 
-  /**
-    @brief Temporary sets the data path
-    @param path The new data path
-  */
-  void Settings::_tsetDataPath(const std::string& path)
-  {
-    ModifyConfigValue(dataPath_, tset, path);
-  }
+    /**
+    @brief
+        Function to collect the SetConfigValue-macro calls.
+    */
+    void Settings::setConfigValues()
+    {
+        SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.");
+        if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+        {
+            ModifyConfigValue(dataPath_, set, dataPath_ + "/");
+        }
 
-  /*static*/ void Settings::tsetDataPath(const std::string& path)
-  {
-    getSingleton()._tsetDataPath(path);
-  }
+        if (dataPath_ == "")
+        {
+            ModifyConfigValue(dataPath_, set, "/");
+            COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
+        }
+    }
 
-  /**
-    @brief Returns the relative path to the game data.
-    @return The path to the game data
-  */
-  /*static*/ const std::string& Settings::getDataPath()
-  {
-    return getSingleton().dataPath_;
-  }
+    /**
+    @brief
+        Temporary sets the data path
+    @param path
+        The new data path
+    */
+    void Settings::_tsetDataPath(const std::string& path)
+    {
+        ModifyConfigValue(dataPath_, tset, path);
+    }
+
+    /**
+    @brief
+        Sets the game mode.
+    */
+    /*static*/ void Settings::setGameMode(const std::string& mode)
+    {
+        std::string modeL = getLowercase(mode);
+        std::map<std::string, const GameMode*>::const_iterator it = getInstance().gameModes_.find(modeL);
+        if (it != getInstance().gameModes_.end())
+            getInstance().gameMode_ = *(*it).second;
+        else
+        {
+            COUT(2) << "Warning: mode \"" << mode << "\" doesn't exist. "
+                    << "Defaulting to 'Standalone'" << std::endl;
+            getInstance().gameMode_ = GameMode::GM_Standalone;
+        }
+    }
+
+    /*static*/ bool Settings::addGameMode(const GameMode* mode)
+    {
+        getInstance().gameModes_[getLowercase(mode->name)] = mode;
+        return true;
+    }
+
+
+    /**
+    @brief
+        Gets an argument from the command line by name.
+    @return
+        Is 0 if name was not found.
+    */
+    /*static*/ const Settings::CommandLineArgument* Settings::getCommandLineArgument(const std::string &name)
+    {
+        std::map<std::string, CommandLineArgument>::const_iterator it = getInstance().commandArguments_.find(name);
+        if (it != getInstance().commandArguments_.end())
+        {
+            return &((*it).second);
+        }
+        else
+            return 0;
+    }
+
 }
Index: code/branches/gui/src/orxonox/Settings.h
===================================================================
--- code/branches/gui/src/orxonox/Settings.h	(revision 1636)
+++ code/branches/gui/src/orxonox/Settings.h	(revision 1638)
@@ -29,5 +29,5 @@
 /**
     @file Core.h
-    @brief Definition of the Settings class.
+    @brief Declaration of the Settings class.
 
     The static Settings class is only used to configure some variables
@@ -41,26 +41,151 @@
 #include <string>
 #include "core/OrxonoxClass.h"
+#include "core/Debug.h"
+#include "util/MultiTypeMath.h"
+#include "util/Convert.h"
 
 namespace orxonox
 {
-  class _OrxonoxExport Settings : public OrxonoxClass
-  {
+    /**
+    @brief
+        Defines a bit field structure that holds the mode as enum plus
+        the attributes as single named bits.
+        Every different GameMode is stored as static const, but if you wish to
+        compare two modes, you will have to use the 'mode' member variable.
+    */
+    struct GameMode
+    {
+        enum Mode
+        {
+            None,
+            Unspecified,
+            Server,
+            Client,
+            Standalone,
+            Dedicated,
+        };
+
+        Mode mode;
+        bool showsGraphics;
+        bool isMaster;
+        bool hasServer;
+        std::string name;
+
+        static const GameMode GM_None;
+        static const GameMode GM_Unspecified;
+        static const GameMode GM_Server;
+        static const GameMode GM_Client;
+        static const GameMode GM_Standalone;
+        static const GameMode GM_Dedicated;
+    };
+
+
+    class _OrxonoxExport Settings : public OrxonoxClass
+    {
     public:
-      void setConfigValues();
+        struct CommandLineArgument
+        {
+            std::string name_;
+            MultiTypeMath value_;
+            bool bHasDefaultValue_;
+        };
 
-      static const std::string& getDataPath();
+        void setConfigValues();
 
-      static void tsetDataPath(const std::string& path);
+        static const std::string& getDataPath();
+        static void tsetDataPath(const std::string& path);
+
+        static const GameMode& getGameMode();
+        static const GameMode& getGameMode(const std::string& name);
+        static void setGameMode(const GameMode& mode);
+        static void setGameMode(const std::string& mode);
+        static bool addGameMode(const GameMode* mode);
+
+        static const CommandLineArgument* getCommandLineArgument(const std::string& name);
+        template <class T>
+        static bool addCommandLineArgument(const std::string &name, const std::string& valueStr, const T& defaultValue);
 
     private:
-      Settings();
-      Settings(const Settings& instance);
-      ~Settings();
-      static Settings& getSingleton();
+        Settings();
+        Settings(const Settings& instance);
+        ~Settings() { }
+        static Settings& getInstance();
 
-      void _tsetDataPath(const std::string& path);
+        void _tsetDataPath(const std::string& path);
 
-      std::string dataPath_;               //!< Path to the game data
-  };
+        std::string dataPath_;                                        //!< Path to the game data
+        GameMode gameMode_;                                           //!< Current game mode
+        std::map<std::string, const GameMode*> gameModes_;            //!< Holds all game modes for easy string access
+        //! holds all command line arguments (even if not given!)
+        std::map<std::string, CommandLineArgument> commandArguments_;
+    };
+
+    /**
+    @brief
+        Returns the relative path to the game data.
+    */
+    inline const std::string& Settings::getDataPath()
+    {
+        return getInstance().dataPath_;
+    }
+
+    inline void Settings::tsetDataPath(const std::string& path)
+    {
+        getInstance()._tsetDataPath(path);
+    }
+
+    inline const GameMode& Settings::getGameMode()
+    {
+        return getInstance().gameMode_;
+    }
+
+    inline const GameMode& Settings::getGameMode(const std::string& name)
+    {
+        if (getInstance().gameModes_.find(name) != getInstance().gameModes_.end())
+            return *getInstance().gameModes_[name];
+        else
+        {
+            COUT(2) << "Warning: GameMode '" << name << "' doesn't exist." << std::endl;
+            return GameMode::GM_None;
+        }
+    }
+
+    inline void Settings::setGameMode(const GameMode& mode)
+    {
+        getInstance().gameMode_ = mode;
+    }
+
+    /**
+    @brief
+        Adds one argument of the command line to the map of command line arguments.
+    @param name
+        Name of the command line option.
+    @param valueStr
+        The value of the command line option as string
+    @param defaultValue
+        Default value for the option (marked when used).
+    @return
+        Dummy return value to enable code execution before main().
+    */
+    template <class T>
+    bool Settings::addCommandLineArgument(const std::string &name, const std::string& valueStr, const T& defaultValue)
+    {
+        T value;
+        bool useDefault = false;
+        if (valueStr == "")
+        {
+            // note: ArgReader only returns "" for not found arguments, " " otherwise for empty ones.
+            value = defaultValue;
+            useDefault = true;
+        }
+        else if (!convertValue(&value, valueStr))
+        {
+            COUT(1) << "Command Line: Couldn't read option '" << name << "'." << std::endl;
+            return false;
+        }
+        CommandLineArgument arg = { name, MultiTypeMath(value), useDefault };
+        getInstance().commandArguments_[name] = arg;
+        return true;
+    }
 }
 
Index: code/branches/gui/src/orxonox/gui/GUIManager.cc
===================================================================
--- code/branches/gui/src/orxonox/gui/GUIManager.cc	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/GUIManager.cc	(revision 1638)
@@ -0,0 +1,295 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Implementation of the GUIManager class.
+*/
+
+#include "OrxonoxStableHeaders.h"
+#include "GUIManager.h"
+
+#include <OgreRenderWindow.h>
+#include <OgreCEGUIRenderer.h>
+#include <OgreRoot.h>
+#include <CEGUI.h>
+#include <CEGUILua.h>
+#include "core/input/InputManager.h"
+#include "core/input/SimpleInputState.h"
+#include "core/tolua/tolua_bind.h"
+#include "core/ConsoleCommand.h"
+#include "core/Exception.h"
+#include "core/Core.h"
+#include "tolua/tolua_bind.h"
+#include "GraphicsEngine.h"
+
+extern "C" {
+#include <lualib.h>
+#include <lauxlib.h>
+}
+
+namespace orxonox
+{
+    SetConsoleCommandShortcut(GUIManager, showGUI_s).setKeybindMode(KeybindMode::OnPress);
+
+    GUIManager::GUIManager()
+        : emptySceneManager_(0)
+        , backgroundSceneManager_(0)
+        , emptyCamera_(0)
+        , backgroundCamera_(0)
+        , viewport_(0)
+        , renderWindow_(0)
+        , guiRenderer_(0)
+        , resourceProvider_(0)
+        , scriptModule_(0)
+        , guiSystem_(0)
+        , state_(Uninitialised)
+    {
+    }
+
+    GUIManager::~GUIManager()
+    {
+        // TODO: destruct at least something
+    }
+
+    bool GUIManager::initialise()
+    {
+        using namespace CEGUI;
+        if (state_ == Uninitialised)
+        {
+            COUT(3) << "Intialising CEGUI." << std::endl;
+
+            try
+            {
+                // get the render window
+                renderWindow_ = GraphicsEngine::getSingleton().getRenderWindow();
+
+                // 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
+                this->guiRenderer_ = new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_MAIN, true, 3000);
+                this->resourceProvider_ = guiRenderer_->createResourceProvider();
+                this->resourceProvider_->setDefaultResourceGroup("GUI");
+                
+                // setup scripting
+                this->scriptModule_ = new LuaScriptModule();
+
+                // create the CEGUI system singleton
+                this->guiSystem_ = new System(this->guiRenderer_, this->resourceProvider_, 0, this->scriptModule_);
+                
+                // set the log level according to ours (translate by subtracting 1)
+                Logger::getSingleton().setLoggingLevel(
+                    (LoggingLevel)(Core::getSoftDebugLevel(OutputHandler::LD_Logfile) - 1));
+                
+                // do this after 'new CEGUI::Sytem' because that creates the lua state in the first place
+                tolua_Core_open(this->scriptModule_->getLuaState());
+                tolua_Orxonox_open(this->scriptModule_->getLuaState());
+
+                // register us as input handler
+                SimpleInputState* state = InputManager::createSimpleInputState("gui", 30);
+                state->setHandler(this);
+                state->setJoyStickHandler(new EmptyHandler());
+
+                // load the background scene
+                loadScenes();
+            }
+            catch (CEGUI::Exception& ex)
+            {
+                throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
+                    ex.getFileName().c_str(), ex.getName().c_str());
+            }
+
+            state_ = Ready;
+        }
+        
+        return true;
+    }
+
+    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
+        try
+        {
+            this->scriptModule_->executeScriptFile("loadGUI.lua", "GUI");
+        }
+        catch (CEGUI::Exception& ex)
+        {
+            throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
+                ex.getFileName().c_str(), ex.getName().c_str());
+        }
+    }
+
+    void GUIManager::showGUI(const std::string& name, bool showBackground)
+    {
+        if (state_ != Uninitialised)
+        {
+            if (state_ == OnDisplay)
+                _hideGUI();
+
+            COUT(3) << "Loading GUI " << name << std::endl;
+            try
+            {
+                if (showBackground)
+                {
+                    // 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(this->emptySceneManager_);
+                    this->viewport_->setCamera(this->emptyCamera_);
+
+                    lua_pushboolean(this->scriptModule_->getLuaState(), false);
+                    lua_setglobal(this->scriptModule_->getLuaState(), "showBackground");
+                }
+
+                this->scriptModule_->executeScriptGlobal("showMainMenu");
+
+                InputManager::requestEnterState("gui");
+
+                this->state_ = OnDisplay;
+            }
+            catch (CEGUI::Exception& ex)
+            {
+                COUT(2) << "Error while executing lua script. Message:\n" << ex.getMessage() << std::endl;
+            }
+            catch (...)
+            {
+                COUT(2) << "Could show a menu due to unknown reasons." << std::endl;
+            }
+        }
+        else
+        {
+            COUT(2) << "Warning: GUI Manager not yet initialised, cannot load a GUI" << std::endl;
+        }
+    }
+
+    void GUIManager::_hideGUI()
+    {
+        if (this->state_ != OnDisplay)
+            return;
+        this->viewport_->setCamera(0);
+        this->state_ = Ready;
+        InputManager::requestLeaveState("gui");
+    }
+
+    void GUIManager::mouseButtonPressed(MouseButton::Enum id)
+    {
+        try
+        {
+            guiSystem_->injectMouseButtonDown(convertButton(id));
+        }
+        catch (CEGUI::ScriptException& ex)
+        {
+            // We simply ignore the exception and proceed
+            COUT(1) << ex.getMessage() << std::endl;
+        }
+    }
+
+    void GUIManager::mouseButtonReleased(MouseButton::Enum id)
+    {
+        try
+        {
+            guiSystem_->injectMouseButtonUp(convertButton(id));
+        }
+        catch (CEGUI::ScriptException& ex)
+        {
+            // We simply ignore the exception and proceed
+            COUT(1) << ex.getMessage() << std::endl;
+        }
+    }
+
+
+    /**
+    @brief
+        Returns a unique instance of GUIManager.
+    @return
+        The instance
+    */
+    GUIManager& GUIManager::getInstance()
+    {
+        static GUIManager instance;
+        return instance;
+    }
+
+    inline CEGUI::MouseButton GUIManager::convertButton(MouseButton::Enum button)
+    {
+        switch (button)
+        {
+        case MouseButton::Left:
+            return CEGUI::LeftButton;
+
+        case MouseButton::Right:
+            return CEGUI::RightButton;
+
+        case MouseButton::Middle:
+            return CEGUI::MiddleButton;
+
+        case MouseButton::Button3:
+            return CEGUI::X1Button;
+
+        case MouseButton::Button4:
+            return CEGUI::X2Button;
+
+        default:
+            return CEGUI::NoButton;
+        }
+    }
+}
Index: code/branches/gui/src/orxonox/gui/GUIManager.h
===================================================================
--- code/branches/gui/src/orxonox/gui/GUIManager.h	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/GUIManager.h	(revision 1638)
@@ -0,0 +1,131 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @brief Declaration of the GUIManager class.
+*/
+
+#ifndef _GUIManager_H__
+#define _GUIManager_H__
+
+#include "OrxonoxPrereqs.h"
+#include <OgrePrerequisites.h>
+#include <CEGUIForwardRefs.h>
+#include <CEGUIInputEvent.h>
+#include <CEGUISystem.h>
+#include "core/input/InputInterfaces.h"
+
+// forward declarations
+namespace CEGUI
+{
+    class OgreCEGUIRenderer;
+    class LuaScriptModule;
+}
+
+namespace orxonox // tolua_export
+{ // tolua_export
+    /**
+    @brief
+        Provides a simple interface to CEGUI with tolua methods and console commands
+    */
+    class _OrxonoxExport GUIManager : public KeyHandler, public MouseHandler
+    /*
+    class GUIManager { // tolua_export
+    */
+    {
+    public:
+        enum State
+        {
+            Uninitialised,
+            Ready,
+            OnDisplay
+        };
+
+        bool initialise();
+        void tick(float dt);
+        void showGUI(const std::string& name, bool showBackground); // tolua_export
+        void _hideGUI(); // tolua_export
+
+        static GUIManager& getInstance(); // tolua_export
+        static void showGUI_s(const std::string& name, bool showBackground)
+        {
+            getInstance().showGUI(name, showBackground);
+        }
+
+    private:
+        GUIManager();
+        GUIManager(const GUIManager& instance);
+        ~GUIManager();
+
+        void keyPressed (const KeyEvent& evt)
+        { guiSystem_->injectKeyDown(evt.key); guiSystem_->injectChar(evt.text); }
+        void keyReleased(const KeyEvent& evt)
+        { guiSystem_->injectKeyUp(evt.key); }
+        void keyHeld    (const KeyEvent& evt)
+        { }
+
+        void mouseButtonPressed (MouseButton::Enum id);
+        void mouseButtonReleased(MouseButton::Enum id);
+        void mouseButtonHeld    (MouseButton::Enum id)
+        { }
+        void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
+        { guiSystem_->injectMouseMove(rel.x, rel.y); }
+        void mouseScrolled      (int abs, int rel)
+        { guiSystem_->injectMouseWheelChange(rel);}
+
+        void tickInput(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_;
+        CEGUI::ResourceProvider*  resourceProvider_;
+        CEGUI::LuaScriptModule*   scriptModule_;
+        CEGUI::System*            guiSystem_;
+        CEGUI::Imageset*          backgroundImage_;
+
+        State state_;
+
+
+        static CEGUI::MouseButton convertButton(MouseButton::Enum button);
+    }; // tolua_export
+
+    inline void GUIManager::tick(float dt)
+    {
+        assert(guiSystem_);
+        guiSystem_->injectTimePulse(dt);
+    }
+} // tolua_export
+
+#endif /* _GUIManager_H__ */
Index: code/branches/gui/src/orxonox/gui/OgreCEGUIRenderer.cpp
===================================================================
--- code/branches/gui/src/orxonox/gui/OgreCEGUIRenderer.cpp	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/OgreCEGUIRenderer.cpp	(revision 1638)
@@ -0,0 +1,800 @@
+/************************************************************************
+    filename: 	OgreCEGUIRenderer.cpp
+    created:	11/5/2004
+    author:		Paul D Turner
+    
+    purpose:	Implementation of Renderer class for Ogre engine
+*************************************************************************/
+/*************************************************************************
+    Crazy Eddie's GUI System (http://www.cegui.org.uk)
+    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*************************************************************************/
+
+#include <CEGUIImagesetManager.h>
+#include <CEGUIImageset.h>
+#include <CEGUIImage.h>
+#include <CEGUIExceptions.h>
+#include <CEGUISystem.h>
+
+#include "OgreCEGUIRenderer.h"
+#include "OgreCEGUITexture.h"
+#include "OgreCEGUIResourceProvider.h"
+
+#include <OgreRenderSystem.h>
+#include <OgreRoot.h>
+#include <OgreHardwareBufferManager.h>
+#include <OgreRenderWindow.h>
+
+// Start of CEGUI namespace section
+namespace CEGUI
+{
+/*************************************************************************
+    Constants definitions
+*************************************************************************/
+const size_t	OgreCEGUIRenderer::VERTEX_PER_QUAD			= 6;
+const size_t	OgreCEGUIRenderer::VERTEX_PER_TRIANGLE		= 3;
+const size_t	OgreCEGUIRenderer::VERTEXBUFFER_INITIAL_CAPACITY	= 256;
+const size_t    OgreCEGUIRenderer::UNDERUSED_FRAME_THRESHOLD = 50000; // halfs buffer every 8 minutes on 100fps
+
+/*************************************************************************
+    Utility function to create a render operation and vertex buffer to render quads
+*************************************************************************/
+static void createQuadRenderOp(Ogre::RenderOperation &d_render_op, 
+    Ogre::HardwareVertexBufferSharedPtr &d_buffer, size_t nquads)
+{
+    using namespace Ogre;
+    // Create and initialise the Ogre specific parts required for use in rendering later.
+    d_render_op.vertexData = new VertexData;
+    d_render_op.vertexData->vertexStart = 0;
+
+    // setup vertex declaration for the vertex format we use
+    VertexDeclaration* vd = d_render_op.vertexData->vertexDeclaration;
+    size_t vd_offset = 0;
+    vd->addElement(0, vd_offset, VET_FLOAT3, VES_POSITION);
+    vd_offset += VertexElement::getTypeSize(VET_FLOAT3);
+    vd->addElement(0, vd_offset, VET_COLOUR, VES_DIFFUSE);
+    vd_offset += VertexElement::getTypeSize(VET_COLOUR);
+    vd->addElement(0, vd_offset, VET_FLOAT2, VES_TEXTURE_COORDINATES);
+
+    // create hardware vertex buffer
+    d_buffer = HardwareBufferManager::getSingleton().createVertexBuffer(vd->getVertexSize(0), nquads,  
+        HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE, false);
+
+    // bind vertex buffer
+    d_render_op.vertexData->vertexBufferBinding->setBinding(0, d_buffer);
+
+    // complete render operation basic initialisation
+    d_render_op.operationType = RenderOperation::OT_TRIANGLE_LIST;
+    d_render_op.useIndexes = false;
+}
+
+static void destroyQuadRenderOp(Ogre::RenderOperation &d_render_op, 
+    Ogre::HardwareVertexBufferSharedPtr &d_buffer)
+{
+    delete d_render_op.vertexData;
+    d_render_op.vertexData = 0;
+    d_buffer.setNull();
+}
+
+/*************************************************************************
+    Constructor
+*************************************************************************/
+OgreCEGUIRenderer::OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads)
+{
+    constructor_impl(window, queue_id, post_queue, max_quads);
+}
+
+
+/*************************************************************************
+    Constructor (specifying scene manager)
+*************************************************************************/
+OgreCEGUIRenderer::OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads, Ogre::SceneManager* scene_manager)
+{
+    constructor_impl(window, queue_id, post_queue, max_quads);
+
+    // hook into ogre rendering system
+    setTargetSceneManager(scene_manager);
+}
+
+
+/*************************************************************************
+    Destructor
+*************************************************************************/
+OgreCEGUIRenderer::~OgreCEGUIRenderer(void)
+{
+    setTargetSceneManager(NULL);
+
+    if (d_ourlistener)
+    {
+        delete d_ourlistener;
+    }
+
+    // cleanup vertex data we allocated in constructor
+    destroyQuadRenderOp(d_render_op, d_buffer);
+    destroyQuadRenderOp(d_direct_render_op, d_direct_buffer);
+
+    destroyAllTextures();
+}
+
+
+/*************************************************************************
+    add's a quad to the list to be rendered
+*************************************************************************/
+void OgreCEGUIRenderer::addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode)
+{
+    // if not queueing, render directly (as in, right now!). This is used for the mouse cursor.
+    if (!d_queueing)
+    {
+        renderQuadDirect(dest_rect, z, tex, texture_rect, colours, quad_split_mode);
+    }
+    else
+    {
+        d_sorted = false;
+        QuadInfo quad;
+        
+        // set quad position, flipping y co-ordinates, and applying appropriate texel origin offset
+        quad.position.d_left	= dest_rect.d_left;
+        quad.position.d_right	= dest_rect.d_right;
+        quad.position.d_top		= d_display_area.getHeight() - dest_rect.d_top;
+        quad.position.d_bottom	= d_display_area.getHeight() - dest_rect.d_bottom;
+        quad.position.offset(d_texelOffset);
+
+        // convert quad co-ordinates for a -1 to 1 co-ordinate system.
+        quad.position.d_left	/= (d_display_area.getWidth() * 0.5f);
+        quad.position.d_right	/= (d_display_area.getWidth() * 0.5f);
+        quad.position.d_top		/= (d_display_area.getHeight() * 0.5f);
+        quad.position.d_bottom	/= (d_display_area.getHeight() * 0.5f);
+        quad.position.offset(Point(-1.0f, -1.0f));
+
+        quad.z				= -1 + z;
+        quad.texture		= ((OgreCEGUITexture*)tex)->getOgreTexture();
+        quad.texPosition	= texture_rect;
+
+        // covert colours for ogre, note that top / bottom are switched.
+        quad.topLeftCol		= colourToOgre(colours.d_bottom_left);
+        quad.topRightCol	= colourToOgre(colours.d_bottom_right);
+        quad.bottomLeftCol	= colourToOgre(colours.d_top_left);
+        quad.bottomRightCol	= colourToOgre(colours.d_top_right);
+        
+        // set quad split mode
+        quad.splitMode = quad_split_mode;
+
+        d_quadlist.insert(quad);
+    }
+}
+
+
+
+/*************************************************************************
+perform final rendering for all queued renderable quads.
+*************************************************************************/
+void OgreCEGUIRenderer::doRender(void)
+{
+    // Render if overlays enabled and the quad list is not empty
+
+    // ORXONOX CHANGE: Even render when OverlaysEnabled is deactivated
+    // The reason is that we don't want the HUD to be shown in the viewport of the
+    // GUI (uses its own viewport to be able render on top of all viewports).
+    // But since we don't use overlays in the GUI, it doesn't matter.
+    //if (d_render_sys->_getViewport()->getOverlaysEnabled() && !d_quadlist.empty())
+    if (!d_quadlist.empty())
+    {
+        /// Quad list needs to be sorted and thus the vertex buffer rebuilt. If not, we can
+        /// reuse the vertex buffer resulting in a nice speed gain.
+        if(!d_sorted)
+        {
+            sortQuads();
+            /// Resize vertex buffer if it is too small
+            size_t size = d_buffer->getNumVertices();
+            size_t requestedSize = d_quadlist.size()*VERTEX_PER_QUAD;
+            if(size < requestedSize)
+            {
+                /// Double buffer size until smaller than requested size
+                while(size < requestedSize)
+                    size = size * 2;
+                /// Reallocate the buffer
+                destroyQuadRenderOp(d_render_op, d_buffer);
+                createQuadRenderOp(d_render_op, d_buffer, size);
+            }
+            else if(requestedSize < size/2 && d_underused_framecount >= UNDERUSED_FRAME_THRESHOLD)
+            {
+                /// Resize vertex buffer if it has been to big for too long
+                size = size / 2;
+                destroyQuadRenderOp(d_render_op, d_buffer);
+                createQuadRenderOp(d_render_op, d_buffer, size);
+                /// Reset underused framecount so it takes another UNDERUSED_FRAME_THRESHOLD to half again
+                d_underused_framecount = 0;
+            }
+            /// Fill the buffer
+            QuadVertex*	buffmem;
+            buffmem = (QuadVertex*)d_buffer->lock(Ogre::HardwareVertexBuffer::HBL_DISCARD);
+            // iterate over each quad in the list
+            for (QuadList::iterator i = d_quadlist.begin(); i != d_quadlist.end(); ++i)
+            {
+                const QuadInfo& quad = (*i);
+                // setup Vertex 1...
+                buffmem->x = quad.position.d_left;
+                buffmem->y = quad.position.d_bottom;
+                buffmem->z = quad.z;
+                buffmem->diffuse = quad.topLeftCol;
+                buffmem->tu1 = quad.texPosition.d_left;
+                buffmem->tv1 = quad.texPosition.d_bottom;
+                ++buffmem;
+    
+                // setup Vertex 2...
+                
+                // top-left to bottom-right diagonal
+                if (quad.splitMode == TopLeftToBottomRight)
+                {
+                    buffmem->x = quad.position.d_right;
+                    buffmem->y = quad.position.d_bottom;
+                    buffmem->z = quad.z;
+                    buffmem->diffuse = quad.topRightCol;
+                    buffmem->tu1 = quad.texPosition.d_right;
+                    buffmem->tv1 = quad.texPosition.d_bottom;
+                }
+                // bottom-left to top-right diagonal
+                else
+                {
+                    buffmem->x = quad.position.d_right;
+                    buffmem->y = quad.position.d_top;
+                    buffmem->z = quad.z;
+                    buffmem->diffuse = quad.bottomRightCol;
+                    buffmem->tu1 = quad.texPosition.d_right;
+                    buffmem->tv1 = quad.texPosition.d_top;
+                }
+                ++buffmem;
+    
+                // setup Vertex 3...
+                buffmem->x = quad.position.d_left;
+                buffmem->y = quad.position.d_top;
+                buffmem->z = quad.z;
+                buffmem->diffuse = quad.bottomLeftCol;
+                buffmem->tu1 = quad.texPosition.d_left;
+                buffmem->tv1 = quad.texPosition.d_top;
+                ++buffmem;
+    
+                // setup Vertex 4...
+                buffmem->x = quad.position.d_right;
+                buffmem->y = quad.position.d_bottom;
+                buffmem->z = quad.z;
+                buffmem->diffuse = quad.topRightCol;
+                buffmem->tu1 = quad.texPosition.d_right;
+                buffmem->tv1 = quad.texPosition.d_bottom;
+                ++buffmem;
+    
+                // setup Vertex 5...
+                buffmem->x = quad.position.d_right;
+                buffmem->y = quad.position.d_top;
+                buffmem->z = quad.z;
+                buffmem->diffuse = quad.bottomRightCol;
+                buffmem->tu1 = quad.texPosition.d_right;
+                buffmem->tv1 = quad.texPosition.d_top;
+                ++buffmem;
+    
+                // setup Vertex 6...
+                
+                // top-left to bottom-right diagonal
+                if (quad.splitMode == TopLeftToBottomRight)
+                {
+                    buffmem->x = quad.position.d_left;
+                    buffmem->y = quad.position.d_top;
+                    buffmem->z = quad.z;
+                    buffmem->diffuse = quad.bottomLeftCol;
+                    buffmem->tu1 = quad.texPosition.d_left;
+                    buffmem->tv1 = quad.texPosition.d_top;
+                }
+                // bottom-left to top-right diagonal
+                else
+                {
+                    buffmem->x = quad.position.d_left;
+                    buffmem->y = quad.position.d_bottom;
+                    buffmem->z = quad.z;
+                    buffmem->diffuse = quad.topLeftCol;
+                    buffmem->tu1 = quad.texPosition.d_left;
+                    buffmem->tv1 = quad.texPosition.d_bottom;
+                }
+                ++buffmem;
+            }
+    
+            // ensure we leave the buffer in the unlocked state
+            d_buffer->unlock();
+        }
+        
+        /// Render the buffer
+        d_bufferPos = 0;
+        bool first = true;
+
+        // Iterate over each quad in the list and render it
+        QuadList::iterator i = d_quadlist.begin();
+        while(i != d_quadlist.end())
+        {
+            
+            d_currTexture = i->texture;
+            d_render_op.vertexData->vertexStart = d_bufferPos;
+            for (; i != d_quadlist.end(); ++i)
+            {
+                const QuadInfo& quad = (*i);
+                if (d_currTexture != quad.texture)
+                {
+                    /// If it has a different texture, render this quad in next operation
+                    /// also need to reset render states
+                    first = true;
+                    break;
+                }
+                d_bufferPos += VERTEX_PER_QUAD;
+            }
+            d_render_op.vertexData->vertexCount = d_bufferPos - d_render_op.vertexData->vertexStart;
+            /// Set texture, and do the render
+            d_render_sys->_setTexture(0, true, d_currTexture);
+            if (first)
+            {
+                initRenderStates();
+                first = false;
+            }
+            d_render_sys->_render(d_render_op);
+        }
+
+    }
+    /// Count frames to check if utilization of vertex buffer was below half the capacity for 500,000 frames
+    if(d_bufferPos < d_buffer->getNumVertices()/2)
+       d_underused_framecount++;
+    else
+       d_underused_framecount = 0;
+}
+
+
+/*************************************************************************
+    clear the queue
+*************************************************************************/
+void OgreCEGUIRenderer::clearRenderList(void)
+{
+    d_sorted = true;
+    d_quadlist.clear();
+}
+
+
+/*************************************************************************
+    create an empty texture
+*************************************************************************/
+Texture* OgreCEGUIRenderer::createTexture(void)
+{
+    OgreCEGUITexture* tex = new OgreCEGUITexture(this);
+    d_texturelist.push_back(tex);
+    return tex;
+}
+
+
+/*************************************************************************
+    create a texture and load it with the specified file.
+*************************************************************************/
+Texture* OgreCEGUIRenderer::createTexture(const String& filename, const String& resourceGroup)
+{
+    OgreCEGUITexture* tex = (OgreCEGUITexture*)createTexture();
+    tex->loadFromFile(filename, resourceGroup);
+
+    return tex;
+}
+
+
+/*************************************************************************
+    create a texture and set it to the specified size
+*************************************************************************/
+Texture* OgreCEGUIRenderer::createTexture(float size)
+{
+    OgreCEGUITexture* tex = (OgreCEGUITexture*)createTexture();
+    tex->setOgreTextureSize((uint)size);
+
+    return tex;
+}
+
+
+/*************************************************************************
+    destroy the given texture
+*************************************************************************/
+void OgreCEGUIRenderer::destroyTexture(Texture* texture)
+{
+    if (texture != NULL)
+    {
+        OgreCEGUITexture* tex = (OgreCEGUITexture*)texture;
+
+        d_texturelist.remove(tex);
+        delete tex;
+    }
+}
+
+
+/*************************************************************************
+    destroy all textures still active
+*************************************************************************/
+void OgreCEGUIRenderer::destroyAllTextures(void)
+{
+    while (!d_texturelist.empty())
+    {
+        destroyTexture(*(d_texturelist.begin()));
+    }
+}
+
+
+/*************************************************************************
+    setup states etc	
+*************************************************************************/
+void OgreCEGUIRenderer::initRenderStates(void)
+{
+    using namespace Ogre;
+
+    // set-up matrices
+    d_render_sys->_setWorldMatrix(Matrix4::IDENTITY);
+    d_render_sys->_setViewMatrix(Matrix4::IDENTITY);
+    d_render_sys->_setProjectionMatrix(Matrix4::IDENTITY);
+
+    // initialise render settings
+    d_render_sys->setLightingEnabled(false);
+    d_render_sys->_setDepthBufferParams(false, false);
+    d_render_sys->_setDepthBias(0, 0);
+    d_render_sys->_setCullingMode(CULL_NONE);
+    d_render_sys->_setFog(FOG_NONE);
+    d_render_sys->_setColourBufferWriteEnabled(true, true, true, true);
+    d_render_sys->unbindGpuProgram(GPT_FRAGMENT_PROGRAM);
+    d_render_sys->unbindGpuProgram(GPT_VERTEX_PROGRAM);
+    d_render_sys->setShadingType(SO_GOURAUD);
+    d_render_sys->_setPolygonMode(PM_SOLID);
+
+    // initialise texture settings
+    d_render_sys->_setTextureCoordCalculation(0, TEXCALC_NONE);
+    d_render_sys->_setTextureCoordSet(0, 0);
+    d_render_sys->_setTextureUnitFiltering(0, FO_LINEAR, FO_LINEAR, FO_POINT);
+    d_render_sys->_setTextureAddressingMode(0, d_uvwAddressMode);
+    d_render_sys->_setTextureMatrix(0, Matrix4::IDENTITY);
+    d_render_sys->_setAlphaRejectSettings(CMPF_ALWAYS_PASS, 0);
+    d_render_sys->_setTextureBlendMode(0, d_colourBlendMode);
+    d_render_sys->_setTextureBlendMode(0, d_alphaBlendMode);
+    d_render_sys->_disableTextureUnitsFrom(1);
+
+    // enable alpha blending
+    d_render_sys->_setSceneBlending(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
+}
+
+
+ 
+/*************************************************************************
+    sort quads list according to texture	
+*************************************************************************/
+void OgreCEGUIRenderer::sortQuads(void)
+{
+    if (!d_sorted)
+    {
+        d_sorted = true;
+    }
+
+}
+
+/*************************************************************************
+render a quad directly to the display
+*************************************************************************/
+void OgreCEGUIRenderer::renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode)
+{
+    // ORXONOX CHANGE: Even render when OverlaysEnabled is deactivated
+    // The reason is that we don't want the HUD to be shown in the viewport of the
+    // GUI (uses its own viewport to be able render on top of all viewports).
+    // But since we don't use overlays in the GUI, it doesn't matter.
+    //if (d_render_sys->_getViewport()->getOverlaysEnabled())
+    if (true)
+    {
+        z = -1 + z;
+
+        Rect final_rect;
+
+        // set quad position, flipping y co-ordinates, and applying appropriate texel origin offset
+        final_rect.d_left	= dest_rect.d_left;
+        final_rect.d_right	= dest_rect.d_right;
+        final_rect.d_top	= d_display_area.getHeight() - dest_rect.d_top;
+        final_rect.d_bottom	= d_display_area.getHeight() - dest_rect.d_bottom;
+        final_rect.offset(d_texelOffset);
+
+        // convert quad co-ordinates for a -1 to 1 co-ordinate system.
+        final_rect.d_left	/= (d_display_area.getWidth() * 0.5f);
+        final_rect.d_right	/= (d_display_area.getWidth() * 0.5f);
+        final_rect.d_top	/= (d_display_area.getHeight() * 0.5f);
+        final_rect.d_bottom	/= (d_display_area.getHeight() * 0.5f);
+        final_rect.offset(Point(-1.0f, -1.0f));
+
+        // convert colours for ogre, note that top / bottom are switched.
+        uint32 topLeftCol	= colourToOgre(colours.d_bottom_left);
+        uint32 topRightCol	= colourToOgre(colours.d_bottom_right);
+        uint32 bottomLeftCol	= colourToOgre(colours.d_top_left);
+        uint32 bottomRightCol= colourToOgre(colours.d_top_right);
+
+        QuadVertex*	buffmem = (QuadVertex*)d_direct_buffer->lock(Ogre::HardwareVertexBuffer::HBL_DISCARD);
+
+        // setup Vertex 1...
+        buffmem->x	= final_rect.d_left;
+        buffmem->y	= final_rect. d_bottom;
+        buffmem->z	= z;
+        buffmem->diffuse = topLeftCol;
+        buffmem->tu1	= texture_rect.d_left;
+        buffmem->tv1	= texture_rect.d_bottom;
+        ++buffmem;
+
+        // setup Vertex 2...
+        
+        // top-left to bottom-right diagonal
+        if (quad_split_mode == TopLeftToBottomRight)
+        {
+            buffmem->x	= final_rect.d_right;
+            buffmem->y = final_rect.d_bottom;
+            buffmem->z	= z;
+            buffmem->diffuse = topRightCol;
+            buffmem->tu1	= texture_rect.d_right;
+            buffmem->tv1	= texture_rect.d_bottom;
+            ++buffmem;
+        }
+        // bottom-left to top-right diagonal
+        else
+        {
+            buffmem->x	= final_rect.d_right;
+            buffmem->y = final_rect.d_top;
+            buffmem->z	= z;
+            buffmem->diffuse = bottomRightCol;
+            buffmem->tu1	= texture_rect.d_right;
+            buffmem->tv1	= texture_rect.d_top;
+            ++buffmem;
+        }
+
+        // setup Vertex 3...
+        buffmem->x	= final_rect.d_left;
+        buffmem->y	= final_rect.d_top;
+        buffmem->z	= z;
+        buffmem->diffuse = bottomLeftCol;
+        buffmem->tu1	= texture_rect.d_left;
+        buffmem->tv1	= texture_rect.d_top;
+        ++buffmem;
+
+        // setup Vertex 4...
+        buffmem->x	= final_rect.d_right;
+        buffmem->y	= final_rect.d_bottom;
+        buffmem->z	= z;
+        buffmem->diffuse = topRightCol;
+        buffmem->tu1	= texture_rect.d_right;
+        buffmem->tv1	= texture_rect.d_bottom;
+        ++buffmem;
+
+        // setup Vertex 5...
+        buffmem->x	= final_rect.d_right;
+        buffmem->y	= final_rect.d_top;
+        buffmem->z	= z;
+        buffmem->diffuse = bottomRightCol;
+        buffmem->tu1	= texture_rect.d_right;
+        buffmem->tv1	= texture_rect.d_top;
+        ++buffmem;
+
+        // setup Vertex 6...
+        
+        // top-left to bottom-right diagonal
+        if (quad_split_mode == TopLeftToBottomRight)
+        {
+            buffmem->x	= final_rect.d_left;
+            buffmem->y = final_rect.d_top;
+            buffmem->z	= z;
+            buffmem->diffuse = bottomLeftCol;
+            buffmem->tu1	= texture_rect.d_left;
+            buffmem->tv1	= texture_rect.d_top;
+        }
+        // bottom-left to top-right diagonal
+        else
+        {
+            buffmem->x	= final_rect.d_left;
+            buffmem->y = final_rect.d_bottom;
+            buffmem->z	= z;
+            buffmem->diffuse = topLeftCol;
+            buffmem->tu1	= texture_rect.d_left;
+            buffmem->tv1	= texture_rect.d_bottom;
+        }
+
+        d_direct_buffer->unlock();
+
+        //
+        // perform rendering...
+        //
+        d_render_sys->_setTexture(0, true, ((OgreCEGUITexture*)tex)->getOgreTexture()->getName());
+        initRenderStates();
+        d_direct_render_op.vertexData->vertexCount = VERTEX_PER_QUAD;
+        d_render_sys->_render(d_direct_render_op);
+    }
+
+}
+
+/*************************************************************************
+    convert ARGB colour value to whatever the Ogre render system is
+    expecting.	
+*************************************************************************/
+uint32 OgreCEGUIRenderer::colourToOgre(const colour& col) const
+{
+    Ogre::ColourValue cv(col.getRed(), col.getGreen(), col.getBlue(), col.getAlpha());
+
+    uint32 final;
+    d_render_sys->convertColourValue(cv, &final);
+
+    return final;
+}
+
+
+/*************************************************************************
+    Set the scene manager to be used for rendering the GUI.	
+*************************************************************************/
+void OgreCEGUIRenderer::setTargetSceneManager(Ogre::SceneManager* scene_manager)
+{
+    // unhook from current scene manager.
+    if (d_sceneMngr != NULL)
+    {
+        d_sceneMngr->removeRenderQueueListener(d_ourlistener);
+        d_sceneMngr = NULL;
+    }
+
+    // hook new scene manager if that is not NULL
+    if (scene_manager != NULL)
+    {
+        d_sceneMngr = scene_manager;
+        d_sceneMngr->addRenderQueueListener(d_ourlistener);
+    }
+
+}
+
+
+/*************************************************************************
+    Set the target render queue for GUI rendering.	
+*************************************************************************/
+void OgreCEGUIRenderer::setTargetRenderQueue(Ogre::uint8 queue_id, bool post_queue)
+{
+    d_queue_id		= queue_id;
+    d_post_queue	= post_queue;
+
+    if (d_ourlistener != NULL)
+    {
+        d_ourlistener->setTargetRenderQueue(queue_id);
+        d_ourlistener->setPostRenderQueue(post_queue);
+    }
+
+}
+
+
+/*************************************************************************
+    perform main work of the constructor
+*************************************************************************/
+void OgreCEGUIRenderer::constructor_impl(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads)
+{
+    using namespace Ogre;
+
+    // initialise the renderer fields
+    d_queueing		= true;
+    d_queue_id		= queue_id;
+    d_currTexture.isNull();
+    d_post_queue	= post_queue;
+    d_sceneMngr		= NULL;
+    d_bufferPos		= 0;
+    d_sorted		= true;
+    d_ogre_root		= Root::getSingletonPtr();
+    d_render_sys	= d_ogre_root->getRenderSystem();
+    // set ID string
+    d_identifierString = "CEGUI::OgreRenderer - Official Ogre based renderer module for CEGUI";
+
+    // Create and initialise the Ogre specific parts required for use in rendering later.
+    // Main GUI
+    createQuadRenderOp(d_render_op, d_buffer, VERTEXBUFFER_INITIAL_CAPACITY);
+    d_underused_framecount = 0;
+
+    // Mouse cursor
+    createQuadRenderOp(d_direct_render_op, d_direct_buffer, VERTEX_PER_QUAD);
+
+    // Discover display settings and setup d_display_area
+    d_display_area.d_left	= 0;
+    d_display_area.d_top	= 0;
+    d_display_area.d_right	= window->getWidth();
+    d_display_area.d_bottom	= window->getHeight();
+
+    // initialise required texel offset
+    d_texelOffset = Point((float)d_render_sys->getHorizontalTexelOffset(), -(float)d_render_sys->getVerticalTexelOffset());
+
+    // create listener which will handler the rendering side of things for us.
+    d_ourlistener = new CEGUIRQListener(this, queue_id, post_queue);
+
+    // Initialise blending modes to be used.
+    d_colourBlendMode.blendType	= Ogre::LBT_COLOUR;
+    d_colourBlendMode.source1	= Ogre::LBS_TEXTURE;
+    d_colourBlendMode.source2	= Ogre::LBS_DIFFUSE;
+    d_colourBlendMode.operation	= Ogre::LBX_MODULATE;
+
+    d_alphaBlendMode.blendType	= Ogre::LBT_ALPHA;
+    d_alphaBlendMode.source1	= Ogre::LBS_TEXTURE;
+    d_alphaBlendMode.source2	= Ogre::LBS_DIFFUSE;
+    d_alphaBlendMode.operation	= Ogre::LBX_MODULATE;
+
+    d_uvwAddressMode.u = Ogre::TextureUnitState::TAM_CLAMP;
+    d_uvwAddressMode.v = Ogre::TextureUnitState::TAM_CLAMP;
+    d_uvwAddressMode.w = Ogre::TextureUnitState::TAM_CLAMP;
+}
+
+
+/*************************************************************************
+    Create a texture from an existing Ogre::TexturePtr object	
+*************************************************************************/
+Texture* OgreCEGUIRenderer::createTexture(Ogre::TexturePtr& texture)
+{
+    OgreCEGUITexture* t = (OgreCEGUITexture*)createTexture();
+
+    if (!texture.isNull())
+    {
+        t->setOgreTexture(texture);
+    }
+
+    return t;
+
+}
+
+/*************************************************************************
+    Create a resource provider object
+*************************************************************************/
+ResourceProvider* OgreCEGUIRenderer::createResourceProvider(void)
+{
+    d_resourceProvider = new OgreCEGUIResourceProvider();
+    return d_resourceProvider;
+}
+
+/*************************************************************************
+Set the size of the display in pixels.	
+*************************************************************************/
+void OgreCEGUIRenderer::setDisplaySize(const Size& sz)
+{
+    if (d_display_area.getSize() != sz)
+    {
+        d_display_area.setSize(sz);
+
+        EventArgs args;
+        fireEvent(EventDisplaySizeChanged, args, EventNamespace);
+    }
+
+}
+
+/*************************************************************************
+    Callback from Ogre invoked before other stuff in our target queue
+    is rendered
+*************************************************************************/
+void CEGUIRQListener::renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, 
+                                         bool& skipThisQueue)
+{
+    if ((!d_post_queue) && (d_queue_id == id))
+    {
+        CEGUI::System::getSingleton().renderGUI();
+    }
+
+}
+
+
+/*************************************************************************
+Callback from Ogre invoked after other stuff in our target queue
+is rendered
+*************************************************************************/
+void CEGUIRQListener::renderQueueEnded(Ogre::uint8 id, const Ogre::String& invocation, bool& repeatThisQueue)
+{
+    if ((d_post_queue) && (d_queue_id == id))
+    {
+        CEGUI::System::getSingleton().renderGUI();
+    }
+
+}
+
+} // End of  CEGUI namespace section
Index: code/branches/gui/src/orxonox/gui/OgreCEGUIRenderer.h
===================================================================
--- code/branches/gui/src/orxonox/gui/OgreCEGUIRenderer.h	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/OgreCEGUIRenderer.h	(revision 1638)
@@ -0,0 +1,464 @@
+/************************************************************************
+    filename: 	OgreCEGUIRenderer.h
+    created:	11/5/2004
+    author:		Paul D Turner
+
+    purpose:	Interface for main Ogre GUI renderer class
+*************************************************************************/
+/*************************************************************************
+    Crazy Eddie's GUI System (http://www.cegui.org.uk)
+    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*************************************************************************/
+/*************************************************************************
+    This file contains code that is specific to Ogre (http://www.ogre3d.org)
+*************************************************************************/
+#ifndef _OgreCEGUIRenderer_h_
+#define _OgreCEGUIRenderer_h_
+
+#include <CEGUIBase.h>
+#include <CEGUIRenderer.h>
+#include <CEGUITexture.h>
+
+#include <OgreRenderQueueListener.h>
+#include <OgreSceneManagerEnumerator.h>
+#include <OgreTextureUnitState.h>
+
+#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32) && !defined(OGRE_STATIC_LIB)
+#   ifdef OGRE_GUIRENDERER_EXPORTS
+#       define OGRE_GUIRENDERER_API __declspec(dllexport)
+#   else
+#       if defined(__MINGW32__)
+#           define OGRE_GUIRENDERER_API
+#       else
+#           define OGRE_GUIRENDERER_API __declspec(dllimport)
+#       endif
+#   endif
+#elif defined ( OGRE_GCC_VISIBILITY )
+#    define OGRE_GUIRENDERER_API  __attribute__ ((visibility("default")))
+#else
+#    define OGRE_GUIRENDERER_API
+#endif
+
+
+// Start of CEGUI namespace section
+namespace CEGUI
+{
+/*************************************************************************
+    Forward refs
+*************************************************************************/
+class OgreCEGUITexture;
+class OgreCEGUIRenderer;
+
+
+/*!
+\brief
+    RenderQueueListener based class used to hook into the ogre rendering system
+*/
+class _OgrePrivate CEGUIRQListener : public Ogre::RenderQueueListener
+{
+public:
+    CEGUIRQListener(OgreCEGUIRenderer* renderer, Ogre::uint8 queue_id, bool post_queue)
+    {
+        d_renderer		= renderer;
+        d_queue_id		= queue_id;
+        d_post_queue	= post_queue;
+    }
+
+    virtual ~CEGUIRQListener() {}
+
+    virtual void	renderQueueStarted(Ogre::uint8 id, const Ogre::String& invocation, bool& skipThisQueue);
+    virtual void	renderQueueEnded(Ogre::uint8 id, const Ogre::String& invocation, bool& repeatThisQueue);
+
+    // methods for adjusting target queue settings
+    void	setTargetRenderQueue(Ogre::uint8 queue_id)		{d_queue_id = queue_id;}
+    void	setPostRenderQueue(bool post_queue)		{d_post_queue = post_queue;}
+
+private:
+    /*************************************************************************
+        Implementation Data
+    *************************************************************************/
+    OgreCEGUIRenderer*				d_renderer;		//!< CEGUI renderer object for Ogre.
+    Ogre::uint8	d_queue_id;		//!< ID of the queue that we are hooked into
+    bool						d_post_queue;	//!< true if we render after everything else in our queue.
+};
+
+
+/*!
+\brief
+    Renderer class to interface with Ogre engine.
+*/
+class OGRE_GUIRENDERER_API OgreCEGUIRenderer : public Renderer
+{
+public:
+    /*!
+    \brief
+        Constructor for renderer class that uses Ogre for rendering. Note that if
+        you use this option you must call setTargetSceneManager before rendering.
+
+    \param window
+        Pointer to an Ogre::RenderWindow object.
+
+    \param queue_id
+        Ogre::uint8 value that specifies where the GUI should appear in the ogre rendering output.
+
+    \param post_queue
+        set to true to have GUI rendered after render queue \a queue_id, or false to have the GUI rendered before render queue
+        \a queue_id.
+
+    \param max_quads
+        Obsolete.  Set to 0.
+
+    */
+    OgreCEGUIRenderer(Ogre::RenderWindow* window,
+        Ogre::uint8 queue_id = Ogre::RENDER_QUEUE_OVERLAY,
+        bool post_queue = false, uint max_quads = 0);
+
+
+    /*!
+    \brief
+        Constructor for renderer class that uses Ogre for rendering.
+
+    \param window
+        Pointer to an Ogre::RenderWindow object.
+
+    \param queue_id
+        Ogre::uint8 value that specifies where the GUI should appear in the ogre rendering output.
+
+    \param post_queue
+        set to true to have GUI rendered after render queue \a queue_id, or false to have the GUI rendered before render queue
+        \a queue_id.
+
+    \param max_quads
+        Obsolete.  Set to 0.
+
+    \param scene_manager
+        Pointer to an Ogre::SceneManager object that is to be used for GUI rendering.
+    */
+    OgreCEGUIRenderer(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads, Ogre::SceneManager* scene_manager);
+
+
+    /*!
+    \brief
+        Destructor for Ogre renderer.
+    */
+    virtual ~OgreCEGUIRenderer(void);
+
+
+
+    // add's a quad to the list to be rendered
+    virtual	void	addQuad(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);
+
+    // perform final rendering for all queued renderable quads.
+    virtual	void	doRender(void);
+
+    // clear the queue
+    virtual	void	clearRenderList(void);
+
+
+    /*!
+    \brief
+        Enable or disable the queueing of quads from this point on.
+
+        This only affects queueing.  If queueing is turned off, any calls to addQuad will cause the quad to be rendered directly.  Note that
+        disabling queueing will not cause currently queued quads to be rendered, nor is the queue cleared - at any time the queue can still
+        be drawn by calling doRender, and the list can be cleared by calling clearRenderList.  Re-enabling the queue causes subsequent quads
+        to be added as if queueing had never been disabled.
+
+    \param setting
+        true to enable queueing, or false to disable queueing (see notes above).
+
+    \return
+        Nothing
+    */
+    virtual void	setQueueingEnabled(bool setting)		{d_queueing = setting;}
+
+
+    // create an empty texture
+    virtual	Texture*	createTexture(void);
+
+    // create a texture and load it with the specified file.
+    virtual	Texture*	createTexture(const String& filename, const String& resourceGroup = "General");
+
+    // create a texture and set it to the specified size
+    virtual	Texture*	createTexture(float size);
+
+    // create an OGRE resource provider.
+    virtual ResourceProvider* createResourceProvider(void);
+
+    // destroy the given texture
+    virtual	void		destroyTexture(Texture* texture);
+
+    // destroy all textures still active
+    virtual void		destroyAllTextures(void);
+
+
+    /*!
+    \brief
+        Return whether queueing is enabled.
+
+    \return
+        true if queueing is enabled, false if queueing is disabled.
+    */
+    virtual bool	isQueueingEnabled(void) const	{return d_queueing;}
+
+
+    /*!
+    \brief
+    Return the current width of the display in pixels
+
+    \return
+    float value equal to the current width of the display in pixels.
+    */
+    virtual float	getWidth(void) const		{return d_display_area.getWidth();}
+
+
+    /*!
+    \brief
+    Return the current height of the display in pixels
+
+    \return
+    float value equal to the current height of the display in pixels.
+    */
+    virtual float	getHeight(void) const		{return d_display_area.getHeight();}
+
+
+    /*!
+    \brief
+    Return the size of the display in pixels
+
+    \return
+    Size object describing the dimensions of the current display.
+    */
+    virtual Size	getSize(void) const			{return d_display_area.getSize();}
+
+
+    /*!
+    \brief
+    Return a Rect describing the screen
+
+    \return
+    A Rect object that describes the screen area.  Typically, the top-left values are always 0, and the size of the area described is
+    equal to the screen resolution.
+    */
+    virtual Rect	getRect(void) const			{return d_display_area;}
+
+
+    /*!
+    \brief
+        Return the maximum texture size available
+
+    \return
+        Size of the maximum supported texture in pixels (textures are always assumed to be square)
+    */
+    virtual	uint	getMaxTextureSize(void) const		{return 2048;}		// TODO: Change to proper value
+
+
+    /*!
+    \brief
+        Return the horizontal display resolution dpi
+
+    \return
+        horizontal resolution of the display in dpi.
+    */
+    virtual	uint	getHorzScreenDPI(void) const	{return 96;}
+
+
+    /*!
+    \brief
+        Return the vertical display resolution dpi
+
+    \return
+        vertical resolution of the display in dpi.
+    */
+    virtual	uint	getVertScreenDPI(void) const	{return 96;}
+
+
+    /*!
+    \brief
+        Set the scene manager to be used for rendering the GUI.
+
+        The GUI system will be unhooked from the current scene manager and attached to what ever
+        is specified here.
+
+    \param scene_manager
+        Pointer to an Ogre::SceneManager object that is the new target Ogre::SceneManager to be
+        used for GUI rendering.
+
+    \return
+        Nothing.
+    */
+    void	setTargetSceneManager(Ogre::SceneManager* scene_manager);
+
+
+    /*!
+    \brief
+        Set the target render queue for GUI rendering.
+
+    \param queue_id
+        Ogre::uint8 value specifying the render queue that the GUI system should attach to.
+
+    \param post_queue
+        - true to specify that the GUI should render after everything else in render queue \a queue_id.
+        - false to specify the GUI should render before everything else in render queue \a queue_id.
+
+    \return
+        Nothing.
+    */
+    void	setTargetRenderQueue(Ogre::uint8 queue_id, bool post_queue);
+
+
+    /*!
+    \brief
+        Create a texture from an existing Ogre::TexturePtr object.
+
+    \note
+        If you want to use an Ogre::RenderTexture (for putting rendered output onto Gui elements or other
+        advanced techniques), you can get the Ogre::TexturePtr to be used by calling Ogre::TextureManager::getByName()
+        passing the name returned from Ogre::RenderTexture::getName() (and casting the result as necessary).
+
+    \param texture
+        pointer to an Ogre::TexturePtr object to be used as the basis for the new CEGUI::Texture
+
+    \return
+        Pointer to the newly created CEGUI::TexturePtr object.
+    */
+    Texture*	createTexture(Ogre::TexturePtr& texture);
+
+
+    /*!
+    \brief
+    Set the size of the display in pixels.
+
+    You do not have to call this method under normal operation as the system
+    will automatically extract the size from the current view port.
+
+    \note
+    This method will cause the EventDisplaySizeChanged event to fire if the
+    display size has changed.
+
+    \param sz
+    Size object describing the size of the display.
+
+    \return
+    Nothing.
+    */
+    void	setDisplaySize(const Size& sz);
+
+
+private:
+    /************************************************************************
+        Implementation Constants
+    ************************************************************************/
+    static const size_t    VERTEX_PER_QUAD;						 //!< number of vertices per quad
+    static const size_t    VERTEX_PER_TRIANGLE;					 //!< number of vertices for a triangle
+    static const size_t    VERTEXBUFFER_INITIAL_CAPACITY;		 //!< initial capacity of the allocated vertex buffer
+    static const size_t    UNDERUSED_FRAME_THRESHOLD;            //!< number of frames to wait before shrinking buffer
+
+    /*************************************************************************
+        Implementation Structs & classes
+    *************************************************************************/
+    /*!
+    \brief
+        structure used for all vertices.
+    */
+    struct QuadVertex {
+        float x, y, z;			//!< The position for the vertex.
+        Ogre::RGBA diffuse;		//!< colour of the vertex
+        float tu1, tv1;			//!< texture coordinates
+    };
+
+    /*!
+    \brief
+        structure holding details about a quad to be drawn
+    */
+    struct QuadInfo
+    {
+        Ogre::TexturePtr		texture;
+        Rect				position;
+        float				z;
+        Rect				texPosition;
+        uint32		        topLeftCol;
+        uint32		        topRightCol;
+        uint32		        bottomLeftCol;
+        uint32		        bottomRightCol;
+
+        QuadSplitMode		splitMode;
+
+        bool operator<(const QuadInfo& other) const
+        {
+            // this is intentionally reversed.
+            return z > other.z;
+        }
+    };
+
+
+    /*************************************************************************
+        Implementation Methods
+    *************************************************************************/
+    // setup states etc
+    void	initRenderStates(void);
+
+    // sort quads list according to texture
+    void	sortQuads(void);
+
+    // render a quad directly to the display
+    void	renderQuadDirect(const Rect& dest_rect, float z, const Texture* tex, const Rect& texture_rect, const ColourRect& colours, QuadSplitMode quad_split_mode);
+
+    // convert colour value to whatever the Ogre render system is expecting.
+    uint32    colourToOgre(const colour& col) const;
+
+    // perform main work of the constructor.  This does everything except the final hook into the render system.
+    void	constructor_impl(Ogre::RenderWindow* window, Ogre::uint8 queue_id, bool post_queue, uint max_quads);
+
+
+    /*************************************************************************
+        Implementation Data
+    *************************************************************************/
+    Rect				d_display_area;
+
+    typedef std::multiset<QuadInfo>		QuadList;
+    QuadList d_quadlist;
+    bool	 d_queueing;		//!< setting for queueing control.
+
+    // Ogre specific bits.
+    Ogre::Root*					d_ogre_root;		//!< pointer to the Ogre root object that we attach to
+    Ogre::RenderSystem*			d_render_sys;		//!< Pointer to the render system for Ogre.
+    Ogre::uint8	d_queue_id;			//!< ID of the queue that we are hooked into
+    Ogre::TexturePtr			d_currTexture;		//!< currently set texture;
+    Ogre::RenderOperation		d_render_op;		//!< Ogre render operation we use to do our stuff.
+    Ogre::HardwareVertexBufferSharedPtr	d_buffer;	//!< vertex buffer to queue sprite rendering
+    size_t d_underused_framecount;                  //!< Number of frames elapsed since buffer utilization was above half the capacity
+    Ogre::RenderOperation		d_direct_render_op;		//!< Renderop for cursor
+    Ogre::HardwareVertexBufferSharedPtr	d_direct_buffer;	//!< Renderop for cursor
+    Ogre::SceneManager*			d_sceneMngr;		//!< The scene manager we are hooked into.
+    Ogre::LayerBlendModeEx		d_colourBlendMode;	//!< Controls colour blending mode used.
+    Ogre::LayerBlendModeEx		d_alphaBlendMode;	//!< Controls alpha blending mode used.
+    Ogre::TextureUnitState::UVWAddressingMode d_uvwAddressMode;
+
+    CEGUIRQListener*			d_ourlistener;
+    bool						d_post_queue;		//!< true if we render after everything else in our queue.
+    size_t						d_bufferPos;		//!< index into buffer where next vertex should be put.
+    bool						d_sorted;			//!< true when data in quad list is sorted.
+    Point						d_texelOffset;		//!< Offset required for proper texel mapping.
+
+    std::list<OgreCEGUITexture*> d_texturelist;		//!< List used to track textures.
+};
+
+} // End of  CEGUI namespace section
+
+
+#endif	// end of guard _OgreCEGUIRenderer_h_
Index: code/branches/gui/src/orxonox/gui/OgreCEGUIResourceProvider.cpp
===================================================================
--- code/branches/gui/src/orxonox/gui/OgreCEGUIResourceProvider.cpp	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/OgreCEGUIResourceProvider.cpp	(revision 1638)
@@ -0,0 +1,97 @@
+/************************************************************************
+    filename: 	OgreCEGUIResourceProvider.cpp
+    created:	8/7/2004
+    author:		James '_mental_' O'Sullivan
+
+    purpose:	Implements the Resource Provider common functionality
+*************************************************************************/
+/*************************************************************************
+    Crazy Eddie's GUI System (http://www.cegui.org.uk)
+    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*************************************************************************/
+#include "OgreCEGUIResourceProvider.h"
+
+#include <CEGUIExceptions.h>
+#include <OgreArchiveManager.h>
+
+
+// Start of CEGUI namespace section
+namespace CEGUI
+{
+    OgreCEGUIResourceProvider::OgreCEGUIResourceProvider() : ResourceProvider()
+    {
+        // set deafult resource group for Ogre
+        d_defaultResourceGroup = Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str();
+    }
+
+//    void OgreResourceProvider::loadInputSourceContainer(const String& filename, InputSourceContainer& output)
+//   {
+//        Ogre::DataStreamPtr input = Ogre::ResourceGroupManager::getSingleton().openResource(filename.c_str());
+//
+//		if (input.isNull())
+//		{
+//			throw InvalidRequestException((utf8*)
+//				"Scheme::Scheme - Filename supplied for Scheme loading must be valid");
+//		}
+//
+//       XERCES_CPP_NAMESPACE_USE
+//        size_t buffsz = input->size();
+//        unsigned char* mem = reinterpret_cast<unsigned char*>(XMLPlatformUtils::fgArrayMemoryManager->allocate(buffsz));
+//        memcpy(mem, input.getPointer()->getAsString().c_str(), buffsz);
+//        InputSource* mInputSource = new MemBufInputSource(mem, buffsz, filename.c_str(), true);
+//        input.setNull();
+//
+//       output.setData(mInputSource);
+//    }
+
+    void OgreCEGUIResourceProvider::loadRawDataContainer(const String& filename, RawDataContainer& output,  const String& resourceGroup)
+    {
+        String orpGroup;
+        if (resourceGroup.empty())
+            orpGroup = d_defaultResourceGroup.empty() ? Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() : d_defaultResourceGroup;
+        else
+            orpGroup = resourceGroup;
+
+        Ogre::DataStreamPtr input =
+            Ogre::ResourceGroupManager::getSingleton().openResource(filename.c_str(), orpGroup.c_str());
+
+        if (input.isNull())
+        {
+            throw InvalidRequestException((utf8*)
+                "OgreCEGUIResourceProvider::loadRawDataContainer - Unable to open resource file '" + filename + (utf8*)"' in resource group '" + orpGroup + (utf8*)"'.");
+        }
+
+        Ogre::String buf = input->getAsString();
+        const size_t memBuffSize = buf.length();
+
+        unsigned char* mem = new unsigned char[memBuffSize];
+        memcpy(mem, buf.c_str(), memBuffSize);
+
+        output.setData(mem);
+        output.setSize(memBuffSize);
+    }
+
+    void OgreCEGUIResourceProvider::unloadRawDataContainer(RawDataContainer& data)
+    {
+        if (data.getDataPtr())
+        {
+            delete[] data.getDataPtr();
+            data.setData(0);
+            data.setSize(0);
+        }
+    }
+} // End of  CEGUI namespace section
Index: code/branches/gui/src/orxonox/gui/OgreCEGUIResourceProvider.h
===================================================================
--- code/branches/gui/src/orxonox/gui/OgreCEGUIResourceProvider.h	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/OgreCEGUIResourceProvider.h	(revision 1638)
@@ -0,0 +1,52 @@
+/************************************************************************
+    filename: 	CEGUIOgreResourceProvider.h
+    created:	8/7/2004
+    author:		James '_mental_' O'Sullivan
+    
+    purpose:	Defines abstract base class for CEGUIData objects
+*************************************************************************/
+/*************************************************************************
+    Crazy Eddie's GUI System (http://www.cegui.org.uk)
+    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*************************************************************************/
+#ifndef _OgreCEGUIResourceProvider_h_
+#define _OgreCEGUIResourceProvider_h_
+
+#include <CEGUIResourceProvider.h>
+#include "OgreCEGUIRenderer.h"
+
+// Start of CEGUI namespace section
+namespace CEGUI
+{
+class _OgrePrivate OgreCEGUIResourceProvider : public ResourceProvider
+{
+public:
+    /*************************************************************************
+        Construction and Destruction
+    *************************************************************************/
+    OgreCEGUIResourceProvider();
+
+    ~OgreCEGUIResourceProvider(void) {}
+
+//    void loadInputSourceContainer(const String& filename, InputSourceContainer& output);
+    void loadRawDataContainer(const String& filename, RawDataContainer& output, const String& resourceGroup);
+    void unloadRawDataContainer(RawDataContainer& output);
+};
+
+} // End of  CEGUI namespace section
+
+#endif	// end of guard _OgreCEGUIResourceProvider_h_
Index: code/branches/gui/src/orxonox/gui/OgreCEGUITexture.cpp
===================================================================
--- code/branches/gui/src/orxonox/gui/OgreCEGUITexture.cpp	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/OgreCEGUITexture.cpp	(revision 1638)
@@ -0,0 +1,268 @@
+/************************************************************************
+    filename: 	OgreCEGUITexture.cpp
+    created:	11/5/2004
+    author:		Paul D Turner
+    
+    purpose:	Implementation of Texture using Ogre engine
+*************************************************************************/
+/*************************************************************************
+    Crazy Eddie's GUI System (http://www.cegui.org.uk)
+    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*************************************************************************/
+
+#include <CEGUISystem.h>
+#include <CEGUIExceptions.h>
+#include "OgreCEGUITexture.h"
+#include "OgreCEGUIRenderer.h"
+
+#include <OgreTextureManager.h>
+
+// Start of CEGUI namespace section
+namespace CEGUI
+{
+/*************************************************************************
+    Static data definition / initialisation
+*************************************************************************/
+uint32 OgreCEGUITexture::d_texturenumber		= 0;
+
+
+/*************************************************************************
+    Constructor
+*************************************************************************/
+OgreCEGUITexture::OgreCEGUITexture(Renderer* owner) :
+    Texture(owner)
+{
+    d_ogre_texture.setNull();
+    d_isLinked = false;
+}
+
+
+/*************************************************************************
+    Destructor
+*************************************************************************/
+OgreCEGUITexture::~OgreCEGUITexture(void)
+{
+    freeOgreTexture();
+}
+
+
+/*************************************************************************
+    Loads the specified image file into the texture.  The texture is
+    resized as required to hold the image.	
+*************************************************************************/
+void OgreCEGUITexture::loadFromFile(const String& filename, const String& resourceGroup)
+{
+    using namespace Ogre;
+
+    // unload old ogre texture
+    freeOgreTexture();
+
+    // create / load a new ogre texture from the specified image
+    try
+    {
+        TextureManager& textureManager = TextureManager::getSingleton();
+
+        // see if texture already exists
+        Ogre::TexturePtr ogreTexture = (Ogre::TexturePtr)textureManager.getByName(filename.c_str());
+
+        if (!ogreTexture.isNull())
+        {
+            // texture already exists, so create a 'linked' texture (ensures texture is not destroyed twice)
+            d_ogre_texture = ogreTexture;
+            d_isLinked = true;
+        }
+        // texture does not already exist, so load it in
+        else
+        {
+            String orpGroup;
+            if (resourceGroup.empty())
+            {
+                const String& defGrp = CEGUI::System::getSingleton().getResourceProvider()->getDefaultResourceGroup();
+                orpGroup = defGrp.empty() ? Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME.c_str() : defGrp;
+            }
+            else
+            {
+                orpGroup = resourceGroup;
+            }
+
+            d_ogre_texture = TextureManager::getSingleton().load(filename.c_str(), orpGroup.c_str(), TEX_TYPE_2D, 0, 1.0f);
+            d_isLinked = false;
+        }
+
+    }
+    catch(Ogre::Exception e)
+    {
+        throw RendererException((utf8*)"Failed to create Texture object from file '" + filename + "'. Additional Information:\n" + e.getFullDescription().c_str());
+    }
+
+    // if we got a pointer cache some details
+    if (!d_ogre_texture.isNull())
+    {
+        d_width		= d_ogre_texture->getWidth();
+        d_height	= d_ogre_texture->getHeight();
+    }
+    // no texture from image so throw.
+    else
+    {
+        throw RendererException((utf8*)"Failed to create Texture object from file '" + filename + "'.  Ogre returned a NULL pointer.");
+    }
+
+}
+
+
+/*************************************************************************
+    Loads (copies) an image in memory into the texture.  The texture is
+    resized as required to hold the image.	
+*************************************************************************/
+
+void _byteSwap(unsigned char* b, int n)
+{
+    register int i = 0;
+    register int j = n-1;
+    while (i<j)
+    {
+        std::swap(b[i], b[j]);
+        i++, j--;
+    }
+}
+#define byteSwap(x) _byteSwap((unsigned char*) &x,sizeof(x))
+
+void OgreCEGUITexture::loadFromMemory(const void* buffPtr, uint buffWidth, uint buffHeight, PixelFormat pixelFormat)
+{
+    using namespace Ogre;
+
+    // get rid of old texture
+    freeOgreTexture();
+
+    // wrap input buffer with an Ogre DataChunk
+    uint32 bytesize = ((buffWidth * sizeof(uint32)) * buffHeight);
+
+#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
+    uint32* swappedBuffer = new uint32[bytesize/4];
+    memcpy(swappedBuffer, buffPtr, bytesize);
+
+    for (int i=0; i < bytesize/4; i++)
+        byteSwap(swappedBuffer[i]);
+
+    DataStreamPtr odc(new MemoryDataStream(static_cast<void*>(swappedBuffer), bytesize, false));
+#else
+    DataStreamPtr odc(new MemoryDataStream(const_cast<void*>(buffPtr), bytesize, false));
+#endif
+
+    // get pixel type for the target texture - the elements here might look wrong, but is just
+    // differences in definition (at the core level, between GL and D3D).
+    Ogre::PixelFormat targetFmt =
+        (pixelFormat == PF_RGBA) ? Ogre::PF_A8R8G8B8 : Ogre::PF_R8G8B8;
+
+    // try to create a Ogre::Texture from the input data
+    d_ogre_texture = TextureManager::getSingleton().loadRawData(getUniqueName(), "General", odc, buffWidth, buffHeight, targetFmt , TEX_TYPE_2D, 0, 1.0f);
+
+    // if we got a pointer cache some details
+    if (!d_ogre_texture.isNull())
+    {
+        d_width		= d_ogre_texture->getWidth();
+        d_height	= d_ogre_texture->getHeight();
+    }
+    // no texture from memory so throw.
+    else
+    {
+        throw RendererException((utf8*)"Failed to create Texture object from memory:  Ogre returned a NULL Ogre::Texture pointer.");
+    }
+
+}
+
+
+/*************************************************************************
+    set the size of the internal Ogre texture.  Previous Ogre texture
+    is lost.	
+*************************************************************************/
+void OgreCEGUITexture::setOgreTextureSize(uint size)
+{
+    using namespace Ogre;
+
+    // unload any current Ogre::Texture
+    freeOgreTexture();
+
+    // Try to create an empty texture of the given size
+    d_ogre_texture = TextureManager::getSingleton().createManual(getUniqueName(), "General", TEX_TYPE_2D, size, size, 0, PF_A8R8G8B8, TU_DEFAULT);
+
+    // if we got a pointer cache some details
+    if (!d_ogre_texture.isNull())
+    {
+        d_width		= d_ogre_texture->getWidth();
+        d_height	= d_ogre_texture->getHeight();
+    }
+    // no texture so throw.
+    else
+    {
+        throw RendererException((utf8*)"Failed to create texture of specified size: Ogre::Texture creation failed.");
+    }
+
+}
+
+
+/*************************************************************************
+    safely free Ogre::Texture texture (can be called multiple times with
+    no ill effect)
+*************************************************************************/
+void OgreCEGUITexture::freeOgreTexture(void)
+{
+    if ((!d_ogre_texture.isNull()) && !d_isLinked)
+    {
+        Ogre::TextureManager::getSingleton().remove(d_ogre_texture->getHandle());
+    }
+    d_ogre_texture.setNull();
+}
+
+
+/*************************************************************************
+    return a Ogre::string that contains a unique name.	
+*************************************************************************/
+Ogre::String OgreCEGUITexture::getUniqueName(void)
+{
+    Ogre::String str;
+
+#ifdef CEGUI_USEOLDOGRESTRING
+    str << "_cegui_ogre_" << d_texturenumber;
+#else
+    Ogre::StringUtil::StrStreamType strstream;
+    strstream << "_cegui_ogre_" << d_texturenumber;
+    str = strstream.str();
+#endif
+
+    ++d_texturenumber;
+
+    return str;
+}
+
+
+/*************************************************************************
+    Set the internal Ogre::Texture object.
+*************************************************************************/
+void OgreCEGUITexture::setOgreTexture(Ogre::TexturePtr& texture)
+{
+    freeOgreTexture();
+
+    d_ogre_texture = texture;
+    d_width	 = d_ogre_texture->getWidth();
+    d_height = d_ogre_texture->getHeight();
+    d_isLinked = true;
+}
+
+
+} // End of  CEGUI namespace section
+
Index: code/branches/gui/src/orxonox/gui/OgreCEGUITexture.h
===================================================================
--- code/branches/gui/src/orxonox/gui/OgreCEGUITexture.h	(revision 1638)
+++ code/branches/gui/src/orxonox/gui/OgreCEGUITexture.h	(revision 1638)
@@ -0,0 +1,179 @@
+/************************************************************************
+    filename: 	OgreCEGUITexture.h
+    created:	11/5/2004
+    author:		Paul D Turner
+    
+    purpose:	Interface to Texture implemented via Ogre engine
+*************************************************************************/
+/*************************************************************************
+    Crazy Eddie's GUI System (http://www.cegui.org.uk)
+    Copyright (C)2004 - 2005 Paul D Turner (paul@cegui.org.uk)
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*************************************************************************/
+#ifndef _OgreCEGUITexture_h_
+#define _OgreCEGUITexture_h_
+
+#include <CEGUIBase.h>
+#include <CEGUIRenderer.h>
+#include <CEGUITexture.h>
+#include "OgreCEGUIRenderer.h"
+
+// Start of CEGUI namespace section
+namespace CEGUI
+{
+/*!
+\brief
+    Texture class that is created by OgreCEGUIRenderer objects
+*/
+class _OgrePrivate OgreCEGUITexture : public Texture
+{
+private:
+    /*************************************************************************
+        Friends (to allow construction and destruction)
+    *************************************************************************/
+    friend	Texture* OgreCEGUIRenderer::createTexture(void);
+    friend	Texture* OgreCEGUIRenderer::createTexture(const String& filename, const String& resourceGroup);
+    friend	Texture* OgreCEGUIRenderer::createTexture(float size);
+    friend	void	 OgreCEGUIRenderer::destroyTexture(Texture* texture);
+
+
+    /*************************************************************************
+        Construction & Destruction (by Renderer object only)
+    *************************************************************************/
+    OgreCEGUITexture(Renderer* owner);
+    virtual ~OgreCEGUITexture(void);
+
+public:
+    /*!
+    \brief
+        Returns the current pixel width of the texture
+
+    \return
+        ushort value that is the current width of the texture in pixels
+    */
+    virtual	ushort	getWidth(void) const		{return d_width;}
+
+
+    /*!
+    \brief
+        Returns the current pixel height of the texture
+
+    \return
+        ushort value that is the current height of the texture in pixels
+    */
+    virtual	ushort	getHeight(void) const		{return d_height;}
+
+
+    /*!
+    \brief
+        Loads the specified image file into the texture.  The texture is resized as required to hold the image.
+
+    \param filename
+        The filename of the image file that is to be loaded into the texture
+
+    \return
+        Nothing.
+    */
+    virtual void	loadFromFile(const String& filename, const String& resourceGroup);
+
+
+    /*!
+    \brief
+        Loads (copies) an image in memory into the texture.  The texture is resized as required to hold the image.
+    
+    \param buffPtr
+        Pointer to the buffer containing the image data
+    
+    \param buffWidth
+        Width of the buffer (in pixels as specified by \a pixelFormat )
+    
+    \param buffHeight
+        Height of the buffer (in pixels as specified by \a pixelFormat )
+    
+    \param pixelFormat
+    PixelFormat value describing the format contained in \a buffPtr
+    
+    \return
+        Nothing.
+    */
+    virtual void	loadFromMemory(const void* buffPtr, uint buffWidth, uint buffHeight, PixelFormat pixelFormat);
+
+
+    /*!
+    \brief
+        Return a pointer to the internal Ogre::Texture object
+
+    \return
+        Pointer to the Ogre::Texture object currently being used by this Texture object
+    */
+    Ogre::TexturePtr	getOgreTexture(void) const		{return d_ogre_texture;}
+
+
+    /*!
+    \brief
+        set the size of the internal Ogre texture.  Previous Ogre texture is lost.
+
+    \param size
+        pixel size of the new internal texture.  This will be rounded up to a power of 2.
+
+    \return
+        Nothing.
+    */
+    void	setOgreTextureSize(uint size);
+
+
+    /*!
+    \brief
+        Set the internal Ogre::TexturePtr object.
+
+    \param texture
+        Reference to an Ogre::TexturePtr object that is to be used by this Texture object.
+
+    \return
+        Nothing.
+    */
+    void	setOgreTexture(Ogre::TexturePtr& texture);
+
+
+private:
+    /*************************************************************************
+        Implementation Functions
+    *************************************************************************/
+    // safely free Ogre::Texture texture (can be called multiple times with no ill effect)
+    void	freeOgreTexture(void);
+
+    // return a Ogre::string that contains a unique name.
+    Ogre::String	getUniqueName(void);
+
+
+    /*************************************************************************
+        Implementation Data
+    *************************************************************************/
+    static	uint32          d_texturenumber;	//!< Counter used to provide unique texture names.
+
+    Ogre::TexturePtr		d_ogre_texture;		//!< The 'real' texture.
+
+    ushort					d_width;			//!< cached width of the texture
+    ushort					d_height;			//!< cached height of the texture
+
+    bool	d_isLinked;		//!< True if we are linked to a texture we did not actually create.
+};
+
+
+} // End of  CEGUI namespace section
+
+
+#endif	// end of guard _OgreCEGUITexture_h_
Index: code/branches/gui/src/orxonox/objects/Ambient.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/Ambient.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/Ambient.cc	(revision 1638)
@@ -65,5 +65,5 @@
 
     bool Ambient::create(){
-      GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
+      GraphicsEngine::getSingleton().getLevelSceneManager()->setAmbientLight(ambientLight_);
       return Synchronisable::create();
     }
@@ -76,5 +76,5 @@
     void Ambient::setAmbientLight(const ColourValue& colour)
     {
-	    GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
+        GraphicsEngine::getSingleton().getLevelSceneManager()->setAmbientLight(colour);
       ambientLight_=colour;	
     }
Index: code/branches/gui/src/orxonox/objects/Backlight.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/Backlight.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/Backlight.cc	(revision 1638)
@@ -58,6 +58,6 @@
         this->attachObject(this->billboard_.getBillboardSet());
 
-        this->ribbonTrail_ = GraphicsEngine::getSingleton().getSceneManager()->createRibbonTrail(this->getName() + "RibbonTrail");
-        this->ribbonTrailNode_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName() + "RibbonTrailNode");
+        this->ribbonTrail_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createRibbonTrail(this->getName() + "RibbonTrail");
+        this->ribbonTrailNode_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName() + "RibbonTrailNode");
         this->ribbonTrailNode_->attachObject(this->ribbonTrail_);
         this->ribbonTrail_->addNode(this->getNode());
@@ -68,5 +68,5 @@
         this->ribbonTrail_->setMaterialName("Trail/backlighttrail");
 
-        this->setTimeFactor(Orxonox::getSingleton()->getTimeFactor());
+        this->setTimeFactor(Orxonox::getSingleton().getTimeFactor());
     }
 
@@ -76,6 +76,6 @@
         {
             this->detachObject(this->billboard_.getBillboardSet());
-            GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
-            GraphicsEngine::getSingleton().getSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
         }
     }
Index: code/branches/gui/src/orxonox/objects/Camera.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/Camera.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/Camera.cc	(revision 1638)
@@ -52,5 +52,5 @@
   {
     this->bHasFocus_ = false;
-    this->cameraNode_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
+    this->cameraNode_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
     if( node != NULL )
       this->setPositionNode(node);
@@ -60,5 +60,5 @@
   {
     CameraHandler::getInstance()->releaseFocus(this);
-    GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
+    GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
   }
 
Index: code/branches/gui/src/orxonox/objects/CameraHandler.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/CameraHandler.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/CameraHandler.cc	(revision 1638)
@@ -44,6 +44,7 @@
   CameraHandler::CameraHandler()
   {
-    this->cam_ = GraphicsEngine::getSingleton().getSceneManager()->createCamera("Cam");
-    GraphicsEngine::getSingleton().getRenderWindow()->addViewport(this->cam_);
+    this->cam_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createCamera("Cam");
+    GraphicsEngine::getSingleton().getLevelViewport()->setCamera(this->cam_);
+    GraphicsEngine::getSingleton().getRenderWindow()->addViewport(this->cam_, 2, 0.4, 0.4, 0.2, 0.2);
     /*this->activeCamera_ = *ObjectList<Camera>::begin();
     this->activeCamera_->cam_ = this->cam_;*/
Index: code/branches/gui/src/orxonox/objects/ParticleSpawner.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/ParticleSpawner.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/ParticleSpawner.cc	(revision 1638)
@@ -79,5 +79,5 @@
         this->setPosition(this->getNode()->getParent()->getPosition());
         this->getNode()->getParent()->removeChild(this->getNode());
-        GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->addChild(this->getNode());
+        GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->addChild(this->getNode());
         if (this->particle_)
             this->particle_->setEnabled(false);
Index: code/branches/gui/src/orxonox/objects/Projectile.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/Projectile.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/Projectile.cc	(revision 1638)
@@ -75,5 +75,5 @@
         SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second");
 
-	if(this->owner_)
+    if(this->owner_)
           this->setVelocity(this->owner_->getInitialDir() * this->speed_);
     }
Index: code/branches/gui/src/orxonox/objects/Skybox.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/Skybox.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/Skybox.cc	(revision 1638)
@@ -56,5 +56,5 @@
     void Skybox::setSkybox(const std::string& skyboxname)
     {
-    	GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(true, skyboxname);
+        GraphicsEngine::getSingleton().getLevelSceneManager()->setSkyBox(true, skyboxname);
     }
 
@@ -92,5 +92,5 @@
     {
         BaseObject::changedVisibility();
-        GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
+        GraphicsEngine::getSingleton().getLevelSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
     }
 }
Index: code/branches/gui/src/orxonox/objects/Tickable.h
===================================================================
--- code/branches/gui/src/orxonox/objects/Tickable.h	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/Tickable.h	(revision 1638)
@@ -29,5 +29,5 @@
 /*!
     @file Tickable.h
-    @brief Definition of the Tickable interface.
+    @brief Declaration of the Tickable interface.
 
     The Tickable interface provides a tick(dt) function, that gets called every frame.
Index: code/branches/gui/src/orxonox/objects/WorldEntity.cc
===================================================================
--- code/branches/gui/src/orxonox/objects/WorldEntity.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/objects/WorldEntity.cc	(revision 1638)
@@ -49,10 +49,10 @@
         RegisterObject(WorldEntity);
 
-        if (GraphicsEngine::getSingleton().getSceneManager())
+        if (GraphicsEngine::getSingleton().getLevelSceneManager())
         {
             std::ostringstream name;
             name << (WorldEntity::worldEntityCounter_s++);
             this->setName("WorldEntity" + name.str());
-            this->node_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
+            this->node_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
 
             registerAllVariables();
@@ -77,5 +77,5 @@
         {
             this->getNode()->removeAndDestroyAllChildren();
-            GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName());
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroySceneNode(this->getName());
         }
     }
@@ -178,5 +178,5 @@
     void WorldEntity::attachObject(const WorldEntity& obj) const
     {
-        GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
+        GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
         this->getNode()->addChild(obj.getNode());
     }
@@ -184,5 +184,5 @@
     void WorldEntity::attachObject(WorldEntity* obj) const
     {
-        GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
+        GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
         this->getNode()->addChild(obj->getNode());
     }
Index: code/branches/gui/src/orxonox/overlays/console/InGameConsole.cc
===================================================================
--- code/branches/gui/src/orxonox/overlays/console/InGameConsole.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/overlays/console/InGameConsole.cc	(revision 1638)
@@ -59,8 +59,14 @@
         @brief Constructor: Creates and initializes the InGameConsole.
     */
-    InGameConsole::InGameConsole() :
-        consoleOverlay_(0), consoleOverlayContainer_(0),
-        consoleOverlayNoise_(0), consoleOverlayCursor_(0), consoleOverlayBorder_(0),
-        consoleOverlayTextAreas_(0)
+    InGameConsole::InGameConsole()
+        : consoleOverlay_(0)
+        , consoleOverlayContainer_(0)
+        , consoleOverlayNoise_(0)
+        , consoleOverlayCursor_(0)
+        , consoleOverlayBorder_(0)
+        , consoleOverlayTextAreas_(0)
+        , emptySceneManager_(0)
+        , emptyCamera_(0)
+        , viewport_(0)
     {
         RegisterObject(InGameConsole);
@@ -188,4 +194,12 @@
 
         Shell::getInstance().addOutputLevel(true);
+
+        // create a sceneManager in order to render in our own viewport
+        this->emptySceneManager_ = Ogre::Root::getSingleton()
+            .createSceneManager(Ogre::ST_GENERIC, "Console/EmptySceneManager");
+        this->emptyCamera_ = this->emptySceneManager_->createCamera("Console/EmptyCamera");
+        this->viewport_ = GraphicsEngine::getSingleton().getRenderWindow()->addViewport(emptyCamera_, 10);
+        this->viewport_->setOverlaysEnabled(true);
+        this->viewport_->setClearEveryFrame(false);
 
         COUT(4) << "Info: InGameConsole initialized" << std::endl;
@@ -476,5 +490,5 @@
         {
             this->bActive_ = true;
-            InputManager::setInputState(InputManager::IS_CONSOLE);
+            InputManager::requestEnterState("console");
             Shell::getInstance().registerListener(this);
 
@@ -498,5 +512,5 @@
         {
             this->bActive_ = false;
-            InputManager::setInputState(InputManager::IS_NORMAL);
+            InputManager::requestLeaveState("console");
             Shell::getInstance().unregisterListener(this);
 
Index: code/branches/gui/src/orxonox/overlays/console/InGameConsole.h
===================================================================
--- code/branches/gui/src/orxonox/overlays/console/InGameConsole.h	(revision 1636)
+++ code/branches/gui/src/orxonox/overlays/console/InGameConsole.h	(revision 1638)
@@ -45,66 +45,70 @@
     class _OrxonoxExport InGameConsole : public TickableReal, public ShellListener, public WindowEventListener
     {
-        public: // functions
-            void initialise();
-            void destroy();
-            void setConfigValues();
+    public: // functions
+        void initialise();
+        void destroy();
+        void setConfigValues();
 
-            void tick(float dt);
+        void tick(float dt);
 
-            static InGameConsole& getInstance();
+        static InGameConsole& getInstance();
 
-            static void openConsole();
-            static void closeConsole();
+        static void openConsole();
+        static void closeConsole();
 
-        private: // functions
-            InGameConsole();
-            InGameConsole(const InGameConsole& other) {}
-            ~InGameConsole();
+    private: // functions
+        InGameConsole();
+        InGameConsole(const InGameConsole& other) {}
+        ~InGameConsole();
 
-            void activate();
-            void deactivate();
+        void activate();
+        void deactivate();
 
-            void linesChanged();
-            void onlyLastLineChanged();
-            void lineAdded();
-            void inputChanged();
-            void cursorChanged();
-            void exit();
+        void linesChanged();
+        void onlyLastLineChanged();
+        void lineAdded();
+        void inputChanged();
+        void cursorChanged();
+        void exit();
 
-            void shiftLines();
-            void colourLine(int colourcode, int index);
-            void setCursorPosition(unsigned int pos);
-            void print(const std::string& text, int index, bool alwaysShift = false);
+        void shiftLines();
+        void colourLine(int colourcode, int index);
+        void setCursorPosition(unsigned int pos);
+        void print(const std::string& text, int index, bool alwaysShift = false);
 
-            void windowResized(int newWidth, int newHeight);
+        void windowResized(int newWidth, int newHeight);
 
-            static Ogre::UTFString convert2UTF(std::string s);
+        static Ogre::UTFString convert2UTF(std::string s);
 
-        private: // variables
-            bool bActive_;
-            int windowW_;
-            int windowH_;
-            int desiredTextWidth_;
-            unsigned int maxCharsPerLine_;
-            unsigned int numLinesShifted_;
-            int scroll_;
-            float cursor_;
-            unsigned int inputWindowStart_;
-            bool bShowCursor_;
-            std::string displayedText_;
-            Ogre::Overlay* consoleOverlay_;
-            Ogre::OverlayContainer* consoleOverlayContainer_;
-            Ogre::PanelOverlayElement* consoleOverlayNoise_;
-            Ogre::TextAreaOverlayElement* consoleOverlayCursor_;
-            Ogre::BorderPanelOverlayElement* consoleOverlayBorder_;
-            Ogre::TextAreaOverlayElement** consoleOverlayTextAreas_;
+    private: // variables
+        bool bActive_;
+        int windowW_;
+        int windowH_;
+        int desiredTextWidth_;
+        unsigned int maxCharsPerLine_;
+        unsigned int numLinesShifted_;
+        int scroll_;
+        float cursor_;
+        unsigned int inputWindowStart_;
+        bool bShowCursor_;
+        std::string displayedText_;
+        Ogre::Overlay* consoleOverlay_;
+        Ogre::OverlayContainer* consoleOverlayContainer_;
+        Ogre::PanelOverlayElement* consoleOverlayNoise_;
+        Ogre::TextAreaOverlayElement* consoleOverlayCursor_;
+        Ogre::BorderPanelOverlayElement* consoleOverlayBorder_;
+        Ogre::TextAreaOverlayElement** consoleOverlayTextAreas_;
 
-            // config values
-            float relativeWidth;
-            float relativeHeight;
-            float blinkTime;
-            float scrollSpeed_;
-            float noiseSize_;
-            char cursorSymbol_;
+        Ogre::SceneManager* emptySceneManager_;     //!< dummy SceneManager to render overlays in empty windows
+        Ogre::Camera*       emptyCamera_;           //!< dummy camera to render overlays in empty windows
+        Ogre::Viewport*     viewport_;
+
+        // config values
+        float relativeWidth;
+        float relativeHeight;
+        float blinkTime;
+        float scrollSpeed_;
+        float noiseSize_;
+        char cursorSymbol_;
     };
 }
Index: code/branches/gui/src/orxonox/overlays/hud/HUDSpeedBar.cc
===================================================================
--- code/branches/gui/src/orxonox/overlays/hud/HUDSpeedBar.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/overlays/hud/HUDSpeedBar.cc	(revision 1638)
@@ -54,5 +54,5 @@
             float v = ship->getVelocity().length();
             float value = v / ship->getMaxSpeed();
-			if (value != this->getValue())
+            if (value != this->getValue())
                 this->setValue(value);
         }
Index: code/branches/gui/src/orxonox/tolua/tolua.pkg
===================================================================
--- code/branches/gui/src/orxonox/tolua/tolua.pkg	(revision 1636)
+++ code/branches/gui/src/orxonox/tolua/tolua.pkg	(revision 1638)
@@ -0,0 +1,1 @@
+$cfile "../../src/orxonox/gui/GUIManager.h"
Index: code/branches/gui/src/orxonox/tools/BillboardSet.cc
===================================================================
--- code/branches/gui/src/orxonox/tools/BillboardSet.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/tools/BillboardSet.cc	(revision 1638)
@@ -50,5 +50,5 @@
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
-        this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(Vector3::ZERO);
         this->billboardSet_->setMaterialName(file);
@@ -59,5 +59,5 @@
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
-        this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(Vector3::ZERO, colour);
         this->billboardSet_->setMaterialName(file);
@@ -68,5 +68,5 @@
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
-        this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(position);
         this->billboardSet_->setMaterialName(file);
@@ -77,5 +77,5 @@
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
-        this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(position, colour);
         this->billboardSet_->setMaterialName(file);
@@ -85,5 +85,5 @@
     {
         if (this->billboardSet_)
-            GraphicsEngine::getSingleton().getSceneManager()->destroyBillboardSet(this->billboardSet_);
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroyBillboardSet(this->billboardSet_);
     }
 }
Index: code/branches/gui/src/orxonox/tools/Light.cc
===================================================================
--- code/branches/gui/src/orxonox/tools/Light.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/tools/Light.cc	(revision 1638)
@@ -49,5 +49,5 @@
         std::ostringstream name;
         name << (Light::lightCounter_s++);
-        this->light_ = GraphicsEngine::getSingleton().getSceneManager()->createLight("Light" + name.str());
+        this->light_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createLight("Light" + name.str());
         this->light_->setType(type);
         this->light_->setDiffuseColour(diffuse);
@@ -58,5 +58,5 @@
     {
         if (this->light_)
-            GraphicsEngine::getSingleton().getSceneManager()->destroyLight(this->light_);
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroyLight(this->light_);
     }
 }
Index: code/branches/gui/src/orxonox/tools/Mesh.cc
===================================================================
--- code/branches/gui/src/orxonox/tools/Mesh.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/tools/Mesh.cc	(revision 1638)
@@ -49,5 +49,5 @@
         std::ostringstream name;
         name << (Mesh::meshCounter_s++);
-        this->entity_ = GraphicsEngine::getSingleton().getSceneManager()->createEntity("Mesh" + name.str(), file);
+        this->entity_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createEntity("Mesh" + name.str(), file);
     }
 
@@ -55,5 +55,5 @@
     {
         if (this->entity_)
-            GraphicsEngine::getSingleton().getSceneManager()->destroyEntity(this->entity_);
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroyEntity(this->entity_);
     }
 }
Index: code/branches/gui/src/orxonox/tools/ParticleInterface.cc
===================================================================
--- code/branches/gui/src/orxonox/tools/ParticleInterface.cc	(revision 1636)
+++ code/branches/gui/src/orxonox/tools/ParticleInterface.cc	(revision 1638)
@@ -55,6 +55,6 @@
     this->bEnabled_ = true;
     this->detaillevel_ = (unsigned int)detaillevel;
-    this->particleSystem_ = GraphicsEngine::getSingleton().getSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
-    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor());
+    this->particleSystem_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton().getTimeFactor());
 
     if (GraphicsEngine::getSingleton().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
@@ -72,5 +72,5 @@
   {
     this->particleSystem_->removeAllEmitters();
-    GraphicsEngine::getSingleton().getSceneManager()->destroyParticleSystem(particleSystem_);
+    GraphicsEngine::getSingleton().getLevelSceneManager()->destroyParticleSystem(particleSystem_);
   }
 
@@ -171,9 +171,9 @@
   void ParticleInterface::setSpeedFactor(float factor)
   {
-    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor() * factor);
+    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton().getTimeFactor() * factor);
   }
   float ParticleInterface::getSpeedFactor() const
   {
-    return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton()->getTimeFactor());
+    return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton().getTimeFactor());
   }
 
Index: code/branches/gui/src/orxonox/tools/WindowEventListener.h
===================================================================
--- code/branches/gui/src/orxonox/tools/WindowEventListener.h	(revision 1636)
+++ code/branches/gui/src/orxonox/tools/WindowEventListener.h	(revision 1638)
@@ -45,12 +45,12 @@
         virtual ~WindowEventListener() { }
 
-		    /** Window has moved position */
-		    virtual void windowMoved() { }
+            /** Window has moved position */
+            virtual void windowMoved() { }
 
-		    /** Window has resized */
-		    virtual void windowResized(int newWidth, int newHeight) { }
+            /** Window has resized */
+            virtual void windowResized(int newWidth, int newHeight) { }
 
-		    /** Window has lost/gained focus */
-		    virtual void windowFocusChanged() { }
+            /** Window has lost/gained focus */
+            virtual void windowFocusChanged() { }
     };
 }
