Struct Body 

pub struct Body {

    pub transform: Transform,
    pub prev_transform: Transform,
    pub velocity: BodyVelocity,
    pub force: [Real; 3],
    pub torque: [Real; 3],
    pub mass: Real,
    pub inv_mass: Real,
    pub inertia: Real,
    pub linear_damping: Real,
    pub angular_damping: Real,
    pub restitution: Real,
    pub mode: BodyMode,
    pub active: bool,
    pub sleep_timer: Real,
    pub generation: u32,
}

All simulation state for a single rigid body.

Fields

transform: Transform

Current world-space transform.

prev_transform: Transform

Previous-frame transform (for CCD and interpolation).

velocity: BodyVelocity

Current velocities.

force: [Real; 3]

Accumulated force for this step (Newtons).

torque: [Real; 3]

Accumulated torque for this step (N·m).

mass: Real

Body mass (kg). 0 means static.

inv_mass: Real

Inverse mass. 0 means static/kinematic.

inertia: Real

Isotropic moment of inertia scalar.

linear_damping: Real

Linear damping coefficient.

angular_damping: Real

Angular damping coefficient.

restitution: Real

Restitution coefficient (bounciness).

mode: BodyMode

Simulation mode.

active: bool

Whether the body is currently active (participating in simulation).

sleep_timer: Real

How many consecutive steps the body has been below sleep thresholds.

generation: u32

Generation counter (for handle validation).

Implementations

impl Body

pub fn new_dynamic(position: [Real; 3], mass: Real) -> Self

Create a dynamic body at the given position with given mass.

pub fn new_static(position: [Real; 3]) -> Self

Create a static body at the given position.

pub fn apply_force(&mut self, force: [Real; 3])

Apply a force to the body (accumulates until cleared).

pub fn apply_torque(&mut self, torque: [Real; 3])

Apply a torque to the body.

pub fn apply_impulse_at(&mut self, impulse: [Real; 3], offset: [Real; 3])

Apply an impulse at a world-space offset (cross-product contributes to angular).

pub fn clear_forces(&mut self)

Clear accumulated forces and torques.

pub fn integrate_velocities(&mut self, gravity: [Real; 3], dt: Real)

Integrate velocities from forces over dt (semi-implicit Euler).

pub fn integrate_positions(&mut self, dt: Real)

Integrate positions from velocities over dt.

pub fn interpolated_transform(&self, alpha: Real) -> Transform

Return an interpolated transform at sub-step fraction α ∈ [0,1].

Trait Implementations

impl Clone for Body

fn clone(&self) -> Body

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Body

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Body

fn default() -> Self

Returns the “default value” for a type.