Changeset 1638 for code/branches/gui/src/orxonox

code/branches/gui

Property svn:mergeinfo set to
/code/branches/input merged eligible

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

-                      r1625
+                      r1638
  */
+ /**
+    @file orxonox.cc
+    @brief Orxonox class
+  */
+/**
+@file
+@brief
+    Implementation of an partial interface to Ogre.
+*/
 #include "OrxonoxStableHeaders.h"
 …
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
+#include "core/Exception.h"
 #include "overlays/console/InGameConsole.h"
 …
 #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);
+    }
+}

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

-                      r1625
+                      r1638
     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
     };
+}

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

-                      r1535
+                      r1638
  *   Author:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      Reto Grieder
  *   Co-authors:
  *      ...
 …
 #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>
 …
              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
 …
 #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;
+}

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

-                      r1625
+                      r1638
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      ...
+ *
  */
 …
 //****** STD *******
 #include <deque>
+#include <cassert>
 //****** OGRE ******
 …
 // 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"
 …
 // 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"
 …
 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");
   /**
 …
     , 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;
+  }
 …
+  {
     // keep in mind: the order of deletion is very important!
     Loader::unload(startLevel_);
+    Loader::unload();
     if (this->startLevel_)
       delete this->startLevel_;
 …
       delete this->timer_;
     InputManager::destroy();
+    GraphicsEngine::getSingleton().destroy();
+    if (this->ogre_)
+      delete ogre_;
     if (network::Client::getSingleton())
 …
     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.");
+  }
 …
    * @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;
+  }
 …
   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
 …
     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;
+  }
 …
   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_);
+  }
 …
     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())
 …
     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())
 …
   /**
-   * 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.
 …
     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;
 …
     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;
+    }
+  }
+}

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

-                      r1625
+                      r1638
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      ...
+ *
  */
 …
 #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:
 …
       // 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;

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

-                      r1631
+                      r1638
 #  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>
 //-----------------------------------------------------------------------
 …
 //-----------------------------------------------------------------------
-#include "ois/OIS.h"
-#include "cpptcl/CppTcl.h"
 #include "tinyxml/ticpp.h"
 #include "tinyxml/tinyxml.h"
 …
 #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"

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

-                      r1625
+                      r1638
 #include "OrxonoxStableHeaders.h"
 #include "Radar.h"
+#include <float.h>
+#include <cfloat>
+#include <cassert>
 #include "objects/WorldEntity.h"
 #include "objects/SpaceShip.h"

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

r1625	r1638
32	32	#include "OrxonoxPrereqs.h"
33	33	#include <string>
	34	#include <cassert>
34	35	#include "util/Math.h"
35	36	#include "core/Debug.h"

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

-                      r1535
+                      r1638
 /**
+    @file
+    @brief Implementation of the Settings class.
+@file
+@brief
+    Implementation of the Settings class.
 */
 …
 #include "Settings.h"
+#include "util/String.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
 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;
+    }
+}

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

-                      r1535
+                      r1638
 /**
     @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
 …
 #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;
+    }
+}

code/branches/gui/src/orxonox/objects/Ambient.cc

r1625	r1638
65	65
66	66	bool Ambient::create(){
67		GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
	67	GraphicsEngine::getSingleton().getLevelSceneManager()->setAmbientLight(ambientLight_);
68	68	return Synchronisable::create();
69	69	}
…	…
76	76	void Ambient::setAmbientLight(const ColourValue& colour)
77	77	{
78		~~GraphicsEngine::getSingleton().get~~SceneManager()->setAmbientLight(colour);
	78	GraphicsEngine::getSingleton().getLevelSceneManager()->setAmbientLight(colour);
79	79	ambientLight_=colour;
80	80	}

code/branches/gui/src/orxonox/objects/Backlight.cc

-                      r1608
+                      r1638
         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());
 …
         this->ribbonTrail_->setMaterialName("Trail/backlighttrail");
         this->setTimeFactor(Orxonox::getSingleton()->getTimeFactor());
+        this->setTimeFactor(Orxonox::getSingleton().getTimeFactor());
+    }
 …
+        {
             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_);
+        }
+    }

code/branches/gui/src/orxonox/objects/Camera.cc

r1505	r1638
52	52	{
53	53	this->bHasFocus_ = false;
54		this->cameraNode_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
	54	this->cameraNode_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
55	55	if( node != NULL )
56	56	this->setPositionNode(node);
…	…
60	60	{
61	61	CameraHandler::getInstance()->releaseFocus(this);
62		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
	62	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
63	63	}
64	64

code/branches/gui/src/orxonox/objects/CameraHandler.cc

-                      r1505
+                      r1638
   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_;*/

code/branches/gui/src/orxonox/objects/ParticleSpawner.cc

r1608	r1638
79	79	this->setPosition(this->getNode()->getParent()->getPosition());
80	80	this->getNode()->getParent()->removeChild(this->getNode());
81		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->addChild(this->getNode());
	81	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->addChild(this->getNode());
82	82	if (this->particle_)
83	83	this->particle_->setEnabled(false);

code/branches/gui/src/orxonox/objects/Projectile.cc

r1602	r1638
75	75	SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second");
76	76
77		if(this->owner_)
	77	if(this->owner_)
78	78	this->setVelocity(this->owner_->getInitialDir() * this->speed_);
79	79	}

code/branches/gui/src/orxonox/objects/Skybox.cc

r1558	r1638
56	56	void Skybox::setSkybox(const std::string& skyboxname)
57	57	{
58		~~GraphicsEngine::getSingleton().get~~SceneManager()->setSkyBox(true, skyboxname);
	58	GraphicsEngine::getSingleton().getLevelSceneManager()->setSkyBox(true, skyboxname);
59	59	}
60	60
…	…
92	92	{
93	93	BaseObject::changedVisibility();
94		GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
	94	GraphicsEngine::getSingleton().getLevelSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
95	95	}
96	96	}

code/branches/gui/src/orxonox/objects/Tickable.h

r1535	r1638
29	29	/*!
30	30	@file Tickable.h
31		@brief De~~fini~~tion of the Tickable interface.
	31	@brief Declaration of the Tickable interface.
32	32
33	33	The Tickable interface provides a tick(dt) function, that gets called every frame.

code/branches/gui/src/orxonox/objects/WorldEntity.cc

r1625	r1638
49	49	RegisterObject(WorldEntity);
50	50
51		if (GraphicsEngine::getSingleton().getSceneManager())
	51	if (GraphicsEngine::getSingleton().getLevelSceneManager())
52	52	{
53	53	std::ostringstream name;
54	54	name << (WorldEntity::worldEntityCounter_s++);
55	55	this->setName("WorldEntity" + name.str());
56		this->node_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
	56	this->node_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
57	57
58	58	registerAllVariables();
…	…
77	77	{
78	78	this->getNode()->removeAndDestroyAllChildren();
79		GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName());
	79	GraphicsEngine::getSingleton().getLevelSceneManager()->destroySceneNode(this->getName());
80	80	}
81	81	}
…	…
178	178	void WorldEntity::attachObject(const WorldEntity& obj) const
179	179	{
180		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
	180	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
181	181	this->getNode()->addChild(obj.getNode());
182	182	}
…	…
184	184	void WorldEntity::attachObject(WorldEntity* obj) const
185	185	{
186		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
	186	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
187	187	this->getNode()->addChild(obj->getNode());
188	188	}

code/branches/gui/src/orxonox/overlays/console/InGameConsole.cc

-                      r1633
+                      r1638
         @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);
 …
         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;
 …
+        {
             this->bActive_ = true;
             InputManager::setInputState(InputManager::IS_CONSOLE);
+            InputManager::requestEnterState("console");
             Shell::getInstance().registerListener(this);
 …
+        {
             this->bActive_ = false;
             InputManager::setInputState(InputManager::IS_NORMAL);
+            InputManager::requestLeaveState("console");
             Shell::getInstance().unregisterListener(this);

code/branches/gui/src/orxonox/overlays/console/InGameConsole.h

-                      r1625
+                      r1638
     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_;
     };
+}

code/branches/gui/src/orxonox/overlays/hud/HUDSpeedBar.cc

r1626	r1638
54	54	float v = ship->getVelocity().length();
55	55	float value = v / ship->getMaxSpeed();
56		if (value != this->getValue())
	56	if (value != this->getValue())
57	57	this->setValue(value);
58	58	}

code/branches/gui/src/orxonox/tolua/tolua.pkg

r1505	r1638
	1	$cfile "../../src/orxonox/gui/GUIManager.h"

code/branches/gui/src/orxonox/tools/BillboardSet.cc

-                      r1602
+                      r1638
         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);
 …
         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);
 …
         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);
 …
         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);
 …
+    {
         if (this->billboardSet_)
             GraphicsEngine::getSingleton().getSceneManager()->destroyBillboardSet(this->billboardSet_);
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroyBillboardSet(this->billboardSet_);
+    }
+}

code/branches/gui/src/orxonox/tools/Light.cc

r1505	r1638
49	49	std::ostringstream name;
50	50	name << (Light::lightCounter_s++);
51		this->light_ = GraphicsEngine::getSingleton().getSceneManager()->createLight("Light" + name.str());
	51	this->light_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createLight("Light" + name.str());
52	52	this->light_->setType(type);
53	53	this->light_->setDiffuseColour(diffuse);
…	…
58	58	{
59	59	if (this->light_)
60		GraphicsEngine::getSingleton().getSceneManager()->destroyLight(this->light_);
	60	GraphicsEngine::getSingleton().getLevelSceneManager()->destroyLight(this->light_);
61	61	}
62	62	}

code/branches/gui/src/orxonox/tools/Mesh.cc

r1505	r1638
49	49	std::ostringstream name;
50	50	name << (Mesh::meshCounter_s++);
51		this->entity_ = GraphicsEngine::getSingleton().getSceneManager()->createEntity("Mesh" + name.str(), file);
	51	this->entity_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createEntity("Mesh" + name.str(), file);
52	52	}
53	53
…	…
55	55	{
56	56	if (this->entity_)
57		GraphicsEngine::getSingleton().getSceneManager()->destroyEntity(this->entity_);
	57	GraphicsEngine::getSingleton().getLevelSceneManager()->destroyEntity(this->entity_);
58	58	}
59	59	}

code/branches/gui/src/orxonox/tools/ParticleInterface.cc

r1563	r1638
55	55	this->bEnabled_ = true;
56	56	this->detaillevel_ = (unsigned int)detaillevel;
57		this->particleSystem_ = GraphicsEngine::getSingleton().getSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
58		this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor());
	57	this->particleSystem_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
	58	this->particleSystem_->setSpeedFactor(Orxonox::getSingleton().getTimeFactor());
59	59
60	60	if (GraphicsEngine::getSingleton().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
…	…
72	72	{
73	73	this->particleSystem_->removeAllEmitters();
74		GraphicsEngine::getSingleton().getSceneManager()->destroyParticleSystem(particleSystem_);
	74	GraphicsEngine::getSingleton().getLevelSceneManager()->destroyParticleSystem(particleSystem_);
75	75	}
76	76
…	…
171	171	void ParticleInterface::setSpeedFactor(float factor)
172	172	{
173		this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor() * factor);
	173	this->particleSystem_->setSpeedFactor(Orxonox::getSingleton().getTimeFactor() * factor);
174	174	}
175	175	float ParticleInterface::getSpeedFactor() const
176	176	{
177		return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton()->getTimeFactor());
	177	return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton().getTimeFactor());
178	178	}
179	179

code/branches/gui/src/orxonox/tools/WindowEventListener.h

-                      r1625
+                      r1638
         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() { }
     };
+}

Context Navigation

Legend:

code/branches/gui

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

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

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

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

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

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

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

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

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

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

code/branches/gui/src/orxonox/objects/Ambient.cc

code/branches/gui/src/orxonox/objects/Backlight.cc

code/branches/gui/src/orxonox/objects/Camera.cc

code/branches/gui/src/orxonox/objects/CameraHandler.cc

code/branches/gui/src/orxonox/objects/ParticleSpawner.cc

code/branches/gui/src/orxonox/objects/Projectile.cc

code/branches/gui/src/orxonox/objects/Skybox.cc

code/branches/gui/src/orxonox/objects/Tickable.h

code/branches/gui/src/orxonox/objects/WorldEntity.cc

code/branches/gui/src/orxonox/overlays/console/InGameConsole.cc

code/branches/gui/src/orxonox/overlays/console/InGameConsole.h

code/branches/gui/src/orxonox/overlays/hud/HUDSpeedBar.cc

code/branches/gui/src/orxonox/tolua/tolua.pkg

code/branches/gui/src/orxonox/tools/BillboardSet.cc

code/branches/gui/src/orxonox/tools/Light.cc

code/branches/gui/src/orxonox/tools/Mesh.cc

code/branches/gui/src/orxonox/tools/ParticleInterface.cc

code/branches/gui/src/orxonox/tools/WindowEventListener.h

Download in other formats: