Struct Quat 

#[repr(C)]
pub struct Quat<T>
where
    T: Scalar,
{
    pub x: T,
    pub y: T,
    pub z: T,
    pub w: T,
}

Fields

x: T

y: T

z: T

w: T

Implementations

impl<T> Quat<T>

where T: FloatScalar,

pub fn identity() -> Quat<T>

pub fn new(x: T, y: T, z: T, w: T) -> Quat<T>

pub fn dot(l: &Quat<T>, r: &Quat<T>) -> T

Computes the dot product of two quaternions.

q₁ · q₂ = x₁x₂ + y₁y₂ + z₁z₂ + w₁w₂

pub fn length(&self) -> T

Computes the length (magnitude) of the quaternion.

||q|| = √(x² + y² + z² + w²)

pub fn conjugate(q: &Quat<T>) -> Quat<T>

Returns the conjugate of the quaternion.

The conjugate inverts the rotation:

q* = -xi - yj - zk + w

pub fn normalize(q: &Quat<T>) -> Quat<T>

Normalizes the quaternion to unit length.

Unit quaternions represent valid rotations:

q̂ = q / ||q||

pub fn neg(q: &Quat<T>) -> Quat<T>

Negates all components of the quaternion.

Note: -q and q represent the same rotation (double cover property).

pub fn add(l: &Quat<T>, r: &Quat<T>) -> Quat<T>

pub fn sub(l: &Quat<T>, r: &Quat<T>) -> Quat<T>

pub fn mul(l: &Quat<T>, r: &Quat<T>) -> Quat<T>

pub fn mulf(l: &Quat<T>, r: T) -> Quat<T>

pub fn fmul(l: T, r: &Quat<T>) -> Quat<T>

pub fn divf(l: &Quat<T>, r: T) -> Quat<T>

pub fn fdiv(l: T, r: &Quat<T>) -> Quat<T>

pub fn inverse(q: &Quat<T>) -> Quat<T>

pub fn mat3(&self) -> Matrix3<T>

Converts the quaternion to a 3x3 rotation matrix.

The conversion formula:

R = I + 2s(q×) + 2(q×)²

where q× is the cross-product matrix of the vector part.

pub fn mat4(&self) -> Matrix4<T>

Converts the quaternion to a 4x4 transformation matrix.

The resulting matrix represents a pure rotation with no translation. The bottom-right element is 1 for homogeneous coordinates.

pub fn to_axis_angle(&self) -> (Vector3<T>, T)

Converts the quaternion to axis-angle representation.

Returns:

• axis: The normalized rotation axis
• angle: The rotation angle in radians

For a quaternion q = cos(θ/2) + sin(θ/2)(xi + yj + zk):

• axis = normalize(x, y, z)
• angle = 2 * acos(w)

pub fn of_matrix3(m: &Matrix3<T>) -> Quat<T>

pub fn of_matrix4(m: &Matrix4<T>) -> Quat<T>

pub fn of_axis_angle(axis: &Vector3<T>, angle: T) -> Quat<T>

Creates a quaternion from an axis and angle.

Parameters

• axis: The rotation axis (will be normalized)
• angle: The rotation angle in radians

The quaternion is constructed as:

q = cos(θ/2) + sin(θ/2) * normalize(axis)

Trait Implementations

impl<T> Add for Quat<T>

where T: FloatScalar,

type Output = Quat<T>

The resulting type after applying the + operator.

fn add(self, rhs: Quat<T>) -> Quat<T>

Performs the + operation.

impl<T> Clone for Quat<T>

where T: Clone + Scalar,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Quat<T>

where T: Debug + Scalar,

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

Formats the value using the given formatter.

impl<T> Default for Quat<T>

where T: Default + Scalar,

fn default() -> Quat<T>

Returns the “default value” for a type.

impl<T> Div<T> for Quat<T>

where T: FloatScalar,

type Output = Quat<T>

The resulting type after applying the / operator.

fn div(self, t: T) -> Quat<T>

Performs the / operation.

impl<T> Mul<T> for Quat<T>

where T: FloatScalar,

type Output = Quat<T>

The resulting type after applying the * operator.

fn mul(self, t: T) -> Quat<T>

Performs the * operation.

impl<T> Mul for Quat<T>

where T: FloatScalar,

type Output = Quat<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Quat<T>) -> Quat<T>

Performs the * operation.

impl<T> Sub for Quat<T>

where T: FloatScalar,

type Output = Quat<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Quat<T>) -> Quat<T>

Performs the - operation.

impl<T> Copy for Quat<T>

where T: Copy + Scalar,