Struct euclid::Rotation3D
source · #[repr(C)]pub struct Rotation3D<T, Src, Dst> {
pub i: T,
pub j: T,
pub k: T,
pub r: T,
/* private fields */
}
Expand description
A transform that can represent rotations in 3d, represented as a quaternion.
Most methods expect the quaternion to be normalized.
When in doubt, use unit_quaternion
instead of quaternion
to create
a rotation as the former will ensure that its result is normalized.
Some people use the x, y, z, w
(or w, x, y, z
) notations. The equivalence is
as follows: x -> i
, y -> j
, z -> k
, w -> r
.
The memory layout of this type corresponds to the x, y, z, w
notation
Fields§
§i: T
Component multiplied by the imaginary number i
.
j: T
Component multiplied by the imaginary number j
.
k: T
Component multiplied by the imaginary number k
.
r: T
The real part.
Implementations§
source§impl<T, Src, Dst> Rotation3D<T, Src, Dst>
impl<T, Src, Dst> Rotation3D<T, Src, Dst>
sourcepub fn quaternion(a: T, b: T, c: T, r: T) -> Self
pub fn quaternion(a: T, b: T, c: T, r: T) -> Self
Creates a rotation around from a quaternion representation.
The parameters are a, b, c and r compose the quaternion a*i + b*j + c*k + r
where a
, b
and c
describe the vector part and the last parameter r
is
the real part.
The resulting quaternion is not necessarily normalized. See unit_quaternion
.
source§impl<T, Src, Dst> Rotation3D<T, Src, Dst>where
T: Copy,
impl<T, Src, Dst> Rotation3D<T, Src, Dst>where T: Copy,
sourcepub fn vector_part(&self) -> Vector3D<T, UnknownUnit>
pub fn vector_part(&self) -> Vector3D<T, UnknownUnit>
Returns the vector part (i, j, k) of this quaternion.
sourcepub fn cast_unit<Src2, Dst2>(&self) -> Rotation3D<T, Src2, Dst2>
pub fn cast_unit<Src2, Dst2>(&self) -> Rotation3D<T, Src2, Dst2>
Cast the unit, preserving the numeric value.
Example
enum Local {}
enum World {}
enum Local2 {}
enum World2 {}
let to_world: Rotation3D<_, Local, World> = Rotation3D::quaternion(1, 2, 3, 4);
assert_eq!(to_world.i, to_world.cast_unit::<Local2, World2>().i);
assert_eq!(to_world.j, to_world.cast_unit::<Local2, World2>().j);
assert_eq!(to_world.k, to_world.cast_unit::<Local2, World2>().k);
assert_eq!(to_world.r, to_world.cast_unit::<Local2, World2>().r);
sourcepub fn to_untyped(&self) -> Rotation3D<T, UnknownUnit, UnknownUnit>
pub fn to_untyped(&self) -> Rotation3D<T, UnknownUnit, UnknownUnit>
Drop the units, preserving only the numeric value.
Example
enum Local {}
enum World {}
let to_world: Rotation3D<_, Local, World> = Rotation3D::quaternion(1, 2, 3, 4);
assert_eq!(to_world.i, to_world.to_untyped().i);
assert_eq!(to_world.j, to_world.to_untyped().j);
assert_eq!(to_world.k, to_world.to_untyped().k);
assert_eq!(to_world.r, to_world.to_untyped().r);
sourcepub fn from_untyped(r: &Rotation3D<T, UnknownUnit, UnknownUnit>) -> Self
pub fn from_untyped(r: &Rotation3D<T, UnknownUnit, UnknownUnit>) -> Self
Tag a unitless value with units.
Example
use euclid::UnknownUnit;
enum Local {}
enum World {}
let rot: Rotation3D<_, UnknownUnit, UnknownUnit> = Rotation3D::quaternion(1, 2, 3, 4);
assert_eq!(rot.i, Rotation3D::<_, Local, World>::from_untyped(&rot).i);
assert_eq!(rot.j, Rotation3D::<_, Local, World>::from_untyped(&rot).j);
assert_eq!(rot.k, Rotation3D::<_, Local, World>::from_untyped(&rot).k);
assert_eq!(rot.r, Rotation3D::<_, Local, World>::from_untyped(&rot).r);
source§impl<T, Src, Dst> Rotation3D<T, Src, Dst>where
T: Real,
impl<T, Src, Dst> Rotation3D<T, Src, Dst>where T: Real,
sourcepub fn unit_quaternion(i: T, j: T, k: T, r: T) -> Self
pub fn unit_quaternion(i: T, j: T, k: T, r: T) -> Self
Creates a rotation around from a quaternion representation and normalizes it.
The parameters are a, b, c and r compose the quaternion a*i + b*j + c*k + r
before normalization, where a
, b
and c
describe the vector part and the
last parameter r
is the real part.
sourcepub fn around_axis(axis: Vector3D<T, Src>, angle: Angle<T>) -> Self
pub fn around_axis(axis: Vector3D<T, Src>, angle: Angle<T>) -> Self
Creates a rotation around a given axis.
sourcepub fn euler(roll: Angle<T>, pitch: Angle<T>, yaw: Angle<T>) -> Self
pub fn euler(roll: Angle<T>, pitch: Angle<T>, yaw: Angle<T>) -> Self
Creates a rotation from Euler angles.
The rotations are applied in roll then pitch then yaw order.
- Roll (also called bank) is a rotation around the x axis.
- Pitch (also called bearing) is a rotation around the y axis.
- Yaw (also called heading) is a rotation around the z axis.
sourcepub fn inverse(&self) -> Rotation3D<T, Dst, Src>
pub fn inverse(&self) -> Rotation3D<T, Dst, Src>
Returns the inverse of this rotation.
sourcepub fn square_norm(&self) -> T
pub fn square_norm(&self) -> T
Computes the squared norm of this quaternion.
sourcepub fn normalize(&self) -> Self
pub fn normalize(&self) -> Self
Returns a unit quaternion from this one.
sourcepub fn is_normalized(&self) -> boolwhere
T: ApproxEq<T>,
pub fn is_normalized(&self) -> boolwhere T: ApproxEq<T>,
Returns true
if norm of this quaternion is (approximately) one.
sourcepub fn slerp(&self, other: &Self, t: T) -> Selfwhere
T: ApproxEq<T>,
pub fn slerp(&self, other: &Self, t: T) -> Selfwhere T: ApproxEq<T>,
Spherical linear interpolation between this rotation and another rotation.
t
is expected to be between zero and one.
sourcepub fn lerp(&self, other: &Self, t: T) -> Self
pub fn lerp(&self, other: &Self, t: T) -> Self
Basic Linear interpolation between this rotation and another rotation.
sourcepub fn transform_point3d(&self, point: Point3D<T, Src>) -> Point3D<T, Dst>where
T: ApproxEq<T>,
pub fn transform_point3d(&self, point: Point3D<T, Src>) -> Point3D<T, Dst>where T: ApproxEq<T>,
Returns the given 3d point transformed by this rotation.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_point2d(&self, point: Point2D<T, Src>) -> Point2D<T, Dst>where
T: ApproxEq<T>,
pub fn transform_point2d(&self, point: Point2D<T, Src>) -> Point2D<T, Dst>where T: ApproxEq<T>,
Returns the given 2d point transformed by this rotation then projected on the xy plane.
The input point must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_vector3d(&self, vector: Vector3D<T, Src>) -> Vector3D<T, Dst>where
T: ApproxEq<T>,
pub fn transform_vector3d(&self, vector: Vector3D<T, Src>) -> Vector3D<T, Dst>where T: ApproxEq<T>,
Returns the given 3d vector transformed by this rotation.
The input vector must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn transform_vector2d(&self, vector: Vector2D<T, Src>) -> Vector2D<T, Dst>where
T: ApproxEq<T>,
pub fn transform_vector2d(&self, vector: Vector2D<T, Src>) -> Vector2D<T, Dst>where T: ApproxEq<T>,
Returns the given 2d vector transformed by this rotation then projected on the xy plane.
The input vector must be use the unit Src, and the returned point has the unit Dst.
sourcepub fn to_transform(&self) -> Transform3D<T, Src, Dst>where
T: ApproxEq<T>,
pub fn to_transform(&self) -> Transform3D<T, Src, Dst>where T: ApproxEq<T>,
Returns the matrix representation of this rotation.
sourcepub fn then<NewDst>(
&self,
other: &Rotation3D<T, Dst, NewDst>
) -> Rotation3D<T, Src, NewDst>where
T: ApproxEq<T>,
pub fn then<NewDst>( &self, other: &Rotation3D<T, Dst, NewDst> ) -> Rotation3D<T, Src, NewDst>where T: ApproxEq<T>,
Returns a rotation representing this rotation followed by the other rotation.