Struct jumpy::core::physics::rapier::RigidBody

pub struct RigidBody {

    pub(crate) pos: RigidBodyPosition,
    pub(crate) mprops: RigidBodyMassProps,
    pub(crate) integrated_vels: RigidBodyVelocity,
    pub(crate) vels: RigidBodyVelocity,
    pub(crate) damping: RigidBodyDamping,
    pub(crate) forces: RigidBodyForces,
    pub(crate) ccd: RigidBodyCcd,
    pub(crate) ids: RigidBodyIds,
    pub(crate) colliders: RigidBodyColliders,
    pub(crate) activation: RigidBodyActivation,
    pub(crate) changes: RigidBodyChanges,
    pub(crate) body_type: RigidBodyType,
    pub(crate) dominance: RigidBodyDominance,
    pub(crate) enabled: bool,
    pub(crate) additional_solver_iterations: usize,
    pub user_data: u128,
}

A rigid body.

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

Fields

pos: RigidBodyPosition

mprops: RigidBodyMassProps

integrated_vels: RigidBodyVelocity

vels: RigidBodyVelocity

damping: RigidBodyDamping

forces: RigidBodyForces

ccd: RigidBodyCcd

ids: RigidBodyIds

colliders: RigidBodyColliders

activation: RigidBodyActivation

changes: RigidBodyChanges

body_type: RigidBodyType

dominance: RigidBodyDominance

enabled: bool

additional_solver_iterations: usize

user_data: u128

User-defined data associated to this rigid-body.

Implementations

impl RigidBody

pub fn copy_from(&mut self, other: &RigidBody)

Copy all the characteristics from other to self.

If you have a mutable reference to a rigid-body rigid_body: &mut RigidBody, attempting to assign it a whole new rigid-body instance, e.g., *rigid_body = RigidBodyBuilder::dynamic().build(), will crash due to some internal indices being overwritten. Instead, use rigid_body.copy_from(&RigidBodyBuilder::dynamic().build()).

This method will allow you to set most characteristics of this rigid-body from another rigid-body instance without causing any breakage.

This method cannot be used for editing the list of colliders attached to this rigid-body. Therefore, the list of colliders attached to self won’t be replaced by the one attached to other.

The pose of other will only copied into self if self doesn’t have a parent (if it has a parent, its position is directly controlled by the parent rigid-body).

pub fn additional_solver_iterations(&self) -> usize

Set the additional number of solver iterations run for this rigid-body and everything interacting with it.

See Self::set_additional_solver_iterations for additional information.

pub fn set_additional_solver_iterations(&mut self, additional_iterations: usize)

Set the additional number of solver iterations run for this rigid-body and everything interacting with it.

Increasing this number will help improve simulation accuracy on this rigid-body and every rigid-body interacting directly or indirectly with it (through joints or contacts). This implies a performance hit.

The default value is 0, meaning exactly [IntegrationParameters::num_solver_iterations] will be used as number of solver iterations for this body.

pub fn activation(&self) -> &RigidBodyActivation

The activation status of this rigid-body.

pub fn activation_mut(&mut self) -> &mut RigidBodyActivation

Mutable reference to the activation status of this rigid-body.

pub fn is_enabled(&self) -> bool

Is this rigid-body enabled?

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

Sets whether this rigid-body is enabled or not.

pub fn linear_damping(&self) -> f32

The linear damping coefficient of this rigid-body.

pub fn set_linear_damping(&mut self, damping: f32)

Sets the linear damping coefficient of this rigid-body.

pub fn angular_damping(&self) -> f32

The angular damping coefficient of this rigid-body.

pub fn set_angular_damping(&mut self, damping: f32)

Sets the angular damping coefficient of this rigid-body.

pub fn body_type(&self) -> RigidBodyType

The type of this rigid-body.

pub fn set_body_type(&mut self, status: RigidBodyType, wake_up: bool)

Sets the type of this rigid-body.

pub fn center_of_mass(&self) -> &OPoint<f32, Const<2>>

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

pub fn mass_properties(&self) -> &RigidBodyMassProps

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 set_locked_axes(&mut self, locked_axes: LockedAxes, wake_up: bool)

Sets the axes along which this rigid-body cannot translate or rotate.

pub fn locked_axes(&self) -> LockedAxes

The axes along which this rigid-body cannot translate or rotate.

pub fn lock_rotations(&mut self, locked: bool, wake_up: bool)

Locks or unlocks all the rotations of this rigid-body.

pub fn set_enabled_rotations( &mut self, allow_rotations_x: bool, allow_rotations_y: bool, allow_rotations_z: bool, wake_up: bool, )

Locks or unlocks rotations of this rigid-body along each cartesian axes.

pub fn restrict_rotations( &mut self, allow_rotations_x: bool, allow_rotations_y: bool, allow_rotations_z: bool, wake_up: bool, )

👎Deprecated: Use set_enabled_rotations instead

Locks or unlocks rotations of this rigid-body along each cartesian axes.

pub fn lock_translations(&mut self, locked: bool, wake_up: bool)

Locks or unlocks all the rotations of this rigid-body.

pub fn set_enabled_translations( &mut self, allow_translation_x: bool, allow_translation_y: bool, wake_up: bool, )

Locks or unlocks rotations of this rigid-body along each cartesian axes.

pub fn restrict_translations( &mut self, allow_translation_x: bool, allow_translation_y: bool, wake_up: bool, )

👎Deprecated: Use set_enabled_translations instead

Locks or unlocks rotations of this rigid-body along each cartesian axes.

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.

CCD prevents tunneling, but may still allow limited interpenetration of colliders.

pub fn is_ccd_enabled(&self) -> bool

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

pub fn set_soft_ccd_prediction(&mut self, prediction_distance: f32)

Sets the maximum prediction distance Soft Continuous Collision-Detection.

When set to 0, soft-CCD is disabled. Soft-CCD helps prevent tunneling especially of slow-but-thin to moderately fast objects. The soft CCD prediction distance indicates how far in the object’s path the CCD algorithm is allowed to inspect. Large values can impact performance badly by increasing the work needed from the broad-phase.

It is a generally cheaper variant of regular CCD (that can be enabled with RigidBody::enable_ccd since it relies on predictive constraints instead of shape-cast and substeps.

pub fn soft_ccd_prediction(&self) -> f32

The soft-CCD prediction distance for this rigid-body.

See the documentation of RigidBody::set_soft_ccd_prediction for additional details on soft-CCD.

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 enabled to run for this rigid-body or if it is completely disabled (independently from its velocity).

pub fn recompute_mass_properties_from_colliders( &mut self, colliders: &ColliderSet, )

Recompute the mass-properties of this rigid-bodies based on its currently attached colliders.

pub fn set_additional_mass(&mut self, additional_mass: f32, wake_up: bool)

Sets the rigid-body’s additional mass.

The total angular inertia of the rigid-body will be scaled automatically based on this additional mass. If this scaling effect isn’t desired, use Self::set_additional_mass_properties instead of this method.

This is only the “additional” mass because the total mass of the rigid-body is equal to the sum of this additional mass and the mass computed from the colliders (with non-zero densities) attached to this rigid-body.

That total mass (which includes the attached colliders’ contributions) will be updated at the name physics step, or can be updated manually with Self::recompute_mass_properties_from_colliders.

This will override any previous mass-properties set by Self::set_additional_mass, Self::set_additional_mass_properties, RigidBodyBuilder::additional_mass, or RigidBodyBuilder::additional_mass_properties for 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_additional_mass_properties( &mut self, props: MassProperties, wake_up: bool, )

Sets the rigid-body’s additional mass-properties.

This is only the “additional” mass-properties because the total mass-properties of the rigid-body is equal to the sum of this additional mass-properties and the mass computed from the colliders (with non-zero densities) attached to this rigid-body.

That total mass-properties (which include the attached colliders’ contributions) will be updated at the name physics step, or can be updated manually with Self::recompute_mass_properties_from_colliders.

This will override any previous mass-properties set by Self::set_additional_mass, Self::set_additional_mass_properties, RigidBodyBuilder::additional_mass, or RigidBodyBuilder::additional_mass_properties for 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 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_fixed(&self) -> bool

Is this rigid body fixed?

A fixed 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 next_position(&self) -> &Isometry<f32, Unit<Complex<f32>>, 2>

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

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

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

Sets the gravity scale facter for this rigid-body.

pub fn dominance_group(&self) -> i8

The dominance group of this rigid-body.

pub fn set_dominance_group(&mut self, dominance: i8)

The dominance group of this rigid-body.

pub fn add_collider( &mut self, co_handle: ColliderHandle, co_parent: &ColliderParent, co_pos: &mut ColliderPosition, co_shape: &SharedShape, co_mprops: &ColliderMassProps, )

Adds a collider to 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 linvel( &self, ) -> &Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>

The linear velocity of this rigid-body.

pub fn angvel(&self) -> f32

The angular velocity of this rigid-body.

pub fn set_linvel( &mut self, linvel: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, 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: f32, 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<f32, Unit<Complex<f32>>, 2>

The world-space position of this rigid-body.

pub fn translation( &self, ) -> &Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>

The translational part of this rigid-body’s position.

pub fn set_translation( &mut self, translation: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, wake_up: bool, )

Sets the translational part of this rigid-body’s position.

pub fn rotation(&self) -> &Unit<Complex<f32>>

The rotational part of this rigid-body’s position.

pub fn set_rotation(&mut self, rotation: Unit<Complex<f32>>, wake_up: bool)

Sets the rotational part of this rigid-body’s position.

pub fn set_position( &mut self, pos: Isometry<f32, Unit<Complex<f32>>, 2>, 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_rotation(&mut self, rotation: Unit<Complex<f32>>)

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

pub fn set_next_kinematic_translation( &mut self, translation: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, )

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

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

If this rigid body is kinematic, sets its future position (translation and orientation) after the next timestep integration.

pub fn predict_position_using_velocity_and_forces( &self, dt: f32, ) -> Isometry<f32, Unit<Complex<f32>>, 2>

Predicts the next position of this rigid-body, by integrating its velocity and forces by a time of dt.

pub fn predict_position_using_velocity( &self, dt: f32, ) -> Isometry<f32, Unit<Complex<f32>>, 2>

Predicts the next position of this rigid-body, by integrating only its velocity by a time of dt.

The forces that were applied to this rigid-body since the last physics step will be ignored by this function. Use Self::predict_position_using_velocity_and_forces instead to take forces into account.

impl RigidBody

Applying forces and torques

pub fn reset_forces(&mut self, wake_up: bool)

Resets to zero all the constant (linear) forces manually applied to this rigid-body.

pub fn reset_torques(&mut self, wake_up: bool)

Resets to zero all the constant torques manually applied to this rigid-body.

pub fn add_force( &mut self, force: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, wake_up: bool, )

Adds to this rigid-body a constant force applied at its center-of-mass.ç

This does nothing on non-dynamic bodies.

pub fn add_torque(&mut self, torque: f32, wake_up: bool)

Adds to this rigid-body a constant torque at its center-of-mass.

This does nothing on non-dynamic bodies.

pub fn add_force_at_point( &mut self, force: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, point: OPoint<f32, Const<2>>, wake_up: bool, )

Adds to this rigid-body a constant force at the given world-space point of this rigid-body.

This does nothing on non-dynamic bodies.

impl RigidBody

Applying impulses and angular impulses

pub fn apply_impulse( &mut self, impulse: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, 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: f32, 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: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, point: OPoint<f32, Const<2>>, 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.

pub fn user_force( &self, ) -> Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>

Retrieves the constant force(s) that the user has added to the body.

Returns zero if the rigid-body isn’t dynamic.

pub fn user_torque(&self) -> f32

Retrieves the constant torque(s) that the user has added to the body.

Returns zero if the rigid-body isn’t dynamic.

impl RigidBody

pub fn velocity_at_point( &self, point: &OPoint<f32, Const<2>>, ) -> Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>

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

pub fn kinetic_energy(&self) -> f32

The kinetic energy of this body.

pub fn gravitational_potential_energy( &self, dt: f32, gravity: Matrix<f32, Const<2>, Const<1>, ArrayStorage<f32, 2, 1>>, ) -> f32

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.

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

Performs copy-assignment from source.

impl Debug for RigidBody

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

Formats the value using the given formatter.

impl Default for RigidBody

fn default() -> RigidBody

Returns the “default value” for a type.

impl From<RigidBodyBuilder> for RigidBody

fn from(val: RigidBodyBuilder) -> RigidBody

Converts to this type from the input type.