physics_kinematics.c

Go to the documentation of this file.

 
#include <banjo/app.h>
#include <banjo/main.h>
#include <banjo/draw.h>
#include <banjo/event.h>
#include <banjo/log.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
 
bj_window* window      = 0;
// Framebuffer pixel mode. Used with bj_get_pixel_value so we can
// pre-compute colours at setup before the first draw callback fires
// (when the framebuffer would otherwise be reachable).
#define FB_PIXEL_MODE  BJ_PIXEL_MODE_XRGB8888
 
#define BALLS_LEN 1000
#define BALLS_RADIUS BJ_F(3.0)
#define GRAVITY BJ_F(50.0)
 
// Each ball tracks its initial conditions and elapsed time. Kinematics needs:
// - initial_position (shared by all balls here)
// - initial_velocity (unique per ball)
// - acceleration (gravity, shared)
// - time_alive (how long since launch)
// From these, we can compute exact position at any time.
struct {
    bj_vec2 initial_velocity;
    bj_vec2 position;
    uint32_t color;
    double time_alive;
} balls[BALLS_LEN];
bj_vec2 gravity;
bj_vec2 initial_position;
 
// Setting up a projectile: choose initial velocity based on desired direction
// and speed. For realistic projectile arcs, use angle and magnitude.
// Angle: -90° points straight up, 0° points right (here: -90° to 0° for fountain effect)
// Magnitude: initial speed in pixels/second
static void reset_ball(size_t at) {
    const uint8_t r = (uint8_t)(128 + rand() % 128);
    const uint8_t g = (uint8_t)(128 + rand() % 128);
    const uint8_t b = (uint8_t)(128 + rand() % 128);
 
    switch (rand() % 3) {
        case 0: balls[at].color = bj_get_pixel_value(FB_PIXEL_MODE, 100, g, b); break;
        case 1: balls[at].color = bj_get_pixel_value(FB_PIXEL_MODE, r, 100, b); break;
        default: balls[at].color = bj_get_pixel_value(FB_PIXEL_MODE, r, g, 100); break;
    }
 
    // Random angle from -90° to 0° (straight up to straight right).
    const bj_real angle_rand = (bj_real)rand() / (bj_real)RAND_MAX;
    const bj_real angle = -BJ_PI / BJ_F(2.0) + angle_rand * (BJ_PI / BJ_F(2.0));
 
    // Random speed between 100 and 200 pixels/second.
    const bj_real magnitude = BJ_F(100.0) + ((bj_real)rand() / (bj_real)RAND_MAX) * BJ_F(100.0);
 
    // Convert angle + magnitude to velocity vector (vx, vy).
    balls[at].initial_velocity.x = bj_cos(angle) * magnitude;
    balls[at].initial_velocity.y = bj_sin(angle) * magnitude;
    balls[at].time_alive = 0;
}
 
static void initialize_balls() {
 
    // Gravity acceleration: (0, 50) means 50 pixels/second² downward.
    // Positive y is down in screen coordinates, so gravity pulls objects down.
    // Adjust this value to make physics feel heavier or lighter.
    gravity = (bj_vec2){0, GRAVITY};
 
    // All balls start from the bottom-left corner.
    initial_position = (bj_vec2){BALLS_RADIUS + 5, SCREEN_HEIGHT - BALLS_RADIUS - 5};
 
    for(size_t b = 0 ; b < BALLS_LEN ; ++b) {
        reset_ball(b);
    }
 
}
 
// Update physics: accumulate time and compute exact positions using kinematics.
// dt is delta time (seconds since last frame) for frame-rate independence.
static void update(bj_real dt) {
    for(size_t b = 0 ; b < BALLS_LEN ; ++b) {
        // Track total time since this ball was launched.
        balls[b].time_alive += dt;
 
        // bj_compute_kinematics_2d() computes position from:
        //   - initial_position: where the ball started
        //   - initial_velocity: how fast it was moving at launch
        //   - gravity: constant acceleration
        //   - time_alive: elapsed time since launch
        // Returns exact position using: p = p₀ + v₀*t + ½*a*t²
        // This is more accurate than integrating velocity frame-by-frame.
        balls[b].position = bj_compute_kinematics_2d(
            initial_position,
            balls[b].initial_velocity,
            gravity,
            balls[b].time_alive
        );
 
        const bj_real x = balls[b].position.x;
        const bj_real y = balls[b].position.y;
 
        // Reset balls that leave the screen.
        if (x + BALLS_RADIUS < BJ_FZERO || x - BALLS_RADIUS > (bj_real)SCREEN_WIDTH ||
            y + BALLS_RADIUS < BJ_FZERO || y - BALLS_RADIUS > (bj_real)SCREEN_HEIGHT
        ) {
            reset_ball(b);
        }
 
 
    }
}
 
static void draw(bj_bitmap* framebuffer) {
    bj_clear_bitmap(framebuffer);
 
    for(size_t b = 0 ; b < BALLS_LEN ; ++b) {
        bj_draw_filled_circle(framebuffer,
            balls[b].position.x, balls[b].position.y, BALLS_RADIUS,
            balls[b].color
        );
    }
}
 
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));
}
 
static void* setup(struct bj_app* app, void* init_data) {
    (void)init_data;
    srand((unsigned)time(NULL));
 
    if (!bj_begin(BJ_VIDEO_SYSTEM, 0)) {
        bj_quit_app(app, 1);
        return 0;
    }
 
    window = bj_bind_window("2D Kinematics", 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);
 
    initialize_balls();
    return 0;
}
 
// Physics runs at the fixed-step rate (60 Hz by default) regardless of
// how often step gets to fire. tick.delta is constant (1 / rate), which
// keeps projectile motion identical across machines.
static void fixed_step(struct bj_app* app, struct bj_tick_info tick, void* user_data) {
    (void)app; (void)user_data;
    update(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);
}