Struct Quat 

pub struct Quat<Unit: Copy = (), Space: Copy = ()> {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
    /* private fields */
}

Quaternion with type-level unit and coordinate space

Fields

x: f32

y: f32

z: f32

w: f32

Implementations

impl<Unit: Copy, Space: Copy> Quat<Unit, Space>

pub const IDENTITY: Self

pub const ZERO: Self

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

pub const fn from_vec4(v: Vec4<Unit, Space>) -> Self

Creates a quaternion from a Vec4 (x, y, z, w components).

pub const fn to_vec4(self) -> Vec4<Unit, Space>

Returns the quaternion as a Vec4.

pub const fn xyz(self) -> Vec3<Unit, Space>

Returns the vector part (x, y, z) of the quaternion.

pub fn from_axis_angle_radians(axis: Vec3<Unit, Space>, angle: Radians) -> Self

Creates a quaternion from an axis and an angle (typed radians).

pub fn from_unit_axis_angle_radians( axis: UnitVec3<Unit, Space>, angle: Radians, ) -> Self

Creates a quaternion from a unit axis and a typed radians angle.

This is the “invariant-preserving” variant: the type system guarantees the axis is normalized.

pub fn from_unit_axis_angle_deg( axis: UnitVec3<Unit, Space>, angle: Degrees, ) -> Self

Creates a quaternion from a unit axis and a typed degrees angle.

pub fn from_axis_angle_deg(axis: Vec3<Unit, Space>, angle: Degrees) -> Self

Creates a quaternion from an axis and an angle (typed degrees).

pub fn from_euler_angles_radians( pitch: Radians, yaw: Radians, roll: Radians, ) -> Self

Creates a quaternion from Euler angles (pitch, yaw, roll) in radians. Matches the yaw -> pitch -> roll order.

pub fn from_euler_angles_deg( pitch: Degrees, yaw: Degrees, roll: Degrees, ) -> Self

Creates a quaternion from Euler angles (pitch, yaw, roll) in typed degrees.

pub const fn dot(self, rhs: Self) -> f32

Calculates the dot product of two quaternions.

pub const fn length_squared(self) -> f32

Calculates the squared length (magnitude) of the quaternion.

pub fn length(self) -> f32

Calculates the length (magnitude) of the quaternion.

pub fn normalize(self) -> Self

Normalizes the quaternion. If the length is zero, returns Quat::zero().

pub fn try_normalize(self) -> Option<Self>

Normalizes the quaternion, returning None if the length is zero.

pub const fn conjugate(self) -> Self

Calculates the conjugate of the quaternion.

pub fn inverse(self) -> Option<Self>

Calculates the inverse of the quaternion. Returns None if the quaternion’s length is zero (cannot be inverted).

pub fn try_inverse(self) -> Option<Self>

Alias for Quat::inverse.

pub fn checked_div_scalar(self, rhs: f32) -> Option<Self>

Divides this quaternion by a scalar, returning None for invalid divisors.

Returns None if rhs is zero (including -0.0) or non-finite (NaN, ±inf).

pub fn to_axis_angle(self) -> (Vec3<Unit, Space>, f32)

Converts the quaternion to an axis and angle (in radians). The returned axis is normalized. If the quaternion is identity, returns (Vec3::X, 0.0) or similar, as angle is 0.

pub fn to_axis_angle_radians(self) -> (Vec3<Unit, Space>, Radians)

Converts the quaternion to an axis and typed angle (radians).

pub fn to_axis_angle_deg(self) -> (Vec3<Unit, Space>, Degrees)

Converts the quaternion to an axis and typed angle (degrees).

pub fn pitch(self) -> f32

Calculates the pitch (rotation around the x-axis) in radians.

pub fn pitch_radians(self) -> Radians

Pitch as a typed radians angle.

pub fn yaw(self) -> f32

Calculates the yaw (rotation around the y-axis) in radians.

pub fn yaw_radians(self) -> Radians

Yaw as a typed radians angle.

pub fn roll(self) -> f32

Calculates the roll (rotation around the z-axis) in radians.

pub fn roll_radians(self) -> Radians

Roll as a typed radians angle.

pub fn from_mat4(m: &Mat4) -> Self

Creates a quaternion from a 4x4 rotation matrix.

pub fn lerp(self, b: Self, t: f32) -> Self

Linear interpolation between two quaternions.

pub fn nlerp(self, b: Self, t: f32) -> Self

Normalized linear interpolation between two quaternions.

pub fn slerp(self, b: Self, t: f32) -> Self

Spherical linear interpolation between two quaternions. Handles inputs that are not normalized and ensures the shortest path.

pub fn slerp_approx(self, b: Self, t: f32) -> Self

Approximate spherical linear interpolation.

pub fn nquad(p: Self, a: Self, b: Self, q: Self, t: f32) -> Self

Normalized quadratic interpolation.

pub fn squad(p: Self, a: Self, b: Self, q: Self, t: f32) -> Self

Spherical quadratic interpolation.

pub fn squad_approx(p: Self, a: Self, b: Self, q: Self, t: f32) -> Self

Approximate spherical quadratic interpolation.

pub fn from_mat3(m: &Mat3) -> Self

Creates a quaternion from a 3x3 rotation matrix.

pub fn to_mat3(&self) -> Mat3<Unit, Space>

Converts the quaternion to a 3x3 rotation matrix.

pub fn is_normalized(&self) -> bool

Returns true if the quaternion is normalized (length is approximately 1).

pub fn angle_between(self, other: Self) -> f32

Returns the angle (in radians) between self and another quaternion.

pub fn angle_between_radians(self, other: Self) -> Radians

Angle between two quaternions as typed radians.

pub fn rotate_vec3(&self, v: &mut Vec3<Unit, Space>)

Rotates a Vec3 in-place by this quaternion.

pub fn ln(self) -> Self

Returns the logarithm of the quaternion (for advanced interpolation).

pub fn exp(self) -> Self

Returns the exponential of the quaternion (for advanced interpolation).

Trait Implementations

impl<Unit: Copy, Space: Copy> Add for Quat<Unit, Space>

type Output = Quat<Unit, Space>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Unit: Copy, Space: Copy> AddAssign for Quat<Unit, Space>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<Unit: Clone + Copy, Space: Clone + Copy> Clone for Quat<Unit, Space>

fn clone(&self) -> Quat<Unit, Space>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Unit: Debug + Copy, Space: Debug + Copy> Debug for Quat<Unit, Space>

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

Formats the value using the given formatter.

impl<Unit: Default + Copy, Space: Default + Copy> Default for Quat<Unit, Space>

fn default() -> Quat<Unit, Space>

Returns the “default value” for a type.

impl<'de, Unit: Copy, Space: Copy> Deserialize<'de> for Quat<Unit, Space>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Unit: Copy, Space: Copy> Div<f32> for Quat<Unit, Space>

type Output = Quat<Unit, Space>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Unit: Copy, Space: Copy> DivAssign<f32> for Quat<Unit, Space>

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<Unit: Copy, Space: Copy> From<Quat<Unit, Space>> for Quaternion<f32>

fn from(q: Quat<Unit, Space>) -> Self

Converts to this type from the input type.

impl<Unit: Copy, Space: Copy> From<Quaternion<f32>> for Quat<Unit, Space>

fn from(q: Quaternion<f32>) -> Self

Converts to this type from the input type.

impl<Unit: Copy, Space: Copy> IntoMint for Quat<Unit, Space>

type MintType = Quaternion<f32>

The mint type that this type is associated with.

impl<Unit: Copy, Space: Copy> Mul<Quat<Unit, Space>> for f32

type Output = Quat<Unit, Space>

The resulting type after applying the * operator.

fn mul(self, rhs: Quat<Unit, Space>) -> Self::Output

Performs the * operation.

impl<Unit: Copy, Space: Copy> Mul<Vec3<Unit, Space>> for Quat<Unit, Space>

type Output = Vec3<Unit, Space>

The resulting type after applying the * operator.

fn mul(self, v: Vec3<Unit, Space>) -> Self::Output

Performs the * operation.

impl<Unit: Copy, Space: Copy> Mul<f32> for Quat<Unit, Space>

type Output = Quat<Unit, Space>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit: Copy, Space: Copy> Mul for Quat<Unit, Space>

type Output = Quat<Unit, Space>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Unit: Copy, Space: Copy> MulAssign<f32> for Quat<Unit, Space>

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl<Unit: Copy, Space: Copy> MulAssign for Quat<Unit, Space>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<Unit: Copy, Space: Copy> Neg for Quat<Unit, Space>

type Output = Quat<Unit, Space>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Unit: PartialEq + Copy, Space: PartialEq + Copy> PartialEq for Quat<Unit, Space>

fn eq(&self, other: &Quat<Unit, Space>) -> 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<Unit: Copy, Space: Copy> Serialize for Quat<Unit, Space>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Unit: Copy, Space: Copy> Sub for Quat<Unit, Space>

type Output = Quat<Unit, Space>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Unit: Copy, Space: Copy> SubAssign for Quat<Unit, Space>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<Unit: Copy + Copy, Space: Copy + Copy> Copy for Quat<Unit, Space>

impl<Unit: Copy, Space: Copy> StructuralPartialEq for Quat<Unit, Space>