Struct InteractionGroups 

#[repr(C)]
pub struct InteractionGroups {
    pub memberships: Group,
    pub filter: Group,
    pub test_mode: InteractionTestMode,
}

Collision filtering system that controls which colliders can interact with each other.

Think of this as “collision layers” in game engines. Each collider has:

• Memberships: What groups does this collider belong to? (up to 32 groups)
• Filter: What groups can this collider interact with?

An interaction is allowed between two colliders a and b when two conditions are met simultaneously for InteractionTestMode::And or individually for InteractionTestMode::Or::

• The groups membership of a has at least one bit set to 1 in common with the groups filter of b.
• The groups membership of b has at least one bit set to 1 in common with the groups filter of a.

In other words, interactions are allowed between two colliders iff. the following condition is met for InteractionTestMode::And:

(self.memberships.bits() & rhs.filter.bits()) != 0 && (rhs.memberships.bits() & self.filter.bits()) != 0

or for InteractionTestMode::Or:

(self.memberships.bits() & rhs.filter.bits()) != 0 || (rhs.memberships.bits() & self.filter.bits()) != 0

Common use cases

• Player vs. Enemy bullets: Players in group 1, enemies in group 2. Player bullets only hit group 2, enemy bullets only hit group 1.
• Trigger zones: Sensors that only detect specific object types.

Example

// Player collider: in group 1, collides with groups 2 and 3
let player_groups = InteractionGroups::new(
    Group::GROUP_1,                    // I am in group 1
    Group::GROUP_2, | Group::GROUP_3,  // I collide with groups 2 and 3
    InteractionTestMode::And
);

// Enemy collider: in group 2, collides with group 1
let enemy_groups = InteractionGroups::new(
    Group::GROUP_2,  // I am in group 2
    Group::GROUP_1,  // I collide with group 1
    InteractionTestMode::And
);

// These will collide because:
// - Player's membership (GROUP_1) is in enemy's filter (GROUP_1) ✓
// - Enemy's membership (GROUP_2) is in player's filter (GROUP_2) ✓
assert!(player_groups.test(enemy_groups));

Fields

memberships: Group

Groups memberships.

filter: Group

Groups filter.

test_mode: InteractionTestMode

Interaction test mode

In case of different test modes between two InteractionGroups, InteractionTestMode::And is given priority.

Implementations

impl InteractionGroups

pub const fn new( memberships: Group, filter: Group, test_mode: InteractionTestMode, ) -> Self

Initializes with the given interaction groups and interaction mask.

pub const fn all() -> Self

Creates a filter that allows interactions with everything (default behavior).

The collider is in all groups and collides with all groups.

pub const fn none() -> Self

Creates a filter that prevents all interactions.

The collider won’t collide with anything. Useful for temporarily disabled colliders.

pub const fn with_memberships(self, memberships: Group) -> Self

Sets the group this filter is part of.

pub const fn with_filter(self, filter: Group) -> Self

Sets the interaction mask of this filter.

pub const fn test_and(self, rhs: Self) -> bool

Check if interactions should be allowed based on the interaction memberships and filter.

An interaction is allowed iff. the memberships of self contain at least one bit set to 1 in common with the filter of rhs, and vice-versa.

pub const fn test_or(self, rhs: Self) -> bool

Check if interactions should be allowed based on the interaction memberships and filter.

An interaction is allowed iff. the groups of self contain at least one bit set to 1 in common with the mask of rhs, or vice-versa.

pub const fn test(self, rhs: Self) -> bool

Check if interactions should be allowed based on the interaction memberships and filter.

See InteractionTestMode for more info.

Trait Implementations

impl Clone for InteractionGroups

fn clone(&self) -> InteractionGroups

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InteractionGroups

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

Formats the value using the given formatter.

impl Default for InteractionGroups

fn default() -> Self

Returns the “default value” for a type.

impl From<InteractionGroups> for QueryFilter<'_>

fn from(groups: InteractionGroups) -> Self

Converts to this type from the input type.

impl Hash for InteractionGroups

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for InteractionGroups

fn eq(&self, other: &InteractionGroups) -> 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 Copy for InteractionGroups

impl Eq for InteractionGroups

impl StructuralPartialEq for InteractionGroups