Struct CollisionGroups

pub struct CollisionGroups { /* private fields */ }

Groups of collision used to filter which object interact with which other one.

There are at most 30 groups indexed from 0 to 29 (included). This identifies collidable entities by combining three attributes:

• A set of group this structure is member of.
• A collision group whitelist.
• A collision group blacklist.

For two entities to interact, they must be member of at least one group part of each-other’s whitelists, and must not be part of any blacklisted group. The blacklist always has priority on the whitelist.

Example

For example if the object A is such that:

• It is part of the groups 1, 3, and 6.
• It whitelists the groups 6 and 7.
• It blacklists the group 1.

Let there be an object B such that:

• It is part of the groups 1, 3, and 7.
• It whitelists the groups 3 and 7.
• It does not blacklist anything.

and an object C such that:

• It is part of the groups 6 and 9.
• It whitelists the groups 3 and 7.
• It does not blacklist anything.

Then we have:

• A and C can interact because A whitelists the group 6 (which C is part of), and, reciprocally, C whitelists the group 3 (which A is part of).
• A and B will not interact because B is part of the group 1 which is blacklisted by A.
• Finally, B and C will not interact either because, even if C whitelists the group 3 (which B is part of), B does not whitelists the groups 6 nor 9 (which B is part of).

Implementations

impl CollisionGroups

pub fn new() -> CollisionGroups

Creates a new CollisionGroups that enables interactions with everything except self-interaction.

pub fn empty() -> CollisionGroups

Creates a new CollisionGroups that disables interactions with everything.

pub fn with_membership(self, groups: &[usize]) -> CollisionGroups

Returns a copy of this object, updated with a new set of membership groups.

Examples

const GROUP_A: usize = 0;
const GROUP_B: usize = 29;
let groups = CollisionGroups::new().with_membership(&[GROUP_A, GROUP_B]);
assert!(groups.is_member_of(GROUP_A));
assert!(groups.is_member_of(GROUP_B));

pub fn with_whitelist(self, groups: &[usize]) -> CollisionGroups

Returns a copy of this object, updated with a new set of whitelisted groups.

Examples

const GROUP_A: usize = 0;
const GROUP_B: usize = 29;
let group_a = CollisionGroups::new().with_whitelist(&[GROUP_B]);
assert!(!group_a.is_group_whitelisted(GROUP_A));
assert!(group_a.is_group_whitelisted(GROUP_B));

pub fn with_blacklist(self, groups: &[usize]) -> CollisionGroups

Returns a copy of this object, updated with a new set of blacklisted groups.

Examples

const GROUP_A: usize = 0;
const GROUP_B: usize = 29;
let group_a = CollisionGroups::new().with_blacklist(&[GROUP_B]);
assert!(!group_a.is_group_blacklisted(GROUP_A));
assert!(group_a.is_group_blacklisted(GROUP_B));

pub fn max_group_id() -> usize

The maximum allowed group identifier.

pub fn add_membership_by_mask(self, group_mask: u32) -> CollisionGroups

adds this entity to the given group by a mask of bits where each bit index represent a group

pub fn remove_membership_by_mask(self, group_mask: u32) -> CollisionGroups

removes this entity from the given group by a mask of bits where each bit index represent a group

pub fn with_membership_by_mask(self, group_mask: u32) -> CollisionGroups

Replaces the membership with a mask of bits where each bit index represent a group

pub fn add_whitelist_by_mask(self, group_mask: u32) -> CollisionGroups

adds this entity to this entity whitelist by a mask of bits where each bit index represent a group

pub fn remove_whitelist_by_mask(self, group_mask: u32) -> CollisionGroups

remove this entity from this entity whitelist by a mask of bits where each bit index represent a group

pub fn with_whitelist_by_mask(self, group_mask: u32) -> CollisionGroups

Replaces the whitelist with a mask of bits where each bit index represent a group

pub fn add_blacklist_by_mask(self, group_mask: u32) -> CollisionGroups

adds this entity to this entity blacklist by a mask of bits where each bit index represent a group

pub fn remove_blacklist_by_mask(self, group_mask: u32) -> CollisionGroups

remove this entity from this entity blacklist by a mask of bits where each bit index represent a group

pub fn with_blacklist_by_mask(self, group_mask: u32) -> CollisionGroups

Replaces the blacklist with a mask of bits where each bit index represent a group

pub fn modify_membership(&mut self, group_id: usize, add: bool)

Adds or removes this entity from the given group.

pub fn modify_whitelist(&mut self, group_id: usize, add: bool)

Adds or removes the given group from this entity whitelist.

pub fn modify_blacklist(&mut self, group_id: usize, add: bool)

Adds or removes this entity from the given group.

pub fn set_membership(&mut self, groups: &[usize])

Make this object member of the given groups only.

pub fn set_whitelist(&mut self, groups: &[usize])

Whitelists the given groups only (others will be un-whitelisted).

pub fn set_blacklist(&mut self, groups: &[usize])

Blacklists the given groups only (others will be un-blacklisted).

pub fn copy_membership(&mut self, other: &CollisionGroups)

Copies the membership of another collision groups.

pub fn copy_whitelist(&mut self, other: &CollisionGroups)

Copies the whitelist of another collision groups.

pub fn copy_blacklist(&mut self, other: &CollisionGroups)

Copies the blacklist of another collision groups.

pub fn enable_self_interaction(&mut self)

Allows the object to interact with itself.

pub fn disable_self_interaction(&mut self)

Prevents the object from interacting with itself.

pub fn is_member_of(&self, group_id: usize) -> bool

Tests if this entity is part of the given group.

pub fn is_group_whitelisted(&self, group_id: usize) -> bool

Tests if the given group is whitelisted.

pub fn is_group_blacklisted(&self, group_id: usize) -> bool

Tests if the given group is blacklisted.

pub fn can_interact_with(&self, group_id: usize) -> bool

Tests whether interactions with a given group is possible.

Collision is possible if group_id is whitelisted but not blacklisted.

pub fn can_interact_with_groups(&self, other: &CollisionGroups) -> bool

Tests whether two collision groups have at least one group in common.

pub fn can_interact_with_self(&self) -> bool

Tests whether self-interaction is enabled.

Trait Implementations

impl Clone for CollisionGroups

fn clone(&self) -> CollisionGroups

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CollisionGroups

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

Formats the value using the given formatter.

impl Default for CollisionGroups

fn default() -> Self

Returns the “default value” for a type.

impl Copy for CollisionGroups