Frame Rate Limiting with High-Res Timers

Frame rate limiting is an important technique in game development to ensure consistent performance and reduce unnecessary resource consumption. High-resolution timers, like SDL_GetPerformanceCounter(), can be used to implement precise frame rate limiting. Here's how you can do it:

Basic Concept

The idea is to calculate how long each frame should take (target frame time) and then wait if the frame finishes early. For example, if we want 60 FPS, each frame should take approximately 1/60 seconds or about 16.67 milliseconds.

Implementation

Here's a basic implementation using SDL's high-resolution timer:

1#include <SDL.h>
2#include <iostream>
3
4const int TARGET_FPS{60};
5const double TARGET_FRAME_TIME
6  {1.0 / TARGET_FPS};
7
8void simulateGameLogic() {
9  // Simulate some game logic
10  SDL_Delay(5); // Simulate 5ms of work
11}
12
13void render() {
14  // Simulate rendering
15  SDL_Delay(3); // Simulate 3ms of rendering
16}
17
18int main(int argc, char** argv) {
19  SDL_Init(SDL_INIT_TIMER);
20
21  Uint64 performanceFrequency{
22    SDL_GetPerformanceFrequency()};
23  Uint64 frameStart;
24  double elapsedSeconds;
25
26  for (int frame{0}; frame < 600; ++frame) {
27    frameStart = SDL_GetPerformanceCounter();
28
29    simulateGameLogic();
30    render();
31
32    elapsedSeconds = (
33        SDL_GetPerformanceCounter() -
34        frameStart) /
35      static_cast<double>(performanceFrequency);
36
37    if (elapsedSeconds < TARGET_FRAME_TIME) {
38      SDL_Delay(
39        static_cast<Uint32>((TARGET_FRAME_TIME -
40          elapsedSeconds) * 1000));
41    }
42
43    if (frame % 60 == 0) {
44      std::cout << "FPS: "
45        << 1.0 / ((SDL_GetPerformanceCounter() -
46            frameStart) /
47          static_cast<double>(
48            performanceFrequency))
49        << '\n';
50    }
51  }
52
53  SDL_Quit();
54  return 0;
55}

1FPS: 60.0213
2FPS: 59.9881
3FPS: 59.9902
4FPS: 60.0156
5FPS: 59.9923
6...

Explanation

1. We define our target FPS and calculate the target frame time.
2. At the start of each frame, we record the current time using SDL_GetPerformanceCounter().
3. We run our game logic and rendering.
4. We calculate how much time has elapsed during this frame.
5. If we've used less time than our target frame time, we delay the remainder.
6. We print the actual FPS every 60 frames to check our results.

Considerations

• This method uses SDL_Delay() for simplicity, but it's not always precise. For more accuracy, you could use a busy-wait loop, though this consumes more CPU:

1while (
2  (SDL_GetPerformanceCounter() - frameStart) /
3    static_cast<double>(performanceFrequency)
4  < TARGET_FRAME_TIME) {
5  // Busy wait
6}

• Frame rate limiting can lead to slightly uneven frame pacing. For smoother animation, you might want to use a fixed time step with interpolation.
• Some displays have variable refresh rates (e.g., 144Hz). You might want to sync with the display's actual refresh rate for optimal smoothness.
• For very high frame rates, the overhead of the timing code itself can become significant. In such cases, you might need more sophisticated approaches.

Remember, while frame rate limiting can save power and provide consistent performance, it's not always necessary. Many games run as fast as they can and use delta time for smooth animation. The best approach depends on your specific requirements.