Data Structures | |
| struct | bj_particle_2d |
| struct | bj_angular_2d |
| struct | bj_rigid_body_2d |
Detailed Description
Physics for things that move on a flat 2D plane: positions, velocities, forces, particles.
The 2D version of the parent physics topic. The 2D helpers work in terms of bj_vec2 (a (x, y) pair) instead of plain scalars, but the ideas are the same: compute where a body is after some elapsed time from its starting position, velocity, and acceleration; or build up a per-frame simulation by accumulating forces on a particle (a point with a mass) and integrating to update its velocity and position.
Use the kinematics helpers (bj_compute_kinematics_2d and friends) when acceleration is constant and you just want to know "where will this be at time t?": projectiles, falling under gravity, anything ballistic.
Use the particle helpers (bj_step_particle_2d and friends) when forces change over time and you want to step the simulation frame-by-frame: orbiting bodies, soft springs, anything where the acceleration depends on what other things are doing.
See physics_kinematics.c and physics_particle.c for runnable demos of each.
Same unit convention as the parent topic
SI by default (metres and seconds), but the formulas are dimensionally consistent, pick any unit system you like, as long as every input to one formula uses the same one. [L] means "length", [T] means "time", [L T^-1] means "length per time" (a velocity), [L T^-2] means "length per time per time" (an acceleration).
Data Structure Documentation
◆ bj_particle_2d
| struct bj_particle_2d |
2D point mass state and physical properties.
Positions, velocities, accelerations and force accumulator are expressed in world space. Damping is a unitless velocity decay factor applied per-step. Mass is represented as inverse mass; use 0 to represent an immovable object.
- Parameters
-
position Current 2D position [L] velocity Current 2D velocity [L T^-1] acceleration Current 2D acceleration [L T^-2] forces Accumulated force for the next integration step [M L T^-2] damping Velocity damping factor in [0, 1] inverse_mass Inverse of mass [M^-1]; 0 means infinite mass
- Examples
- physics_particle.c.
Definition at line 98 of file physics_2d.h.
| Data Fields | ||
|---|---|---|
| struct bj_vec2 | acceleration | |
| bj_real | damping | |
| struct bj_vec2 | forces | |
| bj_real | inverse_mass | |
| struct bj_vec2 | position | |
| struct bj_vec2 | velocity | |
◆ bj_angular_2d
| struct bj_angular_2d |
Angular.
2D angular state and properties (scalar angle about Z).
Angle units are radians. Damping is unitless per-step decay on angular velocity. Inertia is represented via inverse inertia; use 0 for infinite inertia.
- Parameters
-
value Angle theta [rad] velocity Angular velocity omega [rad T^-1] acceleration Angular acceleration alpha [rad T^-2] torque Accumulated torque tau for next step [M L^2 T^-2] damping Angular velocity damping factor in [0, 1] inverse_inertia Inverse moment of inertia I^-1 [M^-1 L^-2]
Definition at line 246 of file physics_2d.h.
| Data Fields | ||
|---|---|---|
| bj_real | acceleration | |
| bj_real | damping | |
| bj_real | inverse_inertia | |
| bj_real | torque | |
| bj_real | value | |
| bj_real | velocity | |
◆ bj_rigid_body_2d
| struct bj_rigid_body_2d |
Rigid body with translational and angular components.
Particle terms are in world space. Angle is about +Z.
- Parameters
-
particle Linear state (position, velocity, forces) angular Angular state (theta, omega, tau)
Definition at line 288 of file physics_2d.h.
| Data Fields | ||
|---|---|---|
| struct bj_angular_2d | angular | |
| struct bj_particle_2d | particle | |
Function Documentation
◆ bj_apply_angular_torque_2d()
| void bj_apply_angular_torque_2d | ( | struct bj_angular_2d * | angular, |
| bj_real | torque ) |
Add torque to the angular accumulator.
- Parameters
-
angular Angular state to modify torque Torque to add tau [M L^2 T^-2]
◆ bj_apply_drag_2d()
| void bj_apply_drag_2d | ( | struct bj_particle_2d * | particle, |
| bj_real | k1, | ||
| bj_real | k2 ) |
Apply quadratic + linear drag to a particle's accumulator.
Drag magnitude = k1 * |v| + k2 * |v|^2 along -v_hat.
- Parameters
-
particle Particle to affect k1 Linear drag coefficient [M T^-1] k2 Quadratic drag coefficient [M L^-1]
◆ bj_apply_gravity_2d()
| void bj_apply_gravity_2d | ( | struct bj_particle_2d * | particle, |
| bj_real | gravity ) |
Apply constant downward gravity in world space to a particle.
Adds force F = m * g * (0, -1) assuming -Y is "down".
- Parameters
-
particle Particle to affect gravity Gravitational acceleration magnitude g >= 0 [L T^-2]
◆ bj_apply_particle_force_2d()
| void bj_apply_particle_force_2d | ( | struct bj_particle_2d * | particle, |
| const struct bj_vec2 | force ) |
Add a force to a particle's accumulator.
The force will be used on the next integration step, then should be cleared by the step routine.
- Parameters
-
particle Particle to modify force Force to add [M L T^-2]
◆ bj_apply_point_gravity_2d()
| void bj_apply_point_gravity_2d | ( | struct bj_particle_2d *restrict | particle_from, |
| const struct bj_particle_2d *restrict | particle_to, | ||
| const bj_real | gravity_factor ) |
Apply point gravity from one particle to another.
Adds a Newtonian attraction from particle_to to particle_from. Uses F = Gm1m2 r_hat / r^2 with gravity_factor = G.
- Parameters
-
particle_from Particle receiving the force particle_to Source particle gravity_factor Gravitational constant G [L^3 M^-1 T^-2]
◆ bj_apply_point_gravity_softened_2d()
| void bj_apply_point_gravity_softened_2d | ( | struct bj_particle_2d *restrict | particle_from, |
| const struct bj_particle_2d *restrict | particle_to, | ||
| const bj_real | gravity_factor, | ||
| const bj_real | epsilon ) |
Apply softened point gravity to avoid singularities at small r.
Uses F proportional to r / (r^2 + epsilon^2)^(3/2).
- Parameters
-
particle_from Particle receiving the force particle_to Source particle gravity_factor Gravitational constant G [L^3 M^-1 T^-2] epsilon Softening length epsilon >= 0 [L]
- Examples
- physics_particle.c.
Referenced by physics().
◆ bj_apply_rigidbody_force_2d()
| void bj_apply_rigidbody_force_2d | ( | struct bj_rigid_body_2d * | body, |
| const struct bj_vec2 | force ) |
Apply a world-space force at the center of mass.
Only affects linear state. Use external torque to affect rotation.
- Parameters
-
body Rigid body to modify force Force to add [M L T^-2]
◆ bj_compute_kinematics_2d()
| struct bj_vec2 bj_compute_kinematics_2d | ( | struct bj_vec2 | position, |
| struct bj_vec2 | velocity, | ||
| struct bj_vec2 | acceleration, | ||
| bj_real | time ) |
Integrate constant-acceleration 2D kinematics: position at time t.
Uses: out = position + velocity * time + 0.5 * acceleration * time^2.
- Parameters
-
position Initial position [L] velocity Initial velocity [L T^-1] acceleration Constant acceleration [L T^-2] time Elapsed time t [T]
- Returns
- Output position at time t [L]
- Examples
- physics_kinematics.c.
Referenced by bj_compute_kinematics_2d(), and update().
◆ bj_compute_kinematics_velocity_2d()
| struct bj_vec2 bj_compute_kinematics_velocity_2d | ( | struct bj_vec2 | velocity, |
| struct bj_vec2 | acceleration, | ||
| bj_real | time ) |
Integrate constant-acceleration 2D kinematics: velocity at time t.
Uses: out = velocity + acceleration * time.
- Parameters
-
velocity Initial velocity [L T^-1] acceleration Constant acceleration [L T^-2] time Elapsed time t [T]
- Returns
- Output velocity at time t [L T^-1]
Referenced by bj_compute_kinematics_velocity_2d().
◆ bj_compute_particle_drag_coefficient_2d()
| bj_real bj_compute_particle_drag_coefficient_2d | ( | const struct bj_vec2 | vel, |
| const bj_real | k1, | ||
| const bj_real | k2 ) |
Return scalar drag coefficient for a velocity.
Computes c = k1 * |v| + k2 * |v|^2.
- Parameters
-
vel Velocity vector [L T^-1] k1 Linear drag coefficient [M T^-1] k2 Quadratic drag coefficient [M L^-1]
- Returns
- c >= 0 [M T^-1]
◆ bj_compute_particle_drag_force_2d()
| struct bj_vec2 bj_compute_particle_drag_force_2d | ( | struct bj_vec2 | vel, |
| const bj_real | k1, | ||
| const bj_real | k2 ) |
Compute drag force for a velocity.
result = -c * v_hat with c as above. Zero if vel is near zero.
- Parameters
-
vel Velocity vector [L T^-1] k1 Linear drag coefficient [M T^-1] k2 Quadratic drag coefficient [M L^-1]
- Returns
- Output force [M L T^-2]
Referenced by bj_compute_particle_drag_force_2d().
◆ bj_step_angular_2d()
| void bj_step_angular_2d | ( | struct bj_angular_2d * | angular, |
| bj_real | delta_time ) |
Semi-implicit Euler step for angular motion.
Integrates alpha and omega, applies damping, and advances theta. Clears torque.
- Parameters
-
angular Angular state to integrate delta_time Time step [T]
◆ bj_step_particle_2d()
| void bj_step_particle_2d | ( | struct bj_particle_2d * | particle, |
| bj_real | dt ) |
Semi-implicit Euler step for a particle.
Integrates acceleration and velocity, applies damping, and advances position. Clears the force accumulator after use.
- Parameters
-
particle Particle to integrate dt Time step [T]
- Examples
- physics_particle.c.
Referenced by physics().
◆ bj_step_rigid_body_2d()
| void bj_step_rigid_body_2d | ( | struct bj_rigid_body_2d * | body, |
| bj_real | delta_time ) |
Step rigid body linear and angular states.
Calls the corresponding particle and angular integrators. Clears accumulators.
- Parameters
-
body Rigid body to integrate delta_time Time step [T]
