physics_particle.c

Go to the documentation of this file.

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