Struct three_d::core::math::Quaternion

#[repr(C)]
pub struct Quaternion<S> {
    pub v: Vector3<S>,
    pub s: S,
}

A quaternion in scalar/vector form.

This type is marked as #[repr(C)].

Fields

v: Vector3<S>

The vector part of the quaternion.

s: S

The scalar part of the quaternion.

Implementations

impl<S> Quaternion<S>

pub const fn new(w: S, xi: S, yj: S, zk: S) -> Quaternion<S>

Construct a new quaternion from one scalar component and three imaginary components.

pub const fn from_sv(s: S, v: Vector3<S>) -> Quaternion<S>

Construct a new quaternion from a scalar and a vector.

impl<S> Quaternion<S> where
    S: BaseFloat, 

pub fn from_arc(
    src: Vector3<S>,
    dst: Vector3<S>,
    fallback: Option<Vector3<S>>
) -> Quaternion<S>

Construct a new quaternion as a closest arc between two vectors

Return the closest rotation that turns src vector into dst.

• [Related StackOverflow question] (http://stackoverflow.com/questions/1171849/finding-quaternion-representing-the-rotation-from-one-vector-to-another)
• [Ogre implementation for normalized vectors] (https://bitbucket.org/sinbad/ogre/src/9db75e3ba05c/OgreMain/include/OgreVector3.h?fileviewer=file-view-default#cl-651)

pub fn conjugate(self) -> Quaternion<S>

The conjugate of the quaternion.

pub fn nlerp(self, other: Quaternion<S>, amount: S) -> Quaternion<S>

Do a normalized linear interpolation with other, by amount.

This takes the shortest path, so if the quaternions have a negative dot product, the interpolation will be between self and -other.

pub fn slerp(self, other: Quaternion<S>, amount: S) -> Quaternion<S>

Spherical Linear Interpolation

Return the spherical linear interpolation between the quaternion and other. Both quaternions should be normalized first.

This takes the shortest path, so if the quaternions have a negative dot product, the interpolation will be between self and -other.

Performance notes

The acos operation used in slerp is an expensive operation, so unless your quaternions are far away from each other it’s generally more advisable to use nlerp when you know your rotations are going to be small.

• [Understanding Slerp, Then Not Using It] (http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/)
• [Arcsynthesis OpenGL tutorial] (http://www.arcsynthesis.org/gltut/Positioning/Tut08%20Interpolation.html)

pub fn is_finite(&self) -> bool

impl<S> Quaternion<S> where
    S: NumCast + Copy, 

pub fn cast<T>(&self) -> Option<Quaternion<T>> where
    T: BaseFloat, 

Component-wise casting to another type.

Trait Implementations

impl<S> AbsDiffEq<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

type Epsilon = <S as AbsDiffEq<S>>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <S as AbsDiffEq<S>>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(
    &self,
    other: &Quaternion<S>,
    epsilon: <S as AbsDiffEq<S>>::Epsilon
) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of [AbsDiffEq::abs_diff_eq].

impl<'a, 'b, S> Add<&'a Quaternion<S>> for &'b Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Quaternion<S>) -> Quaternion<S>

Performs the + operation.

impl<'a, S> Add<&'a Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the + operator.

fn add(self, other: &'a Quaternion<S>) -> Quaternion<S>

Performs the + operation.

impl<S> Add<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the + operator.

fn add(self, other: Quaternion<S>) -> Quaternion<S>

Performs the + operation.

impl<'a, S> Add<Quaternion<S>> for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the + operator.

fn add(self, other: Quaternion<S>) -> Quaternion<S>

Performs the + operation.

impl<S> AddAssign<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat + AddAssign<S>, 

fn add_assign(&mut self, other: Quaternion<S>)

Performs the += operation.

impl<S> AsMut<[S; 4]> for Quaternion<S> where
    S: BaseFloat, 

fn as_mut(&mut self) -> &mut [S; 4]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S> AsMut<(S, S, S, S)> for Quaternion<S> where
    S: BaseFloat, 

fn as_mut(&mut self) -> &mut (S, S, S, S)

Converts this type into a mutable reference of the (usually inferred) input type.

impl<S> AsRef<[S; 4]> for Quaternion<S> where
    S: BaseFloat, 

fn as_ref(&self) -> &[S; 4]

Converts this type into a shared reference of the (usually inferred) input type.

impl<S> AsRef<(S, S, S, S)> for Quaternion<S> where
    S: BaseFloat, 

fn as_ref(&self) -> &(S, S, S, S)

Converts this type into a shared reference of the (usually inferred) input type.

impl<S> Clone for Quaternion<S> where
    S: Clone, 

fn clone(&self) -> Quaternion<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Quaternion<S> where
    S: Debug, 

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

Formats the value using the given formatter.

impl<'a, S> Div<S> for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the / operator.

fn div(self, other: S) -> Quaternion<S>

Performs the / operation.

impl<S> Div<S> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the / operator.

fn div(self, other: S) -> Quaternion<S>

Performs the / operation.

impl<S> DivAssign<S> for Quaternion<S> where
    S: BaseFloat + DivAssign<S>, 

fn div_assign(&mut self, scalar: S)

Performs the /= operation.

impl<'a, S> From<&'a [S; 4]> for &'a Quaternion<S> where
    S: BaseFloat, 

fn from(v: &'a [S; 4]) -> &'a Quaternion<S>

Converts to this type from the input type.

impl<'a, S> From<&'a (S, S, S, S)> for &'a Quaternion<S> where
    S: BaseFloat, 

fn from(v: &'a (S, S, S, S)) -> &'a Quaternion<S>

Converts to this type from the input type.

impl<'a, S> From<&'a mut [S; 4]> for &'a mut Quaternion<S> where
    S: BaseFloat, 

fn from(v: &'a mut [S; 4]) -> &'a mut Quaternion<S>

Converts to this type from the input type.

impl<'a, S> From<&'a mut (S, S, S, S)> for &'a mut Quaternion<S> where
    S: BaseFloat, 

fn from(v: &'a mut (S, S, S, S)) -> &'a mut Quaternion<S>

Converts to this type from the input type.

impl<S> From<[S; 4]> for Quaternion<S> where
    S: BaseFloat, 

fn from(v: [S; 4]) -> Quaternion<S>

Converts to this type from the input type.

impl<S> From<(S, S, S, S)> for Quaternion<S> where
    S: BaseFloat, 

fn from(v: (S, S, S, S)) -> Quaternion<S>

Converts to this type from the input type.

impl<S> From<Basis3<S>> for Quaternion<S> where
    S: BaseFloat, 

fn from(b: Basis3<S>) -> Quaternion<S>

Converts to this type from the input type.

impl<A> From<Euler<A>> for Quaternion<<A as Angle>::Unitless> where
    A: Angle + Into<Rad<<A as Angle>::Unitless>>, 

fn from(src: Euler<A>) -> Quaternion<<A as Angle>::Unitless>

Converts to this type from the input type.

impl<S> From<Matrix3<S>> for Quaternion<S> where
    S: BaseFloat, 

fn from(mat: Matrix3<S>) -> Quaternion<S>

Convert the matrix to a quaternion

impl<S> From<Quaternion<S>> for Matrix4<S> where
    S: BaseFloat, 

fn from(quat: Quaternion<S>) -> Matrix4<S>

Convert the quaternion to a 4 x 4 rotation matrix.

impl<S> From<Quaternion<S>> for Matrix3<S> where
    S: BaseFloat, 

fn from(quat: Quaternion<S>) -> Matrix3<S>

Convert the quaternion to a 3 x 3 rotation matrix.

impl<S> Index<Range<usize>> for Quaternion<S> where
    S: BaseFloat, 

type Output = [S]

The returned type after indexing.

fn index(&'a self, i: Range<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeFrom<usize>> for Quaternion<S> where
    S: BaseFloat, 

type Output = [S]

The returned type after indexing.

fn index(&'a self, i: RangeFrom<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeFull> for Quaternion<S> where
    S: BaseFloat, 

type Output = [S]

The returned type after indexing.

fn index(&'a self, i: RangeFull) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<RangeTo<usize>> for Quaternion<S> where
    S: BaseFloat, 

type Output = [S]

The returned type after indexing.

fn index(&'a self, i: RangeTo<usize>) -> &'a [S]

Performs the indexing (container[index]) operation.

impl<S> Index<usize> for Quaternion<S> where
    S: BaseFloat, 

type Output = S

The returned type after indexing.

fn index(&'a self, i: usize) -> &'a S

Performs the indexing (container[index]) operation.

impl<S> IndexMut<Range<usize>> for Quaternion<S> where
    S: BaseFloat, 

fn index_mut(&'a mut self, i: Range<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeFrom<usize>> for Quaternion<S> where
    S: BaseFloat, 

fn index_mut(&'a mut self, i: RangeFrom<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeFull> for Quaternion<S> where
    S: BaseFloat, 

fn index_mut(&'a mut self, i: RangeFull) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<RangeTo<usize>> for Quaternion<S> where
    S: BaseFloat, 

fn index_mut(&'a mut self, i: RangeTo<usize>) -> &'a mut [S]

Performs the mutable indexing (container[index]) operation.

impl<S> IndexMut<usize> for Quaternion<S> where
    S: BaseFloat, 

fn index_mut(&'a mut self, i: usize) -> &'a mut S

Performs the mutable indexing (container[index]) operation.

impl<S> InnerSpace for Quaternion<S> where
    S: BaseFloat, 

fn dot(self, other: Quaternion<S>) -> S

Vector dot (or inner) product.

fn is_perpendicular(self, other: Self) -> bool where
    Self::Scalar: UlpsEq<Self::Scalar>, 

Returns true if the vector is perpendicular (at right angles) to the other vector.

fn magnitude2(self) -> Self::Scalar

Returns the squared magnitude.

fn angle(self, other: Self) -> Rad<Self::Scalar> where
    Self::Scalar: BaseFloat, 

Returns the angle between two vectors in radians.

fn project_on(self, other: Self) -> Self

Returns the vector projection of the current inner space projected onto the supplied argument.

fn magnitude(self) -> Self::Scalar where
    Self::Scalar: Float, 

The distance from the tail to the tip of the vector.

fn normalize(self) -> Self where
    Self::Scalar: Float, 

Returns a vector with the same direction, but with a magnitude of 1.

fn normalize_to(self, magnitude: Self::Scalar) -> Self where
    Self::Scalar: Float, 

Returns a vector with the same direction and a given magnitude.

impl<S> Into<[S; 4]> for Quaternion<S> where
    S: BaseFloat, 

fn into(self) -> [S; 4]

Converts this type into the (usually inferred) input type.

impl<S> Into<(S, S, S, S)> for Quaternion<S> where
    S: BaseFloat, 

fn into(self) -> (S, S, S, S)

Converts this type into the (usually inferred) input type.

impl<S> MetricSpace for Quaternion<S> where
    S: BaseFloat, 

type Metric = S

The metric to be returned by the distance function.

fn distance2(self, other: Quaternion<S>) -> S

Returns the squared distance.

fn distance(self, other: Self) -> Self::Metric where
    Self::Metric: Float, 

The distance between two values.

impl<'a, S> Mul<&'a Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Quaternion<S>) -> Quaternion<S>

Performs the * operation.

impl<'a, 'b, S> Mul<&'a Quaternion<S>> for &'b Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Quaternion<S>) -> Quaternion<S>

Performs the * operation.

impl<'a, S> Mul<&'a Vector3<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<'a, 'b, S> Mul<&'a Vector3<S>> for &'b Quaternion<S> where
    S: BaseFloat, 

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: &'a Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<S> Mul<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, other: Quaternion<S>) -> Quaternion<S>

Performs the * operation.

impl<'a, S> Mul<Quaternion<S>> for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, other: Quaternion<S>) -> Quaternion<S>

Performs the * operation.

impl<'a, S> Mul<S> for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, other: S) -> Quaternion<S>

Performs the * operation.

impl<S> Mul<S> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the * operator.

fn mul(self, other: S) -> Quaternion<S>

Performs the * operation.

impl<'a, S> Mul<Vector3<S>> for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<S> Mul<Vector3<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Vector3<S>

The resulting type after applying the * operator.

fn mul(self, other: Vector3<S>) -> Vector3<S>

Performs the * operation.

impl<S> MulAssign<S> for Quaternion<S> where
    S: BaseFloat + MulAssign<S>, 

fn mul_assign(&mut self, scalar: S)

Performs the *= operation.

impl<S> Neg for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn neg(self) -> Quaternion<S>

Performs the unary - operation.

impl<'a, S> Neg for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn neg(self) -> Quaternion<S>

Performs the unary - operation.

impl<S> One for Quaternion<S> where
    S: BaseFloat, 

fn one() -> Quaternion<S>

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where
    Self: PartialEq<Self>, 

Returns true if self is equal to the multiplicative identity.

impl<S> PartialEq<Quaternion<S>> for Quaternion<S> where
    S: PartialEq<S>, 

fn eq(&self, other: &Quaternion<S>) -> bool

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

fn ne(&self, other: &Quaternion<S>) -> bool

This method tests for !=.

impl<'a, S> Product<&'a Quaternion<S>> for Quaternion<S> where
    S: 'a + BaseFloat, 

fn product<I>(iter: I) -> Quaternion<S> where
    I: Iterator<Item = &'a Quaternion<S>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<S> Product<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

fn product<I>(iter: I) -> Quaternion<S> where
    I: Iterator<Item = Quaternion<S>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<S> RelativeEq<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

fn default_max_relative() -> <S as AbsDiffEq<S>>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq(
    &self,
    other: &Quaternion<S>,
    epsilon: <S as AbsDiffEq<S>>::Epsilon,
    max_relative: <S as AbsDiffEq<S>>::Epsilon
) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne(
    &self,
    other: &Rhs,
    epsilon: Self::Epsilon,
    max_relative: Self::Epsilon
) -> bool

The inverse of [RelativeEq::relative_eq].

impl<'a, S> Rem<S> for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the % operator.

fn rem(self, other: S) -> Quaternion<S>

Performs the % operation.

impl<S> Rem<S> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the % operator.

fn rem(self, other: S) -> Quaternion<S>

Performs the % operation.

impl<S> RemAssign<S> for Quaternion<S> where
    S: BaseFloat + RemAssign<S>, 

fn rem_assign(&mut self, scalar: S)

Performs the %= operation.

impl<S> Rotation for Quaternion<S> where
    S: BaseFloat, 

fn rotate_vector(&self, vec: Vector3<S>) -> Vector3<S>

Evaluate the conjugation of vec by self.

Note that self should be a unit quaternion (i.e. normalized) to represent a 3D rotation.

type Space = Point3<S>

fn look_at(dir: Vector3<S>, up: Vector3<S>) -> Quaternion<S>

Create a rotation to a given direction with an ‘up’ vector.

fn between_vectors(a: Vector3<S>, b: Vector3<S>) -> Quaternion<S>

Create a shortest rotation to transform vector ‘a’ into ‘b’. Both given vectors are assumed to have unit length.

fn invert(&self) -> Quaternion<S>

Create a new rotation which “un-does” this rotation. That is, r * r.invert() is the identity.

fn rotate_point(&self, point: Self::Space) -> Self::Space

Rotate a point using this rotation, by converting it to its representation as a vector.

impl<S> Rotation3 for Quaternion<S> where
    S: BaseFloat, 

type Scalar = S

fn from_axis_angle<A>(axis: Vector3<S>, angle: A) -> Quaternion<S> where
    A: Into<Rad<S>>, 

Create a rotation using an angle around a given axis.

fn from_angle_x<A>(theta: A) -> Self where
    A: Into<Rad<Self::Scalar>>, 

Create a rotation from an angle around the x axis (pitch).

fn from_angle_y<A>(theta: A) -> Self where
    A: Into<Rad<Self::Scalar>>, 

Create a rotation from an angle around the y axis (yaw).

fn from_angle_z<A>(theta: A) -> Self where
    A: Into<Rad<Self::Scalar>>, 

Create a rotation from an angle around the z axis (roll).

impl<'a, 'b, S> Sub<&'a Quaternion<S>> for &'b Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Quaternion<S>) -> Quaternion<S>

Performs the - operation.

impl<'a, S> Sub<&'a Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn sub(self, other: &'a Quaternion<S>) -> Quaternion<S>

Performs the - operation.

impl<S> Sub<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn sub(self, other: Quaternion<S>) -> Quaternion<S>

Performs the - operation.

impl<'a, S> Sub<Quaternion<S>> for &'a Quaternion<S> where
    S: BaseFloat, 

type Output = Quaternion<S>

The resulting type after applying the - operator.

fn sub(self, other: Quaternion<S>) -> Quaternion<S>

Performs the - operation.

impl<S> SubAssign<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat + SubAssign<S>, 

fn sub_assign(&mut self, other: Quaternion<S>)

Performs the -= operation.

impl<'a, S> Sum<&'a Quaternion<S>> for Quaternion<S> where
    S: 'a + BaseFloat, 

fn sum<I>(iter: I) -> Quaternion<S> where
    I: Iterator<Item = &'a Quaternion<S>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<S> Sum<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

fn sum<I>(iter: I) -> Quaternion<S> where
    I: Iterator<Item = Quaternion<S>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<S> UlpsEq<Quaternion<S>> for Quaternion<S> where
    S: BaseFloat, 

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(
    &self,
    other: &Quaternion<S>,
    epsilon: <S as AbsDiffEq<S>>::Epsilon,
    max_ulps: u32
) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of [UlpsEq::ulps_eq].

impl<S> VectorSpace for Quaternion<S> where
    S: BaseFloat, 

type Scalar = S

The associated scalar.

fn lerp(self, other: Self, amount: Self::Scalar) -> Self

Returns the result of linearly interpolating the vector towards other by the specified amount.

impl<S> Zero for Quaternion<S> where
    S: BaseFloat, 

fn zero() -> Quaternion<S>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<S> Copy for Quaternion<S> where
    S: Copy, 

impl<S> StructuralPartialEq for Quaternion<S>