Struct RapierRigidBodySet 

pub struct RapierRigidBodySet {
    pub bodies: RigidBodySet,
    pub soft_bodies: SoftBodySet,
    /* private fields */
}

The set of rigid-bodies part of the simulation.

This should be attached on an entity with a RapierContextSimulation

With the serde-serialize feature, the entity-to-handle map isn’t serialized: it is rebuilt from the rigid-bodies’ user-data on deserialization (see Self::rebuild_entity_maps).

Fields

bodies: RigidBodySet

The set of rigid-bodies part of the simulation.

soft_bodies: SoftBodySet

The set of soft-bodies part of the simulation.

Implementations

impl RapierRigidBodySet

pub fn rebuild_entity_maps(&mut self)

Rebuilds the map from entities to rigid-body handles from the user-data of the rigid-bodies, which contain the bits of their entity.

This is called automatically when deserializing this component. Call it manually after replacing Self::bodies with a set restored in another way. The transform change detection state is reset, so the next GlobalTransform change of a rigid-body entity is applied to its rigid-body.

The soft-body map is rebuilt from the soft bodies’ user-data too. The hidden proxy rigid-bodies of the soft bodies are not mapped, except the proxies of the clusters that have their own entity (see SoftBodyCluster) and the whole-body proxy of each soft body (see Self::soft_body_whole_proxy).

pub fn soft_body_colliders( &self, colliders: &ColliderSet, entity: Entity, ) -> Option<Vec<ColliderHandle>>

The colliders standing for the soft body of entity: the colliders of its collision meshes (or of its particles), attached to its proxies and reporting entity as their entity. The colliders attached by the user to its proxies (e.g. DeformableColliders or children colliders) are not included.

Returns None if entity has no soft body.

pub fn entity2soft_body(&self) -> &HashMap<Entity, SoftBodyHandle>

The map from entities to soft-body handles.

pub fn soft_body_entity(&self, handle: SoftBodyHandle) -> Option<Entity>

Retrieve the Bevy entity of the given Rapier soft body (identified by its handle).

pub fn soft_body(&self, entity: Entity) -> Option<&RapierSoftBody>

The Rapier soft body attached to the given entity, if any.

pub fn soft_body_mut(&mut self, entity: Entity) -> Option<&mut RapierSoftBody>

The Rapier soft body attached to the given entity, if any.

This gives access to every setter of the soft body (particle positions, velocities and kinematic targets, pinning, forces, impulses, clusters…). Prefer the soft-body components (e.g. SoftBodyMaterial) for the properties they cover, since they are applied again whenever they change.

pub fn soft_body_particle_positions( &self, entity: Entity, ) -> Option<impl ExactSizeIterator<Item = Vect> + '_>

The world-space positions of the particles of the soft body of entity.

Returns None if entity has no soft body.

pub fn soft_body_particle_velocities( &self, entity: Entity, ) -> Option<impl ExactSizeIterator<Item = Vect> + '_>

The world-space velocities of the particles of the soft body of entity.

Returns None if entity has no soft body.

pub fn soft_body_volume(&self, entity: Entity) -> Option<f32>

The area (2D) or volume (3D) currently enclosed by the soft body of entity (0.0 for a soft body without closed boundary).

Returns None if entity has no soft body.

pub fn soft_body_mass(&self, entity: Entity) -> Option<f32>

The total mass of the particles of the soft body of entity.

Returns None if entity has no soft body.

pub fn soft_body_center_of_mass(&self, entity: Entity) -> Option<Vect>

The world-space, mass-weighted, center of the particles of the soft body of entity.

Returns None if entity has no soft body.

pub fn is_soft_body_sleeping(&self, entity: Entity) -> Option<bool>

Whether the soft body of entity is sleeping.

Returns None if entity has no soft body.

pub fn wake_up_soft_body(&mut self, entity: Entity, strong: bool) -> bool

Wakes up the soft body of entity (effective at the start of the next step, together with the island of the bodies it touches).

Returns false if entity has no soft body.

pub fn soft_body_cluster_proxy( &self, entity: Entity, cluster: u32, ) -> Option<RigidBodyHandle>

The proxy rigid-body of the cluster cluster of the soft body of entity.

The cluster 0 is the whole-body cluster created with the soft body. Returns None if entity has no soft body or if that cluster doesn’t exist.

pub fn soft_body_whole_proxy(&self, entity: Entity) -> Option<RigidBodyHandle>

The whole-body proxy rigid-body of the soft body of entity: the proxy of its cluster covering all its particles, which entity is mapped to in Self::entity2body.

This lets the soft body entity be used like a rigid-body entity by impulse joints (as their parent, or on the soft body entity itself). Returns None if entity has no soft body.

pub fn soft_body_cluster_index( &self, entity: Entity, ) -> Option<(SoftBodyHandle, u32)>

The soft body and the index of the cluster standing for entity: a SoftBodyCluster entity, or a soft body entity (for its whole-body cluster).

The index can be given to the cluster methods of RapierSoftBody (e.g. RapierSoftBody::set_cluster_pinned). It may change when the soft body tears, so it should not be stored. Returns None if entity doesn’t stand for a live cluster.

pub fn entity2body(&self) -> &HashMap<Entity, RigidBodyHandle>

The map from entities to rigid-body handles.

pub fn rigid_body_entity(&self, handle: RigidBodyHandle) -> Option<Entity>

Retrieve the Bevy entity the given Rapier rigid-body (identified by its handle) is attached.

pub fn propagate_modified_body_positions_to_colliders( &self, colliders: &mut RapierContextColliders, )

This method makes sure that the rigid-body positions have been propagated to their attached colliders, without having to perform a simulation step.

pub fn impulse_revolute_joint_angle( &self, joints: &RapierContextJoints, entity: Entity, ) -> Option<f32>

Computes the angle between the two bodies attached by the RevoluteJoint component (if any) referenced by the given entity.

The angle is computed along the revolute joint’s principal axis.

Parameter entity should have a ImpulseJoint component with a TypedJoint::RevoluteJoint variant as data.

pub fn velocity_at_point(&self, entity: Entity, point: Vect) -> Option<Vect>

The linear velocity of the given world-space point, assuming it is rigidly attached to the rigid-body of entity.

Unlike crate::dynamics::Velocity::linear_velocity_at_point, this uses the center of mass computed by Rapier. Returns None if entity has no rigid-body.

pub fn is_moving(&self, entity: Entity) -> Option<bool>

Returns true if the rigid-body of entity has a non-zero linear or angular velocity.

Returns None if entity has no rigid-body.

pub fn is_ccd_active(&self, entity: Entity) -> Option<bool>

Returns true if CCD is active for the rigid-body of entity, i.e., if it moved fast enough during the last step to justify a CCD run.

Returns None if entity has no rigid-body.

pub fn next_position(&self, entity: Entity) -> Option<Transform>

The next position of the rigid-body of entity.

For kinematic rigid-bodies, this is the position set by the user for the next step. For other rigid-bodies, this value is currently unspecified. The returned transform has a unit scale. Returns None if entity has no rigid-body.

pub fn predict_position_using_velocity_and_forces( &self, entity: Entity, dt: f32, ) -> Option<Transform>

Predicts the position of the rigid-body of entity after dt seconds, by integrating its current velocity and forces (including gravity).

The returned transform has a unit scale. Returns None if entity has no rigid-body.

pub fn predict_position_using_velocity( &self, entity: Entity, dt: f32, ) -> Option<Transform>

Predicts the position of the rigid-body of entity after dt seconds, by integrating its current velocity only (forces are ignored).

The returned transform has a unit scale. Returns None if entity has no rigid-body.

pub fn kinetic_energy(&self, entity: Entity) -> Option<f32>

The kinetic energy of the rigid-body of entity.

Returns None if entity has no rigid-body.

pub fn gravitational_potential_energy( &self, entity: Entity, dt: f32, gravity: Vect, ) -> Option<f32>

The gravitational potential energy of the rigid-body of entity.

The position is projected back by half a timestep dt so the result is synchronized with Self::kinetic_energy. Returns None if entity has no rigid-body.

pub fn user_force(&self, entity: Entity) -> Option<Vect>

The total user force applied to the rigid-body of entity (e.g. from its crate::dynamics::ExternalForce component).

This is zero for non-dynamic rigid-bodies. Returns None if entity has no rigid-body.

pub fn user_torque(&self, entity: Entity) -> Option<f32>

The total user torque applied to the rigid-body of entity (e.g. from its crate::dynamics::ExternalForce component).

This is zero for non-dynamic rigid-bodies. Returns None if entity has no rigid-body.

pub fn effective_dominance_group(&self, entity: Entity) -> Option<i16>

The dominance group actually used by the solver for the rigid-body of entity.

This is i8::MAX + 1 for non-dynamic rigid-bodies. Returns None if entity has no rigid-body.

pub fn center_of_mass(&self, entity: Entity) -> Option<Vect>

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

Returns None if entity has no rigid-body.

pub fn mass(&self, entity: Entity) -> Option<f32>

The mass of the rigid-body of entity (including the contributions of its colliders).

This is zero for rigid-bodies without mass. Returns None if entity has no rigid-body.

Trait Implementations

impl Clone for RapierRigidBodySet

fn clone(&self) -> RapierRigidBodySet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for RapierRigidBodySet

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = ::bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

type Mutability = Mutable

A marker type to assist Bevy with determining if this component is mutable, or immutable. Mutable components will have Component<Mutability = Mutable>, while immutable components will instead have Component<Mutability = Immutable>.

fn register_required_components( _requiree: ComponentId, required_components: &mut RequiredComponentsRegistrator<'_, '_>, )

Registers required components.

fn clone_behavior() -> ComponentCloneBehavior

Called when registering this component, allowing to override clone function (or disable cloning altogether) for this component.

fn relationship_accessor() -> Option<ComponentRelationshipAccessor<Self>>

Returns ComponentRelationshipAccessor required for working with relationships in dynamic contexts.

fn on_add() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_add ComponentHook for this Component if one is defined.

fn on_insert() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_insert ComponentHook for this Component if one is defined.

fn on_discard() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_discard ComponentHook for this Component if one is defined.

fn on_remove() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_remove ComponentHook for this Component if one is defined.

fn on_despawn() -> Option<for<'w> fn(DeferredWorld<'w>, HookContext)>

Gets the on_despawn ComponentHook for this Component if one is defined.

fn map_entities<E>(_this: &mut Self, _mapper: &mut E)

where E: EntityMapper,

Maps the entities on this component using the given EntityMapper. This is used to remap entities in contexts like scenes and entity cloning. When deriving Component, this is populated by annotating fields containing entities with #[entities]

const HAS_SUMMARY_TICK: bool = false

Set this constant to true if the component should track a summary tick.

impl Default for RapierRigidBodySet

fn default() -> RapierRigidBodySet

Returns the “default value” for a type.