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 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 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 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 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 From<Rot2> for Mat2

fn from(rot: Rot2) -> Mat2

Creates a Mat2 rotation matrix from a Rot2.

impl FromReflect for Mat2

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Mat2>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Mat2

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

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 PartialReflect for Mat2

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Mat2>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Mat2>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Mat2>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn reflect_partial_cmp( &self, value: &(dyn PartialReflect + 'static), ) -> Option<Ordering>

Returns a “partial comparison” result.

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

Debug formatter for the value.

fn reflect_clone(&self) -> Result<Box<dyn Reflect>, ReflectCloneError>

Attempts to clone Self using reflection.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn to_dynamic(&self) -> Result<Box<dyn PartialReflect>, ReflectCloneError>

Converts this reflected value into its dynamic representation based on its kind.

fn reflect_clone_and_take<T>(&self) -> Result<T, ReflectCloneError>

where T: 'static, Self: Sized + TypePath,

For a type implementing PartialReflect, combines reflect_clone and take in a useful fashion, automatically constructing an appropriate ReflectCloneError if the downcast fails.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

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 Reflect for Mat2

fn into_any(self: Box<Mat2>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Mat2>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

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 Struct for Mat2

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Gets a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Gets a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Gets the name of the field with index index.

fn index_of_name(&self, name: &str) -> Option<usize>

Gets the index of the field with the given name.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn to_dynamic_struct(&self) -> Result<DynamicStruct, ReflectCloneError>

Creates a new DynamicStruct from this struct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

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 TypePath for Mat2

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Mat2

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Zeroable for Mat2

fn zeroed() -> Self

Calls zeroed.