Struct RapierContextJoints 

pub struct RapierContextJoints {
    pub impulse_joints: ImpulseJointSet,
    pub multibody_joints: MultibodyJointSet,
    /* private fields */
}

The sets of joints part of the simulation.

This should be attached on an entity with a RapierContextSimulation

With the serde-serialize feature, the entity-to-handle maps aren’t serialized: they are rebuilt from the joints’ user-data on deserialization (see Self::rebuild_entity_maps).

Fields

impulse_joints: ImpulseJointSet

The set of impulse joints part of the simulation.

multibody_joints: MultibodyJointSet

The set of multibody joints part of the simulation.

Implementations

impl RapierContextJoints

pub fn rebuild_entity_maps(&mut self)

Rebuilds the maps from entities to impulse and multibody joint handles from the user-data of the joints, which contain the bits of their entity.

This is called automatically when deserializing this component. Call it manually after replacing the joint sets with sets restored in another way.

pub fn entity2impulse_joint(&self) -> &HashMap<Entity, ImpulseJointHandle>

The map from entities to impulse joint handles.

pub fn entity2multibody_joint(&self) -> &HashMap<Entity, MultibodyJointHandle>

The map from entities to multibody joint handles.

pub fn entity_from_impulse_joint(joint: &RapierImpulseJoint) -> Entity

Retrieve the entity containing the ImpulseJoint component the given Rapier impulse joint was created from.

pub fn impulse_joint_entity(&self, handle: ImpulseJointHandle) -> Option<Entity>

Retrieve the entity containing the ImpulseJoint component of the Rapier impulse joint identified by the given handle.

pub fn impulse_joint_impulses( &self, entity: Entity, ) -> Option<ImpulseJointImpulses>

The impulses applied during the last simulation step by the ImpulseJoint of entity.

This is the value written back into the ImpulseJointImpulses component after each step. Returns None if entity has no impulse joint.

pub fn impulse_joints_between<'a>( &'a self, rigidbody_set: &RapierRigidBodySet, body1: Entity, body2: Entity, ) -> impl Iterator<Item = Entity> + 'a

Iterates through the entities of all the impulse joints attaching the rigid-bodies of body1 and body2 (in any order).

pub fn attached_impulse_joints<'a>( &'a self, rigidbody_set: &RapierRigidBodySet, body: Entity, ) -> impl Iterator<Item = Entity> + 'a

Iterates through the entities of all the impulse joints attached to the rigid-body of body, including disabled joints.

pub fn attached_enabled_impulse_joints<'a>( &'a self, rigidbody_set: &RapierRigidBodySet, body: Entity, ) -> impl Iterator<Item = Entity> + 'a

Iterates through the entities of the enabled impulse joints attached to the rigid-body of body.

pub fn entity_from_multibody_joint(joint: &RapierMultibodyJoint) -> Entity

Retrieve the entity containing the MultibodyJoint component the given Rapier multibody joint was created from.

This is also the entity of the rigid-body of the link containing this joint.

pub fn multibody( &self, rigidbody_set: &RapierRigidBodySet, entity: Entity, ) -> Option<(&Multibody, usize)>

The multibody containing the rigid-body of entity, and the index of the link of that rigid-body in the multibody.

The root rigid-body of a multibody is its link 0. Returns None if the rigid-body is not attached to any MultibodyJoint.

pub fn multibody_mut( &mut self, rigidbody_set: &RapierRigidBodySet, entity: Entity, ) -> Option<(&mut Multibody, usize)>

The multibody containing the rigid-body of entity, and the index of the link of that rigid-body in the multibody, for modification.

Note that Rapier doesn’t wake up the multibody automatically after a modification.

pub fn multibody_root( &self, rigidbody_set: &RapierRigidBodySet, entity: Entity, ) -> Option<Entity>

The entity of the root rigid-body of the multibody containing the rigid-body of entity.

pub fn multibody_links<'a>( &'a self, rigidbody_set: &'a RapierRigidBodySet, entity: Entity, ) -> impl Iterator<Item = Entity> + 'a

Iterates through the entities of the rigid-bodies of all the links of the multibody containing the rigid-body of entity.

The root comes first, and each link is yielded before its descendants. All the entities except the root contain the MultibodyJoint attaching them to their parent link: to remove all the joints of a multibody (like Rapier’s MultibodyJointSet::remove_multibody_articulations), remove the MultibodyJoint component from these entities (for example with .skip(1)).

pub fn multibody_parent_link( &self, rigidbody_set: &RapierRigidBodySet, entity: Entity, ) -> Option<Entity>

The entity of the rigid-body of the parent link of the rigid-body of entity in its multibody.

Returns None if entity is the root of its multibody, or isn’t part of any multibody.

pub fn multibody_joint_between( &self, rigidbody_set: &RapierRigidBodySet, body1: Entity, body2: Entity, ) -> Option<Entity>

The entity of the MultibodyJoint attaching the rigid-bodies of body1 and body2 (in any order), if any.

pub fn attached_multibody_joints<'a>( &'a self, rigidbody_set: &'a RapierRigidBodySet, body: Entity, ) -> impl Iterator<Item = Entity> + 'a

Iterates through the entities of all the multibody joints attached to the rigid-body of body: the joint attaching it to its parent link (if any), and the joints of its child links.

pub fn multibody_link_dofs( &self, rigidbody_set: &RapierRigidBodySet, entity: Entity, ) -> Option<Range<usize>>

The range of the degrees of freedom of the link of entity in the generalized coordinates, velocities and displacements of its multibody.

The degrees of freedom of a joint are its free axes, in JointAxis order.

pub fn multibody_generalized_velocity( &self, rigidbody_set: &RapierRigidBodySet, entity: Entity, ) -> Option<&[f32]>

The generalized velocities of the multibody containing the rigid-body of entity.

See Self::multibody_link_dofs for the range of each link in this slice.

pub fn multibody_generalized_velocity_mut( &mut self, rigidbody_set: &mut RapierRigidBodySet, entity: Entity, ) -> Option<&mut [f32]>

The generalized velocities of the multibody containing the rigid-body of entity, for modification.

This wakes up the rigid-bodies of the multibody.

pub fn multibody_joint_velocity_mut( &mut self, rigidbody_set: &mut RapierRigidBodySet, entity: Entity, ) -> Option<&mut [f32]>

The generalized velocities of the MultibodyJoint of entity, one per free axis in JointAxis order, for modification.

This is typically used to drive a KinematicMultibodyJoint. This wakes up the rigid-bodies of the multibody.

pub fn multibody_joint_state( &self, entity: Entity, ) -> Option<MultibodyJointState>

The state of the MultibodyJoint of entity.

This is the value written back into the MultibodyJointState component after each step.

pub fn multibody_body_jacobian( &self, rigidbody_set: &RapierRigidBodySet, entity: Entity, ) -> Option<&Jacobian<f32>>

The jacobian of the link of entity, mapping the generalized velocities of its multibody to the link’s world-space linear and angular velocities.

This is computed by the last forward kinematics (see Self::multibody_forward_kinematics), which runs at each simulation step.

pub fn multibody_apply_displacements( &mut self, rigidbody_set: &RapierRigidBodySet, entity: Entity, displacements: &[f32], ) -> bool

Applies displacements, in generalized coordinates, to the multibody containing the rigid-body of entity.

displacements must contain one value per degree of freedom of the multibody. This only modifies the joint coordinates: call Self::multibody_forward_kinematics to update the rigid-bodies. Returns false if entity isn’t part of a multibody or the number of displacements doesn’t match.

pub fn multibody_forward_kinematics( &mut self, rigidbody_set: &mut RapierRigidBodySet, entity: Entity, read_root_pose_from_rigid_body: bool, ) -> bool

Runs forward kinematics on the multibody containing the rigid-body of entity, and moves its rigid-bodies to the resulting poses.

Set read_root_pose_from_rigid_body if the root rigid-body was moved and the multibody should follow. The Transform of the rigid-bodies are updated during the next writeback (after the next simulation step). Returns false if entity isn’t part of a multibody.

pub fn multibody_inverse_kinematics( &self, rigidbody_set: &RapierRigidBodySet, link: Entity, target: Transform, options: &InverseKinematicsOption, joint_can_move: impl Fn(Entity) -> bool, displacements: &mut Vec<f32>, ) -> bool

Computes the displacements, in generalized coordinates, moving the link of link as close as possible to the world-space target pose, with a jacobian-based inverse kinematics solver.

displacements is an output buffer: it is cleared and resized to the number of degrees of freedom of the multibody (see Self::multibody_link_dofs), so the solver always starts from the current configuration, then filled with the result, which can then be applied with Self::multibody_apply_displacements. The same buffer can be reused across calls without resetting it. Only the joints for which joint_can_move returns true are moved; it is called with the entity of each link between the root (included) and link. Returns false if link isn’t part of a multibody.

Trait Implementations

impl Clone for RapierContextJoints

fn clone(&self) -> RapierContextJoints

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for RapierContextJoints

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 Debug for RapierContextJoints

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

Formats the value using the given formatter.

impl Default for RapierContextJoints

fn default() -> RapierContextJoints

Returns the “default value” for a type.