Limit while loop to run at 30 "FPS" using a delta variable C++

Question

I basically need a while loop to only run at 30 "FPS". I was told to do this: "Inside your while loop, make a deltaT , and if that deltaT is lesser than 33 miliseconds use sleep(33-deltaT) ."

But I really wasn't quite sure how to initialize the delta/what to set this variable to. I also couldn't get a reply back from the person that suggested this.

I'm also not sure why the value in sleep is 33 instead of 30.

Does anyone know what I can do about this?

This is mainly for a game server to update players at 30FPS, but because I'm not doing any rendering on the server, I need a way to just have the code sleep to limit how many times it can run per second or else it will process the players too fast.

score 5 · Accepted Answer · answered Jan 18 '15 at 10:09

5

You basically need to do something like this:

int now = GetTimeInMilliseconds();
int lastFrame = GetTimeInMilliseconds();

while(running)
{
    now = GetTimeInMilliseconds();
    int delta = now - lastFrame;
    lastFrame = now;

    if(delta < 33)
    {
        Sleep(33 - delta);
    }

    //...
    Update();
    Draw();
}

That way you calculate the amount of milliseconds passed between the current frame and last frame, and if it's smaller than 33 millisecods (1000/30, 1000 milliseconds in a second divided by 30 FPS = 33.333333....) then you sleep until 33 milliseconds has passed. Has for GetTimeInMilliseconds() and Sleep() function, it depends on the library that you're using and/or the platform.

answered Jan 18 '15 at 10:09

UnTraDe

3,747
10
36
60

It doesn't depend on the platform, `` is portable. – MSalters Jan 18 '15 at 10:41
By the way, `int now = GetTimeInMilliseconds();` should be replaced with `int now;`. – HolyBlackCat Jan 18 '15 at 10:51
This is wrong as it will slip over time by the amount of time it takes to execute `Update()` and `Draw()`. The next `lastFrame` has to be `lastFrame + 33;` and not `now`. You may need to skip a frame once in a while too. – Alexis Wilke Mar 08 '18 at 02:30

MikeMB · Answer 2 · 2015-01-18T10:54:26.723

c++11 provides a simple mechanism for that:

#include <chrono>
#include <thread>
#include <iostream>

using namespace std;
using namespace std::chrono;

void doStuff(){
    std::cout << "Loop executed" << std::endl;
}

int main() {

    time_point<system_clock> t = system_clock::now();

    while (1) {
        doStuff();
        t += milliseconds(33);
        this_thread::sleep_until(t);
    }
}

The only thing you have to be aware of though is that if one loop iteration takes longer than the 33ms, the next two iterations will be executed without a pause in between (until t has caught up with the real time), which may or may not be what you want.

You could easily adjust `t` by asking for `now()` again and if `t` is too small, skip frames instantly. — Alexis Wilke, Mar 08 '18 at 02:36

Sebastian Mach · Answer 3 · 2018-03-08T08:23:53.353

Glenn Fiedler has written a nice article on this topic a few years ago. Hacking with sleep() is not very precise, instead you want to run your physics a fixed number of times per second, let your graphics run freely, and between frames, you do as many fixed timesteps as time has passed.

The code that follows looks intimidating at first, but once you get the idea, it becomes simple; it's best to read the article completely.

Fix Your Timestep

double t = 0.0;
double dt = 0.01;

double currentTime = hires_time_in_seconds();
double accumulator = 0.0;

State previous;
State current;

while ( !quit )
{
    double newTime = hires_time_in_seconds();
    double frameTime = newTime - currentTime;
    if ( frameTime > 0.25 )
        frameTime = 0.25;
    currentTime = newTime;

    accumulator += frameTime;

    while ( accumulator >= dt )
    {
        previousState = currentState;
        integrate( currentState, t, dt );
        t += dt;
        accumulator -= dt;
    }

    const double alpha = accumulator / dt;

    State state = currentState * alpha + 
        previousState * ( 1.0 - alpha );

    render( state );
}

_{If it goes offline, there should be several backups available; however, I remember Gaffer on Games for many years already.}

Personally I like to pass the delta to the `Update()` function where all the game logic happens, and then take the delta into account where needed. — UnTraDe, Jan 18 '15 at 10:17
Shouldn't this line `double newTime = time();` use the `hires_time_in_seconds();` function instead of `time()`? — Alexis Wilke, Mar 08 '18 at 02:34

Limit while loop to run at 30 "FPS" using a delta variable C++

3 Answers3

Fix Your Timestep

Linked