Struct CollisionLayers

pub struct CollisionLayers {
    pub memberships: LayerMask,
    pub filters: LayerMask,
}

Defines the collision layers of a collider using memberships and filters.

Memberships indicate what layers the collider is a part of.
Filters indicate what layers the collider can interact with.

Two colliders A and B can interact if and only if:

• The memberships of A contain a layer that is also in the filters of B
• The memberships of B contain a layer that is also in the filters of A

The memberships and filters are stored as LayerMasks, which represent bitmasks for layers. The first bit 0b0001 is reserved for the default layer, which all entities belong to by default.

Colliders without this component have all filters and can interact with any layer.

Creation

Collision layers store memberships and filters using LayerMasks. A LayerMask can be created using bitmasks, or by creating an enum that implements PhysicsLayer.

Many CollisionLayers methods can take any type that implements Into<LayerMask>. For example, you can use bitmasks with CollisionLayers::new:

// Belongs to the second layer and interacts with colliders
// on the first, second, and third layer.
let layers = CollisionLayers::new(0b00010, 0b0111);

You can also use an enum that implements PhysicsLayer:

#[derive(PhysicsLayer, Default)]
enum GameLayer {
    #[default]
    Default, // Layer 0 - the default layer that objects are assigned to
    Player,  // Layer 1
    Enemy,   // Layer 2
    Ground,  // Layer 3
}

// Player collides with enemies and the ground, but not with other players
let layers = CollisionLayers::new(
    GameLayer::Player,
    [GameLayer::Default, GameLayer::Enemy, GameLayer::Ground],
);

You can also use LayerMask directly:

// Belongs to the first layer and interacts with all layers.
let layers = CollisionLayers::new(LayerMask(0b0001), LayerMask::ALL);

Layers can also be defined using constants and bitwise operations:

// `1 << n` is bitshifting: the first layer shifted by `n` layers.
pub const FIRST_LAYER: u32 = 1 << 0; // Note: this is the default layer.
pub const SECOND_LAYER: u32 = 1 << 1;
pub const LAST_LAYER: u32 = 1 << 31;

fn spawn(mut commands: Commands) {
    // This collider belongs to the first two layers and can interact with the last layer.
    commands.spawn((
        Collider::sphere(0.5),
        CollisionLayers::from_bits(FIRST_LAYER | SECOND_LAYER, LAST_LAYER),
    ));
}

Modifying Layers

Existing CollisionLayers can be modified by simply accessing the memberships and filters and changing their LayerMasks.

let mut layers = CollisionLayers::new(0b0010, 0b1011);

// Add memberships (these are equivalent)
layers.memberships.add(0b0001);
layers.memberships |= 0b0001;

assert_eq!(layers.memberships, 0b0011);

// Remove filters
layers.filters.remove(0b0001);
layers.filters &= !0b0001;

assert_eq!(layers.filters, 0b1010);

// Check if layers are contained
assert!(layers.memberships.has_all(0b0011));
assert!((layers.memberships & 0b0011) != 0);

Fields

memberships: LayerMask

The layers that an entity belongs to.

filters: LayerMask

The layers that an entity can interact with.

Implementations

impl CollisionLayers

pub const DEFAULT: Self = _

Contains the default layer and all filters.

pub const ALL: Self = _

Contains all memberships and filters.

pub const NONE: Self = _

Contains no memberships and no filters.

pub const ALL_MEMBERSHIPS: Self = _

Contains all memberships but no filters.

pub const ALL_FILTERS: Self = _

Contains all filters but no memberships.

pub fn new( memberships: impl Into<LayerMask>, filters: impl Into<LayerMask>, ) -> Self

Creates a new CollisionLayers configuration with the given collision memberships and filters.

pub const fn from_bits(memberships: u32, filters: u32) -> Self

Creates a new CollisionLayers configuration using bits.

There is one bit per group and mask, so there are a total of 32 layers. For example, if an entity is a part of the layers [0, 1, 3] and can interact with the layers [1, 2], the memberships in bits would be 0b01011 while the filters would be 0b00110.

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

Returns true if an entity with this CollisionLayers configuration can interact with an entity with the other CollisionLayers configuration.

Trait Implementations

impl Clone for CollisionLayers

fn clone(&self) -> CollisionLayers

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Component for CollisionLayers

where Self: Send + Sync + 'static,

const STORAGE_TYPE: StorageType = bevy::ecs::component::StorageType::Table

A constant indicating the storage type used for this component.

fn register_required_components( requiree: ComponentId, components: &mut Components, storages: &mut Storages, required_components: &mut RequiredComponents, inheritance_depth: u16, )

Registers required components.

fn register_component_hooks(hooks: &mut ComponentHooks)

Called when registering this component, allowing mutable access to its ComponentHooks.

impl Debug for CollisionLayers

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

Formats the value using the given formatter.

impl Default for CollisionLayers

fn default() -> Self

Returns the “default value” for a type.

impl FromReflect for CollisionLayers

where CollisionLayers: Any + Send + Sync, LayerMask: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for CollisionLayers

where CollisionLayers: Any + Send + Sync, LayerMask: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

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 PartialReflect for CollisionLayers

where CollisionLayers: Any + Send + Sync, LayerMask: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

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

Clones the value as a Reflect trait object.

fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

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

Returns an immutable enumeration of “kinds” of type.

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

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Self>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Self>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&dyn Reflect>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Self>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &dyn PartialReflect

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut dyn PartialReflect

Casts this type to a mutable, reflected value.

fn reflect_partial_eq(&self, value: &dyn PartialReflect) -> Option<bool>

Returns a “partial equality” comparison result.

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

Debug formatter for the value.

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

Applies a reflected value to this value.

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

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

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

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl Reflect for CollisionLayers

where CollisionLayers: Any + Send + Sync, LayerMask: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &dyn Any

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut dyn Any

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Self>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut dyn Reflect

Casts this type to a mutable, fully-reflected value.

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

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

impl Struct for CollisionLayers

where CollisionLayers: Any + Send + Sync, LayerMask: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&dyn PartialReflect>

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

fn field_mut(&mut self, name: &str) -> Option<&mut dyn PartialReflect>

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

fn field_at(&self, index: usize) -> Option<&dyn PartialReflect>

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

fn field_at_mut(&mut self, index: usize) -> Option<&mut dyn PartialReflect>

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

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 reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl TypePath for CollisionLayers

where CollisionLayers: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for CollisionLayers

where CollisionLayers: Any + Send + Sync, LayerMask: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

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