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

source ·
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§

source§

impl<'a> CollisionWorld<'a>

source

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.

source

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.

source

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
source§

impl<'a> CollisionWorld<'a>

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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.

source

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

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

source

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

source

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

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

source

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.

source

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.

source

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.

source

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

source

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.

source

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.

source

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

source

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

Get the collider for the given entity.

Trait Implementations§

source§

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. Read more
source§

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

This is called to produce the intermediate state of the system parameter. Read more
source§

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.

Auto Trait Implementations§

§

impl<'a> Freeze for CollisionWorld<'a>

§

impl<'a> !RefUnwindSafe for CollisionWorld<'a>

§

impl<'a> Send for CollisionWorld<'a>

§

impl<'a> Sync for CollisionWorld<'a>

§

impl<'a> Unpin for CollisionWorld<'a>

§

impl<'a> !UnwindSafe for CollisionWorld<'a>

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<Image>) -> U

Return the T [ShaderType] for self. When used in [AsBindGroup] derives, it is safe to assume that all images in self exist.
§

impl<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( self, class: Class, constructed: bool, tag: u32, ) -> TaggedParser<'a, Implicit, Self, E>

source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Conv for T

§

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
§

impl<T> FmtForward for T

§

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.
§

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.
§

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.
§

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.
§

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.
§

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.
§

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.
§

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.
§

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<S> FromSample<S> for S

§

fn from_sample_(s: S) -> S

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided [Span], returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

§

fn into_sample(self) -> T

§

impl<T> Pipe for T
where T: ?Sized,

§

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where Self: Sized,

Pipes by value. This is generally the method you want to use. Read more
§

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where R: 'a,

Borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where R: 'a,

Mutably borrows self and passes that borrow into the pipe function. Read more
§

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

Borrows self, then passes self.borrow() into the pipe function. Read more
§

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more
§

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

Borrows self, then passes self.as_ref() into the pipe function.
§

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.as_mut() into the pipe function.
§

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

Borrows self, then passes self.deref() into the pipe function.
§

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R, ) -> R
where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

Mutably borrows self, then passes self.deref_mut() into the pipe function.
§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
§

impl<T> RawDrop for T

§

unsafe fn raw_drop(ptr: *mut c_void)

Write the default value of the type to the pointer. Read more
§

fn raw_drop_cb() -> Unsafe<&'static (dyn Fn(*mut c_void) + Send + Sync)>

Get a callback suitable for [SchemaData].
source§

impl<T> Same for T

§

type Output = T

Should always be Self
§

impl<SS, SP> SupersetOf<SS> for SP
where SS: SubsetOf<SP>,

§

fn to_subset(&self) -> Option<SS>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset. Read more
§

fn is_in_subset(&self) -> bool

Checks if self is actually part of its subset T (and can be converted to it).
§

fn to_subset_unchecked(&self) -> SS

Use with care! Same as self.to_subset but without any property checks. Always succeeds.
§

fn from_subset(element: &SS) -> SP

The inclusion map: converts self to the equivalent element of its superset.
§

impl<T> Tap for T

§

fn tap(self, func: impl FnOnce(&Self)) -> Self

Immutable access to a value. Read more
§

fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self

Mutable access to a value. Read more
§

fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Immutable access to the Borrow<B> of a value. Read more
§

fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Mutable access to the BorrowMut<B> of a value. Read more
§

fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Immutable access to the AsRef<R> view of a value. Read more
§

fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Mutable access to the AsMut<R> view of a value. Read more
§

fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Immutable access to the Deref::Target of a value. Read more
§

fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Mutable access to the Deref::Target of a value. Read more
§

fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self

Calls .tap() only in debug builds, and is erased in release builds.
§

fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self

Calls .tap_mut() only in debug builds, and is erased in release builds.
§

fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where Self: Borrow<B>, B: ?Sized,

Calls .tap_borrow() only in debug builds, and is erased in release builds.
§

fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where Self: BorrowMut<B>, B: ?Sized,

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds.
§

fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where Self: AsRef<R>, R: ?Sized,

Calls .tap_ref() only in debug builds, and is erased in release builds.
§

fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where Self: AsMut<R>, R: ?Sized,

Calls .tap_ref_mut() only in debug builds, and is erased in release builds.
§

fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where Self: Deref<Target = T>, T: ?Sized,

Calls .tap_deref() only in debug builds, and is erased in release builds.
§

fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where Self: DerefMut<Target = T> + Deref, T: ?Sized,

Calls .tap_deref_mut() only in debug builds, and is erased in release builds.
§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

§

fn to_sample_(self) -> U

§

impl<T> TryConv for T

§

fn try_conv<T>(self) -> Result<T, Self::Error>
where Self: TryInto<T>,

Attempts to convert self into T using TryInto<T>. Read more
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a [WithDispatch] wrapper. Read more
§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,