Struct Mat4

#[repr(C)]
pub struct Mat4 {
    pub cols: [Vec4; 4],
}

A 4x4 column-major matrix, used for 3D affine transformations.

This is the primary type for representing transformations (translation, rotation, scale) in 3D space. It is also used for camera view and projection matrices. The memory layout is column-major, which is compatible with modern graphics APIs like Vulkan, Metal, and DirectX.

Fields

cols: [Vec4; 4]

The columns of the matrix. cols[0] is the first column, and so on.

Implementations

impl Mat4

pub const IDENTITY: Self

The 4x4 identity matrix.

pub const ZERO: Self

A 4x4 matrix with all elements set to 0.

pub fn from_cols(c0: Vec4, c1: Vec4, c2: Vec4, c3: Vec4) -> Self

Creates a new matrix from four column vectors.

pub fn from_translation(v: Vec3) -> Self

Creates a translation matrix.

Arguments

• v: The translation vector to apply.

pub fn from_scale(scale: Vec3) -> Self

Creates a non-uniform scaling matrix.

pub fn from_rotation_x(angle: f32) -> Self

Creates a matrix for a rotation around the X-axis.

Arguments

• angle: The angle of rotation in radians.

pub fn from_rotation_y(angle: f32) -> Self

Creates a matrix for a right-handed rotation around the Y-axis.

Arguments

• angle: The angle of rotation in radians.

pub fn from_rotation_z(angle: f32) -> Self

Creates a matrix for a rotation around the Z-axis.

Arguments

• angle: The angle of rotation in radians.

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

Creates a rotation matrix from a normalized axis and an angle.

Arguments

• axis: The axis of rotation. Must be a unit vector.
• angle: The angle of rotation in radians.

pub fn from_quat(q: Quaternion) -> Self

Creates a rotation matrix from a quaternion.

pub fn perspective_rh_zo( fov_y_radians: f32, aspect_ratio: f32, z_near: f32, z_far: f32, ) -> Self

Creates a right-handed perspective projection matrix with a [0, 1] depth range (ZO).

Arguments

• fov_y_radians: Vertical field of view in radians.
• aspect_ratio: Width divided by height of the viewport.
• z_near: Distance to the near clipping plane (must be positive).
• z_far: Distance to the far clipping plane (must be positive and > z_near).

pub fn orthographic_rh_zo( left: f32, right: f32, bottom: f32, top: f32, z_near: f32, z_far: f32, ) -> Self

Creates a right-handed orthographic projection matrix with a [0, 1] depth range (ZO).

pub fn look_at_rh(eye: Vec3, target: Vec3, up: Vec3) -> Option<Self>

Creates a right-handed view matrix for a camera looking from eye towards target.

Arguments

• eye: The position of the camera in world space.
• target: The point in world space that the camera is looking at.
• up: A vector indicating the “up” direction of the world (commonly Vec3::Y).

Returns

Returns Some(Mat4) if a valid view matrix can be constructed, or None if eye and target are too close, or if up is parallel to the view direction.

pub fn transpose(&self) -> Self

Returns the transpose of the matrix, where rows and columns are swapped.

pub fn determinant(&self) -> f32

Computes the determinant of the matrix.

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

Computes the inverse of the matrix. Returns None if the matrix is not invertible.

pub fn affine_inverse(&self) -> Option<Self>

Computes the inverse of an affine transformation matrix more efficiently and with better numerical stability than the general inverse method.

An affine matrix is one composed of only translation, rotation, and scale.

Returns

None if the matrix is not affine or is not invertible.

Trait Implementations

impl Clone for Mat4

fn clone(&self) -> Mat4

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mat4

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

Formats the value using the given formatter.

impl Default for Mat4

fn default() -> Self

Returns the 4x4 identity matrix.

impl Mul<Vec4> for Mat4

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

Transforms a Vec4 by this matrix.

type Output = Vec4

The resulting type after applying the * operator.

impl Mul for Mat4

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

Multiplies this matrix by another Mat4. Note that matrix multiplication is not commutative.

type Output = Mat4

The resulting type after applying the * operator.

impl PartialEq for Mat4

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

impl StructuralPartialEq for Mat4