Struct bevy_rapier2d::prelude::ColliderPosition

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

The position of a collider.

Tuple Fields

0: Isometry<f32, Unit<Complex<f32>>, 2_usize>

Implementations

impl ColliderPosition

pub fn identity() -> ColliderPosition

The identity position.

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

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 inverse_mut(&mut self)

Inverts self in-place.

Example

let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
let pt = Point2::new(1.0, 2.0);
let transformed_pt = iso * pt;
iso.inverse_mut();

assert_eq!(iso * transformed_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 append_translation_mut(&mut self, t: &Translation<T, D>)

Appends to self the given translation in-place.

Example

let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
let tra = Translation2::new(3.0, 4.0);
// Same as `iso = tra * iso`.
iso.append_translation_mut(&tra);

assert_eq!(iso.translation, Translation2::new(4.0, 6.0));

pub fn append_rotation_mut(&mut self, r: &R)

Appends to self the given rotation in-place.

Example

let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::PI / 6.0);
let rot = UnitComplex::new(f32::consts::PI / 2.0);
// Same as `iso = rot * iso`.
iso.append_rotation_mut(&rot);

assert_relative_eq!(iso, Isometry2::new(Vector2::new(-2.0, 1.0), f32::consts::PI * 2.0 / 3.0), epsilon = 1.0e-6);

pub fn append_rotation_wrt_point_mut(&mut self, r: &R, p: &OPoint<T, Const<D>>)

Appends in-place to self a rotation centered at the point p, i.e., the rotation that lets p invariant.

Example

let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
let pt = Point2::new(1.0, 0.0);
iso.append_rotation_wrt_point_mut(&rot, &pt);

assert_relative_eq!(iso * pt, Point2::new(-2.0, 0.0), epsilon = 1.0e-6);

pub fn append_rotation_wrt_center_mut(&mut self, r: &R)

Appends in-place to self a rotation centered at the point with coordinates self.translation.

Example

let mut iso = Isometry2::new(Vector2::new(1.0, 2.0), f32::consts::FRAC_PI_2);
let rot = UnitComplex::new(f32::consts::FRAC_PI_2);
iso.append_rotation_wrt_center_mut(&rot);

// The translation part should not have changed.
assert_eq!(iso.translation.vector, Vector2::new(1.0, 2.0));
assert_eq!(iso.rotation, UnitComplex::new(f32::consts::PI));

pub fn transform_point(&self, pt: &OPoint<T, Const<D>>) -> OPoint<T, Const<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: &OPoint<T, Const<D>>
) -> OPoint<T, Const<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 AsMut<Isometry<f32, Unit<Complex<f32>>, 2_usize>> for ColliderPosition

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

Performs the conversion.

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, 'w, 'b, 'c> ComponentSet<ColliderPosition> for QueryPipelineColliderComponentsSet<'a, 'w, '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<'world, 'state, 'a> ComponentSet<ColliderPosition> for ColliderComponentsSet<'world, 'state, 'a>

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<'world, 'state, 'a> ComponentSetMut<ColliderPosition> for ColliderComponentsSet<'world, 'state, 'a>

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, 'w, 'b, 'c> ComponentSetOption<ColliderPosition> for QueryPipelineColliderComponentsSet<'a, 'w, 'b, 'c>

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

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

impl<'world, 'state, 'a> ComponentSetOption<ColliderPosition> for ColliderComponentsSet<'world, 'state, 'a>

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 DerefMut for ColliderPosition

pub fn deref_mut(&mut self) -> &mut <ColliderPosition as Deref>::Target

Mutably 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 PartialEq<ColliderPosition> for ColliderPosition

pub fn eq(&self, other: &ColliderPosition) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &ColliderPosition) -> bool

This method tests for !=.

impl Copy for ColliderPosition

impl StructuralPartialEq for ColliderPosition