Struct Quaternion 

pub struct Quaternion<T, A: Alignment>(/* private fields */)
where
    T: Scalar;

A quaternion representing an orientation.

Note: Quaternion is currently missing most of its functionality.

This quaternion is intended to be of unit length but may denormalize due to floating point “error creep” which can occur when successive quaternion operations are applied.

Quaternion is the generic form of:

• Quat<T>
• QuatU<T>

Quaternion is generic over:

• T: Scalar type (see Scalar)
• A: Alignment (see Alignment)

Guarantees

Quaternion<T, A> is a transparent wrapper around Vector<4, T, A>, and thus inherits its guarantees.

Implementations

impl<T, A: Alignment> Quaternion<T, A>

where T: Scalar,

pub const fn new(x: T, y: T, z: T, w: T) -> Self

Creates a rotation quaternion.

This is currently the only way to initialize a quaternion. In the future there will be mathamatical constructors that are recommended over this one.

Unchecked

This function does not check if the input is normalized. It is up to the user to provide normalized input or to normalize the resulting quaternion.

pub const fn from_array(array: [T; 4]) -> Self

Creates a rotation quaternion from an array.

Unchecked

This function does not check if the input is normalized. It is up to the user to provide normalized input or to normalize the resulting quaternion.

pub const fn from_vec(vec: Vector<4, T, A>) -> Self

Creates a rotation quaternion from a 4-dimensional vector.

Unchecked

This function does not check if the input is normalized. It is up to the user to provide normalized input or to normalize the resulting quaternion.

pub const fn to_alignment<A2: Alignment>(self) -> Quaternion<T, A2>

Converts the quaternion to the specified alignment.

See Alignment for more information.

pub const fn align(self) -> Quaternion<T, Aligned>

Converts the quaternion to Aligned alignment.

See Alignment for more information.

pub const fn unalign(self) -> Quaternion<T, Unaligned>

Converts the quaternion to Unaligned alignment.

See Alignment for more information.

pub const fn to_array(self) -> [T; 4]

Converts the quaternion to an array.

pub const fn as_array_ref(&self) -> &[T; 4]

Returns a reference to the quaternion’s components.

pub const fn as_array_mut(&mut self) -> &mut [T; 4]

Returns a mutable reference to the quaternion’s components.

pub const fn to_vec(self) -> Vector<4, T, A>

Converts the quaternion to a 4-dimensional vector.

pub const fn as_vec_ref(&self) -> &Vector<4, T, A>

Returns a reference to the quaternion as a 4-dimensional vector.

pub const fn as_vec_mut(&mut self) -> &mut Vector<4, T, A>

Returns a mutable reference to the quaternion as a 4-dimensional vector.

impl<T, A: Alignment> Quaternion<T, A>

where T: Scalar + Zero,

pub const ZERO: Self

All 0.0.

impl<T, A: Alignment> Quaternion<T, A>

where T: Scalar + Zero + One,

pub const IDENTITY: Self

The identity quaternion. Corresponds to no rotation.

impl<T, A: Alignment> Quaternion<T, A>

where T: Scalar + Nan,

pub const NAN: Self

All NaNs (Not a Number).

Trait Implementations

impl<T, A: Alignment> Add for Quaternion<T, A>

where T: Scalar + Add<Output = T>,

fn add(self, rhs: Self) -> Self::Output

Adds two quaternions.

The sum is not guaranteed to be normalized.

Note that addition is not the same as combining the rotations represented by the two quaternions! That corresponds to multiplication (not implemented yet).

type Output = Quaternion<T, A>

The resulting type after applying the + operator.

impl<T, A: Alignment> AddAssign for Quaternion<T, A>

where T: Scalar + Add<Output = T>,

fn add_assign(&mut self, rhs: Self)

Adds the quaternion rhs to self.

The sum is not guaranteed to be normalized.

Note that addition is not the same as combining the rotations represented by the two quaternions! That corresponds to multiplication (not implemented yet).

impl<T, A: Alignment> Clone for Quaternion<T, A>

where T: Scalar,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, A: Alignment> Debug for Quaternion<T, A>

where T: Scalar + Debug,

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

Formats the value using the given formatter.

impl<T, A: Alignment> Default for Quaternion<T, A>

where T: Scalar + Zero + One,

fn default() -> Self

Returns Quaternion::IDENTITY.

impl<T, A: Alignment> Deref for Quaternion<T, A>

where T: Scalar,

type Target = Xyzw<T>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, A: Alignment> DerefMut for Quaternion<T, A>

where T: Scalar,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, A: Alignment> Display for Quaternion<T, A>

where T: Scalar + Display,

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

Formats the value using the given formatter.

impl<T, A: Alignment> Hash for Quaternion<T, A>

where T: Scalar + Hash,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, A: Alignment> Mul<T> for Quaternion<T, A>

where T: Scalar + Mul<Output = T>,

fn mul(self, rhs: T) -> Self::Output

Multiplies a quaternion by a scalar value.

The product is not guaranteed to be normalized.

type Output = Quaternion<T, A>

The resulting type after applying the * operator.

impl<T, A: Alignment> MulAssign<T> for Quaternion<T, A>

where T: Scalar + Mul<Output = T>,

fn mul_assign(&mut self, rhs: T)

Multiplies the quaternion by a scalar value.

The product is not guaranteed to be normalized.

impl<T, A: Alignment> Neg for Quaternion<T, A>

where T: Scalar + Neg<Output = T>,

type Output = Quaternion<T, A>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, A: Alignment> PartialEq for Quaternion<T, A>

where T: Scalar + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, A: Alignment> Sub for Quaternion<T, A>

where T: Scalar + Sub<Output = T>,

fn sub(self, rhs: Self) -> Self::Output

Subtracts the quaternion rhs from self.

The difference is not guaranteed to be normalized.

type Output = Quaternion<T, A>

The resulting type after applying the - operator.

impl<T, A: Alignment> SubAssign for Quaternion<T, A>

where T: Scalar + Sub<Output = T>,

fn sub_assign(&mut self, rhs: Self)

Subtracts the quaternion rhs from self.

The difference is not guaranteed to be normalized.

impl<T, A: Alignment> Copy for Quaternion<T, A>

where T: Scalar,

impl<T, A: Alignment> Eq for Quaternion<T, A>

where T: Scalar + Eq,