Physical Motion

In this lesson, we'll explore fundamental physics principles and how to implement them in our games. We'll explore how to represent position, velocity, and acceleration using our vector system, and how these properties interact over time.

By the end, you'll understand how to create natural movement, predict object trajectories, and integrate player input with physics systems.

We’ll be working with the basic Scene, GameObject, and Vec2 types we created previously:

1// GameObject.h
2#pragma once
3#include <SDL.h>
4#include "Vec2.h"
5#include "Image.h"
6
7class Scene;
8
9class GameObject {
10 public:
11  GameObject(
12    const std::string& ImagePath,
13    const Vec2& InitialPosition,
14    const Scene& Scene ) : Image{ImagePath},
15                           Position{InitialPosition},
16                           Scene{Scene} {}
17
18  void HandleEvent(SDL_Event& E) {}
19  void Tick(float DeltaTime) {}
20  void Render(SDL_Surface* Surface);
21  Vec2 Position;
22
23 private:
24  Image Image;
25  const Scene& Scene;
26};

1#include <SDL.h>
2#include "GameObject.h"
3#include "Scene.h"
4
5void GameObject::Render(SDL_Surface* Surface) {
6  Image.Render(Surface, Scene.ToScreenSpace(Position));
7}

1#pragma once
2#include <SDL.h>
3#include <vector>
4#include "GameObject.h"
5
6class Scene {
7public:
8  Scene() {
9    Objects.emplace_back("dwarf.png", Vec2{100, 200}, *this);
10  }
11
12  Vec2 ToScreenSpace(const Vec2& Pos) const {
13    auto [vx, vy, vw, vh]{Viewport};
14    float HorizontalScaling{vw / WorldSpaceWidth};
15    float VerticalScaling{vh / WorldSpaceHeight};
16
17    return {
18      vx + Pos.x * HorizontalScaling,
19      vy + (WorldSpaceHeight - Pos.y) * VerticalScaling
20    };
21  }
22
23  void HandleEvent(SDL_Event& E) {
24    for (GameObject& Object : Objects) {
25      Object.HandleEvent(E);
26    }
27  }
28
29  void Tick(float DeltaTime) {
30    for (GameObject& Object : Objects) {
31      Object.Tick(DeltaTime);
32    }
33  }
34
35  void Render(SDL_Surface* Surface) {
36    SDL_GetClipRect(Surface, &Viewport);
37    for (GameObject& Object : Objects) {
38      Object.Render(Surface);
39    }
40  }
41
42private:
43  SDL_Rect Viewport;
44  std::vector<GameObject> Objects;
45  float WorldSpaceWidth{1400};
46  float WorldSpaceHeight{600};
47};

1#pragma once
2#include <iostream>
3
4struct Vec2 {
5  float x;
6  float y;
7
8  float GetLength() const {
9    return std::sqrt(x * x + y * y);
10  }
11
12  float GetDistance(const Vec2& Other) const {
13    return (*this - Other).GetLength();
14  }
15
16  Vec2 Normalize() const {
17    return *this / GetLength();
18  }
19
20  Vec2 operator*(float Multiplier) const {
21    return Vec2{x * Multiplier, y * Multiplier};
22  }
23
24  Vec2 operator/(float Divisor) const {
25    if (Divisor == 0.0f) { return Vec2{0, 0}; }
26
27    return Vec2{x / Divisor, y / Divisor};
28  }
29
30  Vec2& operator*=(float Multiplier) {
31    x *= Multiplier;
32    y *= Multiplier;
33    return *this;
34  }
35
36  Vec2& operator/=(float Divisor) {
37    if (Divisor == 0.0f) { return *this; }
38
39    x /= Divisor;
40    y /= Divisor;
41    return *this;
42  }
43
44  Vec2 operator+(const Vec2& Other) const {
45    return Vec2{x + Other.x, y + Other.y};
46  }
47
48  Vec2 operator-(const Vec2& Other) const {
49    return *this + (-Other);
50  }
51
52  Vec2& operator+=(const Vec2& Other) {
53    x += Other.x;
54    y += Other.y;
55    return *this;
56  }
57
58  Vec2& operator-=(const Vec2& Other) {
59    return *this += (-Other);
60  }
61
62  Vec2 operator-() const {
63    return Vec2{-x, -y};
64  }
65};
66
67inline Vec2 operator*(float M, const Vec2& V) {
68  return V * M;
69}
70
71inline std::ostream& operator<<(
72  std::ostream& Stream, const Vec2& V) {
73  Stream << "{ x = " << V.x
74    << ", y = " << V.y << " }";
75  return Stream;
76}

Our game loop is provided below within main.cpp, as well as our supporting Image and Window components. We won’t be changing any of these in this chapter:

1#include <SDL.h>
2#include "Window.h"
3#include "Scene.h"
4
5int main(int argc, char** argv) {
6  SDL_Init(SDL_INIT_VIDEO);
7  Window GameWindow;
8  Scene GameScene;
9
10  Uint64 LastTick{SDL_GetPerformanceCounter()};
11  SDL_Event Event;
12  while (true) {
13    while (SDL_PollEvent(&Event)) {
14      GameScene.HandleEvent(Event);
15      if (Event.type == SDL_QUIT) {
16        SDL_Quit();
17        return 0;
18      }
19    }
20
21    Uint64 CurrentTick{SDL_GetPerformanceCounter()};
22    float DeltaTime{static_cast<float>(
23      CurrentTick - LastTick) /
24      SDL_GetPerformanceFrequency()
25    };
26    LastTick = CurrentTick;
27
28    // Tick
29    GameScene.Tick(DeltaTime);
30
31    // Render
32    GameWindow.Render();
33    GameScene.Render(GameWindow.GetSurface());
34
35    // Swap
36    GameWindow.Update();
37  }
38
39  return 0;
40}

1#pragma once
2#include <SDL.h>
3#include <SDL_image.h>
4#include <string>
5
6class Image {
7 public:
8  Image() = default;
9  Image(const std::string& Path)
10  : ImageSurface{IMG_Load(Path.c_str())} {
11    if (!ImageSurface) {
12      std::cout << "Error creating image: "
13      << SDL_GetError();
14    }
15  }
16
17  void Render(
18    SDL_Surface* Surface, const Vec2& Pos
19  ) {
20    SDL_Rect Rect(Pos.x, Pos.y, 0, 0);
21    SDL_BlitSurface(
22      ImageSurface, nullptr, Surface, &Rect);
23  }
24
25  // Move constructor
26  Image(Image&& Other) noexcept
27  : ImageSurface(Other.ImageSurface) {
28    Other.ImageSurface = nullptr;
29  }
30  
31  ~Image() {
32    if (ImageSurface) {
33      SDL_FreeSurface(ImageSurface);
34    }
35  }
36
37  // Prevent copying
38  Image(const Image&) = delete;
39  Image& operator=(const Image&) = delete;
40
41 private:
42  SDL_Surface* ImageSurface{nullptr};
43};

1#pragma once
2#include <iostream>
3#include <SDL.h>
4
5class Window {
6public:
7  Window() {
8    SDLWindow = SDL_CreateWindow(
9      "Scene",
10      SDL_WINDOWPOS_UNDEFINED,
11      SDL_WINDOWPOS_UNDEFINED,
12      700, 300, 0
13    );
14  }
15
16  ~Window() {
17    if (SDLWindow) {
18      SDL_DestroyWindow(SDLWindow);
19    }
20  }
21
22  Window(const Window&) = delete;
23  Window& operator=(const Window&) = delete;
24
25  void Render() {
26    SDL_FillRect(
27      GetSurface(), nullptr,
28      SDL_MapRGB(GetSurface()->format,
29        220, 220, 220));
30  }
31
32  void Update() {
33    SDL_UpdateWindowSurface(SDLWindow);
34  }
35
36  SDL_Surface* GetSurface() {
37    return SDL_GetWindowSurface(SDLWindow);
38  }
39
40private:
41  SDL_Window* SDLWindow;
42};

We want our physics calculations to be done in world space. We’ll use the same world space definition we created in the previous section, where the origin is at the bottom left, increasing x values corresponds to rightward movement, whilst increasing y values corresponds to upward movement. Initially, all of our objects are in the range $(0, 0)$ to $(1400, 600)$:

To render our objects, our world space positions are converted to screen space within the Scene class. This is the same class we used in the previous section but, to keep things simple, we’ve removed the camera and are just doing a direct world space to screen space conversion:

1// Scene.h
2// ...
3
4class Scene {
5public:
6  Vec2 ToScreenSpace(const Vec2& Pos) const {
7    auto [vx, vy, vw, vh]{Viewport};
8    float HorizontalScaling{vw / WorldSpaceWidth};
9    float VerticalScaling{vh / WorldSpaceHeight};
10
11    return {
12      vx + Pos.x * HorizontalScaling,
13      vy + (WorldSpaceHeight - Pos.y) * VerticalScaling
14    };
15  }
16  // ...
17
18private:
19  SDL_Rect Viewport;
20  float WorldSpaceWidth{1400};
21  float WorldSpaceHeight{600};
22  // ...
23};

Position and Displacement

Previously, we’ve seen how we can represent the position of an object in a 2D space by using a 2D vector:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  Vec2 Position;
8  // ...
9};

The initial positions of our GameObject instances are set through the constructor:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  GameObject(
7    const std::string& ImagePath,
8    const Vec2& InitialPosition,
9    const Scene& Scene
10  ) : Image{ImagePath},
11      Position{InitialPosition},
12      Scene{Scene} {}
13  // ...
14};

Our Scene object is setting these initial positions when they construct our GameObjects:

1// Scene.h
2// ...
3
4class Scene {
5public:
6  Scene() {
7    Objects.emplace_back("dwarf.png", Vec2{300, 400}, *this);
8  }
9  // ...
10};

Specifically, this is the object’s position relative to the origin of our space. This is sometimes referred to as its displacement.

Units

When working with physics systems, it can be helpful to assign some real-world unit of measurement to this displacement.

For example, the Unity game engine uses meters, whilst Unreal Engine uses centimeters. We’re free to choose whichever we want, but it’s important to be consistent across all our objects. For these examples, we’ll use meters as our unit of distance.

This choice directly impacts how we would define our world space. In the previous section, our world space ranged from $(0, 0)$ to $(1400, 600)$.

If that represents meters, our world space is much larger than we need. Let’s shrink it down to a width of $14m$ and height of $6m$:

1// Scene.h
2// ...
3
4class Scene {
5// ...
6private:
7  float WorldSpaceWidth{14}; // meters
8  float WorldSpaceHeight{6}; // meters
9};

Naturally, any object positioned in this space should adopt the same units of measurement. We’ll update our dwarf’s initial position to be $(3, 4)$:

1// Scene.h
2// ...
3
4class Scene {
5public:
6  Scene() {
7    Objects.emplace_back("dwarf.png", Vec2{3, 4}, *this);
8  }
9  // ...
10};

A position vector of {3, 4} represents the object being displaced 3 meters horizontally from the origin, and 4 meters vertically. In total, the object is 5 meters from the origin, as $\sqrt{3^2 + 4^2} = 5$

Remember, in our simple 2D rendering setup, an object’s position represents the top left corner of its image. We could change that if we want, but we’ll keep it simple for now. To visualize our object’s motion, our screenshots include a red rectangle showing the object’s Position on each frame:

Advanced: User-Defined Literals

When our code contains literal values that represent units of measurement, it can be unclear what units are being used. Our previous example added comments to clarify that our values represent meters:

1float WorldSpaceWidth{14}; // meters
2float WorldSpaceHeight{6}; // meters

However, we may want to improve this, and it is a textbook example of where we’d consider applying user-defined literals. These let us state within our code exactly what our values represent:

1float WorldSpaceWidth{14_meters};
2float WorldSpaceHeight{6_meters};

Beyond documentation, user-defined literals can also unlock some additional capabilities. For example, if we wanted to provide a value in some other unit (such as kilometers or inches) and have it converted to our standard unit of measurement (meters) behind the scenes, they give us a succinct way to do that:

1float WorldSpaceWidth{0.14_kilometers};
2float WorldSpaceHeight{236_inches};

We cover this concept in much more detail in the advanced course, but the quick syntax to make our previous examples possible looks like the following. We’d add these functions to a header file, and then #include it wherever the literals are needed:

1// DistanceLiterals.h
2#pragma once
3
4float operator""_meters(long double D){
5  return D;
6}
7
8float operator""_inches(long double D){
9  return D / 39.37;
10}
11
12float operator""_kilometers(long double D){
13  return D * 1000;
14}

User Defined Literals

A practical guide to user-defined literals in C++, which allow us to write more descriptive and expressive values

Velocity

Velocity is the core idea that allows our objects to move. That is, a velocity represents a change in an object’s displacement over some unit of time. We’ve chosen meters, $m$, as our unit of position, and we’ll commonly use seconds, $s$, as our unit of time. As such, velocity will be measured in meters per second or $m/s$

As movement has a direction, our velocity will also have a direction, so we’ll use our Vec2 type:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  Vec2 Velocity{1, 0};
8  // ...
9};

For example, if an object’s velocity is {x = 1, y = 0}, our object is moving $1$ meter to the right every second.

We can implement this behavior in our Tick() function. Our velocity represents how much we want our displacement to change every second, but our Tick() function isn’t called every second. Therefore, we need to scale our change in velocity by how much time has passed since the previous tick.

We can do this by multiplying our change by our tick function’s DeltaTime argument:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6 // ...
7  void Tick(float DeltaTime) {
8    Position += Velocity * DeltaTime;
9  }
10  // ...
11};

Our application should be ticking multiple times per second, so our DeltaTime argument will be a floating point number between 0 and 1. Multiplying a vector by this value will have the effect of reducing its magnitude but, after one second of tick function invocations, we should see our displacement change by approximately the correct amount.

We can temporarily add a Time variable and some logging to confirm this:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  float Time{0};
8  void Tick(float DeltaTime) {
9    Position += Velocity * DeltaTime;
10    Time += DeltaTime;
11    std::cout << "\nt = " << Time
12      << ", Position = " << Position;
13  }
14  // ...
15};

1t = 0.0223181, Position = { x = 3.02232, y = 4 }
2t = 0.0360435, Position = { x = 3.03604, y = 4 }
3...
4t = 0.9969611, Position = { x = 3.99696, y = 4 }
5t = 0.9983365, Position = { x = 3.99833, y = 4 }
6t = 1.0000551, Position = { x = 4.00005, y = 4 }

1Vec2 Velocity{1, 2};
2auto[dx, dy]{Velocity};

Speed

The concepts of speed and velocity are closely related. The key difference is that velocity includes the concept of direction, whilst speed does not. Accordingly, velocity requires a more complex vector type, whilst speed is a simple scalar, like a float or an int.

To calculate the speed associated with a velocity, we simply calculate the length (or magnitude) of the velocity vector. So, in mathematical notation, $\text{Speed} = \lvert \text{Velocity} \rvert$.

Below, we calculate our speed based on the object’s Velocity variable. We also do some vector arithmetic to confirm our simulation really is moving our object at that speed:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  void Tick(float DeltaTime) {
8    Vec2 PreviousPosition{Position};
9    Position += Velocity * DeltaTime;
10    std::cout << "\nIntended Speed = "
11      << Velocity.GetLength()
12      << ", Actual Speed = "
13      << Position.GetDistance(PreviousPosition)
14           / DeltaTime;
15  }
16  //...
17};

1Intended Speed = 1, Actual Speed = 1.00005
2Intended Speed = 1, Actual Speed = 0.999974
3Intended Speed = 1, Actual Speed = 1.00009
4...

It’s often required to perform this calculation in the opposite direction, where we want to travel at a specific speed in a given direction. Rather than defining a Velocity member for our objects, we could recreate it on-demand by multiplying a direction vector by a movement speed scalar:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  // Now calculated within Tick()
8  Vec2 Velocity{1, 0}; 
9  
10  Vec2 Direction{1, 0};
11  float MaximumSpeed{1}; // meters per second
12
13  void Tick(float DeltaTime) {
14    Vec2 Velocity{
15      Direction.Normalize() * MaximumSpeed};
16    Position += Velocity * DeltaTime;
17
18    Time += DeltaTime;
19    std::cout << "\nt = " << Time
20      << ", Position = " << Position;
21  }
22 
23
24};

1t = 0.0180497, Position = { x = 3.01805, y = 4 }
2t = 0.0251397, Position = { x = 3.02514, y = 4 }
3...
4t = 0.997757, Position = { x = 3.99776, y = 4 }
5t = 0.999264, Position = { x = 3.99926, y = 4 }
6t = 1.00025, Position = { x = 4.00025, y = 4 }

We covered how to use vectors to define movement in more detail earlier in the course:

Moving Objects with Vectors

Explore how to use vectors for representing positions, directions, and implementing speed-limited movement in games.

Acceleration

Just as velocity is the change in displacement over time, acceleration is the change in velocity over time. Therefore, let’s figure out what the units of acceleration should be:

• Displacement is measured in meters: $m$
• Velocity, as the change in displacement over time, is measured in meters per second: $m/s$
• Acceleration, as the change in velocity over time, is measured in meters per second per second: $(m/s)/s$. This is equivalent to $m/(s \times s)$, usually written as $m/s^2$

Acceleration also has a direction, so is typically represented by a vector:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7
8  // Accelerate one meter per second per
9  // second to the left
10  Vec2 Acceleration{-1, 0};
11  // ...
12};

Much like how we used the velocity to update an object’s displacement on tick, we can use acceleration to update an object’s velocity:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  // meters per second
8  Vec2 Velocity{0, 0};
9
10  // meters per second per second
11  Vec2 Acceleration{0, 1};
12
13  void Tick(float DeltaTime) {
14    Velocity += Acceleration * DeltaTime;
15
16    // Unchanged
17    Position += Velocity * DeltaTime;
18
19  }
20  // ...
21};

Deceleration

Acceleration doesn’t necessarily cause an object’s speed to increase. If the direction of acceleration is generally in the opposite direction to the object’s current velocity, that acceleration will cause the speed to reduce.

This is sometimes called "deceleration", but the mechanics are identical. In the following code example, our object has an initial velocity of $(1, 0)$, and constant acceleration of $(-1, 0)$:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  // meters per second
8  Vec2 Velocity{1, 0};
9
10  // meters per second per second
11  Vec2 Acceleration{-1, 0};
12
13  void Tick(float DeltaTime) {
14    Velocity += Acceleration * DeltaTime;
15
16    // Unchanged
17    Position += Velocity * DeltaTime;
18
19    Time += DeltaTime;
20    std::cout << "\nt = " << Time
21      << ", x = " << Position.x
22      << ", dx = " << Velocity.x;
23  }
24  // ...
25};

The initial position of $(3, 0)$, initial velocity of $(1, 0)$, and constant acceleration of $(-1, 0)$ has the following effects:

• Because of the initial velocity, our object is initially moving right (in the positive $x$ direction). However, its acceleration is pointing to the left, thereby reducing that rightward velocity over time.
• After one second ($t = 1$) the acceleration has reduced the velocity to $(0, 0)$ and the object momentarily stops moving.
• From then on, the acceleration and velocity are both pointing left, so the object’s velocity starts to increase again, but now in the opposite direction to its initial velocity. By $t=2$, the object’s velocity has become $(-1, 0)$ and its position is back where it started ($x = 3$)
• If the acceleration doesn’t change, the object will continue to move left at ever-increasing speed.

1t = 0.0179667, x = 3.01764, dx = 0.982033
2t = 0.0358256, x = 3.03486, dx = 0.964174
3...
4t = 0.999145, x = 3.49913, dx = 0.000855972
5t = 1.00022, x = 3.49913, dx = -0.000214628
6...
7t = 1.99998, x = 2.99812, dx = -0.999977
8t = 2.0007, x = 2.99739, dx = -1.0007
9...
10t = 2.99909, x = 1.49116, dx = -1.99909
11t = 3.00025, x = 1.48884, dx = -2.00025

Gravity

The most common accelerative force we simulate is gravity - the force that causes objects to fall to the ground. On Earth, the acceleration caused by gravity is approximately $9.8m/s^2$ towards the ground. As such, an object falling with this acceleration will feel realistic:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  Vec2 Acceleration{0, -9.8};
8  // ...
9};

Later in the chapter, we’ll see how we can stop an object from falling once it hits the ground, or any other surface.

Trajectories

A trajectory is the path that an object takes through space, given its initial velocity and the accelerative forces acting on it. The most common trajectory we’re likely to recognize is projectile motion. For example, when we throw an object, we apply some initial velocity to it and, whilst it flies through the air, gravity is constantly accelerating it towards the ground.

This causes the object to follow a familiar, arcing trajectory:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  Vec2 Velocity{5, 5};
8  Vec2 Acceleration{0, -9.8};
9  // ...
10};

The Relationship Between Displacement, Velocity, and Acceleration

In the previous sections, we saw that acceleration updates velocity, and velocity updates displacement. It’s worth spending a moment reflecting on the implications of these relationships, as they’re not immediately intuitive.

For example, imagine we have an acceleration that is pointing upwards (in the positive $y$ direction) with a magnitude that is not changing over time. On a chart, our acceleration value would be represented as a straight line:

However, as long as the acceleration is not zero, it is continuously changing our velocity value over time. So, a constant acceleration results in a linear change in velocity:

But velocity is also changing our displacement over that time. If our velocity is constantly increasing, that means our displacement is not only changing over time, but the rate at which it is changing is also increasing. On our chart, the exponential increase looks like this:

In the next lesson, we’ll introduce concepts like drag and friction, which counteract these effects and ensure that the effect of acceleration doesn’t result in velocities and displacements that quickly scale towards unmanageably huge numbers.

Combining Player Input with Physics

When making games, our physics simulations typically need to interact in a compelling way with user input. For example, if our player tries to move their character to the right, we need to intervene in our physics simulation to make that happen.

There is no universally correct way of doing that - the best approach just depends on the type of game we’re making, and what feels most realistic or fun when we’re playing.

A common approach is to have player input directly influence an object’s velocity or acceleration, and then have the physics system incorporate that change into its simulation.

This is usually easy to set up as, within each frame, player input is processed before the physics simulation updates. In our context, that means that HandleEvent() happens before Tick(). Below, we let the player set the horizontal component of their character’s velocity before the physics simulation ticks:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    if (E.type == SDL_KEYDOWN) {
9      switch (E.key.keysym.sym) {
10        case SDLK_LEFT:
11          Velocity.x = -5;
12          break;
13        case SDLK_RIGHT:
14          Velocity.x = 5;
15          break;
16      }
17    }
18  }
19  // ...
20};

Later in this chapter, we’ll expand this to include collisions in our physics simulations, which will stop the player from running through walls or falling through the floor.

Equations of Motion and Motion Prediction

Naturally, a lot of academic effort has been made investigating and analyzing the physical world. We can apply those learnings to our own projects when we need to simulate natural processes, such as the motion of objects.

Some of the most useful examples are the SUVAT equations. In scenarios where our acceleration isn’t changing, the SUVAT equations establish relationships between 5 variables:

• $s$ is displacement
• $u$ is the initial velocity
• $v$ is the final velocity
• $a$ is acceleration
• $t$ is time

The equations are as follows:

It’s typically the case that the second equation (or rearrangements of the second equation) are most useful. For example, if we know an object’s current position, current velocity, and acceleration, we can predict where it will be in the future.

1#include <iostream>
2
3int main() {
4  float u{1};   // velocity
5  float a{1};   // acceleration
6  float t{10};  // time
7
8  // displacement
9  float s = u * t + 0.5 * a * t * t; 
10
11  std::cout << "In " << t << " seconds I "
12    "predict I will have moved "
13    << s << " meters";
14
15  float CurrentDisplacement{3};
16  std::cout << "\nMy new displacement would be "
17    << CurrentDisplacement + s << " meters";
18}

1In 10 seconds I predict I will have moved 60 meters
2My new displacement would be 63 meters

How accurate the prediction will be depends on how much the acceleration changes over the time interval. If the acceleration doesn’t change at all, our prediction will be exactly correct.

Using Vectors

Our previous equations and examples were using scalars for displacements, velocities, and acceleration. This is fine if we only care about motion in a straight line, but what about motion in a 2D or 3D space?

Thanks to the magic of vectors, we can drop them straight into the same equations:

1#include <iostream>
2#include "Vec2.h"
3
4int main() {
5  Vec2 u{1, 2};  // 2D velocity
6  Vec2 a{1, 2};  // 2D acceleration
7  float t{10};   // time
8
9  // 2D displacement
10  Vec2 s = u * t + 0.5 * a * t * t; 
11
12  std::cout << "In " << t << " seconds I "
13    "predict I will have moved "
14    << s << " meters";
15
16  std::cout << "\nThis is " << s.GetLength()
17    << " meters in total";
18
19  Vec2 CurrentDisplacement{3, 5};
20  std::cout << "\nMy new displacement would be "
21    << CurrentDisplacement + s << " meters";
22}

1In 10 seconds I predict I will have moved { x = 60, y = 120 } meters
2This is 134.164 meters in total
3My new displacement would be { x = 63, y = 125 } meters

The equivalent to all of the SUVAT equations using vectors is below.

There are two things to note from the vector form of these equations.

Firstly, the time variable ($t$) is a scalar, whilst all other variables are vectors. It’s common in mathematical notation to make vector variables bold

Secondly, $\lvert \bold{v} \rvert ^2 = \lvert \bold{u} \rvert ^2 + 2\bold{a} \cdot \bold{s}$ has been slightly modified from its scalar counterpart $v^2 = u^2 + 2as$. This is to remove some ambiguity associated with vector multiplication.

The equations are equivalent, but it may not be entirely clear what expressions like $\bold{v}^2$, $\bold{u}^2$, and $2\bold{as}$ mean when $\bold{v}$, $\bold{u}$, $\bold{a}$, and $\bold{s}$ are vectors.

Vector Multiplication and Dot Product

A vector product is the result of multiplying two vectors together. Scalar multiplication, as in $2 \times 3$, only has a single definition, but there are two different forms of vector multiplication:

• The dot product, which uses the $\cdot$ symbol, as in $\bold{A} \cdot \bold{B}$
• The cross product, which uses the $\times$ symbol, as in $\bold{A} \times \bold{B}$.

We won’t need vector multiplication in this course, and the cross product isn’t defined for 2D vectors anyway. However, we’ll briefly introduce the dot product here.

The dot product of two vectors is calculated by multiplying their corresponding components together, and then adding those results together.

For example, the dot product of the vectors $(1, 2)$ and $(3, 4)$ is $11$:

$$\begin{aligned} (1, 2) \cdot (3, 4) &= (1 \times 3) + (2 \times 4) \\ &= 3 + 8 \\ &= 11 \end{aligned}$$

Generalizing to any pair of 2D vectors, the equation looks like this:

$$\bold{A} \cdot \bold{B} = (\bold{A}_x \bold{B}_x) + (\bold{A}_y \bold{B}_y)$$

We could add a Dot() method to our Vec2 type like this:

1// Vec2.h
2// ...
3
4struct Vec2 {
5  // ...
6  float Dot(const Vec2& Other) const {
7    return (x * Other.x) + (y * Other.y);
8  }
9};
10
11// ...

We won’t need the dot product in this course, but it has useful properties that are widely used to solve problems in computer graphics and game simulations. For example, the dot product can tell us the extent to which a vector is "facing" another vector:

• If a direction vector is facing toward a position vector, their dot product will be positive
• If a direction vector is facing away from a position vector, their dot product will be negative
• If the vectors are exactly perpendicular, their dot product will be 0

We could use this as part of a calculation to determine whether a character is in some other character’s line of sight:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7
8  // Where am I?
9  Vec2 Position;
10
11  // Which direction am I facing?
12  Vec2 Direction{1, 0};
13
14  bool CanSee(const GameObject& Target) const {
15    // The vector from me to the target
16    Vec2 ToTarget{Target.Position - Position};
17
18    return
19      // Target is close to me...
20      ToTarget.GetLength() < 10
21      // ...and target is in front of me
22      && Direction.Dot(ToTarget) > 0;
23  }
24  
25  // ...
26};

Here are some more properties of the dot product:

• If we normalize our two vectors (that is, set their magnitude $1$), then their dot product will be in the range $-1$ to $1$. This gives us an easy way to determine the exact extent to which two vectors point in the same direction - from $-1$ (directly opposite) to $1$ (exact same direction)
• The dot product of a vector with itself, as in $\bold{v} \cdot \bold{v}$, is equal to the square of the magnitude of $\bold{v}$. Therefore, $\bold{v} \cdot \bold{v}$ and $\lvert \bold{v} \rvert ^2$ are equivalent.
• $\bold{v} \cdot \bold{v}$ and $\lvert \bold{v} \rvert ^2$ is sometimes written as $\bold{v}^2$, but this is slightly ambiguous as, in some contexts, $\bold{v}^2$ is also used to represent the cross product $\bold{v} \times \bold{v}$.

A more detailed introduction to the dot product of two vectors is available at mathisfun.com.

Summary

Physics is the backbone of realistic movement in games. In this lesson, we've explored how to implement fundamental motion physics in C++ using SDL, transforming static objects into dynamic entities that behave naturally. Key takeaways:

• Position and displacement are represented as 2D vectors that define an object's location in world space
• Velocity is the rate of change in position over time, measured in meters per second
• Acceleration changes velocity over time and is measured in meters per second squared
• The relationship between displacement, velocity, and acceleration creates realistic motion
• The SUVAT equations allow us to predict object movement given initial conditions
• Vector mathematics enables us to represent and calculate motion in multiple dimensions
• Physics can be combined with player input to create responsive game controls
• Consistent units (like meters and seconds) are crucial for accurate physics simulations

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

View Course