Struct jumpy::core::physics::collisions::CollisionWorld

pub struct CollisionWorld<'a> {
    pub entities: Res<'a, Entities>,
    pub ctx: ResMutInit<'a, RapierContext>,
    pub actors: CompMut<'a, Actor>,
    pub solids: CompMut<'a, Solid>,
    pub colliders: CompMut<'a, Collider>,
    pub tile_rapier_handles: CompMut<'a, TileRapierHandle>,
    pub tile_layers: Comp<'a, TileLayer>,
    pub tile_collision_kinds: Comp<'a, TileCollisionKind>,
    pub tile_dynamic_colliders: Comp<'a, TileDynamicCollider>,
    pub spawned_map_layer_metas: Comp<'a, SpawnedMapLayerMeta>,
}

Fields

entities: Res<'a, Entities>

ctx: ResMutInit<'a, RapierContext>

The rapier context.

actors: CompMut<'a, Actor>

Actors are things like players that move around and detect collisions, but don’t collide with other actors.

solids: CompMut<'a, Solid>

Solids are things like walls and platforms, that aren’t tiles, that have solid collisions.

colliders: CompMut<'a, Collider>

A collider is anything that can detect collisions in the world other than tiles, and must either be an Actor or Solid to participate in collision detection.

tile_rapier_handles: CompMut<'a, TileRapierHandle>

Contains the rapier collider handles for each map tile.

tile_layers: Comp<'a, TileLayer>

tile_collision_kinds: Comp<'a, TileCollisionKind>

tile_dynamic_colliders: Comp<'a, TileDynamicCollider>

spawned_map_layer_metas: Comp<'a, SpawnedMapLayerMeta>

Implementations

impl<'a> CollisionWorld<'a>

pub fn set_actor_shape(&mut self, entity: Entity, shape: ColliderShape)

Update shape of actor’s Collider. Warns if entity does not have an Actor component.

Updates shape on Collider and rebuilds rapier’s collider on rigidbody.

Use Self::set_actor_shape_from_builder for more control over new collider’s settings.

pub fn set_actor_shape_from_builder( &mut self, entity: Entity, collider_builder: ColliderBuilder, shape: ColliderShape, )

Update shape of actor’s Collider. Warns if entity does not have an Actor component.

Updates shape on Collider and rebuilds rapier’s collider on rigidbody.

Accepts a rapier::ColliderBuilder (can get one with build_actor_rapier_collider) so other settings may be configured on new collider.

pub fn mutate_rigidbody( &mut self, entity: Entity, command: impl FnOnce(&mut RigidBody), ) -> Result<(), PhysicsError>

Call closure with mutable reference to rapier::RigidBody for entity.

Errors

• PhysicsError::BodyNotInitialized when called before physics is updated to initialize body after a Collider component is newly added. (If missing collider or rapier handle does not map to body).

impl<'a> CollisionWorld<'a>

pub fn update( &mut self, dt: f32, physics_params: PhysicsParams, transforms: &mut CompMut<'_, Transform>, dynamic_bodies: &mut CompMut<'_, DynamicBody>, )

Updates the collision world with the entity’s actual transforms. Advance physics, synchronize position of dynamic bodies.

If the transform of an entity is changed without calling update(), then collision queries will be out-of-date with the actual entity positions.

⚠️ Warning: This does not update the map tile collisions. To do that, call update_tiles() instead.

pub fn sync_bodies<'b, Tq>( &mut self, transforms: Tq, dynamic_bodies: &mut CompMut<'_, DynamicBody>, )

where Tq: QueryItem, Tq::Iter: Iterator<Item = &'b Transform>,

Sync the transforms and attributes ( like disabled ) of the colliders. Creates rapier bodies for any object with collision.

Handle DynamicBody toggling between simulation and kinematic mode.

fn apply_simulation_commands<'b, Dq>(&mut self, dynamic_bodies: Dq)

where Dq: QueryItem, Dq::Iter: Iterator<Item = &'b mut DynamicBody>,

Apply simulation commands to dynamic bodies.

Panics

This should be called after bodies are initialized, DynamicBody must have a Collider with valid rapier::RigidBodyHandle otherwise will panic.

pub fn update_tiles(&mut self)

Update all of the map tile collisions.

You should only need to call this when spawning or otherwise completely rebuilding the map layout.

pub fn update_tile(&mut self, layer_idx: u32, pos: UVec2)

Update the collision for the tile with the given layer index and map grid position.

pub fn update_tiles_with_filter<F>(&mut self, filter: F)

where F: FnMut(u32, UVec2) -> bool,

Update the collisions for map tiles that pass the given filter.

The filter is a function that takes the layer index and the tile position as an argument.

pub fn handle_teleport(&mut self, entity: Entity)

When spawning or teleporting an entity, this should be called to make sure the entity doesn’t get stuck in semi-solid platforms, and properly falls out of them if it happens to be colliding with one when spawned.

pub fn actor_collisions(&self, entity: Entity) -> Vec<Entity>

Returns the collisions that one actor has with any other actors.

pub fn actor_collisions_filtered( &self, entity: Entity, filter: impl Fn(Entity) -> bool, ) -> Vec<Entity>

Returns the collisions that one actor has with any other actors filtered by the given Fn

pub fn descent(&mut self, entity: Entity)

Put the entity’s collider into descent mode so that it will fall through jump-through platforms.

pub fn move_vertical( &mut self, transforms: &mut CompMut<'_, Transform>, entity: Entity, dy: f32, ) -> bool

Attempt to move a body vertically. This will return true if an obstacle was run into that caused the movement to stop short.

pub fn move_horizontal( &mut self, transforms: &mut CompMut<'_, Transform>, entity: Entity, dx: f32, ) -> bool

Attempt to move a body horizontally. This will return true if an obstacle was run into that caused the movement to stop short.

pub fn solid_at(&self, pos: Vec2) -> bool

Returns whether or not there is a tile or solid at the given position.

⚠️ Warning: There is a slight difference to how tile_collision_point and tile_collision reports collisions.

tile_collision will report a collision if the collider shape is perfectly lined up along the edge of a tile, but tile_collision_point won’t.

pub fn solid_collision_point(&self, pos: Vec2) -> bool

pub fn tile_collision_point(&self, pos: Vec2) -> TileCollisionKind

Returns the tile collision at the given point.

⚠️ Warning: There is a slight difference to how tile_collision_point and tile_collision reports collisions.

tile_collision will report a collision if the collider shape is perfectly lined up along the edge of a tile, but tile_collision_point won’t.

pub fn tile_collision( &self, transform: Transform, shape: ColliderShape, ) -> TileCollisionKind

Get the TileCollisionKind of the first tile detected colliding with the shape at the given transform.

pub fn tile_collision_filtered( &self, transform: Transform, shape: ColliderShape, filter: impl Fn(Entity) -> bool, ) -> TileCollisionKind

pub fn get_collider(&self, actor: Entity) -> &Collider

Get the collider for the given entity.

Trait Implementations

impl<'a> SystemParam for CollisionWorld<'a>

type State = (<Res<'a, Entities> as SystemParam>::State, <ResMutInit<'a, RapierContext> as SystemParam>::State, <RefMut<'a, ComponentStore<Actor>> as SystemParam>::State, <RefMut<'a, ComponentStore<Solid>> as SystemParam>::State, <RefMut<'a, ComponentStore<Collider>> as SystemParam>::State, <RefMut<'a, ComponentStore<TileRapierHandle>> as SystemParam>::State, <Ref<'a, ComponentStore<TileLayer>> as SystemParam>::State, <Ref<'a, ComponentStore<TileCollisionKind>> as SystemParam>::State, <Ref<'a, ComponentStore<TileDynamicCollider>> as SystemParam>::State, <Ref<'a, ComponentStore<SpawnedMapLayerMeta>> as SystemParam>::State)

The intermediate state for the parameter, that may be extracted from the world.

type Param<'p> = CollisionWorld<'p>

The type of the parameter, ranging over the lifetime of the intermediate state.

fn get_state(world: &World) -> Self::State

This is called to produce the intermediate state of the system parameter.

fn borrow<'s>(world: &'s World, state: &'s mut Self::State) -> Self::Param<'s>

This is used create an instance of the system parame, possibly borrowed from the intermediate parameter state.