[−][src]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)

Methods

`impl Matrix3x2f`[src]

`pub const IDENTITY: Matrix3x2f`[src]

The 2D affine identity matrix.

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

Construct the matrix from an array of the row values.

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

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`[src]

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

`pub fn translation(trans: impl Into<Vector2f>) -> Matrix3x2f`[src]

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

Example Translation

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

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.

Example Scaling

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

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.

Example Rotation

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

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

Example Effect of Skewing

`pub fn linear_transpose(&self) -> Matrix3x2f`[src]

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

`pub fn determinant(&self) -> f32`[src]

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`[src]

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.