Struct Matrix4

#[repr(C, align(64))]
pub struct Matrix4(/* private fields */);

An owning representation of a 4x4 matrix.

Like Mat4, the Matrix4 object represents a matrix in 4D. Unlike the Mat4, this is an owning representation that stores the actual content of the vector.

Matrix4 does not implement Copy to prevent accidental copying of large amounts of data. If you need to copy the data, you can use the Clone trait.

Implementations

impl Matrix4

pub const ZERO: Self = _

The zero matrix.

pub const IDENTITY: Self = _

The identity matrix.

pub const fn new() -> Self

Constructs a new 4x4 matrix with the identity matrix.

pub const fn identity() -> Self

Constructs a new 4x4 matrix as an identity matrix.

pub const fn with_diagonal(diagonal: f32) -> Self

Constructs a new 4x4 matrix with the given value for the diagonal.

Parameters

• diagonal - The value to set on the diagonal.

pub const fn from_arrays(data: [[f32; 4]; 4]) -> Self

Constructs a new 4x4 matrix from the 4x4 array of f32.

Parameters

• data - The 4x4 array of f32 values.

pub const fn from_slice(data: &[f32]) -> Self

Constructs a new 4x4 matrix from a slice of 16 f32 values.

This function will panic if the slice does not have a length of at least 16.

Parameters

• data - The slice of 16 f32 values.

pub const fn from_array_slice(data: &[[f32; 4]]) -> Self

Constructs a new 4x4 matrix from a slice of 4-component arrays of f32.

This function will panic if the slice does not have a length of at least 4.

Parameters

• data - The slice of 4-component arrays of f32 values.

pub const unsafe fn from_ptr_unchecked(ptr: *const f32) -> Self

Constructs a new 4x4 matrix from a mutable slice of 16 f32 values.

Parameters

• data - The mutable pointer to a sequence of 16 f32 values.

Safety

The caller must ensure that the pointer is valid and points to a sequence of 16 f32 reachable values.

pub const fn from_mat4(mat: &Mat4) -> Self

Constructs a new 4x4 matrix with the given Mat4.

Parameters

• mat - The Mat4 to copy the values from.

pub const fn from_rows(r0: &Vec4, r1: &Vec4, r2: &Vec4, r3: &Vec4) -> Self

Creates a new 4x4 matrix from 4 row vectors.

Parameters

• r0 - The first row of the matrix.
• r1 - The second row of the matrix.
• r2 - The third row of the matrix.
• r3 - The fourth row of the matrix.

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

Creates a new 4x4 matrix from 4 column vectors.

Parameters

• c0 - The first column of the matrix.
• c1 - The second column of the matrix.
• c2 - The third column of the matrix.
• c3 - The fourth column of the matrix.

impl Matrix4

pub const fn as_mat4(&self) -> &Mat4

Returns the row at the given index.

pub fn as_mut_mat4(&mut self) -> &mut Mat4

Returns the mutable Mat4 reference.

Methods from Deref<Target = Mat4>

pub const COLS: usize = 4usize

pub const ROWS: usize = 4usize

pub fn as_slice(&self) -> &[f32]

Returns this Mat4 as a slice of f32.

pub fn as_mut_slice(&mut self) -> &mut [f32]

Returns this Mat4 as a mutable slice of f32.

pub fn as_ptr(&self) -> *const f32

Returns this vector as a ptr of f32.

pub fn as_mut_ptr(&mut self) -> *mut f32

Returns this vector as a mutable ptr of f32.

pub fn as_array_slice(&self) -> &[[f32; 4]]

Returns this Mat4 as a slice of 4-component arrays of f32.

pub fn as_mut_array_slice(&mut self) -> &mut [[f32; 4]]

Returns this Mat4 as a mutable slice of 4-component arrays of f32.

pub fn as_array_ref(&self) -> &[[f32; 4]; 4]

Returns this Mat4 as a reference to a 4x4 array of f32.

pub fn as_mut_array_ref(&mut self) -> &mut [[f32; 4]; 4]

Returns this Mat4 as a mutable reference to a 4x4 array of f32.

pub fn to_matrix4(&self) -> Matrix4

Returns this Mat4 as a Matrix4.

This function is const, unlike the equivalent From or ToOwned implementations.

pub fn row(&self, index: usize) -> &Vec4

Returns the row at the given index.

This function will panic if the given index is out of bounds.

Parameters

• index - The index of the row to return.

pub unsafe fn row_unchecked(&self, index: usize) -> &Vec4

Returns the row at the given index without performing bounds checking.

Safety

This function is unsafe because it does not check that the given index is less than 4. If this constraint is violated, memory safety errors can occur.

Parameters

• index - The index of the row to return.

pub fn mut_row(&mut self, index: usize) -> &mut Vec4

Returns a mutable reference to the row at the given index.

This function will panic if the given index is out of bounds.

Parameters

• index - The index of the row to return.

pub unsafe fn mut_row_unchecked(&mut self, index: usize) -> &mut Vec4

Returns a mutable reference to the row at the given index without performing bounds checking.

Safety

This function is unsafe because it does not check that the given index is less than 4. If this constraint is violated, memory safety errors can occur.

Parameters

• index - The index of the row to return.

pub fn col(&self, index: usize) -> &Col4

Returns the column at the given index.

This function will panic if the given index is out of bounds.

Parameters

• index - The index of the column to return.

pub unsafe fn col_unchecked(&self, index: usize) -> &Col4

Returns the column at the given index without performing bounds checking.

Note: Unlike Mat4::row_unchecked, this function returns an owning Vector4 instead of a reference of Vec4.

Safety

This function is unsafe because it does not check that the given index is less than 4. If this constraint is violated, memory safety errors can occur.

Parameters

• index - The index of the column to return.

pub fn mut_col(&mut self, index: usize) -> &mut Col4

Returns a mutable reference to the column at the given index.

This function will panic if the given index is out of bounds.

Parameters

• index - The index of the column to return.

pub unsafe fn mut_col_unchecked(&mut self, index: usize) -> &mut Col4

Returns a mutable reference to the column at the given index without performing bounds checking.

Safety

This function is unsafe because it does not check that the given index is less than 4. If this constraint is violated, memory safety errors can occur.

Parameters

• index - The index of the column to return.

pub fn get(&self, row: usize, col: usize) -> f32

Returns the value at the given column and row.

This function will panic if the given index is out of bounds.

Parameters

• row - The index of the row to return.
• col - The index of the column to return.

pub unsafe fn get_unchecked(&self, row: usize, col: usize) -> f32

Returns the value at the given column and row without performing bounds checking.

Safety

This function is unsafe because it does not check that the given index is less than 4. If this constraint is violated, memory safety errors can occur.

Parameters

• row - The index of the row to return.
• col - The index of the column to return.

pub fn get_mut(&mut self, row: usize, col: usize) -> &mut f32

Returns a mutable reference to the value at the given column and row.

This function will panic if the given index is out of bounds.

Parameters

• row - The index of the row to return.
• col - The index of the column to return.

pub unsafe fn get_mut_unchecked(&mut self, row: usize, col: usize) -> &mut f32

Returns a mutable reference to the value at the given column and row without performing bounds checking.

Safety

This function is unsafe because it does not check that the given index is less than 4. If this constraint is violated, memory safety errors can occur.

Parameters

• row - The index of the row to return.
• col - The index of the column to return.

pub fn scale(&mut self, scale: f32)

Scales each component of the matrix by the given scalar.

Parameters

• scale - The scalar to multiply each component by.

pub fn scale_vec(&mut self, scale: &Vec4)

Scales each row of the matrix by the given vector. This is equivalent to multiplying the matrix by a diagonal matrix with the given vector on the diagonal.

Parameters

• scale - The vector to multiply each row by.

pub fn transpose(&mut self)

Transposes all the elements of this matrix, swapping rows and columns.

pub fn invert(&mut self)

Inverts this matrix.

pub fn determinant(&self) -> f32

Returns the determinant of the matrix.

pub fn trace(&self) -> f32

Returns the trace of the matrix.

pub fn transposed(&self) -> Matrix4

Returns the transpose of the matrix.

pub fn inverted(&self) -> Matrix4

Returns the inverse of the matrix.

pub fn mul_mat4(&self, other: &Mat4) -> Matrix4

Combines this matrix with another matrix by performing matrix multiplication.

Parameters

• other - The matrix to combine with.

pub fn mul_col_vec4(&self, vec: &Vec4) -> Vector4

Combines this matrix with a column vector, returning the resultant vector.

This implements matrix-vector of:

| a b c d |   | x |   | ax + by + cz + dw |
| e f g h | * | y | = | ex + fy + gz + hw |
| i j k l |   | z |   | ix + jy + kz + lw |
| m n o p |   | w |   | mx + ny + oz + pw |

Parameters

• vec - The vector to combine with.

pub fn mul_row_vec4(&self, vec: &Vec4) -> Vector4

Combines this matrix with a row vector, returning the resultant vector.

This implements vector-matrix multiplication of:

| x y z w |   | a b c d |   | ax + ey + iz + mw |
            * | e f g h | = | bx + fy + jz + nw |
              | i j k l |   | cx + gy + kz + ow |
              | m n o p |   | dx + hy + lz + pw |

Trait Implementations

impl Add<&Mat4> for &Matrix4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Mat4> for Matrix4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Matrix4> for &Mat4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&Matrix4> for Matrix4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix4> for &Mat4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Matrix4> for &Matrix4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for &Matrix4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Matrix4

type Output = Matrix4

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Mat4> for Matrix4

fn add_assign(&mut self, rhs: &Mat4)

Performs the += operation.

impl AddAssign<&Matrix4> for Mat4

fn add_assign(&mut self, rhs: &Matrix4)

Performs the += operation.

impl AddAssign<&Matrix4> for Matrix4

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl AddAssign<Matrix4> for Mat4

fn add_assign(&mut self, rhs: Matrix4)

Performs the += operation.

impl AddAssign for Matrix4

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AsMut<Mat4> for Matrix4

fn as_mut(&mut self) -> &mut Mat4

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Mat4> for Matrix4

fn as_ref(&self) -> &Mat4

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<Mat4> for Matrix4

fn borrow(&self) -> &Mat4

Immutably borrows from an owned value.

impl BorrowMut<Mat4> for Matrix4

fn borrow_mut(&mut self) -> &mut Mat4

Mutably borrows from an owned value.

impl Clone for Matrix4

fn clone(&self) -> Matrix4

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Matrix4

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

Formats the value using the given formatter.

impl Default for Matrix4

fn default() -> Matrix4

Returns the “default value” for a type.

impl Deref for Matrix4

type Target = Mat4

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Matrix4

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Display for Matrix4

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

Formats the value using the given formatter.

impl Div<&Matrix4> for f32

type Output = Matrix4

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<f32> for &Matrix4

type Output = Matrix4

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign<f32> for Matrix4

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl Mul<&Mat4> for &Matrix4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Mat4> for Matrix4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Matrix4> for &Mat4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Matrix4> for Matrix4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix4> for &Mat4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix4> for &Matrix4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<f32> for Matrix4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for &Matrix4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Matrix4

type Output = Matrix4

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Mat4> for Matrix4

fn mul_assign(&mut self, rhs: &Mat4)

Performs the *= operation.

impl MulAssign<&Matrix4> for Mat4

fn mul_assign(&mut self, rhs: &Matrix4)

Performs the *= operation.

impl MulAssign<&Matrix4> for Matrix4

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl MulAssign<Matrix4> for Mat4

fn mul_assign(&mut self, rhs: Matrix4)

Performs the *= operation.

impl MulAssign<f32> for Matrix4

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign for Matrix4

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl PartialEq for Matrix4

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

fn partial_cmp(&self, other: &Matrix4) -> 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 Sub<&Mat4> for &Matrix4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Mat4> for Matrix4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Matrix4> for &Mat4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<&Matrix4> for Matrix4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix4> for &Mat4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Matrix4> for &Matrix4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for &Matrix4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Matrix4

type Output = Matrix4

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&Mat4> for Matrix4

fn sub_assign(&mut self, rhs: &Mat4)

Performs the -= operation.

impl SubAssign<&Matrix4> for Mat4

fn sub_assign(&mut self, rhs: &Matrix4)

Performs the -= operation.

impl SubAssign<&Matrix4> for Matrix4

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl SubAssign<Matrix4> for Mat4

fn sub_assign(&mut self, rhs: Matrix4)

Performs the -= operation.

impl SubAssign for Matrix4

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl StructuralPartialEq for Matrix4