Struct Quat 

pub struct Quat<E>(pub Vector<E, 4>)
where
    E: MatEl;

Represents a quaternion using a 4D vector for its components [x, y, z, w].

The w component is the scalar part, and (x, y, z) is the vector part.

Tuple Fields

0: Vector<E, 4>

Implementations

impl<E> Quat<E>

where E: MatEl,

pub fn x(&self) -> E

The x component of Quaternion

pub fn y(&self) -> E

The y component of Quaternion

pub fn z(&self) -> E

The z component of Quaternion

pub fn w(&self) -> E

The w component of Quaternion

impl<E> Quat<E>

where E: MatEl + NdFloat,

pub fn from_axis_angle<T>(axis: T, angle: E) -> Self

where T: VectorIter<E, 3>,

Creates a quaternion from a normalized axis and an angle in radians.

Arguments

• axis - The normalized 3D vector representing the axis of rotation.
• angle - The angle of rotation in radians.

pub fn normalize(self) -> Self

Normalizes the quaternion to have a magnitude of 1.

pub fn to_array(&self) -> [E; 4]

Converts the quaternion’s components into a 4-element array [x, y, z, w].

pub fn conjugate(self) -> Self

Computes the conjugate of the quaternion, inverting its vector part.

pub fn mag2(&self) -> E

Calculates the squared magnitude (length) of the quaternion.

pub fn mag(&self) -> E

Calculates the magnitude (length) of the quaternion.

pub fn dot(&self, other: &Self) -> E

Computes the dot product of this quaternion with another.

pub fn multiply(&self, other: &Self) -> Self

Multiplies this quaternion by another quaternion (self * other).

pub fn multiply_mut(&mut self, other: &Self)

Multiplies this quaternion by another in-place.

pub fn premultiply(&self, other: &Self) -> Self

Multiplies another quaternion by this one (other * self).

pub fn premultiply_mut(&mut self, other: &Self)

Multiplies another quaternion by this one in-place.

pub fn devide(&self, other: &Self) -> Self

Divides this quaternion by another (equivalent to self * other.invert()).

pub fn device_mut(&mut self, other: &Self)

Divides this quaternion by another in-place.

pub fn slerp(self, other: &Self, s: E) -> Self

Performs spherical linear interpolation (slerp) between two unit quaternions.

Arguments

• other - The target quaternion to interpolate towards.
• s - The interpolation factor, a value between 0.0 and 1.0.

pub fn slerp_mut(&mut self, other: &Self, s: E)

Performs spherical linear interpolation (slerp) in-place.

pub fn invert(&self) -> Self

Inverts the unit-length quaternion, which is equivalent to its conjugate.

pub fn to_matrix(&self) -> Mat3<E, DescriptorOrderColumnMajor>

Converts the quaternion into a column-major 3x3 rotation matrix.

pub fn from_angle_x(x: E) -> Self

Creates a quaternion representing a rotation around the X-axis.

Arguments

• x - The rotation angle in radians.

pub fn from_angle_y(y: E) -> Self

Creates a quaternion representing a rotation around the Y-axis.

Arguments

• y - The rotation angle in radians.

pub fn from_angle_z(z: E) -> Self

Creates a quaternion representing a rotation around the Z-axis.

Arguments

• z - The rotation angle in radians.

pub fn from_euler_xyz<T: VectorIter<E, 3>>(angles: T) -> Self

Creates a quaternion from Euler angles in XYZ order.

Arguments

• angles - A 3D vector containing the rotation angles (in radians) for the X, Y, and Z axes.

Trait Implementations

impl<E> AbsDiffEq for Quat<E>

where E: AbsDiffEq + MatEl, E::Epsilon: Copy,

type Epsilon = <Vector<E, 4> as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

fn abs_diff_eq(&self, other: &Self, epsilon: Self::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<E> Add for &Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E> Add for Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E> AddAssign<E> for Quat<E>

where E: MatEl + NdFloat,

fn add_assign(&mut self, rhs: E)

Performs the += operation.

impl<E> AddAssign for Quat<E>

where E: MatEl + NdFloat,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<E> Clone for Quat<E>

where E: MatEl + Clone,

fn clone(&self) -> Quat<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E> Debug for Quat<E>

where E: MatEl + Debug,

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

Formats the value using the given formatter.

impl<E> Default for Quat<E>

where E: MatEl + Default,

fn default() -> Quat<E>

Returns the “default value” for a type.

impl<E> Div<E> for Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the / operator.

fn div(self, rhs: E) -> Self::Output

Performs the / operation.

impl<E> Div for Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E> DivAssign<E> for Quat<E>

where E: MatEl + NdFloat,

fn div_assign(&mut self, rhs: E)

Performs the /= operation.

impl<E> DivAssign for Quat<E>

where E: MatEl + NdFloat,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<E: MatEl> From<&[E]> for Quat<E>

fn from(value: &[E]) -> Self

Converts to this type from the input type.

impl<E: MatEl> From<[E; 4]> for Quat<E>

fn from(value: [E; 4]) -> Self

Converts to this type from the input type.

impl<E: MatEl> From<(E, E, E, E)> for Quat<E>

fn from(value: (E, E, E, E)) -> Self

Converts to this type from the input type.

impl<E> Index<usize> for Quat<E>

where E: MatEl,

type Output = E

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<E> IndexMut<usize> for Quat<E>

where E: MatEl,

fn index_mut(&mut self, index: usize) -> &mut Self::Output

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

impl<E> Mul<E> for Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E> Mul for Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E> MulAssign<E> for Quat<E>

where E: MatEl + NdFloat,

fn mul_assign(&mut self, rhs: E)

Performs the *= operation.

impl<E> MulAssign for Quat<E>

where E: MatEl + NdFloat,

fn mul_assign(&mut self, rhs: Quat<E>)

Performs the *= operation.

impl<E> PartialEq for Quat<E>

where E: MatEl + PartialEq,

fn eq(&self, other: &Quat<E>) -> bool

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

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

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

impl<E> PartialOrd for Quat<E>

where E: MatEl + PartialOrd,

fn partial_cmp(&self, other: &Quat<E>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E> RelativeEq for Quat<E>

where E: RelativeEq + MatEl, E::Epsilon: Copy,

fn default_max_relative() -> Self::Epsilon

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

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::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<E> Sub<E> for Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E> Sub for &Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E> Sub for Quat<E>

where E: MatEl + NdFloat,

type Output = Quat<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E> SubAssign for Quat<E>

where E: MatEl + NdFloat,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<E> UlpsEq for Quat<E>

where E: UlpsEq + MatEl, E::Epsilon: Copy,

fn default_max_ulps() -> u32

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

fn ulps_eq(&self, other: &Self, epsilon: Self::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<E> Copy for Quat<E>

where E: MatEl + Copy,

impl<E> StructuralPartialEq for Quat<E>

where E: MatEl,