Changeset 1755 for code/trunk/src/orxonox

code/trunk

Property svn:mergeinfo changed

/code/branches/gui (added)	merged: 1636,1638,1640-1647,1649-1654,1656,1659-1665,1670,1672-1674,1686,1688-1692,1694-1697,1704
/code/branches/input (added)	merged: 1629-1630

code/trunk/src/orxonox/CMakeLists.txt

-                      r1747
+                      r1755
   GraphicsEngine.cc
   Main.cc
-  Orxonox.cc
   Radar.cc
   RadarListener.cc
 …
   Settings.cc
   SignalHandler.cc
+  gamestates/GSClient.cc
+  gamestates/GSDedicated.cc
+  gamestates/GSGraphics.cc
+  gamestates/GSGUI.cc
+  gamestates/GSIOConsole.cc
+  gamestates/GSLevel.cc
+  gamestates/GSRoot.cc
+  gamestates/GSServer.cc
+  gamestates/GSStandalone.cc
+  gui/GUIManager.cc
+  gui/OgreCEGUIRenderer.cpp
+  gui/OgreCEGUIResourceProvider.cpp
+  gui/OgreCEGUITexture.cpp
   overlays/OrxonoxOverlay.cc
 …
 ADD_CUSTOM_COMMAND(
   OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/tolua/tolua_bind.cc
   COMMAND ${TOLUA_EXE} -n orxonox -o ../../src/orxonox/tolua/tolua_bind.cc -H ../../src/orxonox/tolua/tolua_bind.h ../../src/orxonox/tolua/tolua.pkg
   DEPENDS tolua
+  COMMAND ${TOLUA_EXE} -n Orxonox -o ../../src/orxonox/tolua/tolua_bind.cc -H ../../src/orxonox/tolua/tolua_bind.h ../../src/orxonox/tolua/tolua.pkg
+  DEPENDS tolua ${CMAKE_SOURCE_DIR}/src/orxonox/tolua/tolua.pkg
   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib
+)
 …
   ${OGRE_LIBRARIES}
   ${Lua_LIBRARIES}
+  ${CEGUI_LIBRARIES}
+  ${CEGUI_SCRIPT_LIBRARIES}
   tinyxml
   tolualib

code/trunk/src/orxonox/GraphicsEngine.cc

-                      r1747
+                      r1755
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007, Felix Schulthess
+ *      Felix Schulthess
+ *
  */
+ /**
+    @file orxonox.cc
+    @brief Orxonox class
+  */
+/**
+@file
+@brief
+    Implementation of an partial interface to Ogre.
+*/
 #include "OrxonoxStableHeaders.h"
 #include "GraphicsEngine.h"
+#include <fstream>
+#include <OgreConfigFile.h>
+#include <OgreException.h>
+#include <OgreLogManager.h>
+#include <OgreRoot.h>
+#include <OgreSceneManager.h>
+#include <OgreTextureManager.h>
+#include <OgreViewport.h>
+#include <OgreRenderWindow.h>
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Iterator.h"
-#include "core/CommandExecutor.h"
-#include "core/ConsoleCommand.h"
 #include "util/Debug.h"
-#include "overlays/console/InGameConsole.h"
-#include "overlays/OverlayGroup.h"
 #include "tools/ParticleInterface.h"
-#include "Settings.h"
-#include "tools/WindowEventListener.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;
+  }
+    //SetConsoleCommand(GraphicsEngine, printScreen, true).setKeybindMode(KeybindMode::OnPress);
+  /**
+    @brief Only use constructor to initialise variables and pointers!
+  */
+  GraphicsEngine::GraphicsEngine() :
+    root_(0),
+    scene_(0),
+    renderWindow_(0)
+  {
+    RegisterObject(GraphicsEngine);
+    GraphicsEngine* GraphicsEngine::singletonRef_s = 0;
+    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");
+    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(this, &GraphicsEngine::detailLevelParticleChanged);
+  }
+  void GraphicsEngine::detailLevelParticleChanged()
+  {
+    for (ObjectList<ParticleInterface>::iterator 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)
+    /**
+    @brief
+        Returns the singleton instance.
+    @return
+        The only instance of GraphicsEngine.
+    */
+    /*static*/ GraphicsEngine& GraphicsEngine::getInstance()
+    {
+      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.
+#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);
+#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;
+        assert(singletonRef_s);
+        return *singletonRef_s;
+    }
+    try
+    /**
+    @brief
+        Non-initialising constructor.
+    */
+    GraphicsEngine::GraphicsEngine()
+        : root_(0)
+        , renderWindow_(0)
+        , levelSceneManager_(0)
+        , viewport_(0)
+    {
+      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;
+        RegisterObject(GraphicsEngine);
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
+        this->detailLevelParticle_ = 0;
+        this->setConfigValues();
+        CCOUT(4) << "Constructed" << std::endl;
+    }
     if (!root_->getInstalledPlugins().size())
+    void GraphicsEngine::setConfigValues()
+    {
+      COUT(1) << "Error: No plugins declared. Cannot load Ogre." << std::endl;
+      COUT(0) << "Is the plugins file correctly declared?" << std::endl;
+      return false;
+        SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(this, &GraphicsEngine::detailLevelParticleChanged);
+    }
+#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);
+#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_ == "")
+    void GraphicsEngine::detailLevelParticleChanged()
+    {
       COUT(1) << "Error: Resource file set to \"\". Cannot load." << std::endl;
       return false;
+        for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
+            it->detailLevelChanged(this->detailLevelParticle_);
+    }
+    // Load resource paths from data file using configfile ressource type
+    Ogre::ConfigFile cf;
+    try
+    /**
+    @brief
+        Destroys all the Ogre related objects
+    */
+    GraphicsEngine::~GraphicsEngine()
+    {
+      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;
+        singletonRef_s = 0;
+    }
+    // Go through all sections & settings in the file
+    Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
+    std::string secName, typeName, archName;
+    while (seci.hasMoreElements())
+    /**
+    @brief
+        Get the width of the render window
+    @return
+        The width of the render window
+    */
+    int GraphicsEngine::getWindowWidth() const
+    {
+      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 (this->renderWindow_)
+            return this->renderWindow_->getWidth();
+        else
+            return 0;
+    }
+    if (!root_->isInitialised())
+    /**
+    @brief
+        Get the height of the render window
+    @return
+        The height of the render window
+    */
+    int GraphicsEngine::getWindowHeight() const
+    {
+      CCOUT(2) << "Error: Initialising Ogre root object failed." << std::endl;
+      return false;
+        if (this->renderWindow_)
+            return this->renderWindow_->getHeight();
+        else
+            return 0;
+    }
-    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
+    /**
+    @brief
+        Returns the window aspect ratio height/width.
+    @return
+        The window aspect ratio
+    */
+    float GraphicsEngine::getWindowAspectRatio() const
+    {
+      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]);
+      }*/
+        if (this->renderWindow_)
+            return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
+        else
+            return 1.0f;
+    }
-    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 (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); 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 (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); 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 (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); 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);
+  }
+}

code/trunk/src/orxonox/GraphicsEngine.h

-                      r1747
+                      r1755
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007, Felix Schulthess
+ *      Felix Schulthess
+ *
  */
 …
 #include <OgrePrerequisites.h>
-#include <OgreLog.h>
-#include <OgreRenderWindow.h>
-#include <OgreWindowEventUtilities.h>
 #include "core/OrxonoxClass.h"
 namespace orxonox
 …
     @brief Graphics engine manager class
     */
     class _OrxonoxExport GraphicsEngine : public Ogre::WindowEventListener, public Ogre::LogListener, public OrxonoxClass
+    class _OrxonoxExport GraphicsEngine : public OrxonoxClass
+    {
+        public:
+            void setConfigValues();
+            void detailLevelParticleChanged();
+            bool setup();
+            bool declareRessourceLocations();
+            bool loadRenderer();
+            bool initialiseResources();
+            bool createNewScene();
+        // HACK: temporary means
+        friend class GSGraphics;
+            void destroy();
+    public:
+        GraphicsEngine();
+        ~GraphicsEngine();
+            Ogre::SceneManager* getSceneManager() { return scene_; }
+        void setConfigValues();
+        void detailLevelParticleChanged();
+            // 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 setLevelSceneManager(Ogre::SceneManager* sceneMgr) { this->levelSceneManager_ = sceneMgr; }
+        Ogre::SceneManager* getLevelSceneManager() { return levelSceneManager_; }
             void setWindowActivity(bool activity)
             { if (this->renderWindow_) this->renderWindow_->setActive(activity); }
+        Ogre::Viewport* getViewport() { return this->viewport_; }
+        Ogre::Root*     getOgreRoot() { return this->root_; }
+            void windowMoved       (Ogre::RenderWindow* rw);
+            void windowResized     (Ogre::RenderWindow* rw);
+            void windowFocusChanged(Ogre::RenderWindow* rw);
+            void windowClosed      (Ogre::RenderWindow* rw);
+        // several window properties
+        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; }
             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& getInstance();
+        static GraphicsEngine* getInstancePtr() { return singletonRef_s; }
+    private:
+        // don't mess with singletons
+        GraphicsEngine(GraphicsEngine&);
+        private:
+            // don't mess with singletons
+            GraphicsEngine();
+            ~GraphicsEngine();
+            GraphicsEngine(GraphicsEngine&) { }
+        Ogre::Root*         root_;                  //!< Ogre's root
+        Ogre::RenderWindow* renderWindow_;          //!< the current render window
+        Ogre::SceneManager* levelSceneManager_;     //!< scene manager of the game
+        Ogre::Viewport*     viewport_;              //!< default full size viewport
             //! Method called by the LogListener from Ogre
             void messageLogged(const std::string&, Ogre::LogMessageLevel,
                              bool, const std::string&);
+        // stats
+        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::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
+        // config values
+        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/trunk/src/orxonox/Main.cc

-                      r1747
+                      r1755
  *   Author:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      Reto Grieder
  *   Co-authors:
  *      ...
 …
 #include <exception>
+#include <cassert>
 #include "util/OrxonoxPlatform.h"
 #include "SignalHandler.h"
+#include "Orxonox.h"
+#include "util/Debug.h"
+#include "gamestates/GSRoot.h"
+#include "gamestates/GSGraphics.h"
+#include "gamestates/GSStandalone.h"
+#include "gamestates/GSServer.h"
+#include "gamestates/GSClient.h"
+#include "gamestates/GSDedicated.h"
+#include "gamestates/GSGUI.h"
+#include "gamestates/GSIOConsole.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
-#ifdef __cplusplus
-extern "C" {
-#endif
+int main(int argc, char **argv)
+//#ifdef __cplusplus
+//extern "C" {
+//#endif
+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 ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
+    res = orx->init(argc, argv, macBundlePath());
+#else
+    res = orx->init(argc, argv);
+#endif
+    GSRoot root;
+    GSGraphics graphics;
+    GSStandalone standalone;
+    GSServer server;
+    GSClient client;
+    GSDedicated dedicated;
+    GSGUI gui;
+    GSIOConsole ioConsole;
+    if (res)
+      orx->start();
+    orx->destroySingleton();
+  /*}
+  catch (std::exception &ex)
+  {
+    std::cerr << "Exception:\n";
+    std::cerr << ex.what() << "\n";
+    return 1;
+  }*/
+    root.addChild(&graphics);
+    graphics.addChild(&standalone);
+    graphics.addChild(&server);
+    graphics.addChild(&client);
+    graphics.addChild(&gui);
+  return 0;
+    root.addChild(&ioConsole);
+    root.addChild(&dedicated);
+    root.start(argc, argv);
+    return 0;
+}
 #ifdef __cplusplus
+}
 #endif
+//#ifdef __cplusplus
+//}
+//#endif

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r1625
+                      r1755
     class GraphicsEngine;
     class Orxonox;
+    class Settings;
     class RadarViewable;
 …
     class Backlight;
     class Camera;
-    class Fighter;
     class Model;
     class NPC;
 …
     class OverlayGroup;
     class OverlayText;
+    //gui
+    class GUIManager;
+    // game states
+    class GSRoot;
+    class GSGraphics;
+    class GSIO;
+    class GSIOConsole;
+    class GSLevel;
+    class GSStandalone;
+    class GSServer;
+    class GSClient;
+    class GSGUI;
+}
 …
+}
+namespace CEGUI
+{
+    class LuaScriptModule;
+    class OgreCEGUIRenderer;
+    class OgreCEGUIResourceProvider;
+    class OgreCEGUITexture;
+}
+struct lua_State;
 #endif /* _OrxonoxPrereqs_H__ */

code/trunk/src/orxonox/OrxonoxStableHeaders.h

-                      r1747
+                      r1755
 /**
  @file  OrxonoxStableHeaders.h
  @brief Contains the bigger (or smaller) header files in order to precompile them with MSVC
+ @file
+ @brief Contains the frequently used header files of our own writing
  */
 …
 #include "util/OrxonoxPlatform.h"
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC && !defined(ORXONOX_DISABLE_PCH)
 // including std headers here is useless since they're already precompiled
 …
 #  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 <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
-//-----------------------------------------------------------------------
-// ORXONOX HEADERS
-//-----------------------------------------------------------------------
-#include "ois/OIS.h"
-#include "cpptcl/CppTcl.h"
 #include "tinyxml/ticpp.h"
 #include "tinyxml/tinyxml.h"
+//----------- Our files ----------
+//--------------------------------
+// only include when not debugging so that we may find issues with missing headers quicker
+#if defined(NDEBUG)
 #include "util/Convert.h"
 …
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/CommandExecutor.h"
 #include "core/Executor.h"
 #include "core/XMLPort.h"
 …
 //#include "objects/WorldEntity.h"
+#endif /* Compiler MSVC */
+#endif /* ifdef NDEBUG */
+#endif /* ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC && !defined(ORXONOX_DISABLE_PCH) */
 #endif /* _OrxonoxStableHeaders_H__ */

code/trunk/src/orxonox/Radar.cc

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

code/trunk/src/orxonox/RadarViewable.h

r1747	r1755
32	32	#include "OrxonoxPrereqs.h"
33	33	#include <string>
	34	#include <cassert>
34	35	#include "util/Math.h"
35	36	#include "util/Debug.h"

code/trunk/src/orxonox/Settings.cc

-                      r1747
+                      r1755
 /**
+    @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::singletonRef_s = 0;
+  Settings::~Settings()
+  {
+  }
+  /**
+    @brief Returns a unique instance of Core.
+    @return The instance
+  */
+  Settings& Settings::getSingleton()
+  {
+    static Settings instance;
+    return instance;
+  }
+  /**
+    @brief Function to collect the SetConfigValue-macro calls.
+  */
+  void Settings::setConfigValues()
+  {
+    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
+  }
+  /**
+    @brief Callback function if the datapath has changed.
+  */
+  void Settings::dataPathChanged()
+  {
+    if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+    /**
+    @brief
+        Constructor: Registers the object and sets the config-values.
+    */
+    Settings::Settings()
+        : bShowsGraphics_(false)
+        , bHasServer_(false)
+    {
+      ModifyConfigValue(dataPath_, set, dataPath_ + "/");
+        RegisterRootObject(Settings);
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
+        setConfigValues();
+    }
+    if (dataPath_ == "")
+    /**
+    @brief
+        Function to collect the SetConfigValue-macro calls.
+    */
+    void Settings::setConfigValues()
+    {
+      ModifyConfigValue(dataPath_, set, "/");
+      COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
+        SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
+    }
+  }
+  /**
+    @brief Temporary sets the data path
+    @param path The new data path
+  */
+  void Settings::_tsetDataPath(const std::string& path)
+  {
+    ModifyConfigValue(dataPath_, tset, path);
+  }
+    /**
+    @brief
+        Callback function if the datapath has changed.
+    */
+    void Settings::dataPathChanged()
+    {
+        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);
+    }
+}

code/trunk/src/orxonox/Settings.h

-                      r1747
+                      r1755
 /**
     @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 "util/Debug.h"
+#include "util/MultiType.h"
+#include "util/Convert.h"
 namespace orxonox
+{
+  class _OrxonoxExport Settings : public OrxonoxClass
+  {
+    class _OrxonoxExport Settings : public OrxonoxClass
+    {
+        friend class ClassIdentifier<Settings>;
+        friend class GSRoot;
+        friend class GSGraphics;
+        friend class GSServer;
+        friend class GSDedicated;
     public:
+      void setConfigValues();
+      void dataPathChanged();
+        static const std::string& getDataPath()
+        { assert(singletonRef_s); return singletonRef_s->dataPath_; }
+        static void tsetDataPath(const std::string& path)
+        { assert(singletonRef_s); singletonRef_s->_tsetDataPath(path); }
       static const std::string& getDataPath();
       static void tsetDataPath(const std::string& path);
+        // an alternative to a global game mode variable
+        static bool showsGraphics() { assert(singletonRef_s); return singletonRef_s->bShowsGraphics_; }
+        static bool hasServer()     { assert(singletonRef_s); return singletonRef_s->bHasServer_; }
     private:
+      Settings();
+      Settings(const Settings& instance);
+      ~Settings();
+      static Settings& getSingleton();
+        // GSRoot has access to these
+        static void setShowsGraphics(bool val) { assert(singletonRef_s); singletonRef_s->bShowsGraphics_ = val; }
+        static void setHasServer    (bool val) { assert(singletonRef_s); singletonRef_s->bHasServer_     = val; }
+      void _tsetDataPath(const std::string& path);
+        Settings();
+        Settings(const Settings& instance);
+        ~Settings() { singletonRef_s = 0; }
+      std::string dataPath_;               //!< Path to the game data
+  };
+        static Settings& _getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+        void _tsetDataPath(const std::string& path);
+        void dataPathChanged();
+        void setConfigValues();
+        bool bShowsGraphics_;                                  //!< global variable that tells whether to show graphics
+        bool bHasServer_;                                      //!< global variable that tells whether this is a server
+        std::string dataPath_;                                 //!< Path to the game data
+        static Settings* singletonRef_s;                       //!< Static pointer to the only instance.
+    };
+}

code/trunk/src/orxonox/SignalHandler.h

r1747	r1755
29	29	/**
30	30	@file SignalHandler.h
31		@brief De~~fini~~tion of the SignalHandler class.
	31	@brief Declaration of the SignalHandler class.
32	32	*/
33	33

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

-                      r1724
+                      r1755
         int serverPort = CommandLine::getArgument<int>("port")->getValue();
         std::string serverIP = CommandLine::getArgument<std::string>("ip")->getValue();
         this->client_ = network::Client::createSingleton(serverIP, serverPort);
+        this->client_ = new network::Client(serverIP, serverPort);
         if(!client_->establishConnection())
 …
         client_->closeConnection();
+        // TODO: destroy client
+        // destroy client
+        delete this->client_;
         GSLevel::leave();

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

-                      r1724
+                      r1755
         int serverPort = CommandLine::getArgument<int>("port")->getValue();
         this->server_ = network::Server::createSingleton(serverPort);
+        this->server_ = new network::Server(serverPort);
         // call the loader
 …
         FunctorMember01<GSDedicated, float>* functor = createFunctor(&GSDedicated::setTimeFactor);
         functor->setObject(this);
         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor"));
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
+    }
 …
         this->server_->close();
         // TODO: destroy server
+        delete this->server_;
         Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
 …
+    {
         // Call those objects that need the real time
         for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+        for (ObjectList<TickableReal>::iterator it = ObjectList<TickableReal>::begin(); it; ++it)
             it->tick(time.getDeltaTime());
         // Call the scene objects
         for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
             it->tick(time.getDeltaTime() * this->timeFactor_);

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

r1724	r1755
40	40	#include <OgreWindowEventUtilities.h>
41	41
42		#include "~~core~~/Debug.h"
	42	#include "util/Debug.h"
43	43	#include "core/ConsoleCommand.h"
44	44	#include "core/ConfigValueIncludes.h"
…	…
308	308	void GSGraphics::windowMoved(Ogre::RenderWindow *rw)
309	309	{
310		for (~~Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start~~(); it; ++it)
	310	for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
311	311	it->windowMoved();
312	312	}
…	…
323	323	void GSGraphics::windowResized(Ogre::RenderWindow *rw)
324	324	{
325		for (~~Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start~~(); it; ++it)
	325	for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
326	326	it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
327	327	}
…	…
335	335	void GSGraphics::windowFocusChanged(Ogre::RenderWindow *rw)
336	336	{
337		for (~~Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start~~(); it; ++it)
	337	for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
338	338	it->windowFocusChanged();
339	339	}

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

-                      r1724
+                      r1755
         // reset game speed to normal
         timeFactor_ = 1.0f;
+        // TODO: insert slomo console command with
+        // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
+    }
 …
+    {
         // Call those objects that need the real time
         for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+        for (ObjectList<TickableReal>::iterator it = ObjectList<TickableReal>::begin(); it; ++it)
             it->tick(time.getDeltaTime());
         // Call the scene objects
         for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
             it->tick(time.getDeltaTime() * this->timeFactor_);
         for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; ++it)
+        for (ObjectList<TimerBase>::iterator it = ObjectList<TimerBase>::begin(); it; ++it)
             it->tick(time);
+    }
 …
         float change = factor / this->timeFactor_;
         this->timeFactor_ = factor;
         for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+        for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
             it->setSpeedFactor(it->getSpeedFactor() * change);
         for (Iterator<Backlight> it = ObjectList<Backlight>::begin(); it; ++it)
+        for (ObjectList<Backlight>::iterator it = ObjectList<Backlight>::begin(); it; ++it)
             it->setTimeFactor(timeFactor_);
+    }

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

-                      r1724
+                      r1755
 #include "core/ConsoleCommand.h"
 #include "core/CommandLine.h"
 #include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/Exception.h"
 #include "core/TclBind.h"
 …
+    {
 #if ORXONOX_DEBUG_MODE == 1
         ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox_d.ini");
+        ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox_d.ini");
 #else
         ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox.ini");
+        ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox.ini");
 #endif

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

-                      r1724
+                      r1755
         int serverPort = CommandLine::getArgument<int>("port")->getValue();
+        this->server_ = network::Server::createSingleton(serverPort);
+        this->server_ = new network::Server(serverPort);
+        COUT(0) << "Loading scene in server mode" << std::endl;
         this->loadLevel();
 …
         FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
         functor->setObject(this);
         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor"));
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
         // level is loaded: we can start capturing the input
 …
         this->server_->close();
         // TODO: destroy server
+        delete this->server_;
         GSLevel::leave();

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

r1724	r1755
53	53	FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
54	54	functor->setObject(this);
55		CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor"));
	55	CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
56	56
57	57	// level is loaded: we can start capturing the input

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

r1724	r1755
57	57	namespace orxonox
58	58	{
59		SetConsoleCommandShortcut(GUIManager, showGUI_s).~~setK~~eybindMode(KeybindMode::OnPress);
	59	SetConsoleCommandShortcut(GUIManager, showGUI_s).keybindMode(KeybindMode::OnPress);
60	60
61	61	GUIManager* GUIManager::singletonRef_s = 0;

code/trunk/src/orxonox/objects/Ambient.cc

-                      r1747
+                      r1755
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
+#include "Settings.h"
 #include "GraphicsEngine.h"
 …
     bool Ambient::create()
+    {
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
+        if (Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->setAmbientLight(ambientLight_);
         return Synchronisable::create();
+    }
 …
     void Ambient::setAmbientLight(const ColourValue& colour)
+    {
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
+        ambientLight_=colour;
+        if (Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->setAmbientLight(colour);
+        ambientLight_ = colour;
+    }
     /**
+        @brief XML loading and saving.
+        @param xmlelement The XML-element
+        @param loading Loading (true) or saving (false)
+        @return The XML-element
+    @brief
+        XML loading and saving.
+    @param
+        xmlelement The XML-element
+    @param
+        loading Loading (true) or saving (false)
+    @return
+        The XML-element
     */
     void Ambient::XMLPort(Element& xmlelement, XMLPort::Mode mode)

code/trunk/src/orxonox/objects/Backlight.cc

-                      r1747
+                      r1755
 #include <OgreBillboard.h>
 #include <OgreRibbonTrail.h>
+#include <OgreSceneManager.h>
 #include "core/CoreIncludes.h"
 …
 #include "util/Math.h"
 #include "GraphicsEngine.h"
-#include "Orxonox.h"
 namespace orxonox
 …
         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::getInstance().getLevelSceneManager()->createRibbonTrail(this->getName() + "RibbonTrail");
+        this->ribbonTrailNode_ = GraphicsEngine::getInstance().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::getInstance().getTimeFactor());
+        this->setTimeFactor(1.0f);
+    }
 …
+        {
             this->detachObject(this->billboard_.getBillboardSet());
             GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
             GraphicsEngine::getSingleton().getSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
+        }
+    }

code/trunk/src/orxonox/objects/Camera.cc

r1747	r1755
52	52	{
53	53	this->bHasFocus_ = false;
54		this->cameraNode_ = GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
	54	this->cameraNode_ = GraphicsEngine::getInstance().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::get~~Singleton().get~~SceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
	62	GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
63	63	}
64	64

code/trunk/src/orxonox/objects/CameraHandler.cc

-                      r1505
+                      r1755
   CameraHandler::CameraHandler()
+  {
+    this->cam_ = GraphicsEngine::getSingleton().getSceneManager()->createCamera("Cam");
+    GraphicsEngine::getSingleton().getRenderWindow()->addViewport(this->cam_);
+    this->cam_ = GraphicsEngine::getInstance().getLevelSceneManager()->createCamera("Cam");
+    GraphicsEngine::getInstance().getViewport()->setCamera(this->cam_);
+    //GraphicsEngine::getInstance().getRenderWindow()->addViewport(this->cam_, 2, 0.4, 0.4, 0.2, 0.2);
     /*this->activeCamera_ = *ObjectList<Camera>::begin();
     this->activeCamera_->cam_ = this->cam_;*/

code/trunk/src/orxonox/objects/ParticleSpawner.cc

-                      r1608
+                      r1755
 #include "ParticleSpawner.h"
+#include <OgreSceneManager.h>
 #include "core/CoreIncludes.h"
 #include "core/Executor.h"
 …
         this->setPosition(this->getNode()->getParent()->getPosition());
         this->getNode()->getParent()->removeChild(this->getNode());
         GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->addChild(this->getNode());
+        GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->addChild(this->getNode());
         if (this->particle_)
             this->particle_->setEnabled(false);

code/trunk/src/orxonox/objects/Skybox.cc

r1747	r1755
39	39	#include "core/XMLPort.h"
40	40	#include "util/Debug.h"
	41	#include "Settings.h"
41	42
42	43	namespace orxonox
…	…
56	57	void Skybox::setSkybox(const std::string& skyboxname)
57	58	{
58		GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(true, skyboxname);
	59	if (Settings::showsGraphics())
	60	GraphicsEngine::getInstance().getLevelSceneManager()->setSkyBox(true, skyboxname);
59	61	}
60	62
…	…
87	89	{
88	90	SUPER(Skybox, changedVisibility);
89		GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
	91	if (Settings::showsGraphics())
	92	GraphicsEngine::getInstance().getLevelSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
90	93	}
91	94	}

code/trunk/src/orxonox/objects/SpaceShip.cc

-                      r1751
+                      r1755
 #include "CameraHandler.h"
 #include "ParticleSpawner.h"
+#include "Settings.h"
 #include "RotatingProjectile.h"
 #include "ParticleProjectile.h"
 …
+      }
       assert(0);
+      return 0;
+    }
 …
     void SpaceShip::init()
+    {
+        // START CREATING THRUSTERS
+        this->tt1_ = new ParticleInterface("Orxonox/thruster1", LODParticle::low);
+        this->tt1_->createNewEmitter();
+        this->tt1_->getAllEmitters()->setDirection(-this->getInitialDir());
+        this->tt1_->getEmitter(0)->setPosition(Vector3(-15, 20, -1));
+        this->tt1_->getEmitter(1)->setPosition(Vector3(-15, -20, -1));
+        this->tt1_->setSpeedFactor(3.0);
+        Ogre::SceneNode* node2a = this->getNode()->createChildSceneNode(this->getName() + "particle2a");
+        node2a->setInheritScale(false);
+        node2a->setScale(1, 1, 1);
+        tt1_->addToSceneNode(node2a);
+        this->tt2_ = new ParticleInterface("Orxonox/thruster2", LODParticle::normal);
+        this->tt2_->createNewEmitter();
+        this->tt2_->getAllEmitters()->setDirection(Vector3(-1, 0, 0));
+        this->tt2_->getEmitter(0)->setPosition(Vector3(-30, 40, -2));
+        this->tt2_->getEmitter(1)->setPosition(Vector3(-30, -40, -2));
+        Ogre::SceneNode* node2b = this->getNode()->createChildSceneNode(this->getName() + "particle2b");
+        node2b->setInheritScale(false);
+        node2b->setScale(0.5, 0.5, 0.5);
+        tt2_->addToSceneNode(node2b);
+        this->leftThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, -10, -0.5));
+        this->rightThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, 10, -0.5));
+        Ogre::SceneNode* node2c = this->getNode()->createChildSceneNode(this->getName() + "particle2c");
+        node2c->setInheritScale(false);
+        node2c->setScale(2, 2, 2);
+        node2c->attachObject(this->leftThrusterFlare_.getBillboardSet());
+        node2c->attachObject(this->rightThrusterFlare_.getBillboardSet());
+        // END CREATING THRUSTERS
+        // START CREATING BLINKING LIGHTS
+        this->redBillboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
+        this->greenBillboard_.setBillboardSet("Examples/Flare", ColourValue(0.0, 1.0, 0.0), 1);
+        this->redNode_ = this->getNode()->createChildSceneNode(this->getName() + "red", Vector3(0.3, 4.0, -0.3));
+        this->redNode_->setInheritScale(false);
+        this->greenNode_ = this->getNode()->createChildSceneNode(this->getName() + "green", Vector3(0.3, -4.0, -0.3));
+        this->greenNode_->setInheritScale(false);
+        this->redNode_->attachObject(this->redBillboard_.getBillboardSet());
+        this->redNode_->setScale(0.3, 0.3, 0.3);
+        this->greenNode_->attachObject(this->greenBillboard_.getBillboardSet());
+        this->greenNode_->setScale(0.3, 0.3, 0.3);
+        // END CREATING BLINKING LIGHTS
+        // START CREATING ADDITIONAL EFFECTS
+        /*if(!network::Host::running() || network::Host::isServer()){
+          this->backlight_ = new Backlight(this->maxSpeed_, 0.8);
+          this->attachObject(this->backlight_);
+          this->backlight_->setPosition(-2.35, 0, 0.2);
+          this->backlight_->setColour(this->getProjectileColour());
+          this->smoke_ = new ParticleSpawner();
+          this->smoke_->setParticle("Orxonox/smoke5", LODParticle::normal, 0, 0, 3);
+          this->attachObject(this->smoke_);
+          this->fire_ = new ParticleSpawner();
+          this->fire_->setParticle("Orxonox/fire3", LODParticle::normal, 0, 0, 1);
+          this->attachObject(this->fire_);
+        }*/
+        // END CREATING ADDITIONAL EFFECTS
+        if (this->isExactlyA(Class(SpaceShip)))
+        {
+            // START of testing crosshair
+            this->crosshairNear_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+            this->crosshairFar_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+            this->chNearNode_ = this->getNode()->createChildSceneNode(this->getName() + "near", Vector3(50.0, 0.0, 0.0));
+            this->chNearNode_->setInheritScale(false);
+            this->chFarNode_ = this->getNode()->createChildSceneNode(this->getName() + "far", Vector3(200.0, 0.0, 0.0));
+            this->chFarNode_->setInheritScale(false);
+            this->chNearNode_->attachObject(this->crosshairNear_.getBillboardSet());
+            this->chNearNode_->setScale(0.2, 0.2, 0.2);
+            this->chFarNode_->attachObject(this->crosshairFar_.getBillboardSet());
+            this->chFarNode_->setScale(0.4, 0.4, 0.4);
+            // END of testing crosshair
+        if (Settings::showsGraphics())
+        {
+            // START CREATING THRUSTERS
+            this->tt1_ = new ParticleInterface("Orxonox/thruster1", LODParticle::low);
+            this->tt1_->createNewEmitter();
+            this->tt1_->getAllEmitters()->setDirection(-this->getInitialDir());
+            this->tt1_->getEmitter(0)->setPosition(Vector3(-15, 20, -1));
+            this->tt1_->getEmitter(1)->setPosition(Vector3(-15, -20, -1));
+            this->tt1_->setSpeedFactor(3.0);
+            Ogre::SceneNode* node2a = this->getNode()->createChildSceneNode(this->getName() + "particle2a");
+            node2a->setInheritScale(false);
+            node2a->setScale(1, 1, 1);
+            tt1_->addToSceneNode(node2a);
+            this->tt2_ = new ParticleInterface("Orxonox/thruster2", LODParticle::normal);
+            this->tt2_->createNewEmitter();
+            this->tt2_->getAllEmitters()->setDirection(Vector3(-1, 0, 0));
+            this->tt2_->getEmitter(0)->setPosition(Vector3(-30, 40, -2));
+            this->tt2_->getEmitter(1)->setPosition(Vector3(-30, -40, -2));
+            Ogre::SceneNode* node2b = this->getNode()->createChildSceneNode(this->getName() + "particle2b");
+            node2b->setInheritScale(false);
+            node2b->setScale(0.5, 0.5, 0.5);
+            tt2_->addToSceneNode(node2b);
+            this->leftThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, -10, -0.5));
+            this->rightThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, 10, -0.5));
+            Ogre::SceneNode* node2c = this->getNode()->createChildSceneNode(this->getName() + "particle2c");
+            node2c->setInheritScale(false);
+            node2c->setScale(2, 2, 2);
+            node2c->attachObject(this->leftThrusterFlare_.getBillboardSet());
+            node2c->attachObject(this->rightThrusterFlare_.getBillboardSet());
+            // END CREATING THRUSTERS
+            // START CREATING BLINKING LIGHTS
+            this->redBillboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
+            this->greenBillboard_.setBillboardSet("Examples/Flare", ColourValue(0.0, 1.0, 0.0), 1);
+            this->redNode_ = this->getNode()->createChildSceneNode(this->getName() + "red", Vector3(0.3, 4.0, -0.3));
+            this->redNode_->setInheritScale(false);
+            this->greenNode_ = this->getNode()->createChildSceneNode(this->getName() + "green", Vector3(0.3, -4.0, -0.3));
+            this->greenNode_->setInheritScale(false);
+            this->redNode_->attachObject(this->redBillboard_.getBillboardSet());
+            this->redNode_->setScale(0.3, 0.3, 0.3);
+            this->greenNode_->attachObject(this->greenBillboard_.getBillboardSet());
+            this->greenNode_->setScale(0.3, 0.3, 0.3);
+            // END CREATING BLINKING LIGHTS
+            // START CREATING ADDITIONAL EFFECTS
+            /*this->backlight_ = new Backlight(this->maxSpeed_, 0.8);
+            this->attachObject(this->backlight_);
+            this->backlight_->setPosition(-2.35, 0, 0.2);
+            this->backlight_->setColour(this->getProjectileColour());
+            this->smoke_ = new ParticleSpawner();
+            this->smoke_->setParticle("Orxonox/smoke5", LODParticle::normal, 0, 0, 3);
+            this->attachObject(this->smoke_);
+            this->fire_ = new ParticleSpawner();
+            this->fire_->setParticle("Orxonox/fire3", LODParticle::normal, 0, 0, 1);
+            this->attachObject(this->fire_);
+            */
+            // END CREATING ADDITIONAL EFFECTS
+            if (this->isExactlyA(Class(SpaceShip)))
+            {
+                // START of testing crosshair
+                this->crosshairNear_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+                this->crosshairFar_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+                this->chNearNode_ = this->getNode()->createChildSceneNode(this->getName() + "near", Vector3(50.0, 0.0, 0.0));
+                this->chNearNode_->setInheritScale(false);
+                this->chFarNode_ = this->getNode()->createChildSceneNode(this->getName() + "far", Vector3(200.0, 0.0, 0.0));
+                this->chFarNode_->setInheritScale(false);
+                this->chNearNode_->attachObject(this->crosshairNear_.getBillboardSet());
+                this->chNearNode_->setScale(0.2, 0.2, 0.2);
+                this->chFarNode_->attachObject(this->crosshairFar_.getBillboardSet());
+                this->chFarNode_->setScale(0.4, 0.4, 0.4);
+                // END of testing crosshair
+            }
+        }
         // END of testing crosshair
 …
             this->cam_->tick(dt);
+        if (this->smoke_)
+            this->smoke_->setVisible(this->isVisible() && this->health_ < 40);
+        if (this->fire_)
+            this->fire_->setVisible(this->isVisible() && this->health_ < 20);
+        if (this->backlight_)
+        {   // (there's already fire ||                 we're to slow                 ||                  we're moving backwards                  )
+            if (this->health_ < 20   || this->getVelocity().squaredLength() < 150*150 || this->getVelocity().dotProduct(this->getInitialDir()) < 0)
+                this->backlight_->setActive(false);
+            else
+                this->backlight_->setActive(true);
+        }
+        if (this->redNode_ && this->greenNode_)
+        {
+            this->blinkTime_ += dt;
+            float redScale = 0.15 + 0.15 * sin(this->blinkTime_ * 10.0);
+            float greenScale = 0.15 - 0.15 * sin(this->blinkTime_ * 10.0);
+            this->redNode_->setScale(redScale, redScale, redScale);
+            this->greenNode_->setScale(greenScale, greenScale, greenScale);
+        if (Settings::showsGraphics())
+        {
+            if (this->smoke_)
+                this->smoke_->setVisible(this->isVisible() && this->health_ < 40);
+            if (this->fire_)
+                this->fire_->setVisible(this->isVisible() && this->health_ < 20);
+            if (this->backlight_)
+            {   // (there's already fire ||                 we're to slow                 ||                  we're moving backwards                  )
+                if (this->health_ < 20   || this->getVelocity().squaredLength() < 150*150 || this->getVelocity().dotProduct(this->getInitialDir()) < 0)
+                    this->backlight_->setActive(false);
+                else
+                    this->backlight_->setActive(true);
+            }
+            if (this->redNode_ && this->greenNode_)
+            {
+                this->blinkTime_ += dt;
+                float redScale = 0.15 + 0.15 * sin(this->blinkTime_ * 10.0);
+                float greenScale = 0.15 - 0.15 * sin(this->blinkTime_ * 10.0);
+                this->redNode_->setScale(redScale, redScale, redScale);
+                this->greenNode_->setScale(greenScale, greenScale, greenScale);
+            }
+        }

code/trunk/src/orxonox/objects/SpaceShipAI.cc

-                      r1747
+                      r1755
 #include "core/XMLPort.h"
 #include "tools/ParticleInterface.h"
+#include "Settings.h"
 #define ACTION_INTERVAL 1.0f
 …
             newenemy->XMLPort(xmlelement, XMLPort::LoadObject);
+            ParticleSpawner* spawneffect = new ParticleSpawner("Orxonox/fairytwirl", LODParticle::normal, 2.0, 0, 0, newenemy->getOrth());
+            spawneffect->setPosition(newenemy->getPosition() - newenemy->getOrth() * 50);
+            spawneffect->create();
+            if (Settings::showsGraphics())
+            {
+                ParticleSpawner* spawneffect = new ParticleSpawner("Orxonox/fairytwirl", LODParticle::normal, 2.0, 0, 0, newenemy->getOrth());
+                spawneffect->setPosition(newenemy->getPosition() - newenemy->getOrth() * 50);
+                spawneffect->create();
+            }
+        }
+    }
 …
     void SpaceShipAI::kill()
+    {
+        ParticleSpawner* explosion = new ParticleSpawner("Orxonox/BigExplosion1part1", LODParticle::low, 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::normal, 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::high, 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        Vector3 ringdirection = Vector3(rnd(), rnd(), rnd());
+        ringdirection.normalise();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::normal, 3.0, 0.5, 0, ringdirection);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::high, 3.0, 0.5, 0, ringdirection);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        if (Settings::showsGraphics())
+        {
+            ParticleSpawner* explosion = new ParticleSpawner("Orxonox/BigExplosion1part1", LODParticle::low, 3.0);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::normal, 3.0);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::high, 3.0);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            Vector3 ringdirection = Vector3(rnd(), rnd(), rnd());
+            ringdirection.normalise();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::normal, 3.0, 0.5, 0, ringdirection);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::high, 3.0, 0.5, 0, ringdirection);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+        }
         delete this;

code/trunk/src/orxonox/objects/Tickable.h

r1747	r1755
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/trunk/src/orxonox/objects/WorldEntity.cc

r1747	r1755
32	32	#include <string>
33	33	#include <sstream>
	34	#include <OgreSceneManager.h>
34	35
35	36	#include "tinyxml/tinyxml.h"
…	…
49	50	RegisterObject(WorldEntity);
50	51
51		if (GraphicsEngine::get~~Singleton().get~~SceneManager())
	52	if (GraphicsEngine::getInstance().getLevelSceneManager())
52	53	{
53	54	std::ostringstream name;
54	55	name << (WorldEntity::worldEntityCounter_s++);
55	56	this->setName("WorldEntity" + name.str());
56		this->node_ = GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
	57	this->node_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
57	58
58	59	registerAllVariables();
…	…
77	78	{
78	79	this->getNode()->removeAndDestroyAllChildren();
79		GraphicsEngine::get~~Singleton().get~~SceneManager()->destroySceneNode(this->getName());
	80	GraphicsEngine::getInstance().getLevelSceneManager()->destroySceneNode(this->getName());
80	81	}
81	82	}
…	…
177	178	void WorldEntity::attachObject(const WorldEntity& obj) const
178	179	{
179		GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->removeChild(obj.getNode());
	180	GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
180	181	this->getNode()->addChild(obj.getNode());
181	182	}
…	…
183	184	void WorldEntity::attachObject(WorldEntity* obj) const
184	185	{
185		GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->removeChild(obj->getNode());
	186	GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
186	187	this->getNode()->addChild(obj->getNode());
187	188	}

code/trunk/src/orxonox/objects/WorldEntity.h

-                      r1747
+                      r1755
 #include "OrxonoxPrereqs.h"
+#include <OgrePrerequisites.h>
-#include <OgreSceneManager.h>
 #include <OgreSceneNode.h>
 #include "util/Math.h"
 #include "util/XMLIncludes.h"

code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

-                      r1747
+                      r1755
             // We'll have to get the aspect ratio manually for the first time. Afterwards windowResized() gets
             // called automatically by the GraphicsEngine.
             this->windowResized(GraphicsEngine::getSingleton().getWindowWidth(),
                 GraphicsEngine::getSingleton().getWindowHeight());
+            this->windowResized(GraphicsEngine::getInstance().getWindowWidth(),
+                GraphicsEngine::getInstance().getWindowHeight());
             this->changedVisibility();

code/trunk/src/orxonox/overlays/console/InGameConsole.cc

-                      r1747
+                      r1755
 #include "core/ConsoleCommand.h"
 #include "core/input/InputManager.h"
+#include "core/input/SimpleInputState.h"
+#include "core/input/InputBuffer.h"
 #include "GraphicsEngine.h"
 …
     SetConsoleCommand(InGameConsole, closeConsole, true);
+    InGameConsole* InGameConsole::singletonRef_s = 0;
     /**
         @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)
+    {
         RegisterObject(InGameConsole);
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
         this->bActive_ = false;
 …
     InGameConsole::~InGameConsole(void)
+    {
+        this->destroy();
+    }
+    /**
+        @brief Returns a reference to the only existing instance of InGameConsole.
+    */
+    InGameConsole& InGameConsole::getInstance()
+    {
+        static InGameConsole instance;
+        return instance;
+    }
+    /**
+        @brief Sets the config values, describing the size of the console.
+    */
+    void InGameConsole::setConfigValues()
+    {
+        SetConfigValue(relativeWidth, 0.8);
+        SetConfigValue(relativeHeight, 0.4);
+        SetConfigValue(blinkTime, 0.5);
+        SetConfigValue(scrollSpeed_, 3.0f);
+        SetConfigValue(noiseSize_, 1.0f);
+        SetConfigValue(cursorSymbol_, '|');
+    }
+    /**
+        @brief Initializes the InGameConsole.
+    */
+    void InGameConsole::initialise()
+    {
+        // create overlay and elements
+        Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();
+        // create actual overlay
+        this->consoleOverlay_ = ovMan->create("InGameConsoleConsole");
+        // create a container
+        this->consoleOverlayContainer_ = static_cast<Ogre::OverlayContainer*>(ovMan->createOverlayElement("Panel", "InGameConsoleContainer"));
+        this->consoleOverlayContainer_->setMetricsMode(Ogre::GMM_RELATIVE);
+        this->consoleOverlayContainer_->setPosition((1 - this->relativeWidth) / 2, 0);
+        this->consoleOverlayContainer_->setDimensions(this->relativeWidth, this->relativeHeight);
+        this->consoleOverlay_->add2D(this->consoleOverlayContainer_);
+        // create BorderPanel
+        this->consoleOverlayBorder_ = static_cast<Ogre::BorderPanelOverlayElement*>(ovMan->createOverlayElement("BorderPanel", "InGameConsoleBorderPanel"));
+        this->consoleOverlayBorder_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayBorder_->setMaterialName("ConsoleCenter");
+        this->consoleOverlayBorder_->setBorderSize(16, 16, 0, 16);
+        this->consoleOverlayBorder_->setBorderMaterialName("ConsoleBorder");
+        this->consoleOverlayBorder_->setLeftBorderUV(0.0, 0.49, 0.5, 0.51);
+        this->consoleOverlayBorder_->setRightBorderUV(0.5, 0.49, 1.0, 0.5);
+        this->consoleOverlayBorder_->setBottomBorderUV(0.49, 0.5, 0.51, 1.0);
+        this->consoleOverlayBorder_->setBottomLeftBorderUV(0.0, 0.5, 0.5, 1.0);
+        this->consoleOverlayBorder_->setBottomRightBorderUV(0.5, 0.5, 1.0, 1.0);
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayBorder_);
+        // create a new font to match the requested size exactly
+        Ogre::FontPtr font = static_cast<Ogre::FontPtr>
+            (Ogre::FontManager::getSingleton().create("MonofurConsole", "General"));
+        font->setType(Ogre::FT_TRUETYPE);
+        font->setSource("Monofur.ttf");
+        font->setTrueTypeSize(18);
+        // reto: I don't know why, but setting the resolution twice as high makes the font look a lot clearer
+        font->setTrueTypeResolution(192);
+        font->addCodePointRange(Ogre::Font::CodePointRange(33, 126));
+        font->addCodePointRange(Ogre::Font::CodePointRange(161, 255));
+        // create the text lines
+        this->consoleOverlayTextAreas_ = new Ogre::TextAreaOverlayElement*[LINES];
+        for (int i = 0; i < LINES; i++)
+        {
+            this->consoleOverlayTextAreas_[i] = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + convertToString(i)));
+            this->consoleOverlayTextAreas_[i]->setMetricsMode(Ogre::GMM_PIXELS);
+            this->consoleOverlayTextAreas_[i]->setFontName("MonofurConsole");
+            this->consoleOverlayTextAreas_[i]->setCharHeight(18);
+            this->consoleOverlayTextAreas_[i]->setParameter("colour_top", "0.21 0.69 0.21");
+            this->consoleOverlayTextAreas_[i]->setLeft(8);
+            this->consoleOverlayTextAreas_[i]->setCaption("");
+            this->consoleOverlayContainer_->addChild(this->consoleOverlayTextAreas_[i]);
+        }
+        // create cursor (also a text area overlay element)
+        this->consoleOverlayCursor_ = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleCursor"));
+        this->consoleOverlayCursor_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayCursor_->setFontName("MonofurConsole");
+        this->consoleOverlayCursor_->setCharHeight(18);
+        this->consoleOverlayCursor_->setParameter("colour_top", "0.21 0.69 0.21");
+        this->consoleOverlayCursor_->setLeft(7);
+        this->consoleOverlayCursor_->setCaption(std::string(this->cursorSymbol_, 1));
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayCursor_);
+        // create noise
+        this->consoleOverlayNoise_ = static_cast<Ogre::PanelOverlayElement*>(ovMan->createOverlayElement("Panel", "InGameConsoleNoise"));
+        this->consoleOverlayNoise_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayNoise_->setPosition(5,0);
+        this->consoleOverlayNoise_->setMaterialName("ConsoleNoiseSmall");
+        // comment following line to disable noise
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayNoise_);
+        this->windowResized(GraphicsEngine::getSingleton().getWindowWidth(), GraphicsEngine::getSingleton().getWindowHeight());
+        // move overlay "above" the top edge of the screen
+        // we take -1.2 because the border makes the panel bigger
+        this->consoleOverlayContainer_->setTop(-1.2 * this->relativeHeight);
+        Shell::getInstance().addOutputLevel(true);
+        COUT(4) << "Info: InGameConsole initialized" << std::endl;
+    }
+    /**
+        @brief Destroys all the elements if necessary.
+    */
+    void InGameConsole::destroy()
+    {
+        this->deactivate();
+        // destroy the input state previously created (InputBuffer gets destroyed by the Shell)
+        InputManager::getInstance().requestDestroyState("console");
         Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();
         if (ovMan)
 …
             this->consoleOverlayTextAreas_ = 0;
+        }
+        singletonRef_s = 0;
+    }
+    /**
+        @brief Sets the config values, describing the size of the console.
+    */
+    void InGameConsole::setConfigValues()
+    {
+        SetConfigValue(relativeWidth, 0.8);
+        SetConfigValue(relativeHeight, 0.4);
+        SetConfigValue(blinkTime, 0.5);
+        SetConfigValue(scrollSpeed_, 3.0f);
+        SetConfigValue(noiseSize_, 1.0f);
+        SetConfigValue(cursorSymbol_, '|');
+    }
+    /**
+        @brief Initializes the InGameConsole.
+    */
+    void InGameConsole::initialise()
+    {
+        // create the corresponding input state
+        InputManager::getInstance().createInputState<SimpleInputState>("console", 40)
+            ->setKeyHandler(Shell::getInstance().getInputBuffer());
+        // create overlay and elements
+        Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();
+        // create actual overlay
+        this->consoleOverlay_ = ovMan->create("InGameConsoleConsole");
+        // create a container
+        this->consoleOverlayContainer_ = static_cast<Ogre::OverlayContainer*>(ovMan->createOverlayElement("Panel", "InGameConsoleContainer"));
+        this->consoleOverlayContainer_->setMetricsMode(Ogre::GMM_RELATIVE);
+        this->consoleOverlayContainer_->setPosition((1 - this->relativeWidth) / 2, 0);
+        this->consoleOverlayContainer_->setDimensions(this->relativeWidth, this->relativeHeight);
+        this->consoleOverlay_->add2D(this->consoleOverlayContainer_);
+        // create BorderPanel
+        this->consoleOverlayBorder_ = static_cast<Ogre::BorderPanelOverlayElement*>(ovMan->createOverlayElement("BorderPanel", "InGameConsoleBorderPanel"));
+        this->consoleOverlayBorder_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayBorder_->setMaterialName("ConsoleCenter");
+        this->consoleOverlayBorder_->setBorderSize(16, 16, 0, 16);
+        this->consoleOverlayBorder_->setBorderMaterialName("ConsoleBorder");
+        this->consoleOverlayBorder_->setLeftBorderUV(0.0, 0.49, 0.5, 0.51);
+        this->consoleOverlayBorder_->setRightBorderUV(0.5, 0.49, 1.0, 0.5);
+        this->consoleOverlayBorder_->setBottomBorderUV(0.49, 0.5, 0.51, 1.0);
+        this->consoleOverlayBorder_->setBottomLeftBorderUV(0.0, 0.5, 0.5, 1.0);
+        this->consoleOverlayBorder_->setBottomRightBorderUV(0.5, 0.5, 1.0, 1.0);
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayBorder_);
+        // create a new font to match the requested size exactly
+        Ogre::FontPtr font = static_cast<Ogre::FontPtr>
+            (Ogre::FontManager::getSingleton().create("MonofurConsole", "General"));
+        font->setType(Ogre::FT_TRUETYPE);
+        font->setSource("Monofur.ttf");
+        font->setTrueTypeSize(18);
+        // reto: I don't know why, but setting the resolution twice as high makes the font look a lot clearer
+        font->setTrueTypeResolution(192);
+        font->addCodePointRange(Ogre::Font::CodePointRange(33, 126));
+        font->addCodePointRange(Ogre::Font::CodePointRange(161, 255));
+        // create the text lines
+        this->consoleOverlayTextAreas_ = new Ogre::TextAreaOverlayElement*[LINES];
+        for (int i = 0; i < LINES; i++)
+        {
+            this->consoleOverlayTextAreas_[i] = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + convertToString(i)));
+            this->consoleOverlayTextAreas_[i]->setMetricsMode(Ogre::GMM_PIXELS);
+            this->consoleOverlayTextAreas_[i]->setFontName("MonofurConsole");
+            this->consoleOverlayTextAreas_[i]->setCharHeight(18);
+            this->consoleOverlayTextAreas_[i]->setParameter("colour_top", "0.21 0.69 0.21");
+            this->consoleOverlayTextAreas_[i]->setLeft(8);
+            this->consoleOverlayTextAreas_[i]->setCaption("");
+            this->consoleOverlayContainer_->addChild(this->consoleOverlayTextAreas_[i]);
+        }
+        // create cursor (also a text area overlay element)
+        this->consoleOverlayCursor_ = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleCursor"));
+        this->consoleOverlayCursor_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayCursor_->setFontName("MonofurConsole");
+        this->consoleOverlayCursor_->setCharHeight(18);
+        this->consoleOverlayCursor_->setParameter("colour_top", "0.21 0.69 0.21");
+        this->consoleOverlayCursor_->setLeft(7);
+        this->consoleOverlayCursor_->setCaption(std::string(this->cursorSymbol_, 1));
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayCursor_);
+        // create noise
+        this->consoleOverlayNoise_ = static_cast<Ogre::PanelOverlayElement*>(ovMan->createOverlayElement("Panel", "InGameConsoleNoise"));
+        this->consoleOverlayNoise_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayNoise_->setPosition(5,0);
+        this->consoleOverlayNoise_->setMaterialName("ConsoleNoiseSmall");
+        // comment following line to disable noise
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayNoise_);
+        this->windowResized(GraphicsEngine::getInstance().getWindowWidth(), GraphicsEngine::getInstance().getWindowHeight());
+        // move overlay "above" the top edge of the screen
+        // we take -1.2 because the border makes the panel bigger
+        this->consoleOverlayContainer_->setTop(-1.2 * this->relativeHeight);
+        Shell::getInstance().addOutputLevel(true);
+        COUT(4) << "Info: InGameConsole initialized" << std::endl;
+    }
 …
                 if (output.size() > this->maxCharsPerLine_)
+                {
                     if (Shell::getInstance().getInputBuffer().getCursorPosition() < this->inputWindowStart_)
                         this->inputWindowStart_ = Shell::getInstance().getInputBuffer().getCursorPosition();
                     else if (Shell::getInstance().getInputBuffer().getCursorPosition() >= (this->inputWindowStart_ + this->maxCharsPerLine_ - 1))
                         this->inputWindowStart_ = Shell::getInstance().getInputBuffer().getCursorPosition() - this->maxCharsPerLine_ + 1;
+                    if (Shell::getInstance().getInputBuffer()->getCursorPosition() < this->inputWindowStart_)
+                        this->inputWindowStart_ = Shell::getInstance().getInputBuffer()->getCursorPosition();
+                    else if (Shell::getInstance().getInputBuffer()->getCursorPosition() >= (this->inputWindowStart_ + this->maxCharsPerLine_ - 1))
+                        this->inputWindowStart_ = Shell::getInstance().getInputBuffer()->getCursorPosition() - this->maxCharsPerLine_ + 1;
                     output = output.substr(this->inputWindowStart_, this->maxCharsPerLine_);
 …
+        {
             this->bActive_ = true;
             InputManager::setInputState(InputManager::IS_CONSOLE);
+            InputManager::getInstance().requestEnterState("console");
             Shell::getInstance().registerListener(this);
 …
+        {
             this->bActive_ = false;
             InputManager::setInputState(InputManager::IS_NORMAL);
+            InputManager::getInstance().requestLeaveState("console");
             Shell::getInstance().unregisterListener(this);

code/trunk/src/orxonox/overlays/console/InGameConsole.h

-                      r1747
+                      r1755
 #include "core/Shell.h"
 #include "objects/Tickable.h"
+#include "core/OrxonoxClass.h"
 #include "tools/WindowEventListener.h"
 …
 namespace orxonox
+{
     class _OrxonoxExport InGameConsole : public TickableReal, public ShellListener, public WindowEventListener
+    class _OrxonoxExport InGameConsole : virtual public OrxonoxClass, public ShellListener, public WindowEventListener
+    {
+        public: // functions
+            void initialise();
+            void destroy();
+            void setConfigValues();
+    public: // functions
+        InGameConsole();
+        ~InGameConsole();
+            virtual void tick(float dt);
+        void initialise();
+        void destroy();
+        void setConfigValues();
             static InGameConsole& getInstance();
+        virtual void tick(float dt);
             static void openConsole();
             static void closeConsole();
+        static InGameConsole& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+        static InGameConsole* getInstancePtr() { return singletonRef_s; }
+        private: // functions
+            InGameConsole();
+            InGameConsole(const InGameConsole& other) {}
+            ~InGameConsole();
+        static void openConsole();
+        static void closeConsole();
             void activate();
             void deactivate();
+    private: // functions
+        InGameConsole(const InGameConsole& other) {}
+            void linesChanged();
+            void onlyLastLineChanged();
+            void lineAdded();
+            void inputChanged();
+            void cursorChanged();
+            void exit();
+        void activate();
+        void deactivate();
+            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 linesChanged();
+        void onlyLastLineChanged();
+        void lineAdded();
+        void inputChanged();
+        void cursorChanged();
+        void exit();
+            void windowResized(int newWidth, int newHeight);
+        void shiftLines();
+        void colourLine(int colourcode, int index);
+        void setCursorPosition(unsigned int pos);
+        void print(const std::string& text, int index, bool alwaysShift = false);
             static Ogre::UTFString convert2UTF(std::string s);
+        void windowResized(int newWidth, int newHeight);
+        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_;
+        static Ogre::UTFString convert2UTF(std::string s);
+            // config values
+            float relativeWidth;
+            float relativeHeight;
+            float blinkTime;
+            float scrollSpeed_;
+            float noiseSize_;
+            char cursorSymbol_;
+    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_;
+        static InGameConsole* singletonRef_s;
     };
+}

code/trunk/src/orxonox/overlays/debug/DebugFPSText.cc

r1625	r1755
49	49	void DebugFPSText::tick(float dt)
50	50	{
51		float fps = GraphicsEngine::get~~Singleton~~().getAverageFramesPerSecond();
	51	float fps = GraphicsEngine::getInstance().getAverageFramesPerSecond();
52	52	this->text_->setCaption(this->getCaption() + convertToString(fps));
53	53	}

code/trunk/src/orxonox/overlays/debug/DebugRTRText.cc

r1625	r1755
49	49	void DebugRTRText::tick(float dt)
50	50	{
51		float rtr = GraphicsEngine::get~~Singleton~~().getAverageTickTime();
	51	float rtr = GraphicsEngine::getInstance().getAverageTickTime();
52	52	this->text_->setCaption(this->getCaption() + convertToString(rtr));
53	53	}

code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.cc

r1626	r1755
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/trunk/src/orxonox/tolua/tolua.pkg

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

code/trunk/src/orxonox/tools/BillboardSet.cc

-                      r1602
+                      r1755
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getInstance().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::getInstance().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::getInstance().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::getInstance().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::getInstance().getLevelSceneManager()->destroyBillboardSet(this->billboardSet_);
+    }
+}

code/trunk/src/orxonox/tools/Light.cc

r1505	r1755
49	49	std::ostringstream name;
50	50	name << (Light::lightCounter_s++);
51		this->light_ = GraphicsEngine::get~~Singleton().get~~SceneManager()->createLight("Light" + name.str());
	51	this->light_ = GraphicsEngine::getInstance().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::get~~Singleton().get~~SceneManager()->destroyLight(this->light_);
	60	GraphicsEngine::getInstance().getLevelSceneManager()->destroyLight(this->light_);
61	61	}
62	62	}

code/trunk/src/orxonox/tools/Mesh.cc

-                      r1505
+                      r1755
 #include <sstream>
 #include <OgreSceneManager.h>
 #include "GraphicsEngine.h"
+#include "Settings.h"
 namespace orxonox
 …
         std::ostringstream name;
         name << (Mesh::meshCounter_s++);
+        this->entity_ = GraphicsEngine::getSingleton().getSceneManager()->createEntity("Mesh" + name.str(), file);
+        if (Settings::showsGraphics())
+            this->entity_ = GraphicsEngine::getInstance().getLevelSceneManager()->createEntity("Mesh" + name.str(), file);
+    }
     Mesh::~Mesh()
+    {
         if (this->entity_)
             GraphicsEngine::getSingleton().getSceneManager()->destroyEntity(this->entity_);
+        if (this->entity_ && Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroyEntity(this->entity_);
+    }
+}

code/trunk/src/orxonox/tools/ParticleInterface.cc

-                      r1563
+                      r1755
 #include "GraphicsEngine.h"
-#include "Orxonox.h"
 #include "core/CoreIncludes.h"
 #include "util/Convert.h"
 …
     this->bEnabled_ = true;
     this->detaillevel_ = (unsigned int)detaillevel;
+    this->particleSystem_ = GraphicsEngine::getSingleton().getSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor());
+    this->particleSystem_ = GraphicsEngine::getInstance().getLevelSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+    //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
+    this->particleSystem_->setSpeedFactor(1.0f);
     if (GraphicsEngine::getSingleton().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
+    if (GraphicsEngine::getInstance().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
+    {
       this->bVisible_ = false;
 …
+  {
     this->particleSystem_->removeAllEmitters();
     GraphicsEngine::getSingleton().getSceneManager()->destroyParticleSystem(particleSystem_);
+    GraphicsEngine::getInstance().getLevelSceneManager()->destroyParticleSystem(particleSystem_);
+  }
 …
   void ParticleInterface::setSpeedFactor(float factor)
+  {
+    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor() * factor);
+    //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+    this->particleSystem_->setSpeedFactor(1.0f * factor);
+  }
   float ParticleInterface::getSpeedFactor() const
+  {
+    return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton()->getTimeFactor());
+    //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+    return (this->particleSystem_->getSpeedFactor() / 1.0f);
+  }

code/trunk/src/orxonox/tools/Timer.cc

-                      r1552
+                      r1755
 #include "core/ConsoleCommand.h"
 #include "core/CommandExecutor.h"
+#include "core/Clock.h"
 namespace orxonox
 …
         @brief Updates the timer before the frames are rendered.
     */
     void TimerBase::tick(float dt)
+    void TimerBase::tick(const Clock& time)
+    {
         if (this->bActive_)
+        {
             // If active: Decrease the timer by the duration of the last frame
             this->time_ -= dt;
+            this->time_ -= time.getDeltaTimeMicroseconds();
             if (this->time_ <= 0)

code/trunk/src/orxonox/tools/Timer.h

-                      r1608
+                      r1755
 #include "OrxonoxPrereqs.h"
 #include "objects/Tickable.h"
+#include "core/OrxonoxClass.h"
 namespace orxonox
 …
     //! TimerBase is the parent of the Timer class.
     class _OrxonoxExport TimerBase : public Tickable
+    class _OrxonoxExport TimerBase : public OrxonoxClass
+    {
         public:
 …
             /** @brief Returns the remaining time until the Timer calls the function. @return The remaining time */
             inline float getRemainingTime() const
                 { return this->time_; }
+                { return (float)this->time_ / 1000000.0f; }
             /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */
             inline void addTime(float time)
                 { this->time_ += time; }
+                { if (time > 0.0f) this->time_ += (long long)(time * 1000000.0f); }
             /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */
             inline void removeTime(float time)
                 { this->time_ -= time; }
+                { if (time > 0.0f) this->time_ -= (long long)(time * 1000000.0f); }
             /** @brief Sets the interval of the Timer. @param interval The interval */
             inline void setInterval(float interval)
                 { this->interval_ = interval; }
+                { this->interval_ = (long long)(interval * 1000000.0f); }
             /** @brief Sets bLoop to a given value. @param bLoop True = loop */
             inline void setLoop(bool bLoop)
                 { this->bLoop_ = bLoop; }
             void tick(float dt);
+            void tick(const Clock& time);
         protected:
 …
             Executor* executor_; //!< The executor of the function that should be called when the time expires
             float interval_;     //!< The time-interval in seconds
+            long long interval_; //!< The time-interval in micro seconds
             bool bLoop_;         //!< If true, the function gets called every 'interval' seconds
             bool bActive_;       //!< If true, the Timer ticks and calls the function if the time's up
             float time_;         //!< Internal variable, counting the time till the next function-call
+            long long time_;     //!< Internal variable, counting the time till the next function-call
     };
 …
                 this->deleteExecutor();
                 this->interval_ = interval;
+                this->setInterval(interval);
                 this->bLoop_ = bLoop;
                 executor->setObject(object);
 …
                 this->bActive_ = true;
                 this->time_ = interval;
+                this->time_ = this->interval_;
+            }
     };
 …
                 this->deleteExecutor();
                 this->interval_ = interval;
+                this->setInterval(interval);
                 this->bLoop_ = bLoop;
                 this->executor_ = (Executor*)executor;
                 this->bActive_ = true;
                 this->time_ = interval;
+                this->time_ = this->interval_;
+            }
     };

code/trunk/src/orxonox/tools/WindowEventListener.h

-                      r1625
+                      r1755
         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:

Download in other formats: