Trait mgf::Contacts

pub trait Contacts<RHS> {
    fn contacts<F: FnMut(Contact)>(&self, rhs: &RHS, callback: F) -> bool;

    fn last_contact(&self, rhs: &RHS) -> Option<Contact> { ... }
}

A type that can produce a point of contact with another.

Contacts models a hybrid discrete/continuous approach to collision detection that uses continuous detection to find precise contact points and collision normals over discrete timesteps.

Either the type implementing Contacts or the type paramater must be Volumetric. Both can be as well. In addition, at least one of the types must be Moving in some way.

A Contact collision can potentially produce multiple contacts, in the case of Capsule/Polygon collision and Compound collisions. This is handled by passing a closure to the collision handler.

Required methods

fn contacts<F: FnMut(Contact)>(&self, rhs: &RHS, callback: F) -> bool

Calls the closure for each contact found. Returns true if any contact was found.

Loading content...

Provided methods

fn last_contact(&self, rhs: &RHS) -> Option<Contact>

Returns the last contact found, if one exists.

Loading content...

Implementors

impl Contacts<Moving<Component>> for Capsule

fn contacts<F: FnMut(Contact)>(
    &self,
    rhs: &Moving<Component>,
    callback: F
) -> bool

impl Contacts<Moving<Component>> for Plane

fn contacts<F: FnMut(Contact)>(
    &self,
    rhs: &Moving<Component>,
    callback: F
) -> bool

impl Contacts<Moving<Component>> for Rectangle

fn contacts<F: FnMut(Contact)>(
    &self,
    rhs: &Moving<Component>,
    callback: F
) -> bool

impl Contacts<Moving<Component>> for Sphere

fn contacts<F: FnMut(Contact)>(
    &self,
    rhs: &Moving<Component>,
    callback: F
) -> bool

impl Contacts<Moving<Component>> for Triangle

fn contacts<F: FnMut(Contact)>(
    &self,
    rhs: &Moving<Component>,
    callback: F
) -> bool

impl Contacts<Moving<Capsule>> for Capsule

fn contacts<F: FnMut(Contact)>(
    &self,
    capsule: &Moving<Capsule>,
    callback: F
) -> bool

impl Contacts<Moving<Capsule>> for Plane

fn contacts<F: FnMut(Contact)>(
    &self,
    capsule: &Moving<Capsule>,
    callback: F
) -> bool

impl Contacts<Moving<Capsule>> for Sphere

fn contacts<F: FnMut(Contact)>(
    &self,
    rhs: &Moving<Capsule>,
    callback: F
) -> bool

impl Contacts<Moving<Sphere>> for Capsule

fn contacts<F: FnMut(Contact)>(
    &self,
    sphere: &Moving<Sphere>,
    callback: F
) -> bool

impl Contacts<Moving<Sphere>> for Plane

fn contacts<F: FnMut(Contact)>(
    &self,
    sphere: &Moving<Sphere>,
    callback: F
) -> bool

impl Contacts<Moving<Sphere>> for Sphere

fn contacts<F: FnMut(Contact)>(
    &self,
    sphere: &Moving<Sphere>,
    callback: F
) -> bool

impl Contacts<Plane> for Moving<Capsule>

fn contacts<F: FnMut(Contact)>(&self, rhs: &Plane, callback: F) -> bool

impl Contacts<Plane> for Moving<Sphere>

fn contacts<F: FnMut(Contact)>(&self, rhs: &Plane, callback: F) -> bool

impl Contacts<Rectangle> for Moving<Capsule>

fn contacts<F: FnMut(Contact)>(&self, rhs: &Rectangle, callback: F) -> bool

impl Contacts<Rectangle> for Moving<Sphere>

fn contacts<F: FnMut(Contact)>(&self, rhs: &Rectangle, callback: F) -> bool

impl Contacts<Triangle> for Moving<Capsule>

fn contacts<F: FnMut(Contact)>(&self, rhs: &Triangle, callback: F) -> bool

impl Contacts<Triangle> for Moving<Sphere>

fn contacts<F: FnMut(Contact)>(&self, rhs: &Triangle, callback: F) -> bool

impl<Poly: Polygon> Contacts<Moving<Capsule>> for Poly

Colliding a moving capsule with a single-faced polygon can potentially produce multiple contacts depending on the angle between the capsule's length and the normal of the polygon's face.

fn contacts<F: FnMut(Contact)>(
    &self,
    capsule: &Moving<Capsule>,
    callback: F
) -> bool

impl<Poly: Polygon> Contacts<Moving<Sphere>> for Poly

fn contacts<F: FnMut(Contact)>(
    &self,
    sphere: &Moving<Sphere>,
    callback: F
) -> bool

impl<RHS> Contacts<RHS> for Compound where
    RHS: Contacts<Component> + BoundedBy<AABB>, 

fn contacts<F: FnMut(Contact)>(&self, rhs: &RHS, callback: F) -> bool

impl<RHS> Contacts<RHS> for Mesh where
    RHS: Contacts<Triangle> + Contacts<Rectangle> + BoundedBy<AABB>, 

fn contacts<F: FnMut(Contact)>(&self, rhs: &RHS, callback: F) -> bool

impl<RHS> Contacts<RHS> for Moving<Component> where
    RHS: Contacts<Moving<Sphere>> + Contacts<Moving<Capsule>>, 

fn contacts<F: FnMut(Contact)>(&self, rhs: &RHS, callback: F) -> bool

impl<Recv, Arg> Contacts<Moving<Arg>> for Moving<Recv> where
    Recv: Contacts<Moving<Arg>> + Shape + Copy,
    Arg: Shape + Copy, 

Any two moving object collision can be reduced to a one moving one static object collision. This is done by finding the relative velocity between the two objects.

fn contacts<F: FnMut(Contact)>(&self, rhs: &Moving<Arg>, callback: F) -> bool

impl<Recv, Arg> Contacts<Arg> for Moving<Recv> where
    Arg: Shape + Copy,
    Recv: Contacts<Moving<Arg>> + Shape, 

fn contacts<F: FnMut(Contact)>(&self, rhs: &Arg, callback: F) -> bool

impl<ShapeA, ShapeB> Contacts<ShapeB> for ShapeA where
    ShapeA: Convex + Volumetric,
    ShapeB: Convex + Volumetric, 

fn contacts<F: FnMut(Contact)>(&self, rhs: &ShapeB, callback: F) -> bool

Loading content...