Changeset 1662

Timestamp:

Aug 19, 2008, 8:12:15 PM (16 years ago)

Author:

rgrieder

Message:

• Changed static Executor/Functor in ConsoleCommand to generic one that enables console commands for member functions. (This is more of a temporary solution, but can be made permanent with right adjustments)
• The whole GameState thing seems to works so far. But I there's only standalone mode at the moment
• Console now shows in GUI too. I will have to implement a master InputState in the InputManager (little bit of a break with the concept, but probably necessary)

Location:

code/branches/gui/src

Files:

• core/ConsoleCommand.cc (modified) (1 diff)
• core/ConsoleCommand.h (modified) (2 diffs)
• orxonox/Orxonox.cc (modified) (1 diff)
• orxonox/gamestates/GSGUI.cc (modified) (1 diff)
• orxonox/gamestates/GSGraphics.cc (modified) (3 diffs)
• orxonox/gamestates/GSGraphics.h (modified) (2 diffs)
• orxonox/gamestates/GSLevel.cc (modified) (6 diffs)
• orxonox/gamestates/GSLevel.h (modified) (1 diff)
• orxonox/gamestates/GSRoot.cc (modified) (5 diffs)
• orxonox/gamestates/GSRoot.h (modified) (1 diff)
• orxonox/gui/GUIManager.cc (modified) (1 diff)
• orxonox/objects/Backlight.cc (modified) (1 diff)
• orxonox/overlays/console/InGameConsole.h (modified) (2 diffs)
• orxonox/tools/ParticleInterface.cc (modified) (2 diffs)

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

@@ -31 +31 @@
 namespace orxonox
 {
-    ConsoleCommand::ConsoleCommand(FunctorStatic* functor, const std::string& name) : ExecutorStatic(functor, name)
+    ConsoleCommand::ConsoleCommand(Functor* functor, const std::string& name) : Executor(functor, name)
     {
         this->accessLevel_ = AccessLevel::None;

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

@@ -70 +70 @@
     }
 
-    class _CoreExport ConsoleCommand : public ExecutorStatic
+    class _CoreExport ConsoleCommand : public Executor
     {
         public:
-            ConsoleCommand(FunctorStatic* functor, const std::string& name = "");
+            ConsoleCommand(Functor* functor, const std::string& name = "");
 
             inline ConsoleCommand& setDescription(const std::string& description)
-                { this->ExecutorStatic::setDescription(description); return (*this); }
+                { this->Executor::setDescription(description); return (*this); }
             inline ConsoleCommand& setDescriptionParam(int param, const std::string& description)
-                { this->ExecutorStatic::setDescriptionParam(param, description); return (*this); }
+                { this->Executor::setDescriptionParam(param, description); return (*this); }
             inline ConsoleCommand& setDescriptionReturnvalue(const std::string& description)
-                { this->ExecutorStatic::setDescriptionReturnvalue(description); return (*this); }
+                { this->Executor::setDescriptionReturnvalue(description); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1)
-                { this->ExecutorStatic::setDefaultValues(param1); return (*this); }
+                { this->Executor::setDefaultValues(param1); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2)
-                { this->ExecutorStatic::setDefaultValues(param1, param2); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3)
-                { this->ExecutorStatic::setDefaultValues(param1, param2, param3); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2, param3); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4)
-                { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2, param3, param4); return (*this); }
             inline ConsoleCommand& setDefaultValues(const MultiTypeMath& param1, const MultiTypeMath& param2, const MultiTypeMath& param3, const MultiTypeMath& param4, const MultiTypeMath& param5)
-                { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
             inline ConsoleCommand& setDefaultValue(unsigned int index, const MultiTypeMath& param)
-                { this->ExecutorStatic::setDefaultValue(index, param); return (*this); }
+                { this->Executor::setDefaultValue(index, param); return (*this); }
 
             inline ConsoleCommand& setAccessLevel(AccessLevel::Level level)
@@ -135 +135 @@
     };
 
-    inline ConsoleCommand* createConsoleCommand(FunctorStatic* functor, const std::string& name = "")
+    inline ConsoleCommand* createConsoleCommand(Functor* functor, const std::string& name = "")
     {
         return new ConsoleCommand(functor, name);

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

@@ -88 +88 @@
 namespace orxonox
 {
-  SetConsoleCommand(Orxonox, exit, true).setKeybindMode(KeybindMode::OnPress);
-  SetConsoleCommand(Orxonox, slomo, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
-  SetConsoleCommand(Orxonox, setTimeFactor, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
-  SetConsoleCommand(Orxonox, loadGame, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, "standalone");
+  //SetConsoleCommand(Orxonox, exit, true).setKeybindMode(KeybindMode::OnPress);
+  //SetConsoleCommand(Orxonox, slomo, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
+  //SetConsoleCommand(Orxonox, setTimeFactor, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
+  //SetConsoleCommand(Orxonox, loadGame, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, "standalone");
 
   /**

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

@@ -33 +33 @@
 #include "core/input/InputManager.h"
 #include "core/input/SimpleInputState.h"
-#include "core/input/KeyBinder.h"
-#include "overlays/console/InGameConsole.h"
 #include "gui/GUIManager.h"
 

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

@@ -35 +35 @@
 #include <OgreWindowEventUtilities.h>
 
+#include "core/ConsoleCommand.h"
+#include "core/ConfigValueIncludes.h"
 #include "core/input/InputManager.h"
-#include "core/input/SimpleInputState.h"
-#include "core/input/KeyBinder.h"
 #include "core/Core.h"
-
-#include "GraphicsEngine.h"
 #include "overlays/console/InGameConsole.h"
 #include "gui/GUIManager.h"
+#include "GraphicsEngine.h"
 
 namespace orxonox
@@ -88 +87 @@
         guiManager_ = new GUIManager();
         guiManager_->initialise();
+
+        // use the ogre timer class to measure time.
+        timer_ = new Ogre::Timer();
+
+        // add console commands
+        FunctorMember<GSGraphics>* functor = createFunctor(&GSGraphics::exitGame);
+        functor->setObject(this);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "exit"));
     }
 
     void GSGraphics::leave()
     {
-        if (this->guiManager_)
-          delete guiManager_;
-
-        if (this->console_)
-          delete this->console_;
-
-        if (inputManager_)
-          delete inputManager_;
-
-        // TODO: deintialise graphics
-    }
-
+        delete this->timer_;
+
+        delete this->guiManager_;
+
+        delete this->console_;
+
+        delete this->inputManager_;
+
+        // TODO: destroy render window
+    }
+
+    /**
+        Main loop of the orxonox game.
+        We use the Ogre::Timer to measure time since it uses the most precise
+        method an a platform (however the windows timer lacks time when under
+        heavy kernel load!).
+        There is a simple mechanism to measure the average time spent in our
+        ticks as it may indicate performance issues.
+        A note about the Ogre::FrameListener: Even though we don't use them,
+        they still get called. However, the delta times are not correct (except
+        for timeSinceLastFrame, which is the most important). A little research
+        as shown that there is probably only one FrameListener that doesn't even
+        need the time. So we shouldn't run into problems.
+    */
     bool GSGraphics::tick(float dt)
     {
+        // note: paramter 'dt' is of no meaning
+
         Ogre::Root& ogreRoot = Ogre::Root::getSingleton();
-
-        // use the ogre timer class to measure time.
-        if (!timer_)
-            timer_ = new Ogre::Timer();
 
         unsigned long frameCount = 0;
@@ -146 +163 @@
                     this->getActiveChild()->tick(dt);
 
+                // tick console
+                this->console_->tick(dt);
+
                 // get current time once again
                 timeAfterTick = timer_->getMicroseconds();

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

@@ -31 +31 @@
 
 #include "OrxonoxPrereqs.h"
+#include <OgrePrerequisites.h>
 #include "core/GameState.h"
+#include "core/OrxonoxClass.h"
 
 namespace orxonox
@@ -43 +45 @@
         bool tick(float dt);
         void setConfigValues();
+
+        void exitGame() { this->bAbort_ = true; }
 
     private:

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

@@ -23 +23 @@
  *      Reto Grieder
  *   Co-authors:
- *      ...
+ *      Fabian 'x3n' Landau
  *
  */
@@ -30 +30 @@
 #include "GSLevel.h"
 
-#include "GraphicsEngine.h"
 #include "core/ConsoleCommand.h"
 #include "core/input/InputManager.h"
 #include "core/input/SimpleInputState.h"
 #include "core/input/KeyBinder.h"
+#include "core/Loader.h"
 #include "overlays/console/InGameConsole.h"
 #include "gui/GUIManager.h"
+#include "objects/Backlight.h"
+#include "tools/ParticleInterface.h"
+#include "Radar.h"
+#include "Settings.h"
+#include "GraphicsEngine.h"
 
 namespace orxonox
@@ -43 +48 @@
         : GameState("level")
         , timefactor_(1.0f)
+        , keyBinder_(0)
+        , radar_(0)
+        , startLevel_(0)
+        , hud_(0)
     {
     }
@@ -52 +61 @@
     void GSLevel::enter()
     {
-        KeyBinder* keyBinder = new KeyBinder();
-        keyBinder->loadBindings();
-        InputManager::getInstance().createInputState<SimpleInputState>("game", 20)->setHandler(keyBinder);
+        keyBinder_ = new KeyBinder();
+        keyBinder_->loadBindings();
+        InputManager::getInstance().createInputState<SimpleInputState>("game", 20)->setHandler(keyBinder_);
+
+        // create Ogre SceneManager for the level
+        GraphicsEngine::getInstance().createNewScene();
+
+        // Start the Radar
+        this->radar_ = new Radar();
+
+        // Load the HUD
+        COUT(3) << "Orxonox: Loading HUD" << std::endl;
+        hud_ = new Level(Settings::getDataPath() + "overlay/hud.oxo");
+        Loader::load(hud_);
+
+        // call the loader
+        COUT(0) << "Loading level..." << std::endl;
+        startLevel_ = new Level(Settings::getDataPath() + "levels/sample.oxw");
+        Loader::open(startLevel_);
 
         // add console commands
-        //ConsoleCommand* command = createConsoleCommand(createFunctor(&classname::function), )
-        //CommandExecutor::addConsoleCommandShortcut(command);
+        FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
+        functor->setObject(this);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor"));
+
+        // level is loaded: we can start capturing the input
+        InputManager::getInstance().requestEnterState("game");
     }
 
     void GSLevel::leave()
     {
+        InputManager::getInstance().requestLeaveState("game");
+
+        // TODO: Remove and destroy console command
+
+        Loader::unload(startLevel_);
+        delete this->startLevel_;
+
+        Loader::unload(hud_);
+        delete this->hud_;
+
+        // this call will delete every BaseObject!
+        // But currently this will call methods of objects that exist no more
+        // The only 'memory leak' is the ParticleSpawer. They would be deleted here
+        // and call a sceneNode method that has already been destroy by the corresponding space ship.
+        //Loader::close();
+
+        delete this->radar_;
+
+        // TODO: delete SceneManager
+
+        InputManager::getInstance().destroyState("game");
+        delete this->keyBinder_;
     }
 
@@ -74 +125 @@
             it->tick(dt * this->timefactor_);
 
+        // TODO: split file into server/client/standalone
         // call server/client with normal dt
         //if (client_g)
@@ -87 +139 @@
         Changes the speed of Orxonox
     */
-    //void GSLevel::setTimeFactor(float factor)
-    //{
-    //    float change = factor / Orxonox::getInstance().getTimeFactor();
-    //    Orxonox::getInstance().timefactor_ = factor;
-    //    for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
-    //        it->setSpeedFactor(it->getSpeedFactor() * change);
+    void GSLevel::setTimeFactor(float factor)
+    {
+        float change = factor / this->timefactor_;
+        this->timefactor_ = factor;
+        for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+            it->setSpeedFactor(it->getSpeedFactor() * change);
 
-    //    for (Iterator<Backlight> it = ObjectList<Backlight>::begin(); it; ++it)
-    //        it->setTimeFactor(Orxonox::getInstance().getTimeFactor());
-    //}
+        for (Iterator<Backlight> it = ObjectList<Backlight>::begin(); it; ++it)
+            it->setTimeFactor(timefactor_);
+    }
 }

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

@@ -49 +49 @@
         void setTimeFactor(float factor);
 
-        float                 timefactor_;       //!< A factor to change the gamespeed
+        float timefactor_;       //!< A factor to change the gamespeed
+
+        KeyBinder*            keyBinder_;        //!< tool that loads and manages the input bindings
+        Radar*                radar_;            //!< represents the Radar (not the HUD part)
+        Level*                startLevel_;       //!< current hard coded default level
+        Level*                hud_;              //!< 'level' object fo the HUD
     };
 }

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

@@ -30 +30 @@
 #include "GSRoot.h"
 
-#include <cassert>
 #include "core/Factory.h"
 #include "core/ConfigFileManager.h"
@@ -36 +35 @@
 #include "core/ConsoleCommand.h"
 #include "core/Debug.h"
-//#include "core/Exception.h"
+#include "core/Exception.h"
 #include "core/TclBind.h"
 #include "core/Core.h"
@@ -65 +64 @@
         Factory::createClassHierarchy();
 
-        // TODO: config values
-        //setConfigValues();
-
         const Settings::CommandLineArgument* dataPath = Settings::getCommandLineArgument("dataPath");
         assert(dataPath);
@@ -81 +77 @@
         TclBind::getInstance().setDataPath(Settings::getDataPath());
 
+        // initialise graphics engine. Doesn't load the render window yet!
         graphicsEngine_ = new GraphicsEngine();
         graphicsEngine_->setup();       // creates ogre root and other essentials
 
+        // console commands
+        FunctorMember<GSRoot>* functor = createFunctor(&GSRoot::loadGame);
+        functor->setObject(this);
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "loadGame"));
     }
 
@@ -98 +99 @@
         return true;
     }
+
+    /**
+    @brief
+        Requests a state.
+    */
+    void GSRoot::loadGame(const std::string& name)
+    {
+        this->requestState(name);
+    }
 }

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

@@ -42 +42 @@
 
         bool tick(float dt);
+        void loadGame(const std::string& name);
 
     private:

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

@@ -163 +163 @@
                 // load the background scene
                 loadScenes();
+                //CEGUI::KeyEventArgs e;
+                //e.codepoint
             }
             catch (CEGUI::Exception& ex)

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

@@ -68 +68 @@
         this->ribbonTrail_->setMaterialName("Trail/backlighttrail");
 
-        this->setTimeFactor(Orxonox::getInstance().getTimeFactor());
+        //this->setTimeFactor(Orxonox::getInstance().getTimeFactor());
+        this->setTimeFactor(1.0f);
     }
 

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

@@ -37 +37 @@
 
 #include "core/Shell.h"
-#include "objects/Tickable.h"
+#include "core/OrxonoxClass.h"
 #include "tools/WindowEventListener.h"
 
@@ -43 +43 @@
 namespace orxonox
 {
-    class _OrxonoxExport InGameConsole : public TickableReal, public ShellListener, public WindowEventListener
+    class _OrxonoxExport InGameConsole : virtual public OrxonoxClass, public ShellListener, public WindowEventListener
     {
     public: // functions

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

@@ -56 +56 @@
     this->detaillevel_ = (unsigned int)detaillevel;
     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(Orxonox::getInstance().getTimeFactor());
+    this->particleSystem_->setSpeedFactor(1.0f);
 
     if (GraphicsEngine::getInstance().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
@@ -171 +172 @@
   void ParticleInterface::setSpeedFactor(float factor)
   {
-    this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+    //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+    this->particleSystem_->setSpeedFactor(1.0f * factor);
   }
   float ParticleInterface::getSpeedFactor() const
   {
-    return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+    //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+    return (this->particleSystem_->getSpeedFactor() / 1.0f);
   }