Merge pull request #143 from Hoikas/unlock-framerate

Unlock framerate

Sources/Plasma/Apps/plClient/plClient.cpp

@@ -1290,7 +1290,20 @@ void plClient::IProgressMgrCallbackProc(plOperationProgress * progress)
         return;
 
     fInstance->fMessagePumpProc();
-    fInstance->IDraw();
+
+    // HACK HACK HACK HACK!
+    // Yes, this is the ORIGINAL, EVIL famerate limit from plClient::IDraw (except I bumped it to 60fps)
+    // As it so happens, this callback is happening in the main resource loading thread
+    // Without this NASTY ASS HACK, we draw after loading every KO, which starves the loader.
+    // At some point, a better solution should be found... Like running the loader in a separate thread.
+    static float lastDrawTime;
+    static const float kMaxFrameRate = 1.f/60.f;
+    float currTime = (float) hsTimer::GetSeconds();
+    if ((currTime - lastDrawTime) > kMaxFrameRate)
+    {
+        fInstance->IDraw();
+        lastDrawTime = currTime;
+    }
 }
 
 //============================================================================
@@ -1836,22 +1849,6 @@ hsBool plClient::IDrawProgress() {
 
 hsBool plClient::IDraw()
 {
-    // Limit framerate
-    static float lastDrawTime;
-    static const float kMaxFrameRate = 1.f/30.f;
-    float currTime = (float) hsTimer::GetSeconds();
-    if (!fPipeline->IsDebugFlagSet(plPipeDbg::kFlagNVPerfHUD))
-    {
-        // If we're using NVPerfHUD to step through draw calls,
-        // We're going to have a frame delta of zero. In that
-        // case we need to draw no matter what, and we don't
-        // care as much about starving other threads because
-        // we're presumably just debugging a graphics glitch.
-        if ((currTime - lastDrawTime) < kMaxFrameRate)
-            return true;
-    }
-    lastDrawTime = currTime;
-
     // If we're shutting down, don't attempt to draw.  Doing so
     // tends to cause a device reload each frame.   
     if (fDone)

Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp

@@ -390,8 +390,6 @@ plSimulationMgr* plSimulationMgr::GetInstance()
 
 plSimulationMgr::plSimulationMgr()
     : fSuspended(true)
-    , fMaxDelta(kDefaultMaxDelta)
-    , fStepSize(kDefaultStepSize)
     , fLOSDispatch(new plLOSDispatch())
     , fSoundMgr(new plPhysicsSoundMgr)
     , fLog(nil)
@@ -450,16 +448,20 @@ NxScene* plSimulationMgr::GetScene(plKey world)
 
     if (!scene)
     {
-        uint32_t maxSteps = (uint32_t)ceil(fMaxDelta / fStepSize);
-
         NxSceneDesc sceneDesc;
         sceneDesc.gravity.set(0, 0, -32.174049f);
         sceneDesc.userTriggerReport = &gSensorReport;
         sceneDesc.userContactReport = &gContactReport;
-        sceneDesc.maxTimestep = fStepSize;
-        sceneDesc.maxIter = maxSteps;
         scene = fSDK->createScene(sceneDesc);
 
+        // See "Advancing The Simulation State" in the PhysX SDK Documentation
+        // This will cause PhysX to only update for our step size. If we call simulate
+        // faster than that, PhysX will return immediately. If we call it slower than that,
+        // PhysX will do some extra steps for us (isn't that nice?).
+        // Anyway, this should be a good way to make us independent of the framerate.
+        // If not, I blame the usual suspects (Tye, eap, etc...)
+        scene->setTiming(kDefaultStepSize);
+
         // Most physicals use the default friction and restitution values, so we
         // make them the default.
         NxMaterial* mat = scene->getMaterialFromIndex(0);
@@ -602,12 +604,6 @@ void plSimulationMgr::Advance(float delSecs)
     if (fSuspended)
         return;
 
-    if (delSecs > fMaxDelta)
-    {
-        if (fExtraProfile)
-            Log("Step clamped from %f to limit of %f", delSecs, fMaxDelta);
-        delSecs = fMaxDelta;
-    }
     plProfile_IncCount(StepLen, (int)(delSecs*1000));
 
 #ifndef PLASMA_EXTERNAL_RELASE
@@ -771,26 +767,6 @@ hsBool plSimulationMgr::MsgReceive(plMessage *msg)
 //
 /////////////////////////////////////////////////////////////////
 
-void plSimulationMgr::SetMaxDelta(float maxDelta)
-{
-    fMaxDelta = maxDelta;
-}
-
-float plSimulationMgr::GetMaxDelta() const
-{
-    return fMaxDelta;
-}
-
-void plSimulationMgr::SetStepsPerSecond(int stepsPerSecond)
-{
-    fStepSize = 1.0f / (float)stepsPerSecond;
-}
-
-int plSimulationMgr::GetStepsPerSecond()
-{
-    return (int)((1.0 / fStepSize) + 0.5f); // round to nearest int
-}
-
 int plSimulationMgr::GetMaterialIdx(NxScene* scene, float friction, float restitution)
 {
     if (friction == 0.5f && restitution == 0.5f)

Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.h

@@ -115,20 +115,6 @@ protected:
     plSimulationMgr();
     virtual ~plSimulationMgr();
 
-    // Set the maximum amount of time (in seconds) that the physics will advance
-    // between frames. If a frame-to-frame delta is bigger than this, we'll
-    // clamp it to this value.
-    // WARNING: animation doesn't do this, so if we clamp the time animated
-    // physicals and the avatar may move at a faster rate than usual.
-    void SetMaxDelta(float maxDelta);
-    float GetMaxDelta() const;
-    
-    // Set the number of steps per second that physics will advance.
-    // The more steps per second, the less fallthough and more accurate
-    // simulation response.
-    void SetStepsPerSecond(int stepsPerSecond);
-    int GetStepsPerSecond();
-
     // Walk through the synchronization requests and send them as appropriate.
     void IProcessSynchs();
 
@@ -151,9 +137,6 @@ protected:
     // but nothing will move.
     bool fSuspended;
 
-    float fMaxDelta;
-    float fStepSize;
-
     // A utility class to keep track of a request for a physical synchronization.
     // These requests must pass a certain criteria (see the code for the latest)
     // before they are actually either sent over the network or rejected.