Struct avian3d::collision::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

Colliders without this component can be considered as having all memberships and filters, and they can interact with everything that belongs on 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)]
enum GameLayer {
    Player, // Layer 0
    Enemy,  // Layer 1
    Ground, // Layer 2
}

// Player collides with enemies and the ground, but not with other players
let layers = CollisionLayers::new(GameLayer::Player, [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;
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 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_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 Self: Any + Send + Sync, LayerMask: FromReflect + TypePath + RegisterForReflection,

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

Constructs a concrete instance of Self from a reflected value.

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

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

impl GetTypeRegistration for CollisionLayers

where Self: Any + Send + Sync, LayerMask: FromReflect + TypePath + 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

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

where Self: Any + Send + Sync, LayerMask: FromReflect + TypePath + RegisterForReflection,

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

Returns the TypeInfo of the type represented by this value.

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 reflected value.

fn as_reflect(&self) -> &dyn Reflect

Casts this type to a reflected value.

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

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 try_apply(&mut self, value: &dyn Reflect) -> 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 reflect_partial_eq(&self, value: &dyn Reflect) -> 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 Reflect + '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 Struct for CollisionLayers

where Self: Any + Send + Sync, LayerMask: FromReflect + TypePath + RegisterForReflection,

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

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>

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>

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>

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

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

impl TypePath for CollisionLayers

where Self: 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 Self: Any + Send + Sync, LayerMask: FromReflect + TypePath + 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