Struct Matrix 

#[repr(C)]
pub struct Matrix<T> {
    pub xx: T,
    pub yx: T,
    pub xy: T,
    pub yy: T,
    pub dx: T,
    pub dy: T,
}

A transformation matrix.

This is a column-major 3x2 affine matrix with the following representation:

| xx xy dx |
| yx yy dy |

with the basis vectors (xx, yx), (xy, yy) and the translation (dx, dy).

Transformation of the point (x, y) is applied as follows:

x' = xx * x + xy * y + dx
y' = yx * x + yy * y + dy

Our matrices are typically considered to be right-handed, meaning that positive angles apply counter-clockwise rotations and the rotation matrix for angle a is:

| cos(a) -sin(a) 0 |
| sin(a)  cos(a) 0 |

Matrix multiplication chains transforms in right to left order meaning that for C = A * B, matrix C will apply B and then A.

Fields

xx: T

yx: T

xy: T

yy: T

dx: T

dy: T

Implementations

impl<T: Copy> Matrix<T>

pub const fn from_elements(elements: [T; 6]) -> Self

Creates a new matrix from an array of elements in the order [xx, yx, xy, yy, dx, dy].

pub const fn elements(&self) -> [T; 6]

Returns the elements as an array in the order [xx, yx, xy, yy, dx, dy].

pub fn map<U: Copy>(self, f: impl FnMut(T) -> U) -> Matrix<U>

Maps Matrix<T> to Matrix<U> by applying a function to each element.

impl<T: MatrixElement> Matrix<T>

pub const IDENTITY: Self

The identity matrix.

pub fn transform(&self, x: T, y: T) -> (T, T)

Applies the matrix to the given coordinates.

Trait Implementations

impl<T: Clone> Clone for Matrix<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Matrix<T>

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

Formats the value using the given formatter.

impl<T: MatrixElement> Default for Matrix<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Matrix<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: MatrixElement> Mul<Point<T>> for Matrix<T>

type Output = Point<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<T>) -> Self::Output

Performs the * operation.

impl<T: MatrixElement> Mul for Matrix<T>

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T: MatrixElement> MulAssign for Matrix<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T: PartialEq> PartialEq for Matrix<T>

fn eq(&self, other: &Matrix<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> Serialize for Matrix<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Zeroable for Matrix<T>

where T: AnyBitPattern,

fn zeroed() -> Self

Calls zeroed.

impl<T> AnyBitPattern for Matrix<T>

where T: AnyBitPattern,

impl<T: Copy> Copy for Matrix<T>

impl<T: Eq> Eq for Matrix<T>

impl<T> StructuralPartialEq for Matrix<T>