Changeset 900 for code/branches/input/src/orxonox/Orxonox.cc

Timestamp:

Mar 18, 2008, 12:27:16 PM (16 years ago)

Author:

rgrieder

Message:

• implemented a new main loop, calling the ticks and the timers. —> removed the (Timer/Tick)FrameListener and displaced the code to Orxonox.cc (don't like it yet)

File:

• code/branches/input/src/orxonox/Orxonox.cc (modified) (7 diffs)

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

@@ -44 +44 @@
 #include <OgreOverlay.h>
 #include <OgreOverlayManager.h>
+#include <OgreTimer.h>
+#include <OgreWindowEventUtilities.h>
 
 //****** OIS *******
@@ -140 +142 @@
     this->frameListener_ = 0;
     this->root_ = 0;
+    // turn frame smoothing on by setting a value different from 0
+    this->frameSmoothingTime_ = 0.1f;
   }
 
@@ -368 +372 @@
   }
 
-  /**
-   *
-   * @param
-   */
   void Orxonox::createScene(void)
   {
@@ -386 +386 @@
 
     Ogre::Overlay* hudOverlay = Ogre::OverlayManager::getSingleton().getByName("Orxonox/HUD1.2");
-    HUD* orxonoxHud;
-    orxonoxHud = new HUD();
-    orxonoxHud->setEnergyValue(20);
-    orxonoxHud->setEnergyDistr(20,20,60);
+    //HUD* orxonoxHud;
+    orxonoxHUD_ = new HUD();
+    orxonoxHUD_->setEnergyValue(20);
+    orxonoxHUD_->setEnergyDistr(20,20,60);
     hudOverlay->show();
 
@@ -401 +401 @@
 
 
-  /**
-   *
-   */
   void Orxonox::setupScene()
   {
@@ -454 +451 @@
   void Orxonox::createFrameListener()
   {
-    TickFrameListener* TickFL = new TickFrameListener();
-    ogre_->getRoot()->addFrameListener(TickFL);
-
-    TimerFrameListener* TimerFL = new TimerFrameListener();
-    ogre_->getRoot()->addFrameListener(TimerFL);
+    //TickFrameListener* TickFL = new TickFrameListener();
+    //ogre_->getRoot()->addFrameListener(TickFL);
+
+    //TimerFrameListener* TimerFL = new TimerFrameListener();
+    //ogre_->getRoot()->addFrameListener(TimerFL);
 
     //if(mode_!=CLIENT) // FIXME just a hack ------- remove this in future
@@ -480 +477 @@
       ms.height = height;
     }
-    ogre_->getRoot()->startRendering();
+    //ogre_->getRoot()->startRendering();
+    mainLoop();
+  }
+
+  /**
+    Main loop of the orxonox game.
+    This is a new solution, using the ogre engine instead of beeing used by it.
+    An alternative solution would be to simply use the timer of the Root object,
+    but that implies using Ogre in any case. There would be no way to test
+    our code without the help of the root object.
+    There's even a chance that we can dispose of the root object entirely
+    in server mode.
+    About the loop: The design is almost exactly like the one in ogre, so that
+    if any part of ogre registers a framelisteners, it will still behave
+    correctly. Furthermore I have taken over the time smoothing feature from
+    ogre. If turned on (see orxonox constructor), it will calculate the dt_n by
+    means of the recent most dt_n-1, dt_n-2, etc.
+  */
+  void Orxonox::mainLoop()
+  {
+    // use the ogre timer class to measure time.
+    Ogre::Timer *timer = new Ogre::Timer();
+    timer->reset();
+
+    // Contains the times of recently fired events
+    std::deque<unsigned long> eventTimes[3];
+    // Clear event times
+    for (int i = 0; i < 3; ++i)
+      eventTimes[i].clear();
+
+          while (true)
+          {
+                  //Pump messages in all registered RenderWindows
+      Ogre::WindowEventUtilities::messagePump();
+
+      // get current time
+      unsigned long now = timer->getMilliseconds();
+
+      // create an event to pass to the frameStarted method in ogre
+      Ogre::FrameEvent evt;
+      evt.timeSinceLastEvent = calculateEventTime(now, eventTimes[0]);
+      evt.timeSinceLastFrame = calculateEventTime(now, eventTimes[1]);
+
+      // show the current time in the HUD
+      orxonoxHUD_->setTime((int)now, 0);
+
+      // don't forget to call _fireFrameStarted in ogre to make sure
+      // everything goes smoothly
+      if (!ogre_->getRoot()->_fireFrameStarted(evt))
+        break;
+
+      // Iterate through all Tickables and call their tick(dt) function
+      for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; )
+        (it++)->tick((float)evt.timeSinceLastFrame);
+
+      // Update the timers
+      updateTimers((float)evt.timeSinceLastFrame);
+
+      if (mode_ != SERVER)
+      {
+        // only render in non-server mode
+        ogre_->getRoot()->_updateAllRenderTargets();
+      }
+
+      // get current time
+      now = timer->getMilliseconds();
+
+      // create an event to pass to the frameEnded method in ogre
+      evt.timeSinceLastEvent = calculateEventTime(now, eventTimes[0]);
+      evt.timeSinceLastFrame = calculateEventTime(now, eventTimes[2]);
+
+      // again, just to be sure ogre works fine
+      if (!ogre_->getRoot()->_fireFrameEnded(evt))
+        break;
+          }
+  }
+
+  /**
+    Timer updater function.
+    Updates all timers with the current dt.
+    Timers have been tested since their displacement.
+    @param dt The delta time
+  */
+  void Orxonox::updateTimers(float dt)
+  {
+    // Iterate through all Timers
+    for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; )
+    {
+      if (it->isActive())
+      {
+        // If active: Decrease the timer by the duration of the last frame
+        it->time_ -= dt;
+
+        if (it->time_ <= 0)
+        {
+          // It's time to call the function
+          if (it->bLoop_)
+            it->time_ += it->interval_; // Q: Why '+=' and not '='? A: Think about it. It's more accurate like that. Seriously.
+          else
+            it->stopTimer(); // Stop the timer if we don't want to loop
+
+          (it++)->run();
+        }
+        else
+        ++it;
+      }
+      else
+      ++it;
+    }
+
+  }
+  /**
+    Method for calculating the average time between recently fired events.
+    Code directly taken from OgreRoot.cc
+    @param now The current time in ms.
+    @param type The type of event to be considered.
+  */
+  float Orxonox::calculateEventTime(unsigned long now, std::deque<unsigned long> &times)
+  {
+    // Calculate the average time passed between events of the given type
+    // during the last mFrameSmoothingTime seconds.
+
+    times.push_back(now);
+
+    if(times.size() == 1)
+      return 0;
+
+    // Times up to mFrameSmoothingTime seconds old should be kept
+    unsigned long discardThreshold =
+      static_cast<unsigned long>(frameSmoothingTime_ * 1000.0f);
+
+    // Find the oldest time to keep
+    std::deque<unsigned long>::iterator it = times.begin(),
+      end = times.end()-2; // We need at least two times
+    while(it != end)
+    {
+      if (now - *it > discardThreshold)
+        ++it;
+      else
+        break;
+    }
+
+    // Remove old times
+    times.erase(times.begin(), it);
+
+    return (float)(times.back() - times.front()) / ((times.size()-1) * 1000);
   }
 }