Struct math2d::Matrix3x2f

#[repr(C)]
pub struct Matrix3x2f {
    pub a: f32,
    pub b: f32,
    pub c: f32,
    pub d: f32,
    pub x: f32,
    pub y: f32,
}

2D Affine Transformation Matrix.

Mathematically you can think of this matrix as if it were the following:

[a, b, 0]
[c, d, 0]
[x, y, 1]

Composing matrices

Affine transformations are performed in “Row-Major” order. What this means, if you’re familiar with linear algebra, is that when you compose multiple affine transformations together, the matrix representing the set of operations that should happen “first” must be the left hand operand of the multiplication operator.

This is also why points and vectors are the left-hand operand when multiplied with matrices.

Fields

a: f32

Horizontal scaling / cosine of rotation

b: f32

Vertical shear / sine of rotation

c: f32

Horizontal shear / negative sine of rotation

d: f32

Vertical scaling / cosine of rotation

x: f32

Horizontal translation (always orthogonal regardless of rotation)

y: f32

Vertical translation (always orthogonal regardless of rotation)

Implementations

impl Matrix3x2f

pub const IDENTITY: Matrix3x2f = _

The 2D affine identity matrix.

pub fn new(parts: [[f32; 2]; 3]) -> Matrix3x2f

Construct the matrix from an array of the row values.

pub fn from_slice(values: &[f32]) -> Matrix3x2f

Constructs the matrix from a slice of 6 values as [a, b, c, d, x, y].

Panics if values does not contain exactly 6 elements.

pub fn from_tuple(values: (f32, f32, f32, f32, f32, f32)) -> Matrix3x2f

Constructs the matrix from a tuple of 6 values as (a, b, c, d, x, y).

pub fn translation(trans: impl Into<Vector2f>) -> Matrix3x2f

Creates an affine translation matrix that translates points by the passed vector. The linear part of the matrix is the identity.

Read More

pub fn scaling(
    scale: impl Into<Vector2f>,
    center: impl Into<Point2f>
) -> Matrix3x2f

Creates a scaling matrix that performs scaling around a specified point of origin. This is equivalent to translating the center point back to the origin, scaling around the origin by the scaling value, and then translating the center point back to its original location.

Read More

pub fn rotation(angle: f32, center: impl Into<Point2f>) -> Matrix3x2f

Creates a rotation matrix that performs rotation around a specified point of origin. This is equivalent to translating the center point back to the origin, rotating around the origin by the specified angle, and then translating the center point back to its original location.

Read More

pub fn skew(angle_x: f32, angle_y: f32, center: impl Into<Point2f>) -> Matrix3x2f

Creates a matrix that skews an object by a tangent angle around the center point.

Read More

pub fn linear_transpose(&self) -> Matrix3x2f

Computes the transpose of the linear part of this matrix i.e. swap(b, c).

pub fn determinant(&self) -> f32

Returns the determinant of the matrix. Since this matrix is conceptually 3x3, and the bottom-right element is always 1, this value works out to be a * d - b * c.

pub fn is_invertible(&self) -> bool

Determines if the inverse or try_inverse functions would succeed if called. A matrix is invertible if its determinant is nonzero. Since we’re dealing with floats, we check that the absolute value of the determinant is greater than f32::EPSILON.

pub fn inverse(&self) -> Matrix3x2f

Calculates the inverse of this matrix. Panics if the matrix is not invertible (see above).

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

Calculates the inverse of the matrix. Returns None if the determinant is less than f32::EPSILON.

pub fn unchecked_inverse(&self, det: f32) -> Matrix3x2f

Performs the inverse of the matrix without checking for invertibility.

WARNING: If this matrix is not invertible, you may get NaN or INF!

pub fn compose(
    scaling: impl Into<Vector2f>,
    rotation: f32,
    translation: impl Into<Vector2f>
) -> Matrix3x2f

Compose a matrix from a scaling, rotation, and translation value (combined in that order).

pub fn decompose(&self) -> Decomposition

Decomposes a simple affine transformation into its scaling, rotation, and translation parts.

pub fn transform_point(&self, point: impl Into<Point2f>) -> Point2f

A more explicit way to do point * matrix, while also allowing any type that may be converted into a Point2F with a From/Into impl.

pub fn transform_vector(&self, vec: impl Into<Vector2f>) -> Vector2f

A more explicit way to do vec * matrix, while also allowing any type that may be converted into a Vector2F with a From/Into impl.

pub fn to_row_major(&self) -> [[f32; 3]; 3]

Returns this matrix as a 3x3 float array using the mathematical form described above.

pub fn to_column_major(&self) -> [[f32; 3]; 3]

Returns the matrix as a 3x3 float array in column major form, i.e. the transpose of the row-major version.

pub fn is_approx_eq(&self, other: &Matrix3x2f, epsilon: f32) -> bool

Checks if two matrices are approximately equal given an epsilon value.

pub fn is_identity(&self) -> bool

Checks if this matrix is equal to the identity matrix within 1e-5

Trait Implementations

impl Clone for Matrix3x2f

fn clone(&self) -> Matrix3x2f

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Matrix3x2f

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

Formats the value using the given formatter.

impl Default for Matrix3x2f

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Matrix3x2f

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<[[f32; 2]; 3]> for Matrix3x2f

fn from(parts: [[f32; 2]; 3]) -> Matrix3x2f

Converts to this type from the input type.

impl From<D2D_MATRIX_3X2_F> for Matrix3x2f

fn from(m: D2D_MATRIX_3X2_F) -> Matrix3x2f

Converts to this type from the input type.

impl From<DWRITE_MATRIX> for Matrix3x2f

fn from(m: DWRITE_MATRIX) -> Matrix3x2f

Converts to this type from the input type.

impl From<Matrix3x2f> for [[f32; 2]; 3]

fn from(m: Matrix3x2f) -> [[f32; 2]; 3]

Converts to this type from the input type.

impl From<Matrix3x2f> for [[f32; 3]; 3]

fn from(m: Matrix3x2f) -> [[f32; 3]; 3]

Converts to this type from the input type.

impl From<Matrix3x2f> for D2D_MATRIX_3X2_F

fn from(m: Matrix3x2f) -> D2D_MATRIX_3X2_F

Converts to this type from the input type.

impl From<Matrix3x2f> for DWRITE_MATRIX

fn from(m: Matrix3x2f) -> DWRITE_MATRIX

Converts to this type from the input type.

impl From<Matrix3x2f> for RowMatrix3x2<f32>

fn from(mat: Matrix3x2f) -> RowMatrix3x2<f32>

Converts to this type from the input type.

impl Mul<Matrix3x2f> for Matrix3x2f

type Output = Matrix3x2f

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Matrix3x2f> for Point2f

type Output = Point2f

The resulting type after applying the * operator.

fn mul(self, m: Matrix3x2f) -> Point2f

Performs the * operation.

impl Mul<Matrix3x2f> for Vector2f

type Output = Vector2f

The resulting type after applying the * operator.

fn mul(self, m: Matrix3x2f) -> Vector2f

Performs the * operation.

impl PartialEq<Matrix3x2f> for Matrix3x2f

fn eq(&self, other: &Matrix3x2f) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Matrix3x2f

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Matrix3x2f

impl StructuralPartialEq for Matrix3x2f