Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Aug 27, 2008, 10:21:39 PM (16 years ago)
Author:
rgrieder
Message:
  • Changed GameState so that the new RootGameState can override 2 virtual methods
  • added RootGameState that takes care of state transitions (can only happen between ticks)
  • moved main loop to GSRoot instead of GSGraphics
  • network GameStates not yet finished
  • GraphicsEngine not yet merged into GSGraphics
Location:
code/branches/gui/src/orxonox
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • code/branches/gui/src/orxonox/CMakeLists.txt

    r1665 r1672  
    88  Settings.cc
    99
     10  gamestates/GSClient.cc
    1011  gamestates/GSGraphics.cc
    1112  gamestates/GSGUI.cc
     13  gamestates/GSIO.cc
     14  gamestates/GSIOConsole.cc
    1215  gamestates/GSLevel.cc
    1316  gamestates/GSRoot.cc
     17  gamestates/GSServer.cc
     18  gamestates/GSStandalone.cc
    1419
    1520  gui/GUIManager.cc

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

    r1670 r1672  
    143143
    144144    root.feedCommandLine(argc, argv);
    145     root.requestState("ioConsole");
    146     while (!root.isGameFinished())
    147         root.tick(0.0f);
     145    root.start();
    148146
    149147    return 0;

  • code/branches/gui/src/orxonox/OrxonoxPrereqs.h

    r1663 r1672  
    7575    class GraphicsEngine;
    7676    class Orxonox;
     77    class RootGameState;
    7778    class Settings;
    7879

  • code/branches/gui/src/orxonox/gamestates/GSClient.cc

    r1670 r1672  
    7878    }
    7979
    80     void GSClient::ticked(float dt)
     80    void GSClient::ticked(float dt, uint64_t time)
    8181    {
    82         GSLevel::ticked(dt);
     82        GSLevel::ticked(dt, time);
    8383        client_->tick(dt);
    8484
    85         this->tickChild(dt);
     85        this->tickChild(dt, time);
    8686    }
    8787}

  • code/branches/gui/src/orxonox/gamestates/GSClient.h

    r1670 r1672  
    4646        void enter();
    4747        void leave();
    48         void ticked(float dt);
     48        void ticked(float dt, uint64_t time);
    4949
    5050        network::Client* client_;

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

    r1670 r1672  
    5858    }
    5959
    60     void GSGUI::ticked(float dt)
     60    void GSGUI::ticked(float dt, uint64_t time)
    6161    {
    6262        // tick CEGUI
    6363        GUIManager::getInstance().tick(dt);
    6464
    65         this->tickChild(dt);
     65        this->tickChild(dt, time);
    6666    }
    6767}

  • code/branches/gui/src/orxonox/gamestates/GSGUI.h

    r1670 r1672  
    4444        void enter();
    4545        void leave();
    46         void ticked(float dt);
     46        void ticked(float dt, uint64_t time);
    4747
    4848    };

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

    r1670 r1672  
    3434#include <OgreTimer.h>
    3535#include <OgreWindowEventUtilities.h>
     36#include <OgreRenderWindow.h>
    3637
    3738#include "core/ConsoleCommand.h"
    3839#include "core/ConfigValueIncludes.h"
    3940#include "core/input/InputManager.h"
    40 #include "core/TclThreadManager.h"
    4141//#include "core/Core.h"
    4242#include "overlays/console/InGameConsole.h"
    … …  
    4848    GSGraphics::GSGraphics()
    4949        : GameState("graphics")
    50         , timer_(0)
    5150        , debugRefreshTime_(0.0f)
    5251        , inputManager_(0)
    5352        , console_(0)
    5453        , guiManager_(0)
     54        , frameCount_(0)
    5555    {
    5656    }
    … …  
    6767    void GSGraphics::enter()
    6868    {
     69        this->ogreRoot_ = Ogre::Root::getSingletonPtr();
    6970        this->graphicsEngine_ = GraphicsEngine::getInstancePtr();
    7071
    … …  
    8788        guiManager_ = new GUIManager();
    8889        guiManager_->initialise();
    89 
    90         // use the ogre timer class to measure time.
    91         timer_ = new Ogre::Timer();
    9290    }
    9391
    9492    void GSGraphics::leave()
    9593    {
    96         delete this->timer_;
    97 
    9894        delete this->guiManager_;
    9995
    … …  
    10298        delete this->inputManager_;
    10399
     100        this->ogreRoot_->detachRenderTarget(GraphicsEngine::getInstance().getRenderWindow());
     101        delete GraphicsEngine::getInstance().getRenderWindow();
     102        this->ogreRoot_->shutdown
    104103        // TODO: destroy render window
    105104    }
    … …  
    118117        need the time. So we shouldn't run into problems.
    119118    */
    120     void GSGraphics::ticked(float dt)
     119    void GSGraphics::ticked(float dt, uint64_t time)
    121120    {
    122         // note: paramter 'dt' is of no meaning
     121        this->inputManager_->tick(dt);
    123122
    124         Ogre::Root& ogreRoot = Ogre::Root::getSingleton();
     123        this->tickChild(dt, time);
    125124
    126         unsigned long frameCount = 0;
     125        // tick console
     126        this->console_->tick(dt);
    127127
    128         const unsigned long refreshTime = (unsigned long)(debugRefreshTime_ * 1000000.0f);
    129         unsigned long refreshStartTime = 0;
    130         unsigned long tickTime = 0;
    131         unsigned long oldFrameCount = 0;
     128        //// get current time once again
     129        //timeAfterTick = timer_->getMicroseconds();
    132130
    133         unsigned long timeBeforeTick = 0;
    134         unsigned long timeBeforeTickOld = 0;
    135         unsigned long timeAfterTick = 0;
     131        //tickTime += timeAfterTick - timeBeforeTick;
     132        //if (timeAfterTick > refreshStartTime + refreshTime)
     133        //{
     134        //    GraphicsEngine::getInstance().setAverageTickTime(
     135        //        (float)tickTime * 0.001 / (frameCount - oldFrameCount));
     136        //    float avgFPS = (float)(frameCount - oldFrameCount) / (timeAfterTick - refreshStartTime) * 1000000.0;
     137        //    GraphicsEngine::getInstance().setAverageFramesPerSecond(avgFPS);
    136138
    137         // TODO: Update time in seconds every 7 seconds to avoid any overflow (7 secs is very tight)
     139        //    oldFrameCount = frameCount;
     140        //    tickTime = 0;
     141        //    refreshStartTime = timeAfterTick;
     142        //}
    138143
    139         COUT(3) << "Orxonox: Starting the main loop." << std::endl;
     144        // don't forget to call _fireFrameStarted in ogre to make sure
     145        // everything goes smoothly
     146        Ogre::FrameEvent evt;
     147        evt.timeSinceLastFrame = dt;
     148        evt.timeSinceLastEvent = dt; // note: same time, but shouldn't matter anyway
     149        ogreRoot_->_fireFrameStarted(evt);
    140150
    141         try
    142         {
    143             timer_->reset();
    144             while (!this->hasScheduledTransition())
    145             {
    146                 // get current time
    147                 timeBeforeTickOld = timeBeforeTick;
    148                 timeBeforeTick    = timer_->getMicroseconds();
    149                 float dt = (timeBeforeTick - timeBeforeTickOld) / 1000000.0;
     151        // Pump messages in all registered RenderWindows
     152        // This calls the WindowEventListener objects.
     153        Ogre::WindowEventUtilities::messagePump();
     154        // make sure the window stays active even when not focused
     155        // (probably only necessary on windows)
     156        GraphicsEngine::getInstance().setWindowActivity(true);
    150157
    151                 this->inputManager_->tick(dt);
    152                 TclThreadManager::getInstance().tick(dt);
     158        // render
     159        ogreRoot_->_updateAllRenderTargets();
    153160
    154                 this->tickChild(dt);
     161        // again, just to be sure ogre works fine
     162        ogreRoot_->_fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
    155163
    156                 // tick console
    157                 this->console_->tick(dt);
     164        ++frameCount_;
    158165
    159                 // get current time once again
    160                 timeAfterTick = timer_->getMicroseconds();
    161 
    162                 tickTime += timeAfterTick - timeBeforeTick;
    163                 if (timeAfterTick > refreshStartTime + refreshTime)
    164                 {
    165                     GraphicsEngine::getInstance().setAverageTickTime(
    166                         (float)tickTime * 0.001 / (frameCount - oldFrameCount));
    167                     float avgFPS = (float)(frameCount - oldFrameCount) / (timeAfterTick - refreshStartTime) * 1000000.0;
    168                     GraphicsEngine::getInstance().setAverageFramesPerSecond(avgFPS);
    169 
    170                     oldFrameCount = frameCount;
    171                     tickTime = 0;
    172                     refreshStartTime = timeAfterTick;
    173                 }
    174 
    175                 // don't forget to call _fireFrameStarted in ogre to make sure
    176                 // everything goes smoothly
    177                 Ogre::FrameEvent evt;
    178                 evt.timeSinceLastFrame = dt;
    179                 evt.timeSinceLastEvent = dt; // note: same time, but shouldn't matter anyway
    180                 ogreRoot._fireFrameStarted(evt);
    181 
    182                 // Pump messages in all registered RenderWindows
    183                 // This calls the WindowEventListener objects.
    184                 Ogre::WindowEventUtilities::messagePump();
    185                 // make sure the window stays active even when not focused
    186                 // (probably only necessary on windows)
    187                 GraphicsEngine::getInstance().setWindowActivity(true);
    188 
    189                 // render
    190                 ogreRoot._updateAllRenderTargets();
    191 
    192                 // again, just to be sure ogre works fine
    193                 ogreRoot._fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
    194 
    195                 ++frameCount;
    196             }
    197         }
    198         catch (std::exception& ex)
    199         {
    200             // something went wrong.
    201             COUT(1) << ex.what() << std::endl;
    202             COUT(1) << "Main loop was stopped by an unhandled exception. Shutting down." << std::endl;
    203         }
     166        //}
     167        //catch (std::exception& ex)
     168        //{
     169        //    // something went wrong.
     170        //    COUT(1) << ex.what() << std::endl;
     171        //    COUT(1) << "Main loop was stopped by an unhandled exception. Shutting down." << std::endl;
     172        //}
    204173    }
    205174}

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

    r1670 r1672  
    4848        void enter();
    4949        void leave();
    50         void ticked(float dt);
    51 
    52         Ogre::Timer*          timer_;            //!< Main loop timer
     50        void ticked(float dt, uint64_t time);
    5351
    5452        // config values
    5553        float                 debugRefreshTime_;
    5654
     55        Ogre::Root*           ogreRoot_;
    5756        GraphicsEngine*       graphicsEngine_;   //!< our dearest graphics engine <3
    5857        InputManager*         inputManager_;
    5958        InGameConsole*        console_;
    6059        GUIManager*           guiManager_;
     60
     61
     62        // variables for time statistics
     63        unsigned long         frameCount_;
     64
     65        //const unsigned long refreshTime = (unsigned long)(debugRefreshTime_ * 1000000.0f);
     66        //unsigned long refreshStartTime;
     67        //unsigned long tickTime;
     68        //unsigned long oldFrameCount;
     69
     70        //unsigned long timeBeforeTick;
     71        //unsigned long timeBeforeTickOld;
     72        //unsigned long timeAfterTick;
    6173    };
    6274}

  • code/branches/gui/src/orxonox/gamestates/GSIO.cc

    r1670 r1672  
    5858    }
    5959
    60     void GSIO::ticked(float dt)
     60    void GSIO::ticked(float dt, uint64_t time)
    6161    {
    62         this->tickChild(dt);
     62        this->tickChild(dt, time);
    6363        //Ogre::Root& ogreRoot = Ogre::Root::getSingleton();
    6464

  • code/branches/gui/src/orxonox/gamestates/GSIO.h

    r1670 r1672  
    4545        void enter();
    4646        void leave();
    47         void ticked(float dt);
     47        void ticked(float dt, uint64_t time);
    4848
    4949        //Ogre::Timer*          timer_;            //!< Main loop timer

  • code/branches/gui/src/orxonox/gamestates/GSIOConsole.cc

    r1670 r1672  
    5858    }
    5959
    60     void GSIOConsole::ticked(float dt)
     60    void GSIOConsole::ticked(float dt, uint64_t time)
    6161    {
    62         while (!this->hasScheduledTransition())
    63         {
    64             std::string command;
    65             std::cin >> command;
    66             CommandExecutor::execute(command, true);
    67         }
     62        std::string command;
     63        std::getline(std::cin, command);
     64        CommandExecutor::execute(command, true);
     65       
     66        tickChild(dt, time);
    6867    }
    6968}

  • code/branches/gui/src/orxonox/gamestates/GSIOConsole.h

    r1670 r1672  
    4545        void enter();
    4646        void leave();
    47         void ticked(float dt);
     47        void ticked(float dt, uint64_t time);
    4848    };
    4949}

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

    r1670 r1672  
    9696    }
    9797
    98     void GSLevel::ticked(float dt)
     98    void GSLevel::ticked(float dt, uint64_t time)
    9999    {
    100100        // Call those objects that need the real time

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

    r1670 r1672  
    4949        virtual void enter();
    5050        virtual void leave();
    51         virtual void ticked(float dt);
     51        virtual void ticked(float dt, uint64_t time);
    5252
    5353        void loadLevel();

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

    r1670 r1672  
    4141#include "core/Core.h"
    4242#include "core/CommandLine.h"
     43#include "core/TclThreadManager.h"
    4344#include "GraphicsEngine.h"
    4445#include "Settings.h"
    … …  
    4950
    5051    GSRoot::GSRoot()
    51         : GameState("root")
     52        : RootGameState("root")
    5253        , settings_(0)
    5354        , graphicsEngine_(0)
    54         , bExit_(false)
    5555    {
    5656    }
    … …  
    113113        // initialise TCL
    114114        TclBind::getInstance().setDataPath(Settings::getDataPath());
     115        TclThreadManager::getInstance();
    115116
    116117        // initialise graphics engine. Doesn't load the render window yet!
    … …  
    118119        graphicsEngine_->setup();       // creates ogre root and other essentials
    119120
    120         // console commands
    121         FunctorMember<GSRoot>* functor = createFunctor(&GSRoot::loadGame);
    122         functor->setObject(this);
    123         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "loadGame"));
     121        // add console commands
     122        FunctorMember<GSRoot>* functor1 = createFunctor(&GSRoot::exitGame);
     123        functor1->setObject(this);
     124        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor1, "exit"));
    124125
    125126        // add console commands
    126         functor = createFunctor(&GSRoot::exitGame);
    127         functor->setObject(this);
    128         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "exit"));
     127        FunctorMember01<GameState, const std::string&>* functor2 = createFunctor(&GameState::requestState);
     128        functor2->setObject(this);
     129        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor2, "selectGameState"));
    129130    }
    130131
    … …  
    137138    }
    138139
    139     void GSRoot::ticked(float dt)
     140    void GSRoot::ticked(float dt, uint64_t time)
    140141    {
    141         this->tickChild(dt);
    142     }
     142        TclThreadManager::getInstance().tick(dt);
    143143
    144     /**
    145     @brief
    146         Requests a state.
    147     */
    148     void GSRoot::loadGame(const std::string& name)
    149     {
    150         this->requestState(name);
     144        this->tickChild(dt, time);
    151145    }
    152146}

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

    r1670 r1672  
    3131
    3232#include "OrxonoxPrereqs.h"
    33 #include "core/GameState.h"
     33#include "core/RootGameState.h"
    3434
    3535namespace orxonox
    3636{
    37     class _OrxonoxExport GSRoot : public GameState
     37    class _OrxonoxExport GSRoot : public RootGameState
    3838    {
    3939    public:
    … …  
    4242
    4343        void feedCommandLine(int argc, char** argv);
    44         void loadGame(const std::string& name);
    4544
    4645        void exitGame()
    4746        { requestState("root"); }
    48         bool isGameFinished() { return (this->getActiveChild() == 0); }
    4947
    5048    private:
    5149        void enter();
    5250        void leave();
    53         void ticked(float dt);
     51        void ticked(float dt, uint64_t time);
    5452
    5553        Settings*             settings_;
    56         GraphicsEngine*       graphicsEngine_;   //!< our dearest graphics engine <3
    57         bool                  bExit_;
     54        GraphicsEngine*       graphicsEngine_;   //!< Interface to Ogre
    5855    };
    5956}
    6057
    61 #endif /* _GSGraphics_H__ */
     58#endif /* _GSRoot_H__ */

  • code/branches/gui/src/orxonox/gamestates/GSServer.cc

    r1670 r1672  
    8383    }
    8484
    85     void GSServer::ticked(float dt)
     85    void GSServer::ticked(float dt, uint64_t time)
    8686    {
    87         GSLevel::ticked(dt);
     87        GSLevel::ticked(dt, time);
    8888        server_->tick(dt);
    89         this->tickChild(dt);
     89        this->tickChild(dt, time);
    9090    }
    9191}

  • code/branches/gui/src/orxonox/gamestates/GSServer.h

    r1670 r1672  
    4646        void enter();
    4747        void leave();
    48         void ticked(float dt);
     48        void ticked(float dt, uint64_t time);
    4949
    5050        network::Server*      server_;

  • code/branches/gui/src/orxonox/gamestates/GSStandalone.cc

    r1670 r1672  
    7070    }
    7171
    72     void GSStandalone::ticked(float dt)
     72    void GSStandalone::ticked(float dt, uint64_t time)
    7373    {
    74         GSLevel::ticked(dt);
     74        GSLevel::ticked(dt, time);
    7575
    76         this->tickChild(dt);
     76        this->tickChild(dt, time);
    7777    }
    7878}

  • code/branches/gui/src/orxonox/gamestates/GSStandalone.h

    r1670 r1672  
    4545        void enter();
    4646        void leave();
    47         void ticked(float dt);
     47        void ticked(float dt, uint64_t time);
    4848    };
    4949}
Note: See TracChangeset for help on using the changeset viewer.