[−][src]Struct collision::algorithm::minkowski::GJK
Gilbert-Johnson-Keerthi narrow phase collision detection algorithm.
Type parameters:
S
: simplex processor type. Should be eitherSimplexProcessor2
orSimplexProcessor3
E
: EPA algorithm implementation type. Should be eitherEPA2
orEPA3
Methods
impl<SP, E, S> GJK<SP, E, S> where
SP: SimplexProcessor,
SP::Point: EuclideanSpace<Scalar = S>,
S: BaseFloat,
E: EPA<Point = SP::Point>,
[src]
SP: SimplexProcessor,
SP::Point: EuclideanSpace<Scalar = S>,
S: BaseFloat,
E: EPA<Point = SP::Point>,
pub fn new() -> Self
[src]
Create a new GJK algorithm implementation
pub fn new_with_settings(
distance_tolerance: S,
continuous_tolerance: S,
epa_tolerance: S,
max_iterations: u32
) -> Self
[src]
distance_tolerance: S,
continuous_tolerance: S,
epa_tolerance: S,
max_iterations: u32
) -> Self
Create a new GJK algorithm implementation with the given tolerance settings
pub fn intersect<P, PL, PR, TL, TR>(
&self,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<SmallVec<[SupportPoint<P>; 5]>> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
SP: SimplexProcessor<Point = P>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
TL: Transform<P>,
TR: Transform<P>,
[src]
&self,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<SmallVec<[SupportPoint<P>; 5]>> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
SP: SimplexProcessor<Point = P>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
TL: Transform<P>,
TR: Transform<P>,
Do intersection test on the given primitives
Parameters:
left
: left primitiveleft_transform
: model-to-world-transform for the left primitiveright
: right primitive,right_transform
: model-to-world-transform for the right primitive
Returns:
Will return a simplex if a collision was detected. For 2D, the simplex will be a triangle, for 3D, it will be a tetrahedron. The simplex will enclose the origin. If no collision was detected, None is returned.
pub fn intersection_time_of_impact<P, PL, PR, TL, TR>(
&self,
left: &PL,
left_transform: Range<&TL>,
right: &PR,
right_transform: Range<&TR>
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
SP: SimplexProcessor<Point = P>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
TL: Transform<P> + TranslationInterpolate<S>,
TR: Transform<P> + TranslationInterpolate<S>,
[src]
&self,
left: &PL,
left_transform: Range<&TL>,
right: &PR,
right_transform: Range<&TR>
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
SP: SimplexProcessor<Point = P>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
TL: Transform<P> + TranslationInterpolate<S>,
TR: Transform<P> + TranslationInterpolate<S>,
Do time of impact intersection testing on the given primitives, and return a valid contact at the time of impact.
Parameters:
left
: left primitiveleft_transform
: model-to-world-transform for the left primitiveright
: right primitive,right_transform
: model-to-world-transform for the right primitive
Returns:
Will optionally return a contact manifold at the time of impact. If no collision was detected, None is returned.
pub fn distance<P, PL, PR, TL, TR>(
&self,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<S> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
SP: SimplexProcessor<Point = P>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
TL: Transform<P>,
TR: Transform<P>,
[src]
&self,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<S> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
SP: SimplexProcessor<Point = P>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
TL: Transform<P>,
TR: Transform<P>,
Compute the distance between the given primitives.
Parameters:
left
: left primitiveleft_transform
: model-to-world-transform for the left primitiveright
: right primitive,right_transform
: model-to-world-transform for the right primitive
Returns:
Will optionally return the distance between the objects. Will return None, if the objects are colliding.
pub fn get_contact_manifold<P, PL, PR, TL, TR>(
&self,
simplex: &mut Vec<SupportPoint<P>>,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
[src]
&self,
simplex: &mut Vec<SupportPoint<P>>,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
Given a GJK simplex that encloses the origin, compute the contact manifold.
Uses the EPA algorithm to find the contact information from the simplex.
pub fn intersection<P, PL, PR, TL, TR>(
&self,
strategy: &CollisionStrategy,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
[src]
&self,
strategy: &CollisionStrategy,
left: &PL,
left_transform: &TL,
right: &PR,
right_transform: &TR
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
Do intersection testing on the given primitives, and return the contact manifold.
Parameters:
strategy
: strategy to use, ifCollisionOnly
it will only return a boolean result, otherwise, EPA will be used to compute the exact contact point.left
: left primitiveleft_transform
: model-to-world-transform for the left primitiveright
: right primitive,right_transform
: model-to-world-transform for the right primitive
Returns:
Will optionally return a Contact
if a collision was detected. In CollisionOnly
mode,
this contact will only be a boolean result. For FullResolution
mode, the contact will
contain a full manifold (collision normal, penetration depth and contact point).
pub fn intersection_complex<P, PL, PR, TL, TR>(
&self,
strategy: &CollisionStrategy,
left: &[(PL, TL)],
left_transform: &TL,
right: &[(PR, TR)],
right_transform: &TR
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
[src]
&self,
strategy: &CollisionStrategy,
left: &[(PL, TL)],
left_transform: &TL,
right: &[(PR, TR)],
right_transform: &TR
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
Do intersection test on the given complex shapes, and return the actual intersection point
Parameters:
strategy
: strategy to use, ifCollisionOnly
it will only return a boolean result, otherwise, EPA will be used to compute the exact contact point.left
: shape consisting of a slice of primitive + local-to-model-transform for each primitive,left_transform
: model-to-world-transform for the left shaperight
: shape consisting of a slice of primitive + local-to-model-transform for each primitive,right_transform
: model-to-world-transform for the right shape
Returns:
Will optionally return a Contact
if a collision was detected. In CollisionOnly
mode,
this contact will only be a boolean result. For FullResolution
mode, the contact will
contain a full manifold (collision normal, penetration depth and contact point), for the
contact with the highest penetration depth.
pub fn distance_complex<P, PL, PR, TL, TR>(
&self,
left: &[(PL, TL)],
left_transform: &TL,
right: &[(PR, TR)],
right_transform: &TR
) -> Option<S> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
[src]
&self,
left: &[(PL, TL)],
left_transform: &TL,
right: &[(PR, TR)],
right_transform: &TR
) -> Option<S> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P>,
TR: Transform<P>,
SP: SimplexProcessor<Point = P>,
Compute the distance between the given shapes.
Parameters:
left
: left shapeleft_transform
: model-to-world-transform for the left shaperight
: right shape,right_transform
: model-to-world-transform for the right shape
Returns:
Will optionally return the smallest distance between the objects. Will return None, if the objects are colliding.
pub fn intersection_complex_time_of_impact<P, PL, PR, TL, TR>(
&self,
strategy: &CollisionStrategy,
left: &[(PL, TL)],
left_transform: Range<&TL>,
right: &[(PR, TR)],
right_transform: Range<&TR>
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P> + TranslationInterpolate<S>,
TR: Transform<P> + TranslationInterpolate<S>,
SP: SimplexProcessor<Point = P>,
[src]
&self,
strategy: &CollisionStrategy,
left: &[(PL, TL)],
left_transform: Range<&TL>,
right: &[(PR, TR)],
right_transform: Range<&TR>
) -> Option<Contact<P>> where
P: EuclideanSpace<Scalar = S>,
P::Diff: Neg<Output = P::Diff> + InnerSpace + Zero + Array<Element = S>,
PL: Primitive<Point = P>,
PR: Primitive<Point = P>,
TL: Transform<P> + TranslationInterpolate<S>,
TR: Transform<P> + TranslationInterpolate<S>,
SP: SimplexProcessor<Point = P>,
Do intersection time of impact test on the given complex shapes, and return the contact at the time of impact
Parameters:
strategy
: strategy to use, ifCollisionOnly
it will only return a boolean result, otherwise, a full contact manifold will be returned.left
: shape consisting of a slice of primitive + local-to-model-transform for each primitive,left_transform
: model-to-world-transform for the left shaperight
: shape consisting of a slice of primitive + local-to-model-transform for each primitive,right_transform
: model-to-world-transform for the right shape
Returns:
Will optionally return the contact if a collision was detected.
In CollisionOnly
mode, this contact will only be a time of impact. For FullResolution
mode, the time of impact will be the earliest found among all shape primitives.
Will return None if no collision was found.
Trait Implementations
Auto Trait Implementations
impl<SP, E, S> Send for GJK<SP, E, S> where
E: Send,
S: Send,
SP: Send,
E: Send,
S: Send,
SP: Send,
impl<SP, E, S> Sync for GJK<SP, E, S> where
E: Sync,
S: Sync,
SP: Sync,
E: Sync,
S: Sync,
SP: Sync,
Blanket Implementations
impl<T> From for T
[src]
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,