Momentum and Impulse Forces

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};

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:

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:

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};

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

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