Struct RigidBody 

pub struct RigidBody {

    pub position: Vector3<f32>,
    pub velocity: Vector3<f32>,
    pub mass: f32,
    pub inv_mass: f32,
    pub body_type: BodyType,
    pub restitution: f32,
    pub collider: Option<Collider>,
    pub friction: f32,
    pub damping: f32,
    pub orientation: UnitQuaternion<f32>,
    pub angular_velocity: Vector3<f32>,
    pub inv_inertia_local: Matrix3<f32>,
    pub angular_damping: f32,
    pub active: bool,
    /* private fields */
}

A rigid body with linear and angular dynamics.

Tracks position, velocity, orientation, angular velocity, accumulated forces/torques, and mass/inertia.

Fields

position: Vector3<f32>

velocity: Vector3<f32>

mass: f32

inv_mass: f32

body_type: BodyType

restitution: f32

collider: Option<Collider>

friction: f32

Coulomb friction coefficient (0.0 = frictionless ice, 1.0 = very rough). During collision response the effective friction is the geometric mean of both bodies’ coefficients: sqrt(mu_a * mu_b).

damping: f32

Linear damping factor (0.0 = no damping, 1.0 = full stop). Applied each step as velocity *= (1.0 - damping).

orientation: UnitQuaternion<f32>

Orientation quaternion. Defaults to identity (no rotation).

angular_velocity: Vector3<f32>

Angular velocity in world-space (radians per second).

inv_inertia_local: Matrix3<f32>

Inverse of the inertia tensor in body-local space. For static bodies this is the zero matrix.

angular_damping: f32

Angular damping factor (0.0 = no damping, 1.0 = full stop). Applied each step as angular_velocity *= (1.0 - angular_damping).

active: bool

Whether this body is active. Inactive bodies are skipped during integration and collision detection. Set to false by PhysicsWorld::remove_body.

Implementations

impl RigidBody

pub fn new(mass: f32) -> Self

Create a new dynamic rigid body with the given mass (in kg).

The body starts with a default point-mass inertia tensor (identity scaled by mass). Use [with_inertia_sphere] or [with_inertia_box] after attaching a collider for physically accurate rotation.

Panics

Panics if mass is not positive and finite.

pub fn new_static() -> Self

Create a new static rigid body (infinite mass, unaffected by forces).

pub fn with_position(self, position: Vector3<f32>) -> Self

Builder: set initial position.

pub fn with_velocity(self, velocity: Vector3<f32>) -> Self

Builder: set initial velocity.

pub fn with_restitution(self, restitution: f32) -> Self

Builder: set restitution (bounciness, 0.0..=1.0).

pub fn with_damping(self, damping: f32) -> Self

Builder: set linear damping (0.0..=1.0).

pub fn with_collider(self, collider: Collider) -> Self

Builder: attach a collider for collision detection.

pub fn with_friction(self, friction: f32) -> Self

Builder: set friction coefficient (0.0..=1.0).

pub fn with_angular_velocity(self, angular_velocity: Vector3<f32>) -> Self

Builder: set initial angular velocity (in radians per second).

pub fn with_angular_damping(self, damping: f32) -> Self

Builder: set angular damping (0.0..=1.0).

pub fn with_inertia_sphere(self, radius: f32) -> Self

Builder: set the inertia tensor for a solid sphere of given radius.

Inertia: I = (2/5) * m * r² (uniform along all axes).

pub fn with_inertia_box(self, half_extents: Vector3<f32>) -> Self

Builder: set the inertia tensor for a solid box with given half-extents.

For a box of full dimensions (2*hx, 2*hy, 2*hz):

• Ixx = (1/12) * m * (4*hy² + 4*hz²)
• Iyy = (1/12) * m * (4*hx² + 4*hz²)
• Izz = (1/12) * m * (4*hx² + 4*hy²)

pub fn apply_force(&mut self, force: Vector3<f32>)

Apply a force (in Newtons) to this body. Forces accumulate until the next step().

pub fn apply_impulse(&mut self, impulse: Vector3<f32>)

Apply an instantaneous impulse (change in momentum) to this body. Directly modifies velocity: delta_v = impulse / mass.

pub fn apply_torque(&mut self, torque: Vector3<f32>)

Apply a torque (in N·m) to this body. Torques accumulate until the next step().

pub fn apply_angular_impulse(&mut self, impulse: Vector3<f32>)

Apply an instantaneous angular impulse (change in angular momentum). Directly modifies angular velocity: delta_ω = I⁻¹ * impulse.

pub fn inv_inertia_world(&self) -> Matrix3<f32>

Compute the world-space inverse inertia tensor from the local one and the current orientation: I⁻¹_world = R * I⁻¹_local * Rᵀ.

pub fn speed(&self) -> f32

Returns the current speed (magnitude of velocity).

pub fn kinetic_energy(&self) -> f32

Returns the kinetic energy of this body: 0.5 * m * v^2.

Trait Implementations

impl Clone for RigidBody

fn clone(&self) -> RigidBody

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RigidBody

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

Formats the value using the given formatter.