Struct Mat3

#[repr(C)]
pub struct Mat3<T> {
    pub a11: T,
    pub a12: T,
    pub a13: T,
    pub a21: T,
    pub a22: T,
    pub a23: T,
    pub a31: T,
    pub a32: T,
    pub a33: T,
}

3D transformation matrix.

Each field a_ij represents the i-th row and j-th column of the matrix.

Row-major storage with column-major semantics.

Stored in row-major order (fields appear in reading order), but interpreted as column-major: each column is a transformed basis vector, and matrices are applied to column vectors via mat * vec.

Fields

a11: T

a12: T

a13: T

a21: T

a22: T

a23: T

a31: T

a32: T

a33: T

Implementations

impl<T> Mat3<T>

pub const fn new( a11: T, a12: T, a13: T, a21: T, a22: T, a23: T, a31: T, a32: T, a33: T, ) -> Mat3<T>

Constructs a new matrix from components.

impl<T: Zero> Mat3<T>

pub const ZERO: Mat3<T>

Zero matrix.

impl<T: Zero + One> Mat3<T>

pub const IDENTITY: Mat3<T>

Identity matrix.

impl<T: Float> Mat3<T>

pub fn scale(scale: Vec3<T>) -> Mat3<T>

Scaling matrix.

pub fn rotate(axis: Vec3<T>, angle: Angle<T>) -> Mat3<T>

Rotation matrix around an axis.

impl<T> Mat3<T>

pub fn mat2(self) -> Mat2<T>

Converts to a Mat2 matrix.

pub fn transform3(self) -> Transform3<T>

where T: Zero,

Converts to a Transform3 matrix.

pub fn translate(self, trans: Vec3<T>) -> Transform3<T>

Adds a translation to the matrix.

impl<T> Mat3<T>

pub fn from_row_major(mat: [[T; 3]; 3]) -> Mat3<T>

Imports the matrix from a row-major layout.

pub fn from_column_major(mat: [[T; 3]; 3]) -> Mat3<T>

Imports the matrix from a column-major layout.

pub fn into_row_major(self) -> [[T; 3]; 3]

Exports the matrix as a row-major array.

pub fn into_column_major(self) -> [[T; 3]; 3]

Exports the matrix as a column-major array.

impl<T> Mat3<T>

pub fn compose(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Mat3<T>

Composes the matrix from basis vectors.

pub fn x(self) -> Vec3<T>

Gets the transformed X basis vector.

pub fn y(self) -> Vec3<T>

Gets the transformed Y basis vector.

pub fn z(self) -> Vec3<T>

Gets the transformed Z basis vector.

impl<T: Scalar> Mat3<T>

pub fn det(self) -> T

Computes the determinant.

pub fn trace(self) -> T

Computes the trace.

pub fn flat_norm_sqr(self) -> T

Computes the squared Frobenius norm (sum of squares of all matrix elements).

This measure is useful for quickly checking matrix magnitude or comparing matrices without the cost of a square root operation.

To check if a matrix is effectively zero, test if flat_norm_sqr() is below a small epsilon threshold.

pub fn try_invert(self) -> Option<Mat3<T>>

where T: Float,

pub fn inverse(self) -> Mat3<T>

where T: Float,

Computes the inverse matrix.

Returns the zero matrix if the determinant is near zero.

pub fn transpose(self) -> Mat3<T>

Returns the transposed matrix.

pub fn adjugate(self) -> Mat3<T>

Computes the adjugate matrix.

pub fn lerp(self, rhs: Mat3<T>, t: T) -> Mat3<T>

where T: Float,

Linear interpolation between the matrix elements.

Trait Implementations

impl<T: Clone> Clone for Mat3<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Mat3<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Mat3<T>

fn default() -> Mat3<T>

Returns the “default value” for a type.

impl<T: Display> Display for Mat3<T>

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

Formats the value using the given formatter.

impl<T: Zero + One> From<Mat3<T>> for Mat4<T>

fn from(mat: Mat3<T>) -> Mat4<T>

Converts to this type from the input type.

impl<T: Zero + One> From<Transform2<T>> for Mat3<T>

fn from(mat: Transform2<T>) -> Mat3<T>

Converts to this type from the input type.

impl<T> Mul<&Mat3<T>> for &Mat3<T>

where Mat3<T>: Copy + Mul<Mat3<T>, Output = Mat3<T>>,

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Mat3<T>> for Mat3<T>

where Mat3<T>: Mul<Mat3<T>, Output = Mat3<T>> + Copy,

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&T> for &Mat3<T>

where Mat3<T>: Copy + Mul<T, Output = Mat3<T>>, T: Copy,

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&T> for Mat3<T>

where Mat3<T>: Mul<T, Output = Mat3<T>>, T: Copy,

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Vec3<T>> for &Mat3<T>

where Mat3<T>: Copy + Mul<Vec3<T>, Output = Vec3<T>>, Vec3<T>: Copy,

type Output = Vec3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Vec3<T>> for Mat3<T>

where Mat3<T>: Mul<Vec3<T>, Output = Vec3<T>>, Vec3<T>: Copy,

type Output = Vec3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Mat3<T>> for &Mat3<T>

where Mat3<T>: Copy + Mul<Mat3<T>, Output = Mat3<T>>,

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Mat3<T>> for Transform3<T>

type Output = Transform3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<T> for &Mat3<T>

where Mat3<T>: Copy + Mul<T, Output = Mat3<T>>,

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Mul<Output = T>> Mul<T> for Mat3<T>

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Transform2<T>> for Mat3<T>

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<Vec3<T>> for &Mat3<T>

where Mat3<T>: Copy + Mul<Vec3<T>, Output = Vec3<T>>,

type Output = Vec3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Vec3<T>> for Mat3<T>

type Output = Vec3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul for Mat3<T>

type Output = Mat3<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> MulAssign<&Mat3<T>> for Mat3<T>

where Mat3<T>: MulAssign<Mat3<T>> + Copy,

fn mul_assign(&mut self, rhs: &Mat3<T>)

Performs the *= operation.

impl<T> MulAssign<&T> for Mat3<T>

where Mat3<T>: MulAssign<T>, T: Copy,

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

Performs the *= operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> MulAssign<Mat3<T>> for Transform3<T>

fn mul_assign(&mut self, rhs: Mat3<T>)

Performs the *= operation.

impl<T: Copy + MulAssign> MulAssign<T> for Mat3<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> MulAssign<Transform2<T>> for Mat3<T>

fn mul_assign(&mut self, rhs: Transform2<T>)

Performs the *= operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> MulAssign for Mat3<T>

fn mul_assign(&mut self, rhs: Mat3<T>)

Performs the *= operation.

impl<T: PartialEq> PartialEq for Mat3<T>

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

impl<T> StructuralPartialEq for Mat3<T>