Struct bevy_retrograde_physics::CollisionLayers

pub struct CollisionLayers { /* fields omitted */ }

Components that defines the collision layers of the collision shape.

This component contains two collections of layers: “groups” and “masks”.

Two entities A and B will interact iff:

• There is a layer in the groups of A that is also in the masks of B
• There is a layer in the groups of B that is also in the masks of A

An entity without this component is considered has having all layers in its “groups” and “masks”, and will interact with everything.

This component must be on the same entity of a CollisionShape

To build an instance, start with either CollisionLayers::new(), CollisionLayers::all() or CollisionLayers::none(), and then add or remove layers by calling with_group/without_group and with_mask/without_mask.

Theses methods take a type that implement PhysicsLayer. The best option is to create an enum with a #[derive(PhysicsLayer)] clause.

Example

fn spawn(mut commands: Commands) {
   commands.spawn_bundle(todo!("Spawn a bundle of your choice"))
        .insert(RigidBody::Dynamic) // <-- Create a rigid body
        .insert(CollisionShape::Sphere { radius: 10.0 }) // <-- Attach a collision shape
        .insert(

            // Define the collision layer of this *collision shape*
            CollisionLayers::none()
                .with_group(GameLayer::Player) // <-- Mark it as the player
                .with_masks(&[GameLayer::World, GameLayer::Enemies]) // <-- Defines that the player collides with world and enemies (but not with other players)
        );
}

Implementations

impl CollisionLayers

pub fn new<L>(group: L, mask: L) -> CollisionLayers where
    L: PhysicsLayer, 

Create a new collision layers configuration with a single group and mask.

You may add more groups and mask with with_group and with_mask.

pub fn all<L>() -> CollisionLayers where
    L: PhysicsLayer, 

Contains all layers

The entity,will interacts with everything (except the entities that interact with nothing)

pub fn none() -> CollisionLayers

Contains no layer

The entity, will not interact with anything

pub fn from_bits(groups: u32, masks: u32) -> CollisionLayers

pub fn interacts_with(self, other: CollisionLayers) -> bool

Returns true if the entity would interact with an entity containing the other [CollisionLayers]

pub fn contains_group(self, layer: impl PhysicsLayer) -> bool

Returns true if the given layer is contained in the “groups”

pub fn with_group(self, layer: impl PhysicsLayer) -> CollisionLayers

Add the given layer in the “groups”

pub fn with_groups(
    self,
    layers: impl IntoIterator<Item = impl PhysicsLayer>
) -> CollisionLayers

Add the given layers in the “groups”

pub fn without_group(self, layer: impl PhysicsLayer) -> CollisionLayers

Remove the given layer from the “groups”

pub fn contains_mask(self, layer: impl PhysicsLayer) -> bool

Returns true if the given layer is contained in the “masks”

pub fn with_mask(self, layer: impl PhysicsLayer) -> CollisionLayers

Add the given layer in the “masks”

pub fn with_masks(
    self,
    layers: impl IntoIterator<Item = impl PhysicsLayer>
) -> CollisionLayers

Add the given layers in the “masks”

pub fn without_mask(self, layer: impl PhysicsLayer) -> CollisionLayers

Remove the given layer from the “masks”

pub fn groups_bits(self) -> u32

pub fn masks_bits(self) -> u32

Trait Implementations

impl Clone for CollisionLayers

pub fn clone(&self) -> CollisionLayers

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CollisionLayers

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

Formats the value using the given formatter.

impl Default for CollisionLayers

pub fn default() -> CollisionLayers

Returns the “default value” for a type.

impl GetTypeRegistration for CollisionLayers

pub fn get_type_registration() -> TypeRegistration

impl IntoRapier<InteractionGroups> for CollisionLayers

pub fn into_rapier(self) -> InteractionGroups

impl PartialEq<CollisionLayers> for CollisionLayers

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

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

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

This method tests for !=.

impl Reflect for CollisionLayers

pub fn type_name(&self) -> &str

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

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

pub fn clone_value(&self) -> Box<dyn Reflect + 'static, Global>

pub fn set(
    &mut self,
    value: Box<dyn Reflect + 'static, Global>
) -> Result<(), Box<dyn Reflect + 'static, Global>>

pub fn apply(&mut self, value: &(dyn Reflect + 'static))

pub fn reflect_ref(&self) -> ReflectRef<'_>

pub fn reflect_mut(&mut self) -> ReflectMut<'_>

pub fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable value, if serialization is supported. Otherwise None will be returned.

pub fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type) if hashing is supported. Otherwise None will be returned.

pub fn reflect_partial_eq(
    &self,
    value: &(dyn Reflect + 'static)
) -> Option<bool>

Returns a “partial equal” comparison result if comparison is supported. Otherwise None will be returned.

impl Struct for CollisionLayers

pub fn field(&self, name: &str) -> Option<&(dyn Reflect + 'static)>

pub fn field_mut(&mut self, name: &str) -> Option<&mut (dyn Reflect + 'static)>

pub fn field_at(&self, index: usize) -> Option<&(dyn Reflect + 'static)>

pub fn field_at_mut(
    &mut self,
    index: usize
) -> Option<&mut (dyn Reflect + 'static)>

pub fn name_at(&self, index: usize) -> Option<&str>

pub fn field_len(&self) -> usize

pub fn iter_fields(&self) -> FieldIter<'_>

pub fn clone_dynamic(&self) -> DynamicStruct

impl Copy for CollisionLayers

impl Eq for CollisionLayers

impl StructuralEq for CollisionLayers

impl StructuralPartialEq for CollisionLayers