[][src]Struct ncollide2d::pipeline::object::CollisionGroups

pub struct CollisionGroups { /* fields omitted */ }

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).

Methods

impl CollisionGroups[src]

pub fn new() -> CollisionGroups[src]

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

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

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

Examples

This example is not tested
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[src]

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

Examples

This example is not tested
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[src]

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

Examples

This example is not tested
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[src]

The maximum allowed group identifier.

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

Adds or removes this entity from the given group.

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

Adds or removes the given group from this entity whitelist.

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

Adds or removes this entity from the given group.

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

Make this object member of the given groups only.

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

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

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

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

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

Copies the membership of another collision groups.

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

Copies the whitelist of another collision groups.

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

Copies the blacklist of another collision groups.

pub fn enable_self_interaction(&mut self)[src]

Allows the object to interact with itself.

pub fn disable_self_interaction(&mut self)[src]

Prevents the object from interacting with itself.

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

Tests if this entity is part of the given group.

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

Tests if the given group is whitelisted.

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

Tests if the given group is blacklisted.

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

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[src]

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

pub fn can_interact_with_self(&self) -> bool[src]

Tests whether self-interaction is enabled.

Trait Implementations

impl Clone for CollisionGroups[src]

impl Copy for CollisionGroups[src]

impl Debug for CollisionGroups[src]

impl Default for CollisionGroups[src]

Auto Trait Implementations

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Downcast for T where
    T: Any

impl<T> DowncastSync for T where
    T: Send + Sync + Any

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> Same<T> for T

type Output = T

Should always be Self

impl<T> Slottable for T where
    T: Copy
[src]

impl<SS, SP> SupersetOf<SS> for SP where
    SS: SubsetOf<SP>, 

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<V, T> VZip<V> for T where
    V: MultiLane<T>,