Struct rapier2d::dynamics::RigidBody

pub struct RigidBody {
    pub world_com: Point<Real>,
    pub effective_inv_mass: Real,
    pub effective_world_inv_inertia_sqrt: AngularInertia<Real>,
    pub linear_damping: Real,
    pub angular_damping: Real,
    pub activation: ActivationStatus,
    pub user_data: u128,
    // some fields omitted
}

A rigid body.

To create a new rigid-body, use the RigidBodyBuilder structure.

Fields

world_com: Point<Real>

The world-space center of mass of the rigid-body.

effective_inv_mass: Real

The inverse mass taking into account translation locking.

effective_world_inv_inertia_sqrt: AngularInertia<Real>

The square-root of the world-space inverse angular inertia tensor of the rigid-body, taking into account rotation locking.

linear_damping: Real

Damping factor for gradually slowing down the translational motion of the rigid-body.

angular_damping: Real

Damping factor for gradually slowing down the angular motion of the rigid-body.

activation: ActivationStatus

Whether or not this rigid-body is sleeping.

user_data: u128

User-defined data associated to this rigid-body.

Implementations

impl RigidBody

pub fn body_status(&self) -> BodyStatus

The status of this rigid-body.

pub fn set_body_status(&mut self, status: BodyStatus)

Sets the status of this rigid-body.

pub fn mass_properties(&self) -> &MassProperties

The mass properties of this rigid-body.

pub fn effective_dominance_group(&self) -> i16

The dominance group of this rigid-body.

This method always returns i8::MAX + 1 for non-dynamic rigid-bodies.

pub fn is_translation_locked(&self) -> bool

Are the translations of this rigid-body locked?

pub fn is_rotation_locked(&self) -> bool

Are the rotations of this rigid-body locked?

pub fn enable_ccd(&mut self, enabled: bool)

Enables of disable CCD (continuous collision-detection) for this rigid-body.

pub fn is_ccd_enabled(&self) -> bool

Is CCD (continous collision-detection) enabled for this rigid-body?

pub fn is_ccd_active(&self) -> bool

Is CCD active for this rigid-body?

The CCD is considered active if the rigid-body is moving at a velocity greater than an automatically-computed threshold.

This is not the same as self.is_ccd_enabled which only checks if CCD is allowed to run for this rigid-body or if it is completely disabled (independently from its velocity).

pub fn set_mass_properties(&mut self, props: MassProperties, wake_up: bool)

Sets the rigid-body’s initial mass properties.

If wake_up is true then the rigid-body will be woken up if it was put to sleep because it did not move for a while.

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) -> Real

The mass of this rigid body.

Returns zero if this rigid body has an infinite mass.

pub fn next_position(&self) -> &Isometry<Real>

The predicted position of this rigid-body.

If this rigid-body is kinematic this value is set by the set_next_kinematic_position method and is used for estimating the kinematic body velocity at the next timestep. For non-kinematic bodies, this value is currently unspecified.

pub fn gravity_scale(&self) -> Real

The scale factor applied to the gravity affecting this rigid-body.

pub fn set_gravity_scale(&mut self, scale: Real, wake_up: bool)

Sets the gravity scale facter for this rigid-body.

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, strong: bool)

Wakes up this rigid body if it is sleeping.

If strong is true then it is assured that the rigid-body will remain awake during multiple subsequent timesteps.

pub fn is_sleeping(&self) -> bool

Is this rigid body sleeping?

pub fn is_moving(&self) -> bool

Is the velocity of this body not zero?

pub fn predict_position_using_velocity_and_forces(
    &self,
    dt: Real
) -> Isometry<Real>

Computes the predict position of this rigid-body after dt seconds, taking into account its velocities and external forces applied to it.

pub fn linvel(&self) -> &Vector<Real>

The linear velocity of this rigid-body.

pub fn angvel(&self) -> Real

The angular velocity of this rigid-body.

pub fn set_linvel(&mut self, linvel: Vector<Real>, wake_up: bool)

The linear velocity of this rigid-body.

If wake_up is true then the rigid-body will be woken up if it was put to sleep because it did not move for a while.

pub fn set_angvel(&mut self, angvel: Real, wake_up: bool)

The angular velocity of this rigid-body.

If wake_up is true then the rigid-body will be woken up if it was put to sleep because it did not move for a while.

pub fn position(&self) -> &Isometry<Real>

The world-space position of this rigid-body.

pub fn set_position(&mut self, pos: Isometry<Real>, wake_up: bool)

Sets the position and next_kinematic_position of this rigid body.

This will teleport the rigid-body to the specified position/orientation, completely ignoring any physics rule. If this body is kinematic, this will also set the next kinematic position to the same value, effectively resetting to zero the next interpolated velocity of the kinematic body.

If wake_up is true then the rigid-body will be woken up if it was put to sleep because it did not move for a while.

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

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

impl RigidBody

Applying forces and torques

pub fn apply_force(&mut self, force: Vector<Real>, wake_up: bool)

Applies a force at the center-of-mass of this rigid-body. The force will be applied in the next simulation step. This does nothing on non-dynamic bodies.

pub fn apply_torque(&mut self, torque: Real, wake_up: bool)

Applies a torque at the center-of-mass of this rigid-body. The torque will be applied in the next simulation step. This does nothing on non-dynamic bodies.

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

Applies a force at the given world-space point of this rigid-body. The force will be applied in the next simulation step. This does nothing on non-dynamic bodies.

impl RigidBody

Applying impulses and angular impulses

pub fn apply_impulse(&mut self, impulse: Vector<Real>, wake_up: bool)

Applies an impulse at the center-of-mass of this rigid-body. The impulse is applied right away, changing the linear velocity. This does nothing on non-dynamic bodies.

pub fn apply_torque_impulse(&mut self, torque_impulse: Real, wake_up: bool)

Applies an angular impulse at the center-of-mass of this rigid-body. The impulse is applied right away, changing the angular velocity. This does nothing on non-dynamic bodies.

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

Applies an impulse at the given world-space point of this rigid-body. The impulse is applied right away, changing the linear and/or angular velocities. This does nothing on non-dynamic bodies.

impl RigidBody

pub fn velocity_at_point(&self, point: &Point<Real>) -> Vector<Real>

The velocity of the given world-space point on this rigid-body.

pub fn kinetic_energy(&self) -> Real

The kinetic energy of this body.

pub fn gravitational_potential_energy(
    &self,
    dt: Real,
    gravity: Vector<Real>
) -> Real

The potential energy of this body in a gravity field.

Trait Implementations

impl Clone for RigidBody

fn clone(&self) -> RigidBody

Returns a copy of the value.

pub 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.