Backport of test timing code from Detritus

build/msvc/NxOgre.VC9.vcproj

@@ -1592,6 +1592,14 @@
 			RelativePath="..\source\NxOgreString.h"
 			>
 		</File>
+		<File
+			RelativePath="..\source\NxOgreTime.cpp"
+			>
+		</File>
+		<File
+			RelativePath="..\source\NxOgreTime.h"
+			>
+		</File>
 		<File
 			RelativePath="..\source\NxOgreTimeController.cpp"
 			>

build/source/NxOgreAccumulativeSceneTimer.cpp

@@ -26,6 +26,7 @@
 #include "NxOgreStable.h"
 #include "NxOgreAccumulativeSceneTimer.h"
 #include "NxOgreScene.h"
+#include "NxOgreTime.h"
 
 #include "NxPhysics.h"
 
@@ -37,20 +38,58 @@ namespace NxOgre
 
 
 AccumulativeSceneTimer::AccumulativeSceneTimer(Scene* scene, Real maxTime, Real expectedTime)
-: SceneTimer(scene, maxTime, expectedTime), mAccumulator(0)
+: SceneTimer(scene, maxTime, expectedTime), mOldTime(0.0f), mAccumulator(0.0f)
 {
 }
 
 AccumulativeSceneTimer::~AccumulativeSceneTimer(void)
 {
 }
 
-void AccumulativeSceneTimer::simulate(float user_deltaTime)
+void AccumulativeSceneTimer::simulate(float userDeltaTime)
 {
 
  if (mScene->isWritable() == false)
   return;
 
+ const float now = Functions::time();
+ float deltaTime = now - mOldTime;
+ mOldTime = now;
+
+ if (deltaTime > mMaxTime)
+  deltaTime = mMaxTime;
+
+ mAccumulator += deltaTime;
+
+ TimeStep& ts = mParent->getTimeStep();
+ ts.mSubSteps = 0;
+ ts.mActual = userDeltaTime;
+
+ float sim_time = 0.0f;
+ while (mAccumulator >= mExpectedTime)
+ {
+  ts.mSubSteps++;
+  mScene->simulate(mExpectedTime);
+  mScene->flushStream();
+  mScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
+  mAccumulator -= mExpectedTime;
+ }
+
+ ts.mAlpha = mAccumulator / mExpectedTime;
+ ts.mModified = mExpectedTime;
+
+ if (ts.mSubSteps)
+ {
+  mTimerMode = Enums::TimerMode_Simulating;
+ }
+ else
+ {
+  mTimerMode = Enums::TimerMode_Miss;
+ }
+
+}
+
+#if 0
  if (user_deltaTime > mMaxTime)
   user_deltaTime = mMaxTime;
 
@@ -59,6 +98,7 @@ void AccumulativeSceneTimer::simulate(float user_deltaTime)
  TimeStep& ts = mParent->getTimeStep();
  ts.mActual = user_deltaTime;
  ts.mSubSteps = 0;
+
  while (mAccumulator >= mExpectedTime)
  {
   ts.mSubSteps++;
@@ -70,20 +110,22 @@ void AccumulativeSceneTimer::simulate(float user_deltaTime)
 
  ts.mAlpha = mAccumulator / mExpectedTime;
  ts.mModified = mExpectedTime;
-
-}
+#endif
 
 bool AccumulativeSceneTimer::hasResults(void) const
 {
- return true;// mScene->checkResults(NX_RIGID_BODY_FINISHED);
+ return mScene->checkResults(NX_RIGID_BODY_FINISHED);
 }
 
-void AccumulativeSceneTimer::fetchResults(void) const
+void AccumulativeSceneTimer::fetchResults(void)
 {
+/*
+ mScene->flushStream();
+ mScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
+*/
+ mTimerMode = Enums::TimerMode_FetchedResults;
 }
 
-
-
 
 
 } // namespace NxOgre

build/source/NxOgreAccumulativeSceneTimer.h

@@ -69,13 +69,11 @@ class NxOgrePublicClass AccumulativeSceneTimer : public PointerClass<Classes::_A
 
   /** \brief
   */
-  void                                       fetchResults(void) const;
+  void                                       fetchResults(void);
 
   protected:
 
-  /** \brief
-  */
-              float                           mAccumulator;
+  float                                      mOldTime, mAccumulator;
 
 }; // class AccumulativeSceneTimer
 

build/source/NxOgreCommon.h

@@ -76,6 +76,13 @@ enum Axis
  NoAxis = (1<<3)
 };
 
+enum TimerMode
+{
+ TimerMode_Simulating,
+ TimerMode_FetchedResults,
+ TimerMode_Miss
+};
+
 /** \brief Matrix translation
 */
 enum Translation

build/source/NxOgreFixedSceneTimer.cpp

@@ -24,7 +24,11 @@
 
 
 #include "NxOgreStable.h"
+#include "NxOgreScene.h"
 #include "NxOgreFixedSceneTimer.h"
+#include "NxOgreTime.h"
+
+#include "NxPhysics.h"
 
 
 
@@ -34,8 +38,16 @@ namespace NxOgre
 
 
 FixedSceneTimer::FixedSceneTimer(Scene* scene, Real maxTime, Real expectedTime)
-: SceneTimer(scene, maxTime, expectedTime)
+: SceneTimer(scene, maxTime, expectedTime),
+  mMaxTimeStep(1.0f / 60.0f),
+  mOldTime(0.0f),
+  mAccumulator(0.0f)
 {
+ mScene->setTiming(mMaxTimeStep / 8.0f, 8, NX_TIMESTEP_FIXED);
+ TimeStep& ts = mParent->getTimeStep();
+ ts.mAlpha = 1.0f;
+ ts.mModified = mMaxTimeStep;
+ ts.mSubSteps = 8;
 }
 
 FixedSceneTimer::~FixedSceneTimer(void)
@@ -44,15 +56,44 @@ FixedSceneTimer::~FixedSceneTimer(void)
 
 void FixedSceneTimer::simulate(float user_deltaTimer)
 {
+
+ float now = Functions::time();
+ float deltaTime = now - mOldTime;
+ mOldTime = now;
+
+ // Go ahead PhysX.
+ mScene->simulate(deltaTime);
+ mScene->flushStream();
+
+ // Calculate how much time PhysX did process.
+ mAccumulator += deltaTime;
+
+ TimeStep& ts = mParent->getTimeStep();
+
+ for (unsigned int i=0; i < ts.mSubSteps;i++)
+  if (mAccumulator <= mMaxTimeStep)
+   break;
+  else
+   mAccumulator -= mExpectedTime;
+
+ ts.mAlpha = mAccumulator / mMaxTimeStep;
+ ts.mModified = mExpectedTime;
+
+ // We probably simulated so in goes.
+ mTimerMode = Enums::TimerMode_Simulating;
+ ts.mActual = deltaTime;
+
 }
 
 bool FixedSceneTimer::hasResults(void) const
 {
- return true;
+ return mScene->checkResults(NX_RIGID_BODY_FINISHED, false);
 }
 
-void FixedSceneTimer::fetchResults(void) const
+void FixedSceneTimer::fetchResults(void)
 {
+ mScene->fetchResults(NX_RIGID_BODY_FINISHED, true);
+ mTimerMode = Enums::TimerMode_FetchedResults;
 }
 
 

build/source/NxOgreFixedSceneTimer.h

@@ -72,11 +72,13 @@ class NxOgrePublicClass FixedSceneTimer : public PointerClass<Classes::_FixedSce
 
   /** \brief
   */
-  void                                        fetchResults(void) const;
+  void                                        fetchResults(void);
 
 
   protected:
 
+  float mMaxTimeStep, mOldTime, mAccumulator;
+
 }; // class ClassName
 
 

build/source/NxOgreScene.cpp

@@ -48,6 +48,7 @@
 #include "NxOgreFunctions.h"
 #include "NxOgreRaycastHit.h"
 #include "NxOgreAccumulativeSceneTimer.h"
+#include "NxOgreFixedSceneTimer.h"
 #include "NxOgreMachine.h"
 #include "NxOgreMachinePart.h"
 #include "NxOgreCloth.h"
@@ -87,8 +88,9 @@ Scene::Scene(ScenePrototype* prototype, NxPhysicsSDK* sdk)
 
  scene_description.userTriggerReport = mPhysXCallback;
  scene_description.userContactReport = mPhysXCallback;
-
- scene_description.timeStepMethod = NX_TIMESTEP_VARIABLE; // temp.
+
+ scene_description.timeStepMethod = NX_TIMESTEP_FIXED; // temp.
+ scene_description.maxTimestep = 1.0f/60.0f;
 
  mScene = mSDK->createScene(scene_description);
 
@@ -116,12 +118,10 @@ Scene::Scene(ScenePrototype* prototype, NxPhysicsSDK* sdk)
   mMaterials.insert(material);
 
   TimeController::getSingleton()->mListeners[mProcessingPriority].insert(this);
+  TimeController::getSingleton()->mListeners[mFetchingPriority].insert(this);
 
-  if (mFetchingPriority != mProcessingPriority)
-   TimeController::getSingleton()->mListeners[mFetchingPriority].insert(this);
 
-
-  mSceneTimer = new AccumulativeSceneTimer(this); // temp.
+  mSceneTimer = new FixedSceneTimer(this); // temp.
 
   mMachineIterator = mMachines.getIterator();
 
@@ -223,23 +223,26 @@ SceneGeometry* Scene::createSceneGeometry(Shape* shape, const Matrix44& pose, co
 bool Scene::advance(float user_deltaTime, const Enums::Priority& p)
 {
 
- if (p == mProcessingPriority)
+ if (p == mProcessingPriority && mSceneTimer->getTimerMode() > 0 )
  {
-
   for (Machine* machine = mMachineIterator.begin();machine = mMachineIterator.next();)
    machine->simulate(user_deltaTime);
 
   mCanRender = false;
+
   mSceneTimer->simulate(user_deltaTime);
 
+  return true;
  }
 
- if (p == mFetchingPriority)
+ if (p == mFetchingPriority && mSceneTimer->getTimerMode() == Enums::TimerMode_Simulating)
  {
-  while(!mSceneTimer->hasResults())
-   mSceneTimer->fetchResults();
+
+  mSceneTimer->fetchResults();
 
   mCanRender = true;
+
+  return true;
  }
 
  return true;

build/source/NxOgreSceneTimer.cpp

@@ -36,7 +36,7 @@ namespace NxOgre
 
 
 SceneTimer::SceneTimer(Scene* scene, Real maxTime, Real expectedTime)
-: mParent(scene), mMaxTime(maxTime), mExpectedTime(expectedTime)
+: mParent(scene), mMaxTime(maxTime), mExpectedTime(expectedTime), mTimerMode(Enums::TimerMode_Miss)
 {
  mScene = mParent->getScene();
 }
@@ -54,10 +54,15 @@ bool SceneTimer::hasResults(void) const
  return true;
 }
 
-void SceneTimer::fetchResults(void) const
+void SceneTimer::fetchResults(void)
 {
 }
 
+Enums::TimerMode SceneTimer::getTimerMode() const
+{
+ return mTimerMode;
+}
+
 
 
 } // namespace NxOgre

build/source/NxOgreSceneTimer.h

@@ -49,6 +49,7 @@ class NxOgrePublicClass SceneTimer
    Real mMaxTime;
   };
 
+
   /** \brief Text
   */
                                               SceneTimer(Scene*, Real maxTime, Real expectedTime);
@@ -72,8 +73,12 @@ class NxOgrePublicClass SceneTimer
 
   /** \brief
   */
-  virtual void                                fetchResults(void) const;
+  virtual void                                fetchResults(void);
+
+
 
+  virtual Enums::TimerMode                    getTimerMode() const;
+
   protected:
 
   /** \brief Maximum time that can be injected.
@@ -92,6 +97,9 @@ class NxOgrePublicClass SceneTimer
   */
   NxScene* mScene;
 
+
+  Enums::TimerMode mTimerMode;
+
 }; // class ClassName