physics_particle.c

Particle physics with force integration for orbital mechanics.

Particle physics with force integration for orbital mechanics.Particle physics simulates objects with forces that change over time. Unlike kinematics (constant acceleration), particles accumulate forces each frame and integrate to update velocity and position. Use particles when:

• Forces vary (gravity between moving objects, springs, drag)
• Multiple forces act simultaneously
• You need realistic physics interactions

The particle loop: accumulate forces → integrate → clear forces → repeat This example simulates a solar system where gravitational forces constantly change as planets move, creating realistic orbital mechanics.

 
#include <banjo/app.h>
#include <banjo/main.h>
#include <banjo/assert.h>
#include <banjo/bitmap.h>
#include <banjo/draw.h>
#include <banjo/event.h>
#include <banjo/log.h>
#include <banjo/mat.h>
#include <banjo/physics.h>
#include <banjo/physics_2d.h>
#include <banjo/pixel.h>
#include <banjo/system.h>
#include <banjo/time.h>
#include <banjo/vec.h>
#include <banjo/window.h>
 
#include <stdlib.h>
#include <time.h>
 
#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600
#define CANVAS_WIDTH SCREEN_WIDTH
#define CANVAS_HEIGHT SCREEN_HEIGHT
 
#define FB_PIXEL_MODE  BJ_PIXEL_MODE_XRGB8888
 
bj_window* window      = 0;
bj_mat3x3 projection;
 
static void on_draw(struct bj_window*, struct bj_render_target*,
                    const struct bj_rect*, void*);
 
// Physics constants for the solar system simulation.
// G_SUN: gravitational constant (tuned for visual appeal, not realistic)
// SOFTENING: prevents infinite forces when particles get very close
// Masses: relative to Earth (Jupiter is 317.8× Earth's mass)
#define G_SUN      BJ_F(120.0)
#define SOFTENING  BJ_F(6.0)
#define M_SUN      BJ_F(1000.0)
#define M_MERCURY  BJ_F(0.055)
#define M_VENUS    BJ_F(0.815)
#define M_EARTH    BJ_F(1.0)
#define M_MARS     BJ_F(0.107)
#define M_JUPITER  BJ_F(317.8)
 
// bj_particle_2d contains: position, velocity, forces, inverse_mass, damping
// Forces accumulate during a frame, then bj_step_particle_2d() integrates them
// into velocity and position changes.
typedef struct {
    bj_particle_2d body;
    bj_real radius;
    uint32_t color;
} planet_t;
 
#define N_PLANETS 5
planet_t planets[N_PLANETS];
bj_particle_2d sun = {0};
 
#define N_ASTEROIDS 800
bj_particle_2d asteroids[N_ASTEROIDS];
uint32_t asteroid_color;
 
static void update_projection() {
    bj_mat3x3 ortho, viewport;
    bj_mat3_set_ortho(&ortho, -CANVAS_WIDTH/2, CANVAS_WIDTH/2, -CANVAS_HEIGHT/2, CANVAS_HEIGHT/2);
    bj_mat3_set_viewport(&viewport, 0.f, 0.f, SCREEN_WIDTH, SCREEN_HEIGHT);
    bj_mat3_mul(&projection, &viewport, &ortho);
}
 
// Calculate stable orbital velocity for a circular orbit with softening.
// For realistic orbits, velocity must balance gravitational force.
// Formula: v = sqrt(G*M*r² / (r² + eps²)^1.5)
// Without this, planets would either spiral in or fly away.
static bj_real orbital_speed_soft(bj_real G, bj_real M, bj_real r, bj_real eps) {
    const bj_real r2 = r*r;
    const bj_real denom = bj_pow(r2 + eps*eps, BJ_F(1.5));
    return (denom > BJ_FZERO) ? bj_sqrt( (G*M) * r2 / denom ) : BJ_FZERO;
}
 
static void init_sun() {
    sun.damping = BJ_F(1.0);
    sun.inverse_mass = BJ_F(1.0) / M_SUN;
}
 
// Initialise a planet in a stable circular orbit.
// Setting up particles: configure position, velocity, mass, damping.
// - Position: place at orbital radius r, angle phase
// - Velocity: perpendicular to position vector, magnitude = orbital speed
// - Mass: stored as inverse_mass for efficiency (F = a / inverse_mass)
// - Damping: 1.0 = no damping (perfect conservation of energy)
static void init_planet(planet_t* p, bj_real r, bj_real mass, uint32_t color, bj_real draw_r, bj_real phase) {
    const bj_real a = phase;
    p->body.position.x = r * bj_cos(a);
    p->body.position.y = r * bj_sin(a);
 
    const bj_real v = orbital_speed_soft(G_SUN, M_SUN, r, SOFTENING);
    p->body.velocity.x = -v * bj_sin(a);
    p->body.velocity.y =  v * bj_cos(a);
 
    p->body.forces = BJ_VEC2_ZERO;
    p->body.damping = BJ_F(1.0);
    p->body.inverse_mass = BJ_F(1.0) / mass;
 
    p->radius = draw_r;
    p->color = color;
}
 
static void init_asteroids() {
    asteroid_color = bj_get_pixel_value(FB_PIXEL_MODE, 0xB0, 0xB0, 0xB0);
    for (size_t i = 0; i < N_ASTEROIDS; ++i) {
        const bj_real rmin = BJ_F(190.0), rmax = BJ_F(260.0);
        const bj_real t = (bj_real)rand() / (bj_real)RAND_MAX;
        const bj_real u = (bj_real)rand() / (bj_real)RAND_MAX;
        const bj_real r = rmin + (rmax - rmin) * t;
        const bj_real a = BJ_TAU * u;
 
        asteroids[i].position.x = r * bj_cos(a);
        asteroids[i].position.y = r * bj_sin(a);
 
        const bj_real v = orbital_speed_soft(G_SUN, M_SUN, r, SOFTENING);
        asteroids[i].velocity.x = -v * bj_sin(a);
        asteroids[i].velocity.y =  v * bj_cos(a);
 
        asteroids[i].forces = BJ_VEC2_ZERO;
        asteroids[i].damping = BJ_F(1.0);
        asteroids[i].inverse_mass = 1.0;
    }
}
 
static void initialize() {
    init_sun();
 
    uint32_t col_mercury = bj_get_pixel_value(FB_PIXEL_MODE, 0xC8, 0xC8, 0xC8);
    uint32_t col_venus   = bj_get_pixel_value(FB_PIXEL_MODE, 0xD4, 0xA3, 0x58);
    uint32_t col_earth   = bj_get_pixel_value(FB_PIXEL_MODE, 0x30, 0xA0, 0xFF);
    uint32_t col_mars    = bj_get_pixel_value(FB_PIXEL_MODE, 0xD0, 0x50, 0x30);
    uint32_t col_jupiter = bj_get_pixel_value(FB_PIXEL_MODE, 0xD2, 0xB4, 0x8C);
 
    init_planet(&planets[0], BJ_F(60.0),  M_MERCURY, col_mercury, BJ_F(2.0), BJ_F(0.0));
    init_planet(&planets[1], BJ_F(90.0),  M_VENUS,   col_venus,   BJ_F(3.0), BJ_F(1.2));
    init_planet(&planets[2], BJ_F(130.0), M_EARTH,   col_earth,   BJ_F(3.2), BJ_F(2.0));
    init_planet(&planets[3], BJ_F(170.0), M_MARS,    col_mars,    BJ_F(2.6), BJ_F(2.6));
    init_planet(&planets[4], BJ_F(260.0), M_JUPITER, col_jupiter, BJ_F(6.0), BJ_F(0.8));
 
    init_asteroids();
}
 
// The particle physics loop: apply forces, then integrate. Called from
// fixed_step so dt is constant (1 / fixed_step_rate); the simulation
// timestep is configured to 1/120 s in main() to keep the integrator
// stable for this gravity setup.
//
// 1. bj_apply_point_gravity_softened_2d(): Accumulates gravitational force
//    into particle.forces based on distance and masses. Softening prevents
//    infinite forces when particles are very close.
//
// 2. bj_step_particle_2d(): Integrates accumulated forces:
//    - acceleration = forces * inverse_mass
//    - velocity += acceleration * dt (with damping)
//    - position += velocity * dt
//    - forces = zero (ready for next frame)
//
// This pattern allows multiple forces (gravity, wind, springs) to combine
// naturally. Each force function just adds to particle.forces, then step
// integrates them all at once.
static void physics(bj_real dt) {
    for (size_t i = 0; i < N_PLANETS; ++i) {
        bj_apply_point_gravity_softened_2d(&planets[i].body, &sun, G_SUN, SOFTENING);
        bj_step_particle_2d(&planets[i].body, dt);
    }
    for (size_t i = 0; i < N_ASTEROIDS; ++i) {
        bj_apply_point_gravity_softened_2d(&asteroids[i], &sun, G_SUN, SOFTENING);
        bj_step_particle_2d(&asteroids[i], dt);
    }
}
 
static void draw(bj_bitmap* framebuffer) {
    bj_clear_bitmap(framebuffer);
 
    const uint32_t col_sun = bj_get_pixel_value(FB_PIXEL_MODE, 0xFF, 0xCC, 0x44);
 
    bj_vec3 c = { sun.position.x, sun.position.y, BJ_F(1.0) };
    bj_vec3 pc = bj_mat3_transform_vec3(&projection, c);
    bj_draw_filled_circle(framebuffer, pc.x, pc.y, BJ_F(10.0), col_sun);
 
    for (size_t i = 0; i < N_PLANETS; ++i) {
        c.x = planets[i].body.position.x; c.y = planets[i].body.position.y;
        pc = bj_mat3_transform_vec3(&projection, c);
        bj_draw_filled_circle(framebuffer, pc.x, pc.y, planets[i].radius, planets[i].color);
    }
 
    for (size_t i = 0; i < N_ASTEROIDS; ++i) {
        c.x = asteroids[i].position.x; c.y = asteroids[i].position.y;
        pc = bj_mat3_transform_vec3(&projection, c);
        bj_put_pixel(framebuffer, (int)pc.x, (int)pc.y, asteroid_color);
    }
}
 
static void* setup(struct bj_app* app, void* init_data) {
    (void)init_data;
 
    bj_set_fixed_step_rate(app, 120);
 
    srand((unsigned)time(NULL));
 
    if (!bj_begin(BJ_VIDEO_SYSTEM, 0)) {
        bj_quit_app(app, 1);
        return 0;
    }
 
    window = bj_bind_window("2D Solar System + Asteroids", 100, 100, SCREEN_WIDTH, SCREEN_HEIGHT, 0, 0);
 
    bj_set_key_callback(bj_close_on_escape, 0);
    bj_set_draw_callback(window, on_draw, 0);
 
    update_projection();
    initialize();
    return 0;
}
 
static void on_draw(
    struct bj_window*        w,
    struct bj_render_target* target,
    const struct bj_rect*    dirty,
    void*                    user_data
) {
    (void)w; (void)dirty; (void)user_data;
    draw(bj_render_target_bitmap(target));
}
 
// Particle physics is integrated in fixed_step so the orbits are stable
// regardless of how often step gets to fire. The 120 Hz rate set in main
// keeps dt = 1/120 s, matching what the integrator was already clamping
// to under the old variable-rate model.
//
// Particles vs Kinematics choice:
// - Use particles when forces change (orbiting bodies, springs, interactions)
// - Use kinematics when acceleration is constant (projectiles with gravity only)
// Here, gravity direction/magnitude changes as planets orbit, so particles are needed.
static void fixed_step(struct bj_app* app, struct bj_tick_info tick, void* user_data) {
    (void)app; (void)user_data;
    physics(tick.delta);
}
 
static void step(struct bj_app* app, struct bj_tick_info tick, void* user_data) {
    (void)tick; (void)user_data;
    bj_dispatch_events();
    bj_invalidate_window(window);
 
    if (bj_should_close_window(window)) {
        bj_quit_app(app, 0);
    }
}
 
static void teardown(struct bj_app* app, void* user_data) {
    (void)user_data;
    bj_unbind_window(window);
    bj_end();
}
 
int main(int argc, char* argv[]) {
    (void)argc; (void)argv;
    return bj_run_app(setup, step, fixed_step, teardown, 0);
}