Struct Mat2 

pub struct Mat2(/* private fields */);

A 2x2 column major matrix.

SIMD vector types are used for storage on supported platforms.

This type is 16 byte aligned.

Implementations

impl Mat2

pub const ZERO: Mat2

A 2x2 matrix with all elements set to 0.0.

pub const IDENTITY: Mat2

A 2x2 identity matrix, where all diagonal elements are 1, and all off-diagonal elements are 0.

pub const NAN: Mat2

All NAN:s.

pub const fn from_cols(x_axis: Vec2, y_axis: Vec2) -> Mat2

Creates a 2x2 matrix from two column vectors.

See also Self::from_rows when the data is in row major order.

pub const fn from_rows(row0: Vec2, row1: Vec2) -> Mat2

Creates a 2x2 matrix from two row vectors.

Matrices are stored in column major order, so the given rows are permuted into the matrix layout. Use Self::from_cols instead when the data is already in column major order.

pub const fn from_cols_array(m: &[f32; 4]) -> Mat2

Creates a 2x2 matrix from a [f32; 4] array stored in column major order.

If the data is in row major order use Self::from_rows_array instead.

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

Creates a [f32; 4] array storing data in column major order.

If you require the data in row major order use Self::to_rows_array instead.

pub const fn from_cols_array_2d(m: &[[f32; 2]; 2]) -> Mat2

Creates a 2x2 matrix from a [[f32; 2]; 2] 2D array stored in column major order.

If the data is in row major order transpose the returned matrix.

pub const fn to_cols_array_2d(&self) -> [[f32; 2]; 2]

Creates a [[f32; 2]; 2] 2D array storing data in column major order.

If you require row major order transpose the matrix first.

pub const fn from_rows_array(m: &[f32; 4]) -> Mat2

Creates a 2x2 matrix from a [f32; 4] array stored in row major order.

Matrices are stored in column major order, so the array is permuted into the matrix layout. Use Self::from_cols_array instead when the data is already in column major order.

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

Creates a [f32; 4] array storing data in row major order.

Matrices are stored in column major order, so the array is permuted out of the column major storage. Use Self::to_cols_array instead when you want data in column major order.

pub const fn from_diagonal(diagonal: Vec2) -> Mat2

Creates a 2x2 matrix with its diagonal set to diagonal and all other entries set to 0.

pub fn from_scale_angle(scale: Vec2, angle: f32) -> Mat2

Creates a 2x2 matrix containing the combining non-uniform scale and rotation of angle (in radians).

pub fn from_angle(angle: f32) -> Mat2

Creates a 2x2 matrix containing a rotation of angle (in radians).

pub fn from_mat3(m: Mat3) -> Mat2

Creates a 2x2 matrix from a 3x3 matrix, discarding the 2nd row and column.

pub fn from_mat3_minor(m: Mat3, i: usize, j: usize) -> Mat2

Creates a 2x2 matrix from the minor of the given 3x3 matrix, discarding the ith column and jth row.

Panics

Panics if i or j is greater than 2.

pub fn from_mat3a(m: Mat3A) -> Mat2

Creates a 2x2 matrix from a 3x3 matrix, discarding the 2nd row and column.

pub fn from_mat3a_minor(m: Mat3A, i: usize, j: usize) -> Mat2

Creates a 2x2 matrix from the minor of the given 3x3 matrix, discarding the ith column and jth row.

Panics

Panics if i or j is greater than 2.

pub const fn from_cols_slice(slice: &[f32]) -> Mat2

Creates a 2x2 matrix from the first 4 values in slice.

See also Self::from_rows_slice when the slice is in row major order.

Panics

Panics if slice is less than 4 elements long.

pub fn write_cols_to_slice(&self, slice: &mut [f32])

Writes the columns of self to the first 4 elements in slice.

Panics

Panics if slice is less than 4 elements long.

pub const fn from_rows_slice(slice: &[f32]) -> Mat2

Creates a 2x2 matrix from the first 4 values in slice, stored in row major order.

Matrices are stored in column major order, so the slice is permuted into the matrix layout. Use Self::from_cols_slice instead when the slice is already in column major order.

Panics

Panics if slice is less than 4 elements long.

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

Returns the matrix column for the given index.

Panics

Panics if index is greater than 1.

pub fn col_mut(&mut self, index: usize) -> &mut Vec2

Returns a mutable reference to the matrix column for the given index.

Panics

Panics if index is greater than 1.

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

Returns the matrix row for the given index.

See also Self::set_row when you need to change the row.

Panics

Panics if index is greater than 1.

pub fn set_row(&mut self, index: usize, row: Vec2)

Sets the matrix row for the given index.

Matrices are stored in column major order, so the row is spread across all 2 columns and writing it touches every column. Use Self::col_mut instead when you can work with columns. See also Self::row.

Panics

Panics if index is greater than 1.

pub fn is_finite(&self) -> bool

Returns true if, and only if, all elements are finite. If any element is either NaN, positive or negative infinity, this will return false.

pub fn is_nan(&self) -> bool

Returns true if any elements are NaN.

pub fn transpose(&self) -> Mat2

Returns the transpose of self.

pub fn diagonal(&self) -> Vec2

Returns the diagonal of self.

pub fn determinant(&self) -> f32

Returns the determinant of self.

pub fn inverse(&self) -> Mat2

Returns the inverse of self.

If the matrix is not invertible the returned matrix will be invalid. The returned matrix will also be invalid if the inverse is not finite, which can happen when self contains very large or very small values. Use Self::try_inverse or Self::inverse_or_zero to detect these cases.

Panics

Will panic if the resulting inverted matrix is not finite when glam_assert is enabled.

pub fn try_inverse(&self) -> Option<Mat2>

Returns the inverse of self or None if the matrix is not invertible, or if the inverse is not finite.

pub fn inverse_or_zero(&self) -> Mat2

Returns the inverse of self or Mat2::ZERO if the matrix is not invertible, or if the inverse is not finite.

pub fn mul_vec2(&self, rhs: Vec2) -> Vec2

Transforms a 2D vector.

pub fn mul_transpose_vec2(&self, rhs: Vec2) -> Vec2

Transforms a 2D vector by the transpose of self.

pub fn mul_mat2(&self, rhs: &Mat2) -> Mat2

Multiplies two 2x2 matrices.

pub fn add_mat2(&self, rhs: &Mat2) -> Mat2

Adds two 2x2 matrices.

pub fn sub_mat2(&self, rhs: &Mat2) -> Mat2

Subtracts two 2x2 matrices.

pub fn mul_scalar(&self, rhs: f32) -> Mat2

Multiplies a 2x2 matrix by a scalar.

pub fn mul_diagonal_scale(&self, scale: Vec2) -> Mat2

Multiply self by a scaling vector scale. This is faster than creating a whole diagonal scaling matrix and then multiplying that. This operation is commutative.

pub fn div_scalar(&self, rhs: f32) -> Mat2

Divides a 2x2 matrix by a scalar.

pub fn recip(&self) -> Mat2

Returns a matrix containing the reciprocal 1.0/n of each element of self.

pub fn abs_diff_eq(&self, rhs: Mat2, max_abs_diff: f32) -> bool

Returns true if the absolute difference of all elements between self and rhs is less than or equal to max_abs_diff.

This can be used to compare if two matrices contain similar elements. It works best when comparing with a known value. The max_abs_diff that should be used used depends on the values being compared against.

For more see comparing floating point numbers.

pub fn abs(&self) -> Mat2

Takes the absolute value of each element in self

pub fn as_dmat2(&self) -> DMat2

Trait Implementations

impl AbsDiffEq for Mat2

type Epsilon = <f32 as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> <Mat2 as AbsDiffEq>::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq( &self, other: &Mat2, epsilon: <Mat2 as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl Add for Mat2

type Output = Mat2

The resulting type after applying the + operator.

fn add(self, rhs: Mat2) -> Mat2

Performs the + operation.

impl Add<&Mat2> for Mat2

type Output = Mat2

The resulting type after applying the + operator.

fn add(self, rhs: &Mat2) -> Mat2

Performs the + operation.

impl Add<&Mat2> for &Mat2

type Output = Mat2

The resulting type after applying the + operator.

fn add(self, rhs: &Mat2) -> Mat2

Performs the + operation.

impl Add<Mat2> for &Mat2

type Output = Mat2

The resulting type after applying the + operator.

fn add(self, rhs: Mat2) -> Mat2

Performs the + operation.

impl AddAssign for Mat2

fn add_assign(&mut self, rhs: Mat2)

Performs the += operation.

impl AddAssign<&Mat2> for Mat2

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

Performs the += operation.

impl AsMut<[f32; 4]> for Mat2

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

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

impl AsMutMatrixParts<f32, 2, 2> for Mat2

where Mat2: AsMut<[f32; 4]>, f32: MatrixScalar,

fn as_mut_parts(&mut self) -> &mut [[f32; 2]; 2]

impl AsRef<[f32; 4]> for Mat2

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

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

impl AsRefMatrixParts<f32, 2, 2> for Mat2

where Mat2: AsRef<[f32; 4]>, f32: MatrixScalar,

fn as_ref_parts(&self) -> &[[f32; 2]; 2]

impl Clone for Mat2

fn clone(&self) -> Mat2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Mat2

impl CreateFrom for Mat2

where Mat2: ShaderType<ExtraMetadata = MatrixMetadata> + FromMatrixParts<f32, 2, 2>, f32: MatrixScalar + CreateFrom,

fn create_from<B>(reader: &mut Reader<B>) -> Mat2

where B: BufferRef,

impl Debug for Mat2

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

Formats the value using the given formatter.

impl Default for Mat2

fn default() -> Mat2

Returns the “default value” for a type.

impl Deref for Mat2

type Target = Cols2<Vec2>

The resulting type after dereferencing.

fn deref(&self) -> &<Mat2 as Deref>::Target

Dereferences the value.

impl DerefMut for Mat2

fn deref_mut(&mut self) -> &mut <Mat2 as Deref>::Target

Mutably dereferences the value.

impl<'de> Deserialize<'de> for Mat2

Deserialize expects a sequence of 4 values.

fn deserialize<D>( deserializer: D, ) -> Result<Mat2, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Mat2

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

Formats the value using the given formatter.

impl Div<&f32> for Mat2

type Output = Mat2

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Mat2

Performs the / operation.

impl Div<&f32> for &Mat2

type Output = Mat2

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Mat2

Performs the / operation.

impl Div<f32> for Mat2

type Output = Mat2

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Mat2

Performs the / operation.

impl Div<f32> for &Mat2

type Output = Mat2

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Mat2

Performs the / operation.

impl DivAssign<&f32> for Mat2

fn div_assign(&mut self, rhs: &f32)

Performs the /= operation.

impl DivAssign<f32> for Mat2

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<S> From<Matrix<f32, Const<2>, Const<2>, S>> for Mat2

where S: RawStorage<f32, Const<2>, Const<2>>,

fn from(e: Matrix<f32, Const<2>, Const<2>, S>) -> Mat2

Converts to this type from the input type.

impl From<Rotation<f32, 2>> for Mat2

fn from(e: Rotation<f32, 2>) -> Mat2

Converts to this type from the input type.

impl From<Unit<Complex<f32>>> for Mat2

fn from(e: Unit<Complex<f32>>) -> Mat2

Converts to this type from the input type.

impl FromMatrixParts<f32, 2, 2> for Mat2

fn from_parts(parts: [[f32; 2]; 2]) -> Mat2

impl MatExt for Mat2

type Scalar = f32

The scalar type.

type Vector = Vec2

The vector type.

type SymmetricEigen = SymmetricEigen2

The symmetric eigen decomposition type.

type Svd = Svd2

The Singular Values Decomposition type.

fn abs(&self) -> Mat2

Returns a matrix with all components set to their absolute values.

fn try_inverse(&self) -> Option<Mat2>

Tries to invert the matrix, returning None if not invertible.

fn swap_cols(&mut self, a: usize, b: usize)

Swaps two columns of this matrix.

fn swap_rows(&mut self, a: usize, b: usize)

Swaps two rows of this matrix.

fn symmetric_eigen(&self) -> <Mat2 as MatExt>::SymmetricEigen

Computes the symmetric eigendecomposition.

fn symmetric_eigenvalues(&self) -> <Mat2 as MatExt>::Vector

Computes the eigenvalues of a symmetric matrix.

fn svd(&self) -> <Mat2 as MatExt>::Svd

Computes the SVD of this matrix.

impl Mul for Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: Mat2) -> Mat2

Performs the * operation.

impl Mul<&Mat2> for Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat2) -> Mat2

Performs the * operation.

impl Mul<&Mat2> for &Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: &Mat2) -> Mat2

Performs the * operation.

impl Mul<&Vec2> for Mat2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: &Vec2) -> Vec2

Performs the * operation.

impl Mul<&Vec2> for &Mat2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: &Vec2) -> Vec2

Performs the * operation.

impl Mul<&f32> for Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Mat2

Performs the * operation.

impl Mul<&f32> for &Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Mat2

Performs the * operation.

impl Mul<Mat2> for &Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: Mat2) -> Mat2

Performs the * operation.

impl Mul<Vec2> for Mat2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2) -> <Mat2 as Mul<Vec2>>::Output

Performs the * operation.

impl Mul<Vec2> for &Mat2

type Output = Vec2

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2) -> Vec2

Performs the * operation.

impl Mul<f32> for Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Mat2

Performs the * operation.

impl Mul<f32> for &Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Mat2

Performs the * operation.

impl MulAssign for Mat2

fn mul_assign(&mut self, rhs: Mat2)

Performs the *= operation.

impl MulAssign<&Mat2> for Mat2

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

Performs the *= operation.

impl MulAssign<&f32> for Mat2

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

Performs the *= operation.

impl MulAssign<f32> for Mat2

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl Neg for Mat2

type Output = Mat2

The resulting type after applying the - operator.

fn neg(self) -> <Mat2 as Neg>::Output

Performs the unary - operation.

impl Neg for &Mat2

type Output = Mat2

The resulting type after applying the - operator.

fn neg(self) -> Mat2

Performs the unary - operation.

impl PartialEq for Mat2

fn eq(&self, rhs: &Mat2) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Pod for Mat2

impl Product for Mat2

fn product<I>(iter: I) -> Mat2

where I: Iterator<Item = Mat2>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Product<&'a Mat2> for Mat2

fn product<I>(iter: I) -> Mat2

where I: Iterator<Item = &'a Mat2>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl ReadFrom for Mat2

where Mat2: ShaderType<ExtraMetadata = MatrixMetadata> + AsMutMatrixParts<f32, 2, 2>, f32: MatrixScalar + ReadFrom,

fn read_from<B>(&mut self, reader: &mut Reader<B>)

where B: BufferRef,

impl RelativeEq for Mat2

fn default_max_relative() -> <Mat2 as AbsDiffEq>::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Mat2, epsilon: <Mat2 as AbsDiffEq>::Epsilon, max_relative: <Mat2 as AbsDiffEq>::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl Serialize for Mat2

Serialize as a sequence of 4 values.

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl ShaderSize for Mat2

where f32: ShaderSize,

const SHADER_SIZE: NonZero<u64> = _

Represents WGSL Size (equivalent to ShaderType::min_size)

impl ShaderType for Mat2

where f32: ShaderSize,

fn min_size() -> NonZero<u64>

Represents the minimum size of Self (equivalent to GPUBufferBindingLayout.minBindingSize)

fn size(&self) -> NonZero<u64>

Returns the size of Self at runtime

fn assert_uniform_compat()

Asserts that Self meets the requirements of the uniform address space restrictions on stored values and the uniform address space layout constraints

impl Sub for Mat2

type Output = Mat2

The resulting type after applying the - operator.

fn sub(self, rhs: Mat2) -> Mat2

Performs the - operation.

impl Sub<&Mat2> for Mat2

type Output = Mat2

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat2) -> Mat2

Performs the - operation.

impl Sub<&Mat2> for &Mat2

type Output = Mat2

The resulting type after applying the - operator.

fn sub(self, rhs: &Mat2) -> Mat2

Performs the - operation.

impl Sub<Mat2> for &Mat2

type Output = Mat2

The resulting type after applying the - operator.

fn sub(self, rhs: Mat2) -> Mat2

Performs the - operation.

impl SubAssign for Mat2

fn sub_assign(&mut self, rhs: Mat2)

Performs the -= operation.

impl SubAssign<&Mat2> for Mat2

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

Performs the -= operation.

impl Sum for Mat2

fn sum<I>(iter: I) -> Mat2

where I: Iterator<Item = Mat2>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a> Sum<&'a Mat2> for Mat2

fn sum<I>(iter: I) -> Mat2

where I: Iterator<Item = &'a Mat2>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl UlpsEq for Mat2

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq( &self, other: &Mat2, epsilon: <Mat2 as AbsDiffEq>::Epsilon, max_ulps: u32, ) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl WriteInto for Mat2

where Mat2: ShaderType<ExtraMetadata = MatrixMetadata> + AsRefMatrixParts<f32, 2, 2>, f32: MatrixScalar + WriteInto,

fn write_into<B>(&self, writer: &mut Writer<B>)

where B: BufferMut,

impl Zeroable for Mat2

fn zeroed() -> Self

Calls zeroed.