Struct RapierContextSimulation 

pub struct RapierContextSimulation {
    pub islands: IslandManager,
    pub broad_phase: DefaultBroadPhase,
    pub narrow_phase: NarrowPhase,
    pub ccd_solver: CCDSolver,
    pub pipeline: PhysicsPipeline,
    pub collision_pipeline: CollisionPipeline,
    pub integration_parameters: IntegrationParameters,
    /* private fields */
}

The Rapier context, containing parts of the state of the physics engine, specific to the simulation step.

This is the main driver for a rapier context, which will create other required components if needed.

Additionally to its required components, this component is also always paired with a RapierConfiguration component.

Fields

islands: IslandManager

The island manager, which detects what object is sleeping (not moving much) to reduce computations.

broad_phase: DefaultBroadPhase

The broad-phase, which detects potential contact pairs.

narrow_phase: NarrowPhase

The narrow-phase, which computes contact points, tests intersections, and maintain the contact and intersection graphs.

ccd_solver: CCDSolver

The solver, which handles Continuous Collision Detection (CCD).

pipeline: PhysicsPipeline

The physics pipeline, which advance the simulation step by step.

collision_pipeline: CollisionPipeline

The collision pipeline, which only runs collision detection when the context is in SimulationMode::CollisionOnly.

integration_parameters: IntegrationParameters

The integration parameters, controlling various low-level coefficient of the simulation.

Implementations

impl RapierContextSimulation

pub fn with_broad_phase_optimization_strategy( strategy: BroadPhaseOptimizationStrategy, ) -> Self

Creates a simulation context whose broad-phase uses the given BVH optimization strategy.

This is what RapierContextInitialization::InitializeDefaultRapierContext uses for the default context.

pub fn step_stats(&self) -> &SimulationStepStats

Statistics about the simulation steps executed during the last physics update.

pub fn set_num_threads(&mut self, num_threads: Option<usize>)

Sets the number of threads of the thread pool dedicated to this context’s simulation, or removes that pool if num_threads is None.

The pool is only rebuilt if num_threads differs from the value of the previous call. This is called automatically with RapierConfiguration::num_threads before each simulation step, and does nothing unless the parallel feature is enabled (and unsync-callbacks is not).

pub fn with_query_dispatcher<D>(dispatcher: D) -> Self

where D: 'static + PersistentQueryDispatcher<ContactManifoldData, ContactData>,

Creates a simulation context whose narrow-phase uses a custom query dispatcher.

The query dispatcher computes the contact manifolds and intersections between pairs of shapes, which makes it possible to support custom shapes or override the contact generation of existing ones. Spawn it with RapierContextInitialization::NoAutomaticRapierContext, or see Self::set_query_dispatcher for the default context.

pub fn set_query_dispatcher<D>(&mut self, dispatcher: D)

where D: 'static + PersistentQueryDispatcher<ContactManifoldData, ContactData>,

Replaces the narrow-phase with an empty one using the given custom query dispatcher.

This discards every contact and intersection pair of the current narrow-phase, so it must be called before any collider is added to this context (for example in a Startup system, since colliders are inserted during PhysicsSet::SyncBackend).

pub fn query_dispatcher( &self, ) -> &dyn PersistentQueryDispatcher<ContactManifoldData, ContactData>

The query dispatcher used by the narrow-phase to compute contacts and intersections.

pub fn set_event_handler( &mut self, handler: impl EventHandler + Send + Sync + 'static, )

Installs a Rapier EventHandler called by the physics pipeline for every collision, contact force and soft-body tear event.

It is called in addition to (not instead of) the forwarding of events as CollisionEvent and ContactForceEvent Bevy messages, and replaces the previously installed handler, if any. The handler receives raw Rapier handles: the entity of a collider can be retrieved with RapierContextColliders::entity_from_collider. Note that the colliders of an event flagged with CollisionEventFlags::REMOVED may no longer be part of the collider set.

pub fn remove_event_handler( &mut self, ) -> Option<Box<dyn EventHandler + Send + Sync>>

Removes the event handler installed with Self::set_event_handler and returns it.

pub fn event_handler(&self) -> Option<&(dyn EventHandler + Send + Sync)>

The event handler installed with Self::set_event_handler, if any.

pub fn tear_soft_body( &mut self, colliders: &mut RapierContextColliders, joints: &mut RapierContextJoints, rigidbody_set: &mut RapierRigidBodySet, commands: &mut Commands<'_, '_>, entity: Entity, edges: &[u32], cells: &[u32], ) -> Option<SoftBodyTearResult>

Tears the soft body of entity right away along the given edges and through the given cells (see SoftBodySet::tear).

The entities of the pieces split off the soft body are spawned with commands and returned right away; they get their components and a SoftBodyTearEvent message is sent during the next PhysicsSet::Writeback (see SoftBodyTearResult). Returns None if entity has no soft body or if nothing changed.

pub fn cut_soft_body( &mut self, colliders: &mut RapierContextColliders, joints: &mut RapierContextJoints, rigidbody_set: &mut RapierRigidBodySet, commands: &mut Commands<'_, '_>, entity: Entity, blade: &[Vect; 3], ) -> Option<SoftBodyTearResult>

Cuts the soft body of entity right away along a blade: a world-space segment in 2D, a world-space triangle in 3D (see SoftBodySet::cut).

The entities of the pieces split off the soft body are spawned with commands and returned right away; they get their components and a SoftBodyTearEvent message is sent during the next PhysicsSet::Writeback (see SoftBodyTearResult). Returns None if entity has no soft body or if nothing changed.

pub fn step_simulation( &mut self, colliders: &mut RapierContextColliders, joints: &mut RapierContextJoints, rigidbody_set: &mut RapierRigidBodySet, gravity: Vect, simulation_mode: SimulationMode, timestep_mode: TimestepMode, events: Option<(&MessageWriter<'_, CollisionEvent>, &MessageWriter<'_, ContactForceEvent>)>, hooks: &dyn PhysicsHooks, time: &Time, sim_to_render_time: &mut SimulationToRenderTime, interpolation_query: Option<&mut Query<'_, '_, (&RapierRigidBodyHandle, &mut TransformInterpolation)>>, )

Advance the simulation, based on the given timestep mode.

With SimulationMode::CollisionOnly, only collision detection runs at each step (see SimulationMode).

Steps with a zero (or negative) dt, like the first frame with TimestepMode::Variable, are skipped entirely.

pub fn send_quarantine_events( &mut self, context: Entity, quarantine_event_writer: &mut MessageWriter<'_, PhysicsQuarantineEvent>, )

Sends a PhysicsQuarantineEvent (and logs a warning) if some rigid-bodies, colliders or soft bodies were quarantined by the simulation steps executed since the last call.

context is the entity of this context. This is called automatically by the step_simulation system.

pub fn send_bevy_events( &mut self, collision_event_writer: &mut MessageWriter<'_, CollisionEvent>, contact_force_event_writer: &mut MessageWriter<'_, ContactForceEvent>, )

Generates bevy events for any physics interactions that have happened that are stored in the events list

pub fn move_shape( &mut self, colliders: &mut RapierContextColliders, rigidbody_set: &mut RapierRigidBodySet, movement: Vect, shape: &(impl AsShape + ?Sized), shape_translation: Vect, shape_rotation: Rot, shape_mass: f32, options: &MoveShapeOptions, filter: QueryFilter<'_>, events: impl FnMut(CharacterCollision), ) -> MoveShapeOutput

Attempts to move shape, optionally sliding or climbing obstacles.

The obstacles are the colliders of this context matching filter, detected with this context’s query dispatcher.

Parameters

• colliders, rigidbody_set: the collider and rigid-body sets of this context.
• movement: the translational movement to apply.
• shape: the shape to move.
• shape_translation: the initial position of the shape.
• shape_rotation: the rotation of the shape.
• shape_mass: the mass of the shape to be considered by the impulse calculation if MoveShapeOptions::apply_impulse_to_dynamic_bodies is set to true.
• options: configures the behavior of the automatic sliding and climbing.
• filter: selects the colliders the shape can collide with (exclude the collider or rigid-body of the moved shape itself).
• events: callback run on each obstacle hit by the shape on its path, once the movement is computed.

impl RapierContextSimulation

pub fn contact_pairs_with<'a, 'b: 'a>( &'a self, context_colliders: &'b RapierContextColliders, rigidbody_set: &'b RapierRigidBodySet, collider: Entity, ) -> impl Iterator<Item = ContactPairView<'a>>

All the contact pairs involving the non-sensor collider attached to the given entity.

The returned contact pairs identify pairs of colliders with intersecting bounding-volumes. To check if any geometric contact happened between the collider shapes, check ContactPairView::has_any_active_contact.

pub fn intersection_pairs_with<'a, 'b: 'a>( &'a self, rapier_colliders: &'b RapierContextColliders, collider: Entity, ) -> impl Iterator<Item = (Entity, Entity, bool)> + 'a

All the intersection pairs involving the collider attached to the given entity, where at least one collider involved in the intersection is a sensor.

The returned contact pairs identify pairs of colliders (where at least one is a sensor) with intersecting bounding-volumes. To check if any geometric overlap happened between the collider shapes, check the returned boolean.

pub fn contact_pair<'a, 'b: 'a>( &'a self, context_colliders: &'b RapierContextColliders, rigidbody_set: &'b RapierRigidBodySet, collider1: Entity, collider2: Entity, ) -> Option<ContactPairView<'a>>

The contact pair involving two specific colliders.

If this returns None, there is no contact between the two colliders. If this returns Some, then there may be a contact between the two colliders. Check the result ContactPairView::has_any_active_contact method to see if there is an actual contact.

pub fn intersection_pair( &self, rapier_colliders: &RapierContextColliders, collider1: Entity, collider2: Entity, ) -> Option<bool>

The intersection pair involving two specific colliders (at least one being a sensor).

If this returns None or Some(false), then there is no intersection between the two colliders. If this returns Some(true), then there may be an intersection between the two colliders.

pub fn contact_pairs<'a, 'b: 'a>( &'a self, context_colliders: &'b RapierContextColliders, rigidbody_set: &'b RapierRigidBodySet, ) -> impl Iterator<Item = ContactPairView<'a>>

All the contact pairs detected during the last timestep.

pub fn contact_graph(&self) -> &InteractionGraph<ColliderHandle, ContactPair>

The raw contact graph of the narrow-phase.

Its nodes are the Rapier handles of the colliders, and its edges the raw contact pairs between non-sensor colliders with intersecting bounding volumes. Prefer Self::contact_pairs and Self::contact_pairs_with which yield Bevy entities.

pub fn intersection_graph( &self, ) -> &InteractionGraph<ColliderHandle, IntersectionPair>

The raw intersection graph of the narrow-phase.

Its nodes are the Rapier handles of the colliders, and its edges the raw intersection pairs involving at least one sensor. Prefer Self::intersection_pairs and Self::intersection_pairs_with which yield Bevy entities.

pub fn intersection_pairs<'a, 'b: 'a>( &'a self, rapier_colliders: &'b RapierContextColliders, ) -> impl Iterator<Item = (Entity, Entity, bool)> + 'a

All the intersection pairs detected during the last timestep.

Trait Implementations

impl Component for RapierContextSimulation

where Self: Send + Sync + 'static,

Required Components: RapierContextColliders, RapierRigidBodySet, RapierContextJoints, SimulationToRenderTime.

A component’s Required Components are inserted whenever it is inserted. Note that this will also insert the required components of the required components, recursively, in depth-first order.

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 RapierContextSimulation

fn default() -> Self

Returns the “default value” for a type.