Struct bevy_rapier2d::prelude::ColliderPosition

pub struct ColliderPosition(pub Isometry<f32, Unit<Complex<f32>>, 2_usize>);

The position of a collider.

Implementations

impl ColliderPosition

#[must_use]

pub fn identity() -> ColliderPosition

The identity position.

Methods from Deref<Target = Isometry<f32, Unit<Complex<f32>>, 2_usize>>

#[must_use = "Did you mean to use inverse_mut()?"]

pub fn inverse(&self) -> Isometry<T, R, D>

Inverts self.

Example

let iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
let inv = iso.inverse();
let pt = Point2::new(1.0, 2.0);

assert_eq!(inv * (iso * pt), pt);

pub fn inv_mul(&self, rhs: &Isometry<T, R, D>) -> Isometry<T, R, D>

Computes self.inverse() * rhs in a more efficient way.

Example

let mut iso1 = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
let mut iso2 = Isometry2::new(Vector2::new(10.0, 20.0), f32::consts::FRAC_PI_4);

assert_eq!(iso1.inverse() * iso2, iso1.inv_mul(&iso2));

pub fn transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

Transform the given point by this isometry.

This is the same as the multiplication self * pt.

Example

let tra = Translation3::new(0.0, 0.0, 3.0);
let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
let iso = Isometry3::from_parts(tra, rot);

let transformed_point = iso.transform_point(&Point3::new(1.0, 2.0, 3.0));
assert_relative_eq!(transformed_point, Point3::new(3.0, 2.0, 2.0), epsilon = 1.0e-6);

pub fn transform_vector(
    &self,
    v: &Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>

Transform the given vector by this isometry, ignoring the translation component of the isometry.

This is the same as the multiplication self * v.

Example

let tra = Translation3::new(0.0, 0.0, 3.0);
let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
let iso = Isometry3::from_parts(tra, rot);

let transformed_point = iso.transform_vector(&Vector3::new(1.0, 2.0, 3.0));
assert_relative_eq!(transformed_point, Vector3::new(3.0, 2.0, -1.0), epsilon = 1.0e-6);

pub fn inverse_transform_point(&self, pt: &Point<T, D>) -> Point<T, D>

Transform the given point by the inverse of this isometry. This may be less expensive than computing the entire isometry inverse and then transforming the point.

Example

let tra = Translation3::new(0.0, 0.0, 3.0);
let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
let iso = Isometry3::from_parts(tra, rot);

let transformed_point = iso.inverse_transform_point(&Point3::new(1.0, 2.0, 3.0));
assert_relative_eq!(transformed_point, Point3::new(0.0, 2.0, 1.0), epsilon = 1.0e-6);

pub fn inverse_transform_vector(
    &self,
    v: &Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>
) -> Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>

Transform the given vector by the inverse of this isometry, ignoring the translation component of the isometry. This may be less expensive than computing the entire isometry inverse and then transforming the point.

Example

let tra = Translation3::new(0.0, 0.0, 3.0);
let rot = UnitQuaternion::from_scaled_axis(Vector3::y() * f32::consts::FRAC_PI_2);
let iso = Isometry3::from_parts(tra, rot);

let transformed_point = iso.inverse_transform_vector(&Vector3::new(1.0, 2.0, 3.0));
assert_relative_eq!(transformed_point, Vector3::new(-3.0, 2.0, 1.0), epsilon = 1.0e-6);

pub fn inverse_transform_unit_vector(
    &self,
    v: &Unit<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>
) -> Unit<Matrix<T, Const<D>, Const<1_usize>, ArrayStorage<T, D, 1_usize>>>

Transform the given unit vector by the inverse of this isometry, ignoring the translation component of the isometry. This may be less expensive than computing the entire isometry inverse and then transforming the point.

Example

let tra = Translation3::new(0.0, 0.0, 3.0);
let rot = UnitQuaternion::from_scaled_axis(Vector3::z() * f32::consts::FRAC_PI_2);
let iso = Isometry3::from_parts(tra, rot);

let transformed_point = iso.inverse_transform_unit_vector(&Vector3::x_axis());
assert_relative_eq!(transformed_point, -Vector3::y_axis(), epsilon = 1.0e-6);

pub fn to_homogeneous(
    &self
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
    R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>, 

Converts this isometry into its equivalent homogeneous transformation matrix.

This is the same as self.to_matrix().

Example

let iso = Isometry2::new(Vector2::new(10.0, 20.0), f32::consts::FRAC_PI_6);
let expected = Matrix3::new(0.8660254, -0.5,      10.0,
                            0.5,       0.8660254, 20.0,
                            0.0,       0.0,       1.0);

assert_relative_eq!(iso.to_homogeneous(), expected, epsilon = 1.0e-6);

pub fn to_matrix(
    &self
) -> Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer> where
    R: SubsetOf<Matrix<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <DefaultAllocator as Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>>::Buffer>>,
    Const<D>: DimNameAdd<Const<1_usize>>,
    DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>, 

Converts this isometry into its equivalent homogeneous transformation matrix.

This is the same as self.to_homogeneous().

Example

let iso = Isometry2::new(Vector2::new(10.0, 20.0), f32::consts::FRAC_PI_6);
let expected = Matrix3::new(0.8660254, -0.5,      10.0,
                            0.5,       0.8660254, 20.0,
                            0.0,       0.0,       1.0);

assert_relative_eq!(iso.to_matrix(), expected, epsilon = 1.0e-6);

pub fn lerp_slerp(
    &self,
    other: &Isometry<T, Unit<Quaternion<T>>, 3_usize>,
    t: T
) -> Isometry<T, Unit<Quaternion<T>>, 3_usize> where
    T: RealField, 

Interpolates between two isometries using a linear interpolation for the translation part, and a spherical interpolation for the rotation part.

Panics if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined). Use .try_lerp_slerp instead to avoid the panic.

Examples:

let t1 = Translation3::new(1.0, 2.0, 3.0);
let t2 = Translation3::new(4.0, 8.0, 12.0);
let q1 = UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0);
let q2 = UnitQuaternion::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0);
let iso1 = Isometry3::from_parts(t1, q1);
let iso2 = Isometry3::from_parts(t2, q2);

let iso3 = iso1.lerp_slerp(&iso2, 1.0 / 3.0);

assert_eq!(iso3.translation.vector, Vector3::new(2.0, 4.0, 6.0));
assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));

pub fn try_lerp_slerp(
    &self,
    other: &Isometry<T, Unit<Quaternion<T>>, 3_usize>,
    t: T,
    epsilon: T
) -> Option<Isometry<T, Unit<Quaternion<T>>, 3_usize>> where
    T: RealField, 

Attempts to interpolate between two isometries using a linear interpolation for the translation part, and a spherical interpolation for the rotation part.

Retuns None if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined).

Examples:

let t1 = Translation3::new(1.0, 2.0, 3.0);
let t2 = Translation3::new(4.0, 8.0, 12.0);
let q1 = UnitQuaternion::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0);
let q2 = UnitQuaternion::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0);
let iso1 = Isometry3::from_parts(t1, q1);
let iso2 = Isometry3::from_parts(t2, q2);

let iso3 = iso1.lerp_slerp(&iso2, 1.0 / 3.0);

assert_eq!(iso3.translation.vector, Vector3::new(2.0, 4.0, 6.0));
assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));

pub fn lerp_slerp(
    &self,
    other: &Isometry<T, Rotation<T, 3_usize>, 3_usize>,
    t: T
) -> Isometry<T, Rotation<T, 3_usize>, 3_usize> where
    T: RealField, 

Interpolates between two isometries using a linear interpolation for the translation part, and a spherical interpolation for the rotation part.

Panics if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined). Use .try_lerp_slerp instead to avoid the panic.

Examples:

let t1 = Translation3::new(1.0, 2.0, 3.0);
let t2 = Translation3::new(4.0, 8.0, 12.0);
let q1 = Rotation3::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0);
let q2 = Rotation3::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0);
let iso1 = IsometryMatrix3::from_parts(t1, q1);
let iso2 = IsometryMatrix3::from_parts(t2, q2);

let iso3 = iso1.lerp_slerp(&iso2, 1.0 / 3.0);

assert_eq!(iso3.translation.vector, Vector3::new(2.0, 4.0, 6.0));
assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));

pub fn try_lerp_slerp(
    &self,
    other: &Isometry<T, Rotation<T, 3_usize>, 3_usize>,
    t: T,
    epsilon: T
) -> Option<Isometry<T, Rotation<T, 3_usize>, 3_usize>> where
    T: RealField, 

Attempts to interpolate between two isometries using a linear interpolation for the translation part, and a spherical interpolation for the rotation part.

Retuns None if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined).

Examples:

let t1 = Translation3::new(1.0, 2.0, 3.0);
let t2 = Translation3::new(4.0, 8.0, 12.0);
let q1 = Rotation3::from_euler_angles(std::f32::consts::FRAC_PI_4, 0.0, 0.0);
let q2 = Rotation3::from_euler_angles(-std::f32::consts::PI, 0.0, 0.0);
let iso1 = IsometryMatrix3::from_parts(t1, q1);
let iso2 = IsometryMatrix3::from_parts(t2, q2);

let iso3 = iso1.lerp_slerp(&iso2, 1.0 / 3.0);

assert_eq!(iso3.translation.vector, Vector3::new(2.0, 4.0, 6.0));
assert_eq!(iso3.rotation.euler_angles(), (std::f32::consts::FRAC_PI_2, 0.0, 0.0));

pub fn lerp_slerp(
    &self,
    other: &Isometry<T, Unit<Complex<T>>, 2_usize>,
    t: T
) -> Isometry<T, Unit<Complex<T>>, 2_usize> where
    T: RealField, 

Interpolates between two isometries using a linear interpolation for the translation part, and a spherical interpolation for the rotation part.

Panics if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined). Use .try_lerp_slerp instead to avoid the panic.

Examples:

let t1 = Translation2::new(1.0, 2.0);
let t2 = Translation2::new(4.0, 8.0);
let q1 = UnitComplex::new(std::f32::consts::FRAC_PI_4);
let q2 = UnitComplex::new(-std::f32::consts::PI);
let iso1 = Isometry2::from_parts(t1, q1);
let iso2 = Isometry2::from_parts(t2, q2);

let iso3 = iso1.lerp_slerp(&iso2, 1.0 / 3.0);

assert_eq!(iso3.translation.vector, Vector2::new(2.0, 4.0));
assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2);

pub fn lerp_slerp(
    &self,
    other: &Isometry<T, Rotation<T, 2_usize>, 2_usize>,
    t: T
) -> Isometry<T, Rotation<T, 2_usize>, 2_usize> where
    T: RealField, 

Interpolates between two isometries using a linear interpolation for the translation part, and a spherical interpolation for the rotation part.

Panics if the angle between both rotations is 180 degrees (in which case the interpolation is not well-defined). Use .try_lerp_slerp instead to avoid the panic.

Examples:

let t1 = Translation2::new(1.0, 2.0);
let t2 = Translation2::new(4.0, 8.0);
let q1 = Rotation2::new(std::f32::consts::FRAC_PI_4);
let q2 = Rotation2::new(-std::f32::consts::PI);
let iso1 = IsometryMatrix2::from_parts(t1, q1);
let iso2 = IsometryMatrix2::from_parts(t2, q2);

let iso3 = iso1.lerp_slerp(&iso2, 1.0 / 3.0);

assert_eq!(iso3.translation.vector, Vector2::new(2.0, 4.0));
assert_relative_eq!(iso3.rotation.angle(), std::f32::consts::FRAC_PI_2);

Trait Implementations

impl AsRef<Isometry<f32, Unit<Complex<f32>>, 2_usize>> for ColliderPosition

pub fn as_ref(&self) -> &Isometry<f32, Unit<Complex<f32>>, 2_usize>

Performs the conversion.

impl Clone for ColliderPosition

pub fn clone(&self) -> ColliderPosition

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'b, 'c> ComponentSet<ColliderPosition> for QueryPipelineColliderComponentsSet<'a, 'b, 'c>

fn size_hint(&self) -> usize

The estimated number of elements in this set.

fn for_each(&self, f: impl FnMut(Index, &ColliderPosition))

Iterate through all the elements on this set.

fn index(&self, handle: Index) -> &T

Get the element associated to the given handle.

impl<'a, 'b, 'c> ComponentSet<ColliderPosition> for ColliderComponentsSet<'a, 'b, 'c>

fn size_hint(&self) -> usize

The estimated number of elements in this set.

fn for_each(&self, f: impl FnMut(Index, &ColliderPosition))

Iterate through all the elements on this set.

fn index(&self, handle: Index) -> &T

Get the element associated to the given handle.

impl<'a, 'b, 'c> ComponentSetMut<ColliderPosition> for ColliderComponentsSet<'a, 'b, 'c>

fn set_internal(&mut self, handle: Index, val: ColliderPosition)

Set the value of this element.

fn map_mut_internal<Result>(
    &mut self,
    handle: Index,
    f: impl FnOnce(&mut ColliderPosition) -> Result
) -> Option<Result>

Applies the given closure to the element associated to the given handle.

impl<'a, 'b, 'c> ComponentSetOption<ColliderPosition> for QueryPipelineColliderComponentsSet<'a, 'b, 'c>

fn get(&self, handle: Index) -> Option<&ColliderPosition>

Get the element associated to the given handle, if there is one.

impl<'a, 'b, 'c> ComponentSetOption<ColliderPosition> for ColliderComponentsSet<'a, 'b, 'c>

fn get(&self, handle: Index) -> Option<&ColliderPosition>

Get the element associated to the given handle, if there is one.

impl Debug for ColliderPosition

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

Formats the value using the given formatter.

impl Default for ColliderPosition

pub fn default() -> ColliderPosition

Returns the “default value” for a type.

impl Deref for ColliderPosition

type Target = Isometry<f32, Unit<Complex<f32>>, 2_usize>

The resulting type after dereferencing.

pub fn deref(&self) -> &Isometry<f32, Unit<Complex<f32>>, 2_usize>

Dereferences the value.

impl<T> From<T> for ColliderPosition where
    Isometry<f32, Unit<Complex<f32>>, 2_usize>: From<T>, 

pub fn from(position: T) -> ColliderPosition

Performs the conversion.

impl Copy for ColliderPosition