Struct RigidBody2D 

pub struct RigidBody2D {
    pub id: u64,
    pub position: Vector2D,
    pub velocity: Vector2D,
    pub force_accumulator: Vector2D,
    pub angular_velocity: f64,
    pub mass: f64,
    pub inverse_mass: f64,
    pub friction: f64,
    pub body_type: BodyType,
    /* private fields */
}

A 2D rigid body participating in the physics simulation.

Fields

id: u64

The unique identifier of this body, typically matching a game object ID.

position: Vector2D

The world-space position of the body’s center.

velocity: Vector2D

The linear velocity in pixels per second.

force_accumulator: Vector2D

The accumulated force to be applied during the next physics step.

angular_velocity: f64

The angular velocity in radians per second.

mass: f64

The mass of the body in kilograms. Static bodies have a mass of 0.

inverse_mass: f64

The precomputed inverse mass (1/mass). Static bodies have 0 inverse mass.

friction: f64

The friction coefficient for surface contact.

body_type: BodyType

How this body participates in the simulation.

Implementations

impl RigidBody2D

Implements body creation and force management for RigidBody2D.

pub fn new_dynamic(id: u64, position: Vector2D) -> RigidBody2D

Creates a new dynamic rigid body with default mass and the given position.

Arguments

• u64 - The unique ID.
• Vector2D - The initial position.

Returns

• RigidBody2D - The new body.

pub fn new_static(id: u64, position: Vector2D) -> RigidBody2D

Creates a new static rigid body at the given position with infinite mass.

Arguments

• u64 - The unique ID.
• Vector2D - The position.

Returns

• RigidBody2D - The new static body.

pub fn apply_force(&mut self, force: Vector2D)

Applies a force to the body’s force accumulator.

Arguments

• Vector2D - The force vector.

pub fn apply_impulse(&mut self, impulse: Vector2D)

Applies an instantaneous impulse, directly changing velocity.

Arguments

• Vector2D - The impulse vector.

pub fn update_mass(&mut self, mass: f64)

Sets the mass of the body, updating the inverse mass. A mass of 0 makes the body static (infinite mass).

Arguments

• f64 - The new mass.

pub fn is_dynamic(&self) -> bool

Returns true if this body is affected by forces and collisions.

Returns

• bool - True if the body is dynamic.

pub fn update_collider(&mut self, collider: BodyCollider)

Attaches a collider shape to this body.

Arguments

• BodyCollider - The collider to attach.

pub fn bounding_box(&self) -> Option<Rect>

Returns the world-space bounding box of the attached collider, if any.

Returns

• Option<Rect> - The bounding box, or None if no collider is attached.

impl RigidBody2D

pub fn get_id(&self) -> u64

pub fn get_position(&self) -> Vector2D

pub fn set_position(&mut self, val: Vector2D) -> &mut Self

pub fn get_velocity(&self) -> Vector2D

pub fn set_velocity(&mut self, val: Vector2D) -> &mut Self

pub fn get_force_accumulator(&self) -> Vector2D

pub fn get_angular_velocity(&self) -> f64

pub fn get_mass(&self) -> f64

pub fn get_inverse_mass(&self) -> f64

pub fn set_friction(&mut self, val: f64) -> &mut Self

pub fn get_body_type(&self) -> BodyType

impl RigidBody2D

pub fn new( id: u64, position: Vector2D, mass: f64, inverse_mass: f64, restitution: f64, friction: f64, body_type: BodyType, ) -> Self

Trait Implementations

impl Clone for RigidBody2D

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RigidBody2D

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

Formats the value using the given formatter.

impl PartialEq for RigidBody2D

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RigidBody2D