Struct rapier2d::dynamics::RigidBodyMut

pub struct RigidBodyMut<'a> { /* fields omitted */ }

A mutable reference to a rigid-body.

Methods from Deref<Target = RigidBody>

pub fn colliders(&self) -> &[ColliderHandle]

The handles of colliders attached to this rigid body.

pub fn is_dynamic(&self) -> bool

Is this rigid body dynamic?

A dynamic body can move freely and is affected by forces.

pub fn is_kinematic(&self) -> bool

Is this rigid body kinematic?

A kinematic body can move freely but is not affected by forces.

pub fn is_static(&self) -> bool

Is this rigid body static?

A static body cannot move and is not affected by forces.

pub fn mass(&self) -> f32

The mass of this rigid body.

Returns zero if this rigid body has an infinite mass.

pub fn sleep(&mut self)

Put this rigid body to sleep.

A sleeping body no longer moves and is no longer simulated by the physics engine unless it is waken up. It can be woken manually with self.wake_up or automatically due to external forces like contacts.

pub fn wake_up(&mut self)

Wakes up this rigid body if it is sleeping.

pub fn is_sleeping(&self) -> bool

Is this rigid body sleeping?

pub fn set_position(&mut self, pos: Isometry<f32>)

Sets the position of this rigid body.

pub fn set_next_kinematic_position(&mut self, pos: Isometry<f32>)

If this rigid body is kinematic, sets its future position after the next timestep integration.

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

Applies a force at the center-of-mass of this rigid-body.

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

Applies an impulse at the center-of-mass of this rigid-body.

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

Applies a torque at the center-of-mass of this rigid-body.

pub fn apply_torque_impulse(&mut self, torque_impulse: f32)

Applies an impulsive torque at the center-of-mass of this rigid-body.

pub fn apply_force_at_point(&mut self, force: Vector<f32>, point: Point<f32>)

Applies a force at the given world-space point of this rigid-body.

pub fn apply_impulse_at_point(
    &mut self,
    impulse: Vector<f32>,
    point: Point<f32>
)

Applies an impulse at the given world-space point of this rigid-body.

Trait Implementations

impl<'a> Deref for RigidBodyMut<'a>

type Target = RigidBody

The resulting type after dereferencing.

fn deref(&self) -> &RigidBody

Dereferences the value.

impl<'a> DerefMut for RigidBodyMut<'a>

fn deref_mut(&mut self) -> &mut RigidBody

Mutably dereferences the value.

impl<'a> Drop for RigidBodyMut<'a>

fn drop(&mut self)

Executes the destructor for this type.