Struct RapierContextSimulation

pub struct RapierContextSimulation {
    pub islands: IslandManager,
    pub broad_phase: DefaultBroadPhase,
    pub narrow_phase: NarrowPhase,
    pub ccd_solver: CCDSolver,
    pub pipeline: PhysicsPipeline,
    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.

integration_parameters: IntegrationParameters

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

Implementations

impl RapierContextSimulation

pub fn step_simulation( &mut self, colliders: &mut RapierContextColliders, joints: &mut RapierContextJoints, rigidbody_set: &mut RapierRigidBodySet, gravity: Vect, timestep_mode: TimestepMode, events: Option<(&EventWriter<'_, CollisionEvent>, &EventWriter<'_, 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.

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

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

pub fn move_shape( &mut self, rapier_colliders: &RapierContextColliders, rapier_query_pipeline: &RapierQueryPipeline, rigidbody_set: &mut RapierRigidBodySet, movement: Vect, shape: &Collider, 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.

Parameters

• 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: indicates what collider or rigid-body needs to be ignored by the obstacle detection.
• events: callback run on each obstacle hit by the shape on its path.

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 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, RapierQueryPipeline, 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.

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.

fn register_component_hooks(hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl Default for RapierContextSimulation

fn default() -> Self

Returns the “default value” for a type.