Momentum and Impulse Forces

So far, our examples have implemented forces such that our objects feel their full effect regardless of their position. 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.

We can set that up by calculating the direction from the origin of the force to the position of our object, normalizing that vector so it has a magnitude of $1$, and then multiplying it by the magnitude of the force we're applying:

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

Let's create an example where the player can click a position on the screen to create an explosion, knocking nearby objects away.

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

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 the mouse coordinates to that function, alongside a magnitude that feels right. We'll use 100000 units of impulse, which is roughly enough to knock our character back at a speed of 40 meters/second if they are 1 meter away.

The following example applies the full effect of the force regardless of how far away it is from our object, but we'll implement distance falloff in the next section:

1#include <SDL3/SDL.h>
2#include "GameObject.h"
3#include "Scene.h"
4
5void GameObject::Render(SDL_Surface* Surface) {
6  Image.Render(Surface, Position);
7}
8
9void GameObject::HandleEvent(SDL_Event& E) {
10  if (E.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
11    if (E.button.button == SDL_BUTTON_LEFT) {
12      ApplyPositionalImpulse(
13        Vec2{E.button.x, E.button.y},
14        10000.0f
15      );
16    }
17  } else if (E.type == SDL_EVENT_KEY_DOWN) {
18    if (E.key.key == SDLK_SPACE) {
19      if (Position.y > 200) return;
20      ApplyImpulse({0.0f, -15000.0f});
21    }
22  }
23}

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

Note that the Position of our object currently represents the top left corner of its rendered image. We can change where our image is rendered relative to this position by updating the Render() function of our Image class. For example, the following moves our image up and to the left, such that the Position of our object is at the center of the image:

1// ...
2
3class Image {
4 public:
5  // ...
6
7  void Render(
8    SDL_Surface* Surface, const Vec2& Pos
9  ) {
10    if (ImageSurface) {
11      SDL_Rect Rect{
12        int(Pos.x),
13        int(Pos.x) - ImageSurface->w / 2,
14        int(Pos.y)
15        int(Pos.y) - ImageSurface->h / 2,
16        ImageSurface->w, ImageSurface->h
17      };
18      SDL_BlitSurface(
19        ImageSurface, nullptr, Surface, &Rect);
20    }
21  }
22
23  // ...
24};

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 $1$ meter away experience $100N$ of force. We'll 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:

Minimum Distance

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.

If you've ever seen physics bugs where an object shoots off the screen at incredibly high speed, this division by a very small number was likely the cause.

To solve this, we intervene in our falloff calculation. A common solution is to add some small number to our distances - for example, $0.1$.

Game simulations don't need to be entirely accurate - they just need to look right, and this tiny change isn't noticible when our objects are a normal distance apart. However, it makes a big difference when they're unrealistically close together:

Implementing Falloff

Let's update our ApplyPositionalImpulse() function to modify its effects based on the distance between our object and the origin of the force.

To make the physics calculations intuitive, we'll convert our distance from pixels to meters using our PIXELS_PER_METER constant before applying the inverse-square law. This ensures that "one meter away" actually means 50 pixels away in our game world.

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

Our updated Scene, GameObject header, and GameObject source files are provided below.

The GameObject.cpp file also includes the code we used to draw trajectories in our screenshots for reference, but we'll walk through debug drawing in more detail later in the course.

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.