Applying Forces to Physics Bodies

From Constant Acceleration to Dynamic Forces

In the last lesson, we gave an object an acceleration like (0.0, -0.5, 0.0) and it moved accordingly. But in the real world, acceleration isn't a fixed property; it's the result of forces. You know this from your engineering studies: a heavier object requires more force to accelerate at the same rate as a lighter one.

To get started, let's watch a short, conceptual video that captures the journey from simply moving an object to simulating gravity correctly using Newton's laws.

The key takeaway is that we need to stop thinking about acceleration as a starting point and start thinking about force.

Newton's Second Law and the Force Accumulator

The core of our simulation will be Newton's Second Law. Let's start with a quick refresher.

Our strategy will be to use the formula $a=F/m$. For each physics update step, we will:

1. Sum all forces acting on an object. This sum is the net force, $F$.
2. Calculate acceleration using the net force and the object's mass, $m$.
3. Use this acceleration in our Euler integration step to update velocity and position.
4. Clear the forces so we can start fresh in the next step.

This process of summing forces is handled by a pattern called a force accumulator. We'll add a vector to our PhysicsBody component that will accumulate all forces applied during a single frame.

Why do we do it this way? Let's look at a design-focused article that explains the rationale.

Implementation: Gravity in Action

Now, let's modify our code to implement this. We will apply Earth's gravity, which exerts a force $F_g=m\cdot g$, where $g$ is the acceleration due to gravity (a constant vector, approximately $(0,-9.81,0)$ m/s²).

1. Update the PhysicsBody Component

First, let's modify the PhysicsBody struct. We no longer need to store acceleration directly, as we will calculate it on the fly. Instead, we'll add our force_accumulator.

In your components header file (physics_component.h or similar):

// Before
typedef struct {
    vec3 velocity;
    vec3 acceleration; // We will remove this
    float mass;
} PhysicsBody;

// After
typedef struct {
    vec3 velocity;
    vec3 force_accumulator; // Add this
    float mass;
    float inverse_mass; // We'll add this for a good reason!
} PhysicsBody;

Why inverse_mass?
In our formula $a=F/m$, we perform a division. Division is computationally more expensive than multiplication. A common optimization in physics engines is to store the inverse mass ($1/m$) and calculate acceleration as $a=F\cdot (1/m)$. This turns a division into a multiplication.

There's another benefit: what about objects that shouldn't move? We can give them an "infinite" mass. In our code, this translates to a mass of 0, and therefore an inverse_mass of 0. When we calculate acceleration for these static objects, $a=F\cdot 0$, the result is always zero, so they won't move, and we avoid any division-by-zero errors!

When you initialize a PhysicsBody, you'll set the mass and calculate the inverse mass:

// In your entity creation code
// ...
physics_body.mass = 2.0f; // e.g., 2kg
if (physics_body.mass > 0.0f) {
    physics_body.inverse_mass = 1.0f / physics_body.mass;
} else {
    physics_body.inverse_mass = 0.0f;
}
physics_body.velocity = {0.0f, 0.0f, 0.0f};
glm_vec3_zero(physics_body.force_accumulator); // Start with no forces

2. Create a Function to Add Forces

It's good practice to have a helper function that adds a force to an object's accumulator.

// In physics_system.h or a similar utility header
void physics_body_add_force(PhysicsBody* body, vec3 force) {
    glm_vec3_add(body->force_accumulator, force, body->force_accumulator);
}

3. Update the Physics System

Now for the main event. Let's rewrite physics_system_update. The logic will follow the steps we outlined, using the implementation details from the resources we've reviewed. The Toptal article gives us a great C-based template for this.

Here is the updated physics_system.c:

#include "physics_system.h"
#include <cglm/cglm.h>

const vec3 GRAVITY = {0.0f, -9.81f, 0.0f};

// You can put this helper function here or in a more general file
void physics_body_add_force(PhysicsBody* body, vec3 force) {
    glm_vec3_add(body->force_accumulator, force, body->force_accumulator);
}

void physics_system_update(World* world, float dt) {
    // Iterate over all entities with a Transform and PhysicsBody
    for (int i = 0; i < world->entity_count; ++i) {
        if ((world->entity_masks[i] & (COMPONENT_TRANSFORM | COMPONENT_PHYSICS_BODY)) 
            == (COMPONENT_TRANSFORM | COMPONENT_PHYSICS_BODY)) {
            
            Transform* transform = &world->transforms[i];
            PhysicsBody* physics = &world->physics_bodies[i];

            // Skip static objects (infinite mass)
            if (physics->inverse_mass <= 0.0f) {
                continue;
            }

            // --- 1. Apply Forces ---
            // Apply gravity
            vec3 gravity_force;
            glm_vec3_scale(GRAVITY, physics->mass, gravity_force);
            physics_body_add_force(physics, gravity_force);

            // --- 2. Calculate Acceleration ---
            vec3 acceleration;
            glm_vec3_scale(physics->force_accumulator, physics->inverse_mass, acceleration);

            // --- 3. Integrate (Semi-implicit Euler) ---
            // Update velocity
            vec3 scaled_accel;
            glm_vec3_scale(acceleration, dt, scaled_accel);
            glm_vec3_add(physics->velocity, scaled_accel, physics->velocity);

            // Update position
            vec3 scaled_vel;
            glm_vec3_scale(physics->velocity, dt, scaled_vel);
            glm_vec3_add(transform->position, scaled_vel, transform->position);

            // --- 4. Clear Force Accumulator ---
            glm_vec3_zero(physics->force_accumulator);
        }
    }
}

4. Test It!

In your main.c, create an entity, give it a PhysicsBody with a positive mass, and place it somewhere visible (e.g., position = {0, 5, -10}). When you run your program, you should now see the object accelerate downwards realistically due to gravity! Try creating two objects with different masses; you'll notice they fall at the same rate, just as they should in a vacuum. This is because the mass term cancels out when calculating gravitational acceleration (a = (m*g)/m = g).

Generalizing Forces: Force Generators

We've hard-coded gravity, which is fine for now. In a more complex engine, you might have many sources of force: springs, wind, explosions, thrusters, etc. A common abstraction for this is the concept of a force generator.

Thinking in terms of force generators helps to decouple your physics engine. Instead of one monolithic physics_system_update function that knows about every type of force, you could have a system that iterates through a list of active force generators and applies them to relevant objects.

Conclusion

Excellent work! You have replaced a simple, static motion model with a dynamic system based on one of the fundamental laws of the universe. Your objects now respond to forces.

Key Takeaways:

• Physics simulation calculates acceleration from forces using Newton's Second Law, $a=F/m$.
• A force accumulator is a design pattern where all forces acting on an object in one frame are summed. The accumulator is cleared at the end of the frame.
• Storing inverse mass ($1/m$) is an effective optimization that replaces expensive division with multiplication and elegantly handles static objects (infinite mass).
• The force of gravity is calculated as $F_g=m\cdot g$, where $g$ is the constant gravitational acceleration.

Preview of the Next Lesson:
Our objects can now fall, but they'll fall right through the floor! The next logical step is to make them interact with each other. In the next lesson, you will learn how to implement a simple 'stop' collision response for AABB intersections. This will combine our work on collision detection with our new physics motion to make objects feel solid.