Struct CollisionLayers

pub struct CollisionLayers { /* private fields */ }

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_groups(), CollisionLayers::all_masks(), 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 groups and masks

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

pub fn all_groups<L>() -> CollisionLayers

where L: PhysicsLayer,

Contains all groups and no masks

The entity, will not interact with anything, unless you add masks via CollisionLayers::with_mask. You can also exclude specific groups using CollisionLayers::without_group.

pub fn all_masks<L>() -> CollisionLayers

where L: PhysicsLayer,

Contains no groups and all masks

The entity, will not interact with anything, unless you add group via CollisionLayers::with_group. You can also exclude specific masks using CollisionLayers::without_mask.

pub const fn none() -> CollisionLayers

Contains no masks and groups

The entity, will not interact with anything

pub const 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

fn clone(&self) -> CollisionLayers

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for CollisionLayers

where CollisionLayers: Send + Sync + 'static,

type Storage = TableStorage

impl Debug for CollisionLayers

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

Formats the value using the given formatter.

impl Default for CollisionLayers

fn default() -> CollisionLayers

Returns the “default value” for a type.

impl FromReflect for CollisionLayers

where u32: FromReflect,

fn from_reflect(reflect: &(dyn Reflect + 'static)) -> Option<CollisionLayers>

Constructs a concrete instance of Self from a reflected value.

impl GetTypeRegistration for CollisionLayers

fn get_type_registration() -> TypeRegistration

impl IntoBevy<CollisionLayers> for InteractionGroups

fn into_bevy(self) -> CollisionLayers

impl IntoRapier<InteractionGroups> for CollisionLayers

fn into_rapier(self) -> InteractionGroups

impl PartialEq for CollisionLayers

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Reflect for CollisionLayers

fn type_name(&self) -> &str

Returns the type name of the underlying type.

fn get_type_info(&self) -> &'static TypeInfo

Returns the TypeInfo of the underlying type.

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

Returns the value as a Box<dyn Any>.

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

Returns the value as a &dyn Any.

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

Returns the value as a &mut dyn Any.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a reflected value

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable reflected value

fn clone_value(&self) -> Box<dyn Reflect>

Clones the value as a Reflect trait object.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

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

Applies a reflected value to this value.

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

Returns an enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

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

Returns a “partial equality” comparison result.

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

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

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

Returns a serializable version of the value.

impl Struct for CollisionLayers

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

Returns a reference to the value of the field named name as a &dyn Reflect.

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

Returns a mutable reference to the value of the field named name as a &mut dyn Reflect.

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

Returns a reference to the value of the field with index index as a &dyn Reflect.

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

Returns a mutable reference to the value of the field with index index as a &mut dyn Reflect.

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

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

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

Returns an iterator over the values of the struct’s fields.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl Typed for CollisionLayers

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for CollisionLayers

impl Eq for CollisionLayers

impl StructuralPartialEq for CollisionLayers