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.

Starting Point

This lesson builds on the concepts from the previous lesson, where we set up a basic World and GameObject hierarchy.

Our starting point includes the Window, GameObject, World, and Goblin classes, with a single Goblin spawned in our main() function.

Compared to the last lesson, we've also updated our x and y position values from integers to floating point numbers, which is more common when implementing time deltas:

Files

src

Select a file to view its content

Using `SDL_GetTicks()`

The SDL_GetTicks() 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:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4
5int main(int, char**) {
6  SDL_Init(SDL_INIT_VIDEO);
7
8  SDL_Event Event;
9  bool IsRunning{true};
10
11  while (IsRunning) {
12    while (SDL_PollEvent(&Event)) {
13      if (Event.type == SDL_EVENT_QUIT) {
14        IsRunning = false;
15      }
16    }
17
18    std::cout << "Milliseconds Passed: "
19      << SDL_GetTicks() << '\n';
20  }
21
22  SDL_Quit();
23  return 0;
24}

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 iteration of our application loop, we need to compare the value returned by SDL_GetTicks() on this iteration to the value it returned in the previous iteration:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4
5int main(int, char**) {
6  SDL_Init(SDL_INIT_VIDEO);
7
8  SDL_Event Event;
9  bool IsRunning{true};
10  Uint64 PreviousFrame{0};
11
12  while (IsRunning) {
13    while (SDL_PollEvent(&Event)) {
14      if (Event.type == SDL_EVENT_QUIT) {
15        IsRunning = false;
16      }
17    }
18
19    Uint64 ThisFrame{SDL_GetTicks()};
20    std::cout << "Time Delta: "
21      << ThisFrame - PreviousFrame << '\n';
22    PreviousFrame = ThisFrame;
23  }
24
25  SDL_Quit();
26  return 0;
27}

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 - in this case, two calls to SDL_GetTicks().

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 chapter. Real-world interactive applications typically aim to have their loops iterate dozens or hundreds of times per second, meaning time deltas will be in the region of 5-50 milliseconds.

Using Time Deltas in Tick Functions

Now that we have calculated the time delta in our application loop, we 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 to include this argument:

src/GameObject.h

1#pragma once
2#include <SDL3/SDL.h>
3
4class GameObject {
5 public:
6  virtual void HandleEvent(const SDL_Event& E) {}
7  virtual void Tick(float TimeDelta) {}
8  virtual void Render(SDL_Surface* Surface) {}
9  virtual ~GameObject() = default;
10};

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

src/World.h

1#pragma once
2#include <vector>
3#include <memory>
4#include <string>
5#include "GameObject.h"
6#include "Goblin.h"
7
8class World {
9 public:
10  void HandleEvent(const SDL_Event& E) {
11    for (auto& Object : Objects) {
12      Object->HandleEvent(E);
13    }
14  }
15
16  void Tick(float TimeDelta) {
17    for (auto& Object : Objects) {
18      Object->Tick(TimeDelta);
19    }
20  }
21
22  void Render(SDL_Surface* Surface) {
23    for (auto& Object : Objects) {
24      Object->Render(Surface);
25    }
26  }
27
28  Goblin& SpawnGoblin(
29    const std::string& Name, int x, int y
30  ) {
31    Objects.emplace_back(
32      std::make_unique<Goblin>(Name, x, y)
33    );
34    return static_cast<Goblin&>(*Objects.back());
35  }
36
37 private:
38  std::vector<std::unique_ptr<GameObject>> Objects;
39};

Finally, let's pass it through as an argument from our application loop, but it can be helpful to convert the time deltas to a more intuitive unit first.

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 1000.0 before passing it as an argument:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include "Window.h"
4#include "World.h"
5
6int main(int, char**) {
7  SDL_Init(SDL_INIT_VIDEO);
8  Window GameWindow;
9  World GameWorld;
10  GameWorld.SpawnGoblin("Goblin Rogue", 100, 200);
11
12  bool IsRunning = true;
13  SDL_Event Event;
14  Uint64 PreviousFrame{0};
15
16  while (IsRunning) {
17    while (SDL_PollEvent(&Event)) {
18      if (Event.type == SDL_EVENT_QUIT) {
19        IsRunning = false;
20      }
21      GameWorld.HandleEvent(Event);
22    }
23
24    Uint64 ThisFrame{SDL_GetTicks()};
25    Uint64 TimeDelta{ThisFrame - PreviousFrame};
26    PreviousFrame = ThisFrame;
27    GameWorld.Tick(TimeDelta / 1000.0f);
28
29    GameWindow.Render();
30    GameWorld.Render(GameWindow.GetSurface());
31    GameWindow.Update();
32  }
33
34  SDL_Quit();
35  return 0;
36}

Finally, let's update our Goblin to move with a Velocity of 100 units per second:

src/Goblin.h

1#pragma once
2#include <string>
3#include <iostream>
4#include "GameObject.h"
5
6class Goblin : public GameObject {
7 public:
8  Goblin(const std::string& name, int x, int y)
9    : Name(name), xPosition(x), yPosition(y) {}
10
11  void Tick(float TimeDelta) override {
12    xPosition += Velocity * TimeDelta;
13    std::cout << "Goblin position: "
14      << xPosition << '\n';
15  }
16
17  std::string Name;
18  float xPosition;
19  float yPosition;
20  float Velocity{100.0f};
21};

1Goblin position: 100
2Goblin position: 100.1
3Goblin position: 100.1
4Goblin position: 100.2
5...

Remember, if our application completes two iterations of its main loop within the same millisecond, our time delta can be 0 milliseconds, or 0.0 seconds after our conversion. Any logic we build should consider that possibility. For example, if we try to divide something by the time delta, and it has a value of 0, we will run into problems.

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:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4
5int main(int, char**) {
6  SDL_Init(SDL_INIT_VIDEO);
7
8  while (true) {
9   std::cout << "Ticking ("
10      << SDL_GetTicks() << ")\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.

SDL_Delay() expects a Uint32, whilst SDL_GetTicks() returns a Uint64. We can safely cast our Uint64 to a Uint32 in this scenario, as our delays will be relatively small numbers in this context - no larger than 1000 milliseconds:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include <iostream>
4
5void DoWork() {
6  // ...
7}
8
9int main(int, char**) {
10  SDL_Init(SDL_INIT_VIDEO);
11
12  while (true) {
13    Uint64 StartTimer{SDL_GetTicks()};
14    std::cout << "Ticking ("
15      << SDL_GetTicks() << ")\n";
16
17    DoWork();
18
19    Uint64 EndTimer{SDL_GetTicks()};
20    Uint64 TimeElapsed{EndTimer - StartTimer};
21    if (TimeElapsed <= 1000) {
22      SDL_Delay(1000 - Uint32(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:

src/main.cpp

1#include <SDL3/SDL.h>
2#include <SDL3/SDL_main.h>
3#include "Window.h"
4#include "World.h"
5
6int main(int, char**) {
7  SDL_Init(SDL_INIT_VIDEO);
8  Window GameWindow;
9  World GameWorld;
10  GameWorld.SpawnGoblin("Goblin Rogue", 100, 200);
11
12  bool IsRunning = true;
13  SDL_Event Event;
14  Uint64 PreviousFrame{0};
15
16  while (IsRunning) {
17    Uint64 StartTimer{SDL_GetTicks()};
18
19    while (SDL_PollEvent(&Event)) {
20      if (Event.type == SDL_EVENT_QUIT) {
21        IsRunning = false;
22      }
23      GameWorld.HandleEvent(Event);
24    }
25
26    // Update Objects
27    Uint64 ThisFrame{SDL_GetTicks()};
28    Uint64 TimeDelta{ThisFrame - PreviousFrame};
29    PreviousFrame = ThisFrame;
30    GameWorld.Tick(TimeDelta / 1000.0f);
31
32    // Render
33    GameWindow.Render();
34    GameWorld.Render(GameWindow.GetSurface());
35    GameWindow.Update();
36
37    // Capping Frame Rate
38    Uint64 EndTimer{SDL_GetTicks()};
39    Uint64 TimeElapsed{EndTimer - StartTimer};
40    if (TimeElapsed < 10) {
41      SDL_Delay(10 - Uint32(TimeElapsed));
42    }
43  }
44
45  SDL_Quit();
46  return 0;
47}

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.

For example, if we expect a function to be called every 1.000 second, but it's usually being called every 1.001 seconds, these millisecond delays accumulate to significant inaccuracies over longer periods of time. This is sometimes referred to as time drift or clock drift.

Our on std::chrono provides techniques to compensate for this.

Complete Code

A complete version of the architecture we set up in this lesson is available below:

Files

src

Select a file to view its content

Summary

This lesson covered the core time-tracking techniques we need for games and other real-time programs. Here are the key points:

Using SDL_GetTicks() to measure elapsed time.
Calculating time deltas between frames to achieve frame-rate independent animation.
Implementing time-based movement for game objects.
Capping tick rates for consistent performance across different hardware.

By applying these concepts, you can create games that run smoothly and predictably, regardless of the user's hardware.

Tick Rate and Time Deltas

Starting Point

Files

Using `SDL_GetTicks()`

src/main.cpp

Time Deltas

src/main.cpp

Using Time Deltas in Tick Functions

src/GameObject.h

src/World.h

Converting Time Deltas to Seconds

src/main.cpp

src/Goblin.h

Capping Tick Rate

src/main.cpp

src/main.cpp

src/main.cpp

Time Drift

Complete Code

Files

Summary

High-Resolution Timers

Game Development with SDL3

Tick Rate and Time Deltas

Starting Point

Files

Using SDL_GetTicks()

src/main.cpp

Time Deltas

src/main.cpp

Using Time Deltas in Tick Functions

src/GameObject.h

src/World.h

Converting Time Deltas to Seconds

src/main.cpp

src/Goblin.h

Capping Tick Rate

src/main.cpp

src/main.cpp

src/main.cpp

Time Drift

Complete Code

Files

Summary

High-Resolution Timers

Using `SDL_GetTicks()`