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> Matrix<T>

where T: Copy,

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

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>(self, f: impl FnMut(T) -> U) -> Matrix<U>

where U: Copy,

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

impl<T> Matrix<T>

where T: MatrixElement,

pub const IDENTITY: Matrix<T>

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 for Matrix<T>

where T: Clone,

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 for Matrix<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Matrix<T>

where T: MatrixElement,

fn default() -> Matrix<T>

Returns the “default value” for a type.

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

where T: MatrixElement,

type Output = Point<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<T>) -> <Matrix<T> as Mul<Point<T>>>::Output

Performs the * operation.

impl<T> Mul for Matrix<T>

where T: MatrixElement,

type Output = Matrix<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<T>) -> <Matrix<T> as Mul>::Output

Performs the * operation.

impl<T> MulAssign for Matrix<T>

where T: MatrixElement,

fn mul_assign(&mut self, rhs: Matrix<T>)

Performs the *= operation.

impl<T> PartialEq for Matrix<T>

where T: PartialEq,

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> Zeroable for Matrix<T>

where T: AnyBitPattern,

fn zeroed() -> Self

Calls zeroed.

impl<T> AnyBitPattern for Matrix<T>

where T: AnyBitPattern,

impl<T> Copy for Matrix<T>

where T: Copy,

impl<T> Eq for Matrix<T>

where T: Eq,

impl<T> StructuralPartialEq for Matrix<T>