OU/CWE-ou-minkata
2
3
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-14 02:27:40 -04:00
Code Releases Activity

Hoikas' framerate unlock

Browse Source 
https://github.com/H-uru/Plasma/pull/143
This commit is contained in:
John Johns
2021-05-31 15:01:46 -07:00
parent c914ba5bac
commit e455a71c2e
3 changed files with 32 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.cpp
View File

@ -347,8 +347,6 @@ plSimulationMgr* plSimulationMgr::GetInstance()
plSimulationMgr::plSimulationMgr()
: fSuspended(true)
, fMaxDelta(kDefaultMaxDelta)
, fStepSize(kDefaultStepSize)
, fAccumulator(0.0f)
, fStepCount(0)
, fLOSDispatch(TRACKED_NEW plLOSDispatch())
@ -422,16 +420,20 @@ NxScene* plSimulationMgr::GetScene(plKey world)
if (!scene)
{
UInt32 maxSteps = (UInt32)hsCeil(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
scene->setTiming(kDefaultStepSize);
// Most physicals use the default friction and restitution values, so we
// make them the default.
NxMaterial* mat = scene->getMaterialFromIndex(0);
@ -605,25 +607,25 @@ void plSimulationMgr::Advance(float delSecs)
return;
fAccumulator += delSecs;
if (fAccumulator < fStepSize)
if (fAccumulator < kDefaultStepSize)
{
// Not enough time has passed to perform a substep.
plPXPhysicalControllerCore::UpdateNonPhysical(fAccumulator / fStepSize);
plPXPhysicalControllerCore::UpdateNonPhysical(fAccumulator / kDefaultStepSize);
return;
}
else if (fAccumulator > fMaxDelta)
else if (fAccumulator > kDefaultMaxDelta)
{
if (fExtraProfile)
Log("Step clamped from %f to limit of %f", fAccumulator, fMaxDelta);
fAccumulator = fMaxDelta;
Log("Step clamped from %f to limit of %f", fAccumulator, kDefaultMaxDelta);
fAccumulator = kDefaultMaxDelta;
}
++fStepCount;
// Perform as many whole substeps as possible saving the remainder in our accumulator.
int numSubSteps = (int)(fAccumulator / fStepSize + 0.000001f);
float delta = numSubSteps * fStepSize;
fAccumulator -= delta;
// Perform as many whole substeps as possible saving the remainder in our accumulator.
int numSubSteps = (int)(fAccumulator / kDefaultStepSize + 0.000001f);
float delta = numSubSteps * kDefaultStepSize;
fAccumulator -= delta;
plProfile_IncCount(StepLen, (int)(delta*1000));
plProfile_BeginTiming(Step);
@ -649,7 +651,7 @@ void plSimulationMgr::Advance(float delSecs)
}
}
plPXPhysicalControllerCore::Update(numSubSteps, fAccumulator / fStepSize);
plPXPhysicalControllerCore::Update(numSubSteps, fAccumulator / kDefaultStepSize);
//sending off and clearing the Collision Messages generated by scene->simulate
IDispatchCollisionMessages();
@ -773,26 +775,6 @@ void plSimulationMgr::ISendUpdates()
//
/////////////////////////////////////////////////////////////////
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, hsScalar friction, hsScalar restitution)
{
if (friction == 0.5f && restitution == 0.5f)

17
Sources/Plasma/PubUtilLib/plPhysX/plSimulationMgr.h
View File

@ -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();
@ -157,10 +143,7 @@ protected:
// but nothing will move.
bool fSuspended;
float fMaxDelta;
float fStepSize;
float fAccumulator;
UInt32 fStepCount;
// A utility class to keep track of a request for a physical synchronization.