Momentum and Impulse Forces

In this lesson, we'll explore how to implement physics interactions by adding momentum and impulses to our simulations.

We'll learn we can use physics to create features requiring sudden changes to motion, such as having our characters jump or get knocked back by explosions. We’ll also learn how to modify the strength of those forces based on how far away the source of the force is.

This lesson continues to use the components and application loop we introduced earlier in the section. We’ll mostly be working in the GameObject class.

The most relevant parts of this class to note for this lesson are its Tick() and ApplyForce() functions, as well as the Position, Velocity, Acceleration, and Mass variables. Those functions and variables currently look like this:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  void Tick(float DeltaTime) {
7    ApplyForce(FrictionForce(DeltaTime));
8    ApplyForce(DragForce());
9    Velocity += Acceleration * DeltaTime;
10    Position += Velocity * DeltaTime;
11
12    Acceleration = {0, -9.8};
13    Clamp(Velocity);
14
15    // Don't fall through the floor
16    if (Position.y < 2) Position.y = 2;
17  }
18
19  void ApplyForce(const Vec2& Force) {
20    Acceleration += Force / Mass;
21  }
22  
23  // ...
24
25 private:
26  Vec2 Position{0, 0};
27  Vec2 Velocity{5, 0};
28  Vec2 Acceleration{0, -9.8};
29  float Mass{70};
30  // ....
31};

Momentum

Before we start adding to our class, there are two more concepts in physics we need to understand - momentum, and impulse. Momentum is a combination of an object’s velocity with its mass:

For example, if two objects have the same velocity, the heavier object will have more momentum. If a lighter object has the same momentum as a heavier object, that means the lighter object is moving faster.

Given that momentum is a mass multiplied by a velocity, the unit used to represent momentum will be a unit of mass (often kilograms, $kg$) multiplied by a unit of velocity (often meters per second, $m/s$). When units are multiplied together, it’s common to represent that multiplication using a center dot $\cdot$

For example:

• A $1kg$ object moving at $1m/s$ has a momentum of $1kg\mathclose{\cdot} m/s$
• A $10kg$ object moving at $1m/s$ has a momentum of $10kg\mathclose{\cdot} m/s$
• A $1kg$ object moving at $10m/s$ also has a momentum of $10kg\mathclose{\cdot} m/s$

Impulse

A change in an object’s momentum is called an impulse. In our simulations, changes in momentum are almost always caused by changes in velocity, rather than a change in the object’s mass.

As we’ve seen, a change in velocity requires acceleration, and acceleration is caused by a force being applied to an object for some period of time. Increasing the force, or applying the force for a longer duration, results in larger changes of momentum.  Therefore:

Newton-Seconds

The $kg\mathclose{\cdot}m/s$ unit used to measure momentum (and changes in momentum) is often referred to by an alternative, equivalent unit: the Newton-second, $\text{N}\mathclose{\cdot}s$. For example:

• Applying $1N$ of force for $1s$ creates an impulse of $1\text{N}\mathclose{\cdot}s$
• Applying $10N$ of force for $1s$ creates an impulse of $10\text{N}\mathclose{\cdot}s$
• Applying $1N$ of force for $10s$ also creates an impulse of $10\text{N}\mathclose{\cdot}s$

Previously, we saw how a Newton is the amount of force required to accelerate a $1kg$ object by $1m/s^2$.

If we apply this $1m/s^2$ acceleration for one second, the object’s velocity will change by $1m/s$. And, given the object has $1kg$ of mass, its momentum will change by $1kg\mathclose{\cdot} m/s$. Therefore, $1 \text{N}\mathclose{\cdot}s = 1 kg \cdot m/s$. Here are some more examples:

• $10 \text{N}\mathclose{\cdot}s$ of impulse will change a $1kg$ object’s velocity by $10 m/s$
• $100 \text{N}\mathclose{\cdot}s$ of impulse will change a $10kg$ object’s velocity by $10 m/s$
• $100 \text{N}\mathclose{\cdot}s$ of impulse will change a $100kg$ object’s velocity by $1 m/s$

Implementing Impulses

The time component of an impulse can be any duration but, in our simulations, the main use case for impulses is to apply instantaneous changes in momentum. That is, a force that is applied a single time, within a single tick / frame.

Examples of this might include letting our character jump off the ground or having objects react to an explosition.

The key technical difference between an instant impulse and a continuous force is that impulses should not be modified by our frame’s delta time. A continuous force gets applied across many steps of our simulation, so its effect on each frame should depend on how much time has passed since the previous frame.

But an instant impulse is applied all within a single step, and its magnitude should not depend on how long that frame took to generate. Therefore, an implementation of impulses might look like this:

1// GameObject.h
2// ...
3
4class GameObject {
5// ...
6 private:
7  void ApplyImpulse(const Vec2& Impulse) {
8    Velocity += Impulse / Mass;
9  }
10  // ...
11};

Example: Jumping

Below, we use this mechanism to let our character jump when the player presses their spacebar:

1// GameObject.h
2// ...
3
4class GameObject {
5 public:
6  // ...
7  void HandleEvent(const SDL_Event& E) {
8    if (E.type == SDL_KEYDOWN) {
9      if (E.key.keysym.sym == SDLK_SPACE) {
10        ApplyImpulse({0.0f, 15.0f});
11      }
12    }
13  }
14  // ...
15};

Non-Instant Impulses

If we want to apply a force that continues for a fixed period of time, we can use our previous ApplyForce() technique, in conjunction with some mechanism that keeps track of time.

For example, we could use the SDL_Timer mechanisms we introduced previously, or accumulate time deltas that are flowing through our Tick() function until our accumulation has reached some target.

The following program uses the latter technique to apply a force for approximately 5 seconds:

1// GameObject.h
2// ...
3
4class GameObject {
5public:
6  // ...
7  void Tick(float DeltaTime) {
8    ApplyForce(FrictionForce(DeltaTime));
9    ApplyForce(DragForce());
10    
11    // Apply the timed force if active
12    if (ForceTimeRemaining > 0) {
13      ApplyForce({1, 2});
14      ForceTimeRemaining -= DeltaTime;
15    }
16    
17    Velocity += Acceleration * DeltaTime;
18    Position += Velocity * DeltaTime;
19
20    Acceleration = {0.0f, -9.8};
21    Clamp(Velocity);
22
23    // Don't fall through the floor
24    if (Position.y < 2) {
25      Position.y = 2;
26      Velocity.y = 0;
27    }
28  }
29  
30  // ...
31private:
32  float ForceTimeRemaining{5.0f};
33  // ...
34};

Positional Impulses

So far, our examples have implemented forces such that our objects feel their full effect. This is reasonable for effects like gravity and jumping but, in many cases, we want to simulate forces that have a specific point of origin.

For example, we might have an explosion happening somewhere in the world, with the effect that objects are knocked away from that location.

As such, the direction of the effect of that force on each object depends on that specific object’s position relative to where the explosion happened. Let’s set that up:

1// GameObject.h
2// ...
3
4class GameObject {
5// ...
6 private:
7  void ApplyPositionalImpulse(
8    const Vec2& Origin, float Magnitude
9  ) {
10    Vec2 Direction{(Position - Origin)
11      .Normalize()};
12  
13    ApplyImpulse(Direction * Magnitude);
14  }
15  // ...
16};

Example: Explosions

Let’s create an example where the player can click a position on the screen to create an explosion, knocking nearby objects away. The first challenge we have is that SDL will report the position of the click in screen-space, and we need the position to be in world-space for our physics simulation.

Our Scene class already has a function to convert world space positions to screen space positions. Let’s add an inverse function for converting screen space to world space:

1// Scene.h
2// ...
3
4class Scene {
5public:
6  // ...
Screen Space Transformation (for reference)|Show
7  Vec2 ToScreenSpace(const Vec2&) {/*...*/}
19
20  Vec2 ToWorldSpace(const Vec2& Pos) const {
21    auto [vx, vy, vw, vh]{Viewport};
22    float HorizontalScaling{WorldSpaceWidth / vw};
23    float VerticalScaling{WorldSpaceHeight / vh};
24
25    return {
26      (Pos.x - vx) * HorizontalScaling,
27      WorldSpaceHeight - (Pos.y - vy)
28        * VerticalScaling
29    };
30  }
31  // ...
32};

Our GameObject instances are currently receiving events within their HandleEvent() method, so we can access click events and the corresponding mouse position from there.

However, within our GameObject.h file, Scene is an incomplete type, meaning we can’t use our new ToWorldSpace() function from this header file. So, similar to our Render() function, our HandleEvent() function definition needs to move to the source file:

1// GameObject.h
2// ...
3
4class Scene;  // Incomplete type
5
6class GameObject {
7 public:
8  // Definition moved to GameObject.cpp
9  void HandleEvent(const SDL_Event& E); 
10};

In our source file, we’ll create a Vec2 based on the mouse position, and we’ll pass that vector to our new ToWorldSpace() function to determine where that click happened in our world.

The force from an explosion is a quick, sudden, blast. As such, we’ll implement it as an immediate change in momentum using our ApplyPositionalImpulse() function. We’ll pass our Vec2 to that function, alongside a magnitude that feels right We’ll go with $100N$ for now:

1// GameObject.cpp
2// ...
3
4void GameObject::HandleEvent(const SDL_Event& E) {
5  if (E.type == SDL_MOUSEBUTTONDOWN) {
6    if (E.button.button == SDL_BUTTON_LEFT) {
7      ApplyPositionalImpulse(
8        Scene.ToWorldSpace({
9          static_cast<float>(E.button.x),
10          static_cast<float>(E.button.y)
11      }), 100);
12    }
13  }
14  // ... Other event handlers
15}

Running our game, we should now see that any time we click in our window, our objects are knocked away from our mouse:

Falloff and the Inverse-Square Law

An additional property of a force originating from a specific position, such as an explosion, is that objects closer to the explosion are affected more than objects further away.

To make our calculations simpler, when specifying the magnitude of a positional force, we specify it in terms of how that force will feel to an object that is one meter away from it.

For example, we might want to create an explosion where objects one meter away experience $100N$ of force. Let’s represent that as $\text{F(1)} = 100$.

The magnitude of the force experienced by objects at different distances follows the inverse-square law, where the effect falls off in proportion to the square of the distance.

As such, a function for calculating this falloff would look something like the following, where $d$ represents the distance between the explosion and the object that’s reacting to it, and $\text{F(1)}$ is the magnitude that would be experienced by an object one meter away:

Let’s revisit our hypothetical explosion, where we defined $\text{F(1)}$ to be $100N$. An object $10$ meters away from the same explosion will experience $1$ Newton of force as:

An object that is only $50$ centimeters ($0.5$ meters) away will experience $400$ Newtons of force as:

Implementing Falloff

Let’s update our ApplyPositionalForce() function to modify its effects based on the distance between our object and the origin of the force:

1// GameObject.h
2// ...
3
4class GameObject {
5// ...
6 private:
7  void ApplyPositionalImpulse(
8    const Vec2& Origin, float Magnitude
9  ) {
10    Vec2  Displacement{Position - Origin};
11    Vec2  Direction{Displacement.Normalize()};
12    float Distance{Displacement.GetLength()};
13  
14    // Apply inverse-square law with a small
15    // offset to prevent extreme forces
16    float AdjustedMagnitude{Magnitude /
17      (Distance * Distance)};
18  
19    ApplyImpulse(Direction * AdjustedMagnitude);
20  }
21  // ...
22};

The inverse-linear law is quite often a source of janky physics as, when the distance between an object and a force gets very small, the resulting magnitude of that force becomes extremely large. Additionally, if the distance is ever exactly $0$, our division will become problematic.

To solve this, we should intervene in our falloff calculation. In games, we don’t need to be especially accurate, but we do need to be resource-efficient, so a common solution is to add some small number to our distances:

Let’s update our code to use this:

1// GameObject.h
2// ...
3
4class GameObject {
5// ...
6 private:
7  void ApplyPositionalImpulse(
8    const Vec2& Origin, float Magnitude
9  ) {
10    Vec2  Displacement{Position - Origin};
11    Vec2  Direction{Displacement.Normalize()};
12    float Distance{Displacement.GetLength()};
13  
14    // Apply inverse-square law with a small
15    // offset to prevent extreme forces
16    float AdjustedMagnitude{Magnitude /
17      ((Distance + 0.1f) * (Distance + 0.1f))};
18  
19    ApplyImpulse(Direction * AdjustedMagnitude);
20  }
21  // ...
22};

Complete Code

Our updated Scene and GameObject classes that include all of the topics we covered are provided below:

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

1#pragma once
2#include <SDL.h>
3#include "Vec2.h"
4#include "Image.h"
5
6class Scene;
7
8class GameObject {
9 public:
10  GameObject(
11    const std::string& ImagePath,
12    const Vec2& InitialPosition,
13    const Scene& Scene
14  ) : Image{ImagePath},
15      Position{InitialPosition},
16      Scene{Scene} {}
17
18  void HandleEvent(const SDL_Event& E);
19
20  void Tick(float DeltaTime) {
21    ApplyForce(FrictionForce(DeltaTime));
22    ApplyForce(DragForce());
23    Velocity += Acceleration * DeltaTime;
24    Position += Velocity * DeltaTime;
25
26    Acceleration = {0, -9.8};
27
28    // Don't fall through the floor
29    if (Position.y < 2) {
30      Position.y = 2;
31      Velocity.y = 0;
32    }
33    Clamp(Velocity);
34  }
35
36  void Render(SDL_Surface* Surface);
37
38  void ApplyForce(const Vec2& Force) {
39    Acceleration += Force / Mass;
40  }
41
42 private:
43  Image Image;
44  const Scene& Scene;
45
46  Vec2 Position{0, 0};
47  Vec2 Velocity{0, 0};
48  Vec2 Acceleration{0, -9.8};
49  float Mass{70};
50
51  float DragCoefficient{0.2};
52  Vec2 DragForce() const {
53    return -Velocity * DragCoefficient
54      * Velocity.GetLength();
55  }
56
57  float GetFrictionCoefficient() const {
58    if (Position.y > 2) {
59      return 0;
60    }
61
62    return 0.5;
63  }
64  Vec2 FrictionForce(float DeltaTime) const {
65    float MaxMagnitude{GetFrictionCoefficient()
66      * Mass * -Acceleration.y};
67    if (MaxMagnitude <= 0) return Vec2(0, 0);
68
69    float StoppingMagnitude{Mass *
70      Velocity.GetLength() / DeltaTime};
71
72    return -Velocity.Normalize() * std::min(
73      MaxMagnitude, StoppingMagnitude);
74  }
75
76  void Clamp(Vec2& V) const {
77    V.x = std::abs(V.x) > 0.01 ? V.x : 0;
78    V.y = std::abs(V.y) > 0.01 ? V.y : 0;
79  }
80
81  void ApplyImpulse(const Vec2& Impulse) {
82    Velocity += Impulse / Mass;
83  }
84
85  void ApplyPositionalImpulse(
86    const Vec2& Origin, float Magnitude
87  ) {
88    Vec2  Displacement{Position - Origin};
89    Vec2  Direction{Displacement.Normalize()};
90    float Distance{Displacement.GetLength()};
91  
92    // Apply inverse-square law with a small
93    // offset to prevent extreme forces
94    float AdjustedMagnitude{Magnitude /
95      ((Distance + 0.1f) * (Distance + 0.1f))};
96  
97    ApplyImpulse(Direction * AdjustedMagnitude);
98  }
99};

1#include <SDL.h>
2#include "GameObject.h"
3#include "Scene.h"
4
5#define DRAW_DEBUG_HELPERS
6
7#ifdef DRAW_DEBUG_HELPERS
8namespace{
9SDL_Surface* Trajectories{
10  SDL_CreateRGBSurfaceWithFormat(
11    0, 700, 300, 32,
12    SDL_PIXELFORMAT_RGBA32
13  )};
14}
15#endif
16
17void GameObject::Render(SDL_Surface* Surface) {
18#ifdef DRAW_DEBUG_HELPERS
19  auto [x, y] = Scene.ToScreenSpace(Position);
20  SDL_Rect PositionIndicator{
21    int(x) - 10, int(y) - 10, 20, 20};
22  SDL_FillRect(Trajectories, &PositionIndicator,
23    SDL_MapRGB(Trajectories->format, 220, 0, 0));
24                   
25  SDL_BlitSurface(
26    Trajectories, nullptr,
27    Surface, nullptr);
28#endif
29  Image.Render(
30    Surface, Scene.ToScreenSpace(Position)
31  );
32}
33
34void GameObject::HandleEvent(const SDL_Event& E) {
35  if (E.type == SDL_MOUSEBUTTONDOWN) {
36    // Create explosion at click position
37    if (E.button.button == SDL_BUTTON_LEFT) {
38      ApplyPositionalImpulse(
39        Scene.ToWorldSpace({
40          static_cast<float>(E.button.x),
41          static_cast<float>(E.button.y)
42      }),1000);
43    }
44  } else if (E.type == SDL_KEYDOWN) {
45    // Jump
46    if (E.key.keysym.sym == SDLK_SPACE) {
47      if (Position.y > 2) return;
48      ApplyImpulse({0.0f, 300.0f});
49    }
50  }
51}

Summary

This lesson explores implementing momentum and impulses in our physics system, enabling instantaneous forces like jumps and explosions.

We've learned how to calculate the effects of these forces on objects with different masses and at varying distances. Key takeaways:

• Momentum is the product of mass and velocity, measured in $\text{kg} \mathclose{\cdot} \text{m/s}$ or Newton-seconds, $\text{N}\mathclose{\cdot}s$
• Impulse represents a change in momentum and equals force multiplied by time
• Instantaneous impulses apply forces within a single frame without being affected by delta time
• Positional impulses allow for effects like explosions where force originates from a specific point
• Force falloff follows the inverse-square law, making objects closer to the origin experience stronger effects
• Adding a small offset to distance calculations prevents extreme forces when objects are very close to the origin

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