Struct ggez::graphics::na::Quaternion

#[repr(C)]
pub struct Quaternion<N> where
    N: Real,  {
    pub coords: Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>,
}

A quaternion. See the type alias UnitQuaternion = Unit<Quaternion> for a quaternion that may be used as a rotation.

Fields

coords: Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>

This quaternion as a 4D vector of coordinates in the [ x, y, z, w ] storage order.

Methods

impl<N> Quaternion<N> where
    N: Real, 

fn into_owned(self) -> Quaternion<N>

Deprecated

: This method is a no-op and will be removed in a future release.

Moves this unit quaternion into one that owns its data.

fn clone_owned(&self) -> Quaternion<N>

Deprecated

: This method is a no-op and will be removed in a future release.

Clones this unit quaternion into one that owns its data.

fn normalize(&self) -> Quaternion<N>

Normalizes this quaternion.

fn conjugate(&self) -> Quaternion<N>

Compute the conjugate of this quaternion.

fn try_inverse(&self) -> Option<Quaternion<N>>

Inverts this quaternion if it is not zero.

fn lerp(&self, other: &Quaternion<N>, t: N) -> Quaternion<N>

Linear interpolation between two quaternion.

fn vector(
    &self
) -> Matrix<N, U3, U1, SliceStorage<N, U3, U1, <<DefaultAllocator as Allocator<N, U4, U1>>::Buffer as Storage<N, U4, U1>>::RStride, <<DefaultAllocator as Allocator<N, U4, U1>>::Buffer as Storage<N, U4, U1>>::CStride>>

The vector part (i, j, k) of this quaternion.

fn scalar(&self) -> N

The scalar part w of this quaternion.

fn as_vector(
    &self
) -> &Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>

Reinterprets this quaternion as a 4D vector.

fn norm(&self) -> N

The norm of this quaternion.

fn norm_squared(&self) -> N

The squared norm of this quaternion.

fn polar_decomposition(
    &self
) -> (N, N, Option<Unit<Matrix<N, U3, U1, <DefaultAllocator as Allocator<N, U3, U1>>::Buffer>>>)

The polar decomposition of this quaternion.

Returns, from left to right: the quaternion norm, the half rotation angle, the rotation axis. If the rotation angle is zero, the rotation axis is set to None.

fn exp(&self) -> Quaternion<N>

Compute the exponential of a quaternion.

fn ln(&self) -> Quaternion<N>

Compute the natural logarithm of a quaternion.

fn powf(&self, n: N) -> Quaternion<N>

Raise the quaternion to a given floating power.

fn as_vector_mut(
    &mut self
) -> &mut Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>

Transforms this quaternion into its 4D vector form (Vector part, Scalar part).

fn vector_mut(
    &mut self
) -> Matrix<N, U3, U1, SliceStorageMut<N, U3, U1, <<DefaultAllocator as Allocator<N, U4, U1>>::Buffer as Storage<N, U4, U1>>::RStride, <<DefaultAllocator as Allocator<N, U4, U1>>::Buffer as Storage<N, U4, U1>>::CStride>>

The mutable vector part (i, j, k) of this quaternion.

fn conjugate_mut(&mut self)

Replaces this quaternion by its conjugate.

fn try_inverse_mut(&mut self) -> bool

Inverts this quaternion in-place if it is not zero.

fn normalize_mut(&mut self) -> N

Normalizes this quaternion.

impl<N> Quaternion<N> where
    N: Real, 

fn from_vector(
    vector: Matrix<N, U4, U1, <DefaultAllocator as Allocator<N, U4, U1>>::Buffer>
) -> Quaternion<N>

Creates a quaternion from a 4D vector. The quaternion scalar part corresponds to the w vector component.

fn new(w: N, x: N, y: N, z: N) -> Quaternion<N>

Creates a new quaternion from its individual components. Note that the arguments order does not follow the storage order.

The storage order is [ x, y, z, w ].

fn from_parts<SB>(scalar: N, vector: Matrix<N, U3, U1, SB>) -> Quaternion<N> where
    SB: Storage<N, U3, U1>, 

Creates a new quaternion from its scalar and vector parts. Note that the arguments order does not follow the storage order.

The storage order is [ vector, scalar ].

fn from_polar_decomposition<SB>(
    scale: N,
    theta: N,
    axis: Unit<Matrix<N, U3, U1, SB>>
) -> Quaternion<N> where
    SB: Storage<N, U3, U1>, 

Creates a new quaternion from its polar decomposition.

Note that axis is assumed to be a unit vector.

fn identity() -> Quaternion<N>

The quaternion multiplicative identity.

Trait Implementations

impl<N> Neg for Quaternion<N> where
    N: Real, 

type Output = Quaternion<N>

fn neg(self) -> <Quaternion<N> as Neg>::Output

impl<'a, N> Neg for &'a Quaternion<N> where
    N: Real, 

type Output = Quaternion<N>

fn neg(self) -> <&'a Quaternion<N> as Neg>::Output

impl<N> Rand for Quaternion<N> where
    N: Rand + Real, 

fn rand<R>(rng: &mut R) -> Quaternion<N> where
    R: Rng, 

impl<N> Copy for Quaternion<N> where
    N: Real, 

impl<N> Clone for Quaternion<N> where
    N: Real, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> AbstractMonoid<Additive> for Quaternion<N> where
    N: Real, 

impl<N> AbstractMonoid<Multiplicative> for Quaternion<N> where
    N: Real, 

impl<N1, N2> SubsetOf<Quaternion<N2>> for Quaternion<N1> where
    N1: Real,
    N2: Real + SupersetOf<N1>, 

fn to_superset(&self) -> Quaternion<N2>

fn is_in_subset(q: &Quaternion<N2>) -> bool

unsafe fn from_superset_unchecked(q: &Quaternion<N2>) -> Quaternion<N1>

impl<N> Inverse<Additive> for Quaternion<N> where
    N: Real, 

fn inverse(&self) -> Quaternion<N>

impl<'a, N> Div<N> for &'a Quaternion<N> where
    N: Real, 

type Output = Quaternion<N>

fn div(self, n: N) -> <&'a Quaternion<N> as Div<N>>::Output

impl<N> Div<N> for Quaternion<N> where
    N: Real, 

type Output = Quaternion<N>

fn div(self, n: N) -> <Quaternion<N> as Div<N>>::Output

impl<N> AbstractSemigroup<Additive> for Quaternion<N> where
    N: Real, 

impl<N> AbstractSemigroup<Multiplicative> for Quaternion<N> where
    N: Real, 

impl<N> NormedSpace for Quaternion<N> where
    N: Real, 

fn norm_squared(&self) -> N

fn norm(&self) -> N

fn normalize(&self) -> Quaternion<N>

fn normalize_mut(&mut self) -> N

fn try_normalize(&self, min_norm: N) -> Option<Quaternion<N>>

fn try_normalize_mut(&mut self, min_norm: N) -> Option<N>

impl<N> AbstractLoop<Additive> for Quaternion<N> where
    N: Real, 

impl<N> DivAssign<N> for Quaternion<N> where
    N: Real, 

fn div_assign(&mut self, n: N)

impl<N> VectorSpace for Quaternion<N> where
    N: Real, 

type Field = N

impl<N> ApproxEq for Quaternion<N> where
    N: ApproxEq<Epsilon = N> + Real, 

type Epsilon = N

fn default_epsilon() -> <Quaternion<N> as ApproxEq>::Epsilon

fn default_max_relative() -> <Quaternion<N> as ApproxEq>::Epsilon

fn default_max_ulps() -> u32

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

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

impl<N> Hash for Quaternion<N> where
    N: Hash + Real, 

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<N> DerefMut for Quaternion<N> where
    N: Real, 

fn deref_mut(&mut self) -> &mut <Quaternion<N> as Deref>::Target

impl<N> PartialEq<Quaternion<N>> for Quaternion<N> where
    N: Real, 

fn eq(&self, rhs: &Quaternion<N>) -> bool

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

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

This method tests for !=.

impl<N> Add<Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn add(
    self,
    rhs: Quaternion<N>
) -> <Quaternion<N> as Add<Quaternion<N>>>::Output

impl<'a, N> Add<Quaternion<N>> for &'a Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn add(
    self,
    rhs: Quaternion<N>
) -> <&'a Quaternion<N> as Add<Quaternion<N>>>::Output

impl<'b, N> Add<&'b Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn add(
    self,
    rhs: &'b Quaternion<N>
) -> <Quaternion<N> as Add<&'b Quaternion<N>>>::Output

impl<'a, 'b, N> Add<&'b Quaternion<N>> for &'a Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn add(
    self,
    rhs: &'b Quaternion<N>
) -> <&'a Quaternion<N> as Add<&'b Quaternion<N>>>::Output

impl<N> Debug for Quaternion<N> where
    N: Debug + Real, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result<(), Error>

Formats the value using the given formatter.

impl<N> FiniteDimVectorSpace for Quaternion<N> where
    N: Real, 

fn dimension() -> usize

fn canonical_basis_element(i: usize) -> Quaternion<N>

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

unsafe fn component_unchecked(&self, i: usize) -> &N

unsafe fn component_unchecked_mut(&mut self, i: usize) -> &mut N

impl<'b, N> AddAssign<&'b Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

fn add_assign(&mut self, rhs: &'b Quaternion<N>)

impl<N> AddAssign<Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

fn add_assign(&mut self, rhs: Quaternion<N>)

impl<N> AbstractQuasigroup<Additive> for Quaternion<N> where
    N: Real, 

impl<N> SubAssign<Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

fn sub_assign(&mut self, rhs: Quaternion<N>)

impl<'b, N> SubAssign<&'b Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

fn sub_assign(&mut self, rhs: &'b Quaternion<N>)

impl<N> AbstractGroup<Additive> for Quaternion<N> where
    N: Real, 

impl<N> One for Quaternion<N> where
    N: Real, 

fn one() -> Quaternion<N>

impl<N> AbstractModule<Additive, Additive, Multiplicative> for Quaternion<N> where
    N: Real, 

type AbstractRing = N

fn multiply_by(&self, n: N) -> Quaternion<N>

impl<N> Index<usize> for Quaternion<N> where
    N: Real, 

type Output = N

fn index(&self, i: usize) -> &N

impl<N> Identity<Multiplicative> for Quaternion<N> where
    N: Real, 

fn identity() -> Quaternion<N>

impl<N> Identity<Additive> for Quaternion<N> where
    N: Real, 

fn identity() -> Quaternion<N>

impl<N> Eq for Quaternion<N> where
    N: Eq + Real, 

impl<N> Deref for Quaternion<N> where
    N: Real, 

type Target = IJKW<N>

fn deref(&self) -> &<Quaternion<N> as Deref>::Target

impl<N> AbstractGroupAbelian<Additive> for Quaternion<N> where
    N: Real, 

impl<N> Zero for Quaternion<N> where
    N: Real, 

fn zero() -> Quaternion<N>

fn is_zero(&self) -> bool

impl<N> MulAssign<Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

fn mul_assign(&mut self, rhs: Quaternion<N>)

impl<N> MulAssign<N> for Quaternion<N> where
    N: Real, 

fn mul_assign(&mut self, n: N)

impl<'b, N> MulAssign<&'b Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

fn mul_assign(&mut self, rhs: &'b Quaternion<N>)

impl<N> AbstractMagma<Additive> for Quaternion<N> where
    N: Real, 

fn operate(&self, rhs: &Quaternion<N>) -> Quaternion<N>

impl<N> AbstractMagma<Multiplicative> for Quaternion<N> where
    N: Real, 

fn operate(&self, rhs: &Quaternion<N>) -> Quaternion<N>

impl<N> Mul<Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn mul(
    self,
    rhs: Quaternion<N>
) -> <Quaternion<N> as Mul<Quaternion<N>>>::Output

impl<'a, N> Mul<N> for &'a Quaternion<N> where
    N: Real, 

type Output = Quaternion<N>

fn mul(self, n: N) -> <&'a Quaternion<N> as Mul<N>>::Output

impl<N> Mul<N> for Quaternion<N> where
    N: Real, 

type Output = Quaternion<N>

fn mul(self, n: N) -> <Quaternion<N> as Mul<N>>::Output

impl<'a, N> Mul<Quaternion<N>> for &'a Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn mul(
    self,
    rhs: Quaternion<N>
) -> <&'a Quaternion<N> as Mul<Quaternion<N>>>::Output

impl<'b, N> Mul<&'b Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn mul(
    self,
    rhs: &'b Quaternion<N>
) -> <Quaternion<N> as Mul<&'b Quaternion<N>>>::Output

impl<'a, 'b, N> Mul<&'b Quaternion<N>> for &'a Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn mul(
    self,
    rhs: &'b Quaternion<N>
) -> <&'a Quaternion<N> as Mul<&'b Quaternion<N>>>::Output

impl<N> Module for Quaternion<N> where
    N: Real, 

type Ring = N

impl<N> IndexMut<usize> for Quaternion<N> where
    N: Real, 

fn index_mut(&mut self, i: usize) -> &mut N

impl<'a, 'b, N> Sub<&'b Quaternion<N>> for &'a Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn sub(
    self,
    rhs: &'b Quaternion<N>
) -> <&'a Quaternion<N> as Sub<&'b Quaternion<N>>>::Output

impl<'b, N> Sub<&'b Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn sub(
    self,
    rhs: &'b Quaternion<N>
) -> <Quaternion<N> as Sub<&'b Quaternion<N>>>::Output

impl<N> Sub<Quaternion<N>> for Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn sub(
    self,
    rhs: Quaternion<N>
) -> <Quaternion<N> as Sub<Quaternion<N>>>::Output

impl<'a, N> Sub<Quaternion<N>> for &'a Quaternion<N> where
    N: Real,
    DefaultAllocator: Allocator<N, U4, U1>,
    DefaultAllocator: Allocator<N, U4, U1>, 

type Output = Quaternion<N>

fn sub(
    self,
    rhs: Quaternion<N>
) -> <&'a Quaternion<N> as Sub<Quaternion<N>>>::Output

impl<N> Display for Quaternion<N> where
    N: Display + Real, 

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

Formats the value using the given formatter.