What is the correct way to update a physics frame rate?

Question

I've searched around the Internet, and eventually read a suggested article, "Fix your Timestep!". In accordance with the article, I came up with an update method, but I still have problems. Whenever I instantiate more objects, in my scene, I get much slower physical interaction. I've fixed other sub-systems, that they were wasting cycles during the update process, and I've tracked my physics performance drop to this point. I think the way I'm updating my physics is somehow wrong, because I'm using a fixed timing of 1.0 / 60.0 for my Box2D engine.

What are the mistakes I'm making in my update process? What is the correct way to update a physics frame rate? Here is my code:

void Core::Update()
{
    // Input
    this->cInput->Update();

    // Physics
    this->cPhysics->Update();

    // Keep frame rate
    static const double desiredTime = 1.0 / 60.0;
    static double currentTime = (double)(GetTickCount());
    static double accumulator = 0.0;

    double newTime = (double)(GetTickCount());
    double frameTime = newTime - currentTime;

    if(frameTime > 0.25){ frameTime = 0.25; }
    currentTime = newTime;

    accumulator += frameTime;

    while(accumulator >= desiredTime)
    {
        // Input
        this->cInput->Update();

        // Physics
        this->cPhysics->Update(desiredTime);

        // Scripts
        this->cScripts->Update();

        accumulator -= desiredTime;
    }

I've read that you shouldn't tie your physics frame rate to the render frame rate, so I use this->cPhysics->Update();. I've used my previous approach, but with a slight change; I'm not sure if what I'm doing is right, but it solved my performance issue. First, I changed currentTime to get time in milliseconds, instead of seconds. At the end, I've moved all of my update code to a time step loop, except for the renderers update. I still do not know if this is the correct way to go.

Answer 1

The problem lies here

    static double currentTime = (double)time(NULL);
    static double accumulator = 0.0;

    double newTime = (double)time(NULL);

your currentTime and newTime are roughtly the same that way, this can't work.

you need to measure the time you needed for one frame (the last frame) and sleep the remaining time till you hit your 1.0s/60s mark. Don't forget that the sleeping doesn't sleep exactly the amount of time you passed in so you need to compesate for that.

An optional way to get the used time for the frames is to use a sliding window approach for all frame times and sum the times and divide by the count.

Another important oint is to limit your delta-time you actually measured (say to 0.2 seconds) for avoiding instabilities.

Edit 1 Example code to illustrate it

private double Time = 0.0;

private double deltaTArray[10];
private unsigned int deltaTArrayI;

// NOTE< this->currentTime must be set once before this is called >


void Core::Update()
{
    // Input
    this->cInput->Update();

    double newTime = (double)time(NULL);

    double deltaT = newTime - this->currentTime;

    this->currentTime = newTime;

    deltaT = min(deltaT, 0.25); // because of stability

    this->deltaTArray[this->deltaTArrayI] = deltaT;

    (this->deltaTArrayI)++;
    this->deltaTArrayI = this->deltaTArrayI % 10;

    // calculate delta T as average of the sliding window
    double deltaTAverage = 0.0;

    for( unsigned int i = 0; i < 10; ++i )
    {
        deltaTAverage += this->deltaTArray[i];
    }

    deltaTAverage = deltaTAverage / (double)10;

    // Physics
    this->cPhysics->Update(deltaTAverage);

    // Keep frame rate
    sleep(max((1.0/60.0)-deltaTAverage, 0));

    // Render
    this->cRender->Update();
}