Struct avian3d::collision::Collisions

pub struct Collisions(/* private fields */);

A resource that stores all collision pairs.

Each colliding entity pair is associated with Contacts that can be accessed and modified using the various associated methods.

Usage

Collisions can be accessed at almost anytime, but for modifying and filtering collisions, it is recommended to use the PostProcessCollisions schedule. See its documentation for more information.

Querying collisions

The following methods can be used for querying existing collisions:

• get and get_mut
• iter and iter_mut
• contains
• collisions_with_entity and collisions_with_entity_mut

The collisions can be accessed at any time, but modifications to contacts should be performed in the PostProcessCollisions schedule. Otherwise, the physics solver will use the old contact data.

Filtering and removing collisions

The following methods can be used for filtering or removing existing collisions:

• retain
• remove_collision_pair
• remove_collisions_with_entity

Collision filtering and removal should be done in the PostProcessCollisions schedule. Otherwise, the physics solver will use the old contact data.

Adding new collisions

The following methods can be used for adding new collisions:

• insert_collision_pair
• extend

The most convenient place for adding new collisions is in the PostProcessCollisions schedule. Otherwise, the physics solver might not have access to them in time.

Implementation details

Internally, the collisions are stored in an IndexMap that contains collisions from both the current frame and the previous frame, which is used for things like collision events.

However, the public methods only use the current frame’s collisions. To access the internal data structure, you can use get_internal or get_internal_mut.

Implementations

impl Collisions

pub fn get_internal( &self ) -> &IndexMap<(Entity, Entity), Contacts, FxBuildHasher>

Returns a reference to the internal IndexMap.

pub fn get_internal_mut( &mut self ) -> &mut IndexMap<(Entity, Entity), Contacts, FxBuildHasher>

Returns a mutable reference to the internal IndexMap.

pub fn get(&self, entity1: Entity, entity2: Entity) -> Option<&Contacts>

Returns a reference to the contacts stored for the given entity pair if they are colliding, else returns None.

The order of the entities does not matter.

pub fn get_mut( &mut self, entity1: Entity, entity2: Entity ) -> Option<&mut Contacts>

Returns a mutable reference to the contacts stored for the given entity pair if they are colliding, else returns None.

The order of the entities does not matter.

pub fn contains(&self, entity1: Entity, entity2: Entity) -> bool

Returns true if the given entities have been in contact during this frame.

The order of the entities does not matter.

pub fn iter(&self) -> impl Iterator<Item = &Contacts>

Returns an iterator over the current collisions that have happened during the current physics frame.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Contacts>

Returns a mutable iterator over the collisions that have happened during the current physics frame.

pub fn collisions_with_entity( &self, entity: Entity ) -> impl Iterator<Item = &Contacts>

Returns an iterator over all collisions with a given entity.

pub fn collisions_with_entity_mut( &mut self, entity: Entity ) -> impl Iterator<Item = &mut Contacts>

Returns an iterator over all collisions with a given entity.

pub fn insert_collision_pair(&mut self, contacts: Contacts) -> Option<Contacts>

Inserts contact data for a collision between two entities.

If a collision entry with the same entities already exists, it will be overwritten, and the old value will be returned. Otherwise, None is returned.

Note: Manually inserting collisions can be error prone and should generally be avoided. If you simply want to modify existing collisions, consider using methods like get_mut or iter_mut.

pub fn extend<I: IntoIterator<Item = Contacts>>(&mut self, collisions: I)

Extends Collisions with all collision pairs in the given iterable.

This is mostly equivalent to calling insert_collision_pair for each of the collision pairs.

pub fn retain<F>(&mut self, keep: F)

where F: FnMut(&mut Contacts) -> bool,

Retains only the collisions for which the specified predicate returns true. Collisions for which the predicate returns false are removed.

pub fn remove_collision_pair( &mut self, entity1: Entity, entity2: Entity ) -> Option<Contacts>

Removes a collision between two entites and returns its value.

The order of the entities does not matter.

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

Removes all collisions that involve the given entity.

Trait Implementations

impl Clone for Collisions

fn clone(&self) -> Collisions

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Collisions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Collisions

fn default() -> Collisions

Returns the “default value” for a type.

impl PartialEq for Collisions

fn eq(&self, other: &Collisions) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Resource for Collisions

where Self: Send + Sync + 'static,

impl StructuralPartialEq for Collisions