Struct bevy_rapier2d::plugin::RapierContext

pub struct RapierContext {
    pub islands: IslandManager,
    pub broad_phase: DefaultBroadPhase,
    pub narrow_phase: NarrowPhase,
    pub bodies: RigidBodySet,
    pub colliders: ColliderSet,
    pub impulse_joints: ImpulseJointSet,
    pub multibody_joints: MultibodyJointSet,
    pub ccd_solver: CCDSolver,
    pub pipeline: PhysicsPipeline,
    pub query_pipeline: QueryPipeline,
    pub integration_parameters: IntegrationParameters,
    /* private fields */
}

The Rapier context, containing all the state of the physics engine.

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.

bodies: RigidBodySet

The set of rigid-bodies part of the simulation.

colliders: ColliderSet

The set of colliders part of the simulation.

impulse_joints: ImpulseJointSet

The set of impulse joints part of the simulation.

multibody_joints: MultibodyJointSet

The set of multibody joints part of the simulation.

ccd_solver: CCDSolver

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

pipeline: PhysicsPipeline

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

query_pipeline: QueryPipeline

The query pipeline, which performs scene queries (ray-casting, point projection, etc.)

integration_parameters: IntegrationParameters

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

Implementations

impl RapierContext

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

If the collider attached to entity is attached to a rigid-body, this returns the Entity containing that rigid-body.

pub fn rigid_body_colliders( &self, entity: Entity ) -> impl Iterator<Item = Entity> + '_

If entity is a rigid-body, this returns the collider Entitys attached to that rigid-body.

pub fn collider_entity(&self, handle: ColliderHandle) -> Option<Entity>

Retrieve the Bevy entity the given Rapier collider (identified by its handle) is attached.

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 with_query_filter<T>( &self, filter: QueryFilter<'_>, f: impl FnOnce(RapierQueryFilter<'_>) -> T ) -> T

Calls the closure f once after converting the given QueryFilter into a raw rapier::QueryFilter.

pub fn with_query_filter_elts<T>( entity2collider: &HashMap<Entity, ColliderHandle>, entity2body: &HashMap<Entity, RigidBodyHandle>, colliders: &ColliderSet, filter: QueryFilter<'_>, f: impl FnOnce(RapierQueryFilter<'_>) -> T ) -> T

Without borrowing the RapierContext, calls the closure f once after converting the given QueryFilter into a raw rapier::QueryFilter.

pub fn step_simulation( &mut self, 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<Query<'_, '_, (&RapierRigidBodyHandle, &mut TransformInterpolation)>> )

Advance the simulation, based on the given timestep mode.

pub fn propagate_modified_body_positions_to_colliders(&mut self)

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

pub fn update_query_pipeline(&mut self)

Updates the state of the query pipeline, based on the collider positions known from the last timestep or the last call to self.propagate_modified_body_positions_to_colliders().

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

The map from entities to rigid-body handles.

pub fn entity2collider(&self) -> &HashMap<Entity, ColliderHandle>

The map from entities to collider handles.

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 move_shape( &mut self, movement: Vect, shape: &Collider, shape_translation: Vect, shape_rotation: Rot, shape_mass: Real, 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.

pub fn cast_ray( &self, ray_origin: Vect, ray_dir: Vect, max_toi: Real, solid: bool, filter: QueryFilter<'_> ) -> Option<(Entity, Real)>

Find the closest intersection between a ray and a set of collider.

Parameters

• ray_origin: the starting point of the ray to cast.
• ray_dir: the direction of the ray to cast.
• max_toi: the maximum time-of-impact that can be reported by this cast. This effectively limits the length of the ray to ray.dir.norm() * max_toi. Use Real::MAX for an unbounded ray.
• solid: if this is true an impact at time 0.0 (i.e. at the ray origin) is returned if it starts inside of a shape. If this false then the ray will hit the shape’s boundary even if its starts inside of it.
• filter: set of rules used to determine which collider is taken into account by this scene query.

pub fn cast_ray_and_get_normal( &self, ray_origin: Vect, ray_dir: Vect, max_toi: Real, solid: bool, filter: QueryFilter<'_> ) -> Option<(Entity, RayIntersection)>

Find the closest intersection between a ray and a set of collider.

Parameters

• ray_origin: the starting point of the ray to cast.
• ray_dir: the direction of the ray to cast.
• max_toi: the maximum time-of-impact that can be reported by this cast. This effectively limits the length of the ray to ray.dir.norm() * max_toi. Use Real::MAX for an unbounded ray.
• solid: if this is true an impact at time 0.0 (i.e. at the ray origin) is returned if it starts inside of a shape. If this false then the ray will hit the shape’s boundary even if its starts inside of it.
• filter: set of rules used to determine which collider is taken into account by this scene query.

pub fn intersections_with_ray( &self, ray_origin: Vect, ray_dir: Vect, max_toi: Real, solid: bool, filter: QueryFilter<'_>, callback: impl FnMut(Entity, RayIntersection) -> bool )

Find the all intersections between a ray and a set of collider and passes them to a callback.

Parameters

• ray_origin: the starting point of the ray to cast.
• ray_dir: the direction of the ray to cast.
• max_toi: the maximum time-of-impact that can be reported by this cast. This effectively limits the length of the ray to ray.dir.norm() * max_toi. Use Real::MAX for an unbounded ray.
• solid: if this is true an impact at time 0.0 (i.e. at the ray origin) is returned if it starts inside of a shape. If this false then the ray will hit the shape’s boundary even if its starts inside of it.
• filter: set of rules used to determine which collider is taken into account by this scene query.
• callback: function executed on each collider for which a ray intersection has been found. There is no guarantees on the order the results will be yielded. If this callback returns false, this method will exit early, ignore any further raycast.

pub fn intersection_with_shape( &self, shape_pos: Vect, shape_rot: Rot, shape: &Collider, filter: QueryFilter<'_> ) -> Option<Entity>

Gets the handle of up to one collider intersecting the given shape.

Parameters

• shape_pos - The position of the shape used for the intersection test.
• shape - The shape used for the intersection test.
• filter: set of rules used to determine which collider is taken into account by this scene query.

pub fn project_point( &self, point: Vect, solid: bool, filter: QueryFilter<'_> ) -> Option<(Entity, PointProjection)>

Find the projection of a point on the closest collider.

Parameters

• point - The point to project.
• solid - If this is set to true then the collider shapes are considered to be plain (if the point is located inside of a plain shape, its projection is the point itself). If it is set to false the collider shapes are considered to be hollow (if the point is located inside of an hollow shape, it is projected on the shape’s boundary).
• filter: set of rules used to determine which collider is taken into account by this scene query.

pub fn intersections_with_point( &self, point: Vect, filter: QueryFilter<'_>, callback: impl FnMut(Entity) -> bool )

Find all the colliders containing the given point.

Parameters

• point - The point used for the containment test.
• filter: set of rules used to determine which collider is taken into account by this scene query.
• callback - A function called with each collider with a shape containing the point. If this callback returns false, this method will exit early, ignore any further point projection.

pub fn project_point_and_get_feature( &self, point: Vect, filter: QueryFilter<'_> ) -> Option<(Entity, PointProjection, FeatureId)>

Find the projection of a point on the closest collider.

The results include the ID of the feature hit by the point.

Parameters

• point - The point to project.
• solid - If this is set to true then the collider shapes are considered to be plain (if the point is located inside of a plain shape, its projection is the point itself). If it is set to false the collider shapes are considered to be hollow (if the point is located inside of an hollow shape, it is projected on the shape’s boundary).
• filter: set of rules used to determine which collider is taken into account by this scene query.

pub fn colliders_with_aabb_intersecting_aabb( &self, aabb: Aabb, callback: impl FnMut(Entity) -> bool )

Finds all entities of all the colliders with an Aabb intersecting the given Aabb.

pub fn cast_shape( &self, shape_pos: Vect, shape_rot: Rot, shape_vel: Vect, shape: &Collider, options: ShapeCastOptions, filter: QueryFilter<'_> ) -> Option<(Entity, ShapeCastHit)>

Casts a shape at a constant linear velocity and retrieve the first collider it hits.

This is similar to ray-casting except that we are casting a whole shape instead of just a point (the ray origin). In the resulting ShapeCastHit, witness and normal 1 refer to the world collider, and are in world space.

Parameters

• shape_pos - The initial translation of the shape to cast.
• shape_rot - The rotation of the shape to cast.
• shape_vel - The constant velocity of the shape to cast (i.e. the cast direction).
• shape - The shape to cast.
• max_toi - The maximum time-of-impact that can be reported by this cast. This effectively limits the distance traveled by the shape to shapeVel.norm() * maxToi.
• stop_at_penetration - If the casted shape starts in a penetration state with any collider, two results are possible. If stop_at_penetration is true then, the result will have a toi equal to start_time. If stop_at_penetration is false then the nonlinear shape-casting will see if further motion wrt. the penetration normal would result in tunnelling. If it does not (i.e. we have a separating velocity along that normal) then the nonlinear shape-casting will attempt to find another impact, at a time > start_time that could result in tunnelling.
• filter: set of rules used to determine which collider is taken into account by this scene query.

pub fn intersections_with_shape( &self, shape_pos: Vect, shape_rot: Rot, shape: &Collider, filter: QueryFilter<'_>, callback: impl FnMut(Entity) -> bool )

Retrieve all the colliders intersecting the given shape.

Parameters

• shapePos - The position of the shape to test.
• shapeRot - The orientation of the shape to test.
• shape - The shape to test.
• filter: set of rules used to determine which collider is taken into account by this scene query.
• callback - A function called with the entities of each collider intersecting the shape.

impl RapierContext

pub fn contact_pairs_with( &self, collider: Entity ) -> impl Iterator<Item = ContactPairView<'_>>

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( &self, collider: Entity ) -> impl Iterator<Item = (Entity, Entity, bool)> + '_

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( &self, collider1: Entity, collider2: Entity ) -> Option<ContactPairView<'_>>

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 [ContactPair::has_any_active_collider] method to see if there is an actual contact.

pub fn intersection_pair( &self, 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(&self) -> impl Iterator<Item = ContactPairView<'_>>

All the contact pairs detected during the last timestep.

pub fn intersection_pairs( &self ) -> impl Iterator<Item = (Entity, Entity, bool)> + '_

All the intersection pairs detected during the last timestep.

Trait Implementations

impl Default for RapierContext

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RapierContext

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RapierContext

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Resource for RapierContext

where Self: Send + Sync + 'static,