In the previous lesson, we introduced the concept of ticking and tick functions, which allow our game objects to update on every iteration of our application loop.

However, we should note that when we're implementing logic in a Tick() function, we don't know how quickly our objects will tick. That is, we do not know how much time has passed since the previous invocation of that object's Tick() function.

1// Goblin.h
2#pragma once
3#include "GameObject.h"
4
5class Goblin : public GameObject {
6 public:
7  int xPosition;
8
9  void Tick() override {
10    // This object moves by one pixel per
11    // invocation of Tick(), but how frequently
12    // is Tick() invoked?
13    xPosition += 1;
14  }
15};

As we add more complexity to our tick functions or more ticking objects, our game will need to perform more work on each iteration of our application loop. As such, it will iterate less frequently, meaning Tick() is invoked less frequently, meaning our object will move slower.

On the other hand, if we perform optimizations or our user has a more powerful computer, our loop can iterate faster, causing our objects to move faster.

To address this inconsistency, we typically want to define properties like movement speed in terms of real-world units of time, such as seconds or milliseconds. Let's learn how to do this.

Using `SDL_GetTicks64()`

The SDL_GetTicks64() function returns a 64-bit unsigned integer, representing the number of milliseconds that have passed since SDL was initialized. Let's call it on every iteration of our application loop:

1// main.cpp
2#include <SDL.h>
3#include <iostream>
4
5int main(int argc, char** argv) {
6  SDL_Init(SDL_INIT_VIDEO);
7  
8  SDL_Event Event;
9  bool shouldContinue{true};
10  
11  while (shouldContinue) {
12    while (SDL_PollEvent(&Event)) {/*...*/}
18
19    std::cout << "\nMilliseconds Passed: "
20      << SDL_GetTicks64();
21  }
22
23  SDL_Quit();
24  return 0;
25}

The value returned from this function will increase over time, although subsequent calls may return the same value if invoked in quick succession:

1Milliseconds Passed: 0
2Milliseconds Passed: 1
3Milliseconds Passed: 1
4Milliseconds Passed: 2
5...

Time Deltas

To understand how many milliseconds have passed between each invocation of our application loop, we need to compare the value returned by SDL_GetTicks64() on this iteration to the value it returned in the previous iteration:

1// main.cpp
2#include <SDL.h>
3#include <iostream>
4
5int main(int argc, char** argv) {
6  SDL_Init(SDL_INIT_VIDEO);
7  
8  SDL_Event Event;
9  bool shouldContinue{true};
10  Uint64 PreviousFrame{0};
11  
12  while (shouldContinue) {
13    while (SDL_PollEvent(&Event)) {/*...*/}
19
20    Uint64 ThisFrame{SDL_GetTicks64()};
21    std::cout << "\nTime Delta: "
22      << ThisFrame - PreviousFrame;
23    PreviousFrame = ThisFrame;
24  }
25
26  SDL_Quit();
27  return 0;
28}

This value is often called a time delta. The greek letter delta - $\delta$ or $\Delta$ - is often used in maths and physics to represent change. As such, a time delta is how much time has passed between two points - two calls to SDL_GetTicks64(), in this case.

Given this program is very simple, our application loop can complete many iterations per millisecond. So, even though some time has passed, the time delta when expressed in milliseconds will often be 0:

1Time Delta: 0
2Time Delta: 1
3Time Delta: 0
4Time Delta: 0

We cover high-resolution clocks with sub-millisecond accuracy later in this section. Real-world interactive applications typically aim to have their loops iterate around 20-100 times per second, meaning time deltas will be in the region of 10-50 milliseconds.

Using Time Deltas in Tick Functions

Now that we have calculated the time delta in our application loop, we now need to give our objects access to that value so they can use it in their Tick() logic.

The easiest and most common approach is to simply provide it as a parameter. Let's update our GameObject base class:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  virtual void Tick(Uint64 TimeDelta) {
7    // ...
8  }
9};

We'll also need to update the class that manages all of our GameObject instances:

1// World.h
2// ...
3
4class World {
5 public:
6  void Tick(Uint64 TimeDelta) {
7    for (auto& Object : Objects) {
8      Object->Tick(TimeDelta);
9    }
10  }
11  
12  // ...
13  
14 private:
15  std::vector<std::unique_ptr<GameObject>> Objects;
16};

Finally, let's pass it through as an argument from our application loop:

1// main.cpp
2#include <SDL.h>
3#include "World.h"
4
5int main(int argc, char** argv) {
6  SDL_Init(SDL_INIT_VIDEO);
7  World GameWorld;
8
9  SDL_Event Event;
10  bool shouldContinue{true};
11  Uint64 PreviousFrame{0};
12
13  while (shouldContinue) {
14    while (SDL_PollEvent(&Event)) {/*...*/}
20
21    Uint64 ThisFrame{SDL_GetTicks64()};
22    Uint64 TimeDelta{ThisFrame - PreviousFrame};
23    PreviousFrame = ThisFrame;
24    GameWorld.Tick(TimeDelta);
25  }
26
27  SDL_Quit();
28  return 0;
29}

Remember, any logic we build based on the time delta should consider the possibility that the value will be 0. For example, if we try to divide something by the time delta, and it has a value of 0, we will run into problems.

Converting Time Deltas to Seconds

For most objects, receiving the time delta in terms of seconds will be more intuitive than working with milliseconds. We can do this by updating our parameter type to be a floating point number, and dividing the millisecond value by 1,000.0 before passing it as an argument:

1// main.cpp
2#include <SDL.h>
3#include "Engine/Window.h"
4#include "World.h"
5#include "Goblin.h"
6
7int main(int argc, char** argv) {
8  SDL_Init(SDL_INIT_VIDEO);
9  World GameWorld;
10  GameWorld.SpawnGoblin();
11
12  SDL_Event Event;
13  bool shouldContinue{true};
14  Uint64 PreviousFrame{0};
15
16  while (shouldContinue) {
17    while (SDL_PollEvent(&Event)) {/*...*/}
23
24    Uint64 ThisFrame{SDL_GetTicks64()};
25    Uint64 TimeDelta{ThisFrame - PreviousFrame};
26    PreviousFrame = ThisFrame;
27    GameWorld.Tick(TimeDelta / 1000.0);
28  }
29
30  SDL_Quit();
31  return 0;
32}

We'd also update our Tick() functions to accept this parameter type, and update the logic to reflect that the time delta is now specified in seconds.

Let's update our Goblin to move with a Velocity of 1 unit per second:

1// Goblin.h
2// ...
3
4class Goblin : public GameObject {
5public:
6  float xPosition;
7  float Velocity{1};
8
9  void Tick(float TimeDelta) override {
10    xPosition += Velocity * TimeDelta;
11
12    std::cout
13      << "\nx = " << xPosition;
14  }
15};

1x = 0.097
2x = 0.1
3x = 0.1
4x = 0.1
5x = 0.101
6...

Capping Tick Rate

In some scenarios, we may find it valuable to limit how fast our application loop (or any other loop) can iterate.

The SDL_Delay() function accepts an integer argument and will wait for at least that many milliseconds before returning:

1// main.cpp
2#include <SDL.h>
3#include <iostream>
4
5int main(int argc, char** argv) {
6  SDL_Init(SDL_INIT_VIDEO);
7
8  while (true) {
9   std::cout << "Ticking ("
10      << SDL_GetTicks64() << ")\n";
11      
12    SDL_Delay(1000);
13  }
14
15  SDL_Quit();
16  return 0;
17}

1Ticking (6)
2Ticking (1007)
3Ticking (2008)
4Ticking (3008)

We can use this to limit the run rate of a loop using the following recipe. If the DoWork() part of our loop body completes in under 1,000ms, we use SDL_Delay() to extend the duration of our iteration:

1// main.cpp
2#include <SDL.h>
3#include <iostream>
4
5void DoWork() {
6  // ...
7}
8
9int main(int argc, char** argv) {
10  SDL_Init(SDL_INIT_VIDEO);
11
12  while (true) {
13    Uint64 StartTimer{SDL_GetTicks64()};
14    std::cout << "Ticking ("
15      << SDL_GetTicks64() << ")\n";
16
17    DoWork();
18
19    Uint64 EndTimer{SDL_GetTicks64()};
20    Uint64 TimeElapsed{EndTimer - StartTimer};
21    if (TimeElapsed <= 1000) {
22      SDL_Delay(1000 - TimeElapsed);
23    }
24  }
25
26  SDL_Quit();
27  return 0;
28}

1Ticking (9)
2Ticking (1010)
3Ticking (2010)
4Ticking (3011)

Let's use it to ensure each iteration of our application loop takes at least 10 milliseconds to complete, thereby ensuring our tick rate doesn't exceed 100 ticks per second:

1// main.cpp
2#include <SDL.h>
3
4#include "Window.h"
5#include "World.h"
6
7int main(int argc, char** argv) {
8  SDL_Init(SDL_INIT_VIDEO);
9  Window GameWindow;
10  World GameWorld;
11
12  SDL_Event Event;
13  bool shouldContinue{true};
14  Uint64 PreviousFrame{0};
15
16  while (shouldContinue) {
17    Uint64 StartTimer{SDL_GetTicks64()};
18    while (SDL_PollEvent(&Event)) {/*...*/}
24
25    // Update Objects
26    Uint64 ThisFrame{SDL_GetTicks64()};
27    Uint64 TimeDelta{ThisFrame - PreviousFrame};
28    PreviousFrame = ThisFrame;
29    GameWorld.Tick(TimeDelta / 1000.0);
30
31    // Render
32    GameWorld.Render(GameWindow.GetSurface());
33
34    // Capping Frame Rate
35    Uint64 EndTimer{SDL_GetTicks64()};
36    Uint64 TimeElapsed{EndTimer - StartTimer};
37    if (TimeElapsed <= 10) {
38      SDL_Delay(10 - TimeElapsed);
39    }
40  }
41
42  SDL_Quit();
43  return 0;
44}

Time Drift

SDL_Delay() causes our application to pause for at least the number of milliseconds we pass as an argument. Because of nuances in how work is scheduled, the delay will always be slightly longer.

We can see this in previous examples, where a SDL_Delay(1000) invocation often causes a delay of 1,001 milliseconds:

1Ticking (6)
2Ticking (1007)
3Ticking (2008)
4Ticking (3008)

These inaccuracies are not a problem for most use cases, but it does mean we should avoid using SDL_Delay() or similar techniques to keep track of time.

A millisecond delay happening every second accumulates to significant inaccuracies over time, sometimes referred to as time drift or clock drift.

Our lesson on std::chrono provides more accurate techniques for working with dates and times:

Dates, Times and Durations

Learn the basics of the chrono library and discover how to effectively manage durations, clocks, and time points

View Related Lesson

Summary

This lesson covered essential time management techniques for game development with SDL and C++. Key points included:

Using SDL_GetTicks64() to measure elapsed time
Calculating time deltas between frames
Implementing time-based movement for game objects
Capping tick rates for consistent performance

By applying these concepts, you can create games that run smoothly on various hardware configurations.

Tick Rate and Time Deltas

Using `SDL_GetTicks64()`

Time Deltas

Using Time Deltas in Tick Functions

Converting Time Deltas to Seconds

Capping Tick Rate

Summary

High-Resolution Timers

Game Development with SDL2

Questions & Answers

Tick Rate and Time Deltas

Using SDL_GetTicks64()

Time Deltas

Using Time Deltas in Tick Functions

Converting Time Deltas to Seconds

Capping Tick Rate

Summary

High-Resolution Timers

Questions & Answers

Using `SDL_GetTicks64()`