Struct Quat 

#[repr(C)]
pub struct Quat {
    pub x: f32,
    pub y: f32,
    pub z: f32,
    pub w: f32,
}

A quaternion for representing rotations.

Stored as (x, y, z, w) where:

• (x, y, z) is the vector part (imaginary components)
• w is the scalar part (real component)

The identity rotation is (0, 0, 0, 1).

Fields

x: f32

The x-component of the vector part.

y: f32

The y-component of the vector part.

z: f32

The z-component of the vector part.

w: f32

The scalar (real) part.

Implementations

impl Quat

pub const IDENTITY: Quat

Identity quaternion representing no rotation.

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

Creates a new quaternion from components.

pub fn from_axis_angle(axis: Vec3, angle: f32) -> Self

Creates a quaternion from axis-angle representation.

Arguments

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

Example

use goud_engine::ecs::components::transform::Quat;
use goud_engine::core::math::Vec3;
use std::f32::consts::PI;

// Rotate 90 degrees around Y axis
let q = Quat::from_axis_angle(Vec3::unit_y(), PI / 2.0);

pub fn from_euler(pitch: f32, yaw: f32, roll: f32) -> Self

Creates a quaternion from Euler angles (in radians).

Uses XYZ rotation order (pitch, yaw, roll):

• X: pitch (rotation around right axis)
• Y: yaw (rotation around up axis)
• Z: roll (rotation around forward axis)

Example

use goud_engine::ecs::components::transform::Quat;
use std::f32::consts::PI;

// 45 degree yaw rotation
let q = Quat::from_euler(0.0, PI / 4.0, 0.0);

pub fn from_rotation_arc(from: Vec3, to: Vec3) -> Self

Creates a quaternion that rotates from one direction to another.

Both vectors should be normalized.

pub fn length_squared(self) -> f32

Returns the squared length of the quaternion.

pub fn length(self) -> f32

Returns the length of the quaternion.

pub fn normalize(self) -> Self

Returns a normalized version of this quaternion.

pub fn conjugate(self) -> Self

Returns the conjugate of this quaternion.

For a unit quaternion, the conjugate is also the inverse.

pub fn inverse(self) -> Self

Returns the inverse of this quaternion.

For unit quaternions (normalized), this is equivalent to the conjugate.

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

Multiplies two quaternions (combines rotations).

This represents combining two rotations, where self is applied first, then other. This is also available via the * operator.

pub fn rotate_vector(self, v: Vec3) -> Vec3

Rotates a vector by this quaternion.

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

Spherical linear interpolation between two quaternions.

This provides smooth interpolation between rotations.

pub fn to_euler(self) -> (f32, f32, f32)

Converts the quaternion to Euler angles (in radians).

Returns (pitch, yaw, roll) using XYZ convention.

pub fn forward(self) -> Vec3

Returns the forward direction vector (negative Z axis after rotation).

pub fn right(self) -> Vec3

Returns the right direction vector (positive X axis after rotation).

pub fn up(self) -> Vec3

Returns the up direction vector (positive Y axis after rotation).

Trait Implementations

impl Clone for Quat

fn clone(&self) -> Quat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Quat

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

Formats the value using the given formatter.

impl Default for Quat

fn default() -> Self

Returns the “default value” for a type.

impl From<Quat> for Quaternion<f32>

fn from(q: Quat) -> Self

Converts to this type from the input type.

impl From<Quaternion<f32>> for Quat

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

Converts to this type from the input type.

impl Mul for Quat

fn mul(self, other: Self) -> Self

Multiplies two quaternions, combining their rotations.

self * other applies self first, then other.

type Output = Quat

The resulting type after applying the * operator.

impl PartialEq for Quat

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

impl StructuralPartialEq for Quat