Struct Mat2

#[repr(C)]
pub struct Mat2<T> {
    pub a11: T,
    pub a12: T,
    pub a21: T,
    pub a22: T,
}

2D transformation matrix.

Each field a_ij represents the i-th row and j-th column of the matrix.

Fields

a11: T

a12: T

a21: T

a22: T

Implementations

impl<T> Mat2<T>

pub const fn new(a11: T, a12: T, a21: T, a22: T) -> Mat2<T>

Constructs a new matrix from components.

impl<T: Zero> Mat2<T>

pub const ZERO: Mat2<T>

Zero matrix.

impl<T: Zero + One> Mat2<T>

pub const IDENTITY: Mat2<T>

Identity matrix.

impl<T: Scalar> Mat2<T>

pub fn scale(scale: impl Into<Vec2<T>>) -> Mat2<T>

Scaling matrix.

Scales around the origin.

Examples found in repository

examples/svgdoc.rs (line 232)

fn reflect_2d() -> String {
	// Calculate data
	let v = Vec2 { x: 10.0, y: 2.5 };
	let this = Vec2 { x: 4.0, y: 4.0 };
	let p = this.project(v);
	let pv = p - this;
	let result = p + pv;
	let origin = Vec2::ZERO;

	// Visualize data
	let transform = Transform2::translate((40.0f32, 120.0f32)) * Mat2::scale((25.0, -25.0));
	let this = transform * this;
	let v = transform * v;
	let p = transform * p;
	let pv = transform * pv;
	let result = transform * result;
	let origin = transform * origin;

	let mut svg = SvgWriter::new(400, 200);
	svg.line(this, result).stroke("black").stroke_width(0.5).stroke_dasharray(&[5.0, 5.0]);
	svg.line(p, pv).stroke("black").stroke_width(0.5).stroke_dasharray(&[5.0, 5.0]);
	svg.line(pv, result).stroke("black").stroke_width(0.5).stroke_dasharray(&[5.0, 5.0]);
	svg.arrow(origin, v, ARROW_SIZE).stroke("black");
	svg.arrow(origin, this, ARROW_SIZE).stroke("black");
	svg.arrow(origin, result, ARROW_SIZE).stroke("red");
	svg.circle(p, 2.0).fill("black");
	svg.text(v, "v").fill("black");
	svg.text(this, "self").fill("black");
	svg.text(p + Vec2(8.0, 10.0), "p").fill("black");
	svg.text(result, "result").fill("red");
	svg.text(p.lerp(pv, 0.9) + Vec2(-15.0, -5.0), "-self").fill("black");
	svg.text(pv.lerp(result, 0.8) + Vec2(0.0, 15.0), "+p").fill("black");
	svg.close()
}

pub fn rotate(angle: impl Angle<T = T>) -> Mat2<T>

Rotation matrix.

Rotates around the origin.

pub fn skew(skew: impl Into<Vec2<T>>) -> Mat2<T>

Skewing matrix.

pub fn reflect(axis: impl Into<Vec2<T>>) -> Mat2<T>

Reflection matrix.

Reflects around the given axis. If axis is the zero vector, returns a point reflection around the origin.

pub fn project(axis: impl Into<Vec2<T>>) -> Mat2<T>

Projection matrix.

Projects onto the given axis. If axis is the zero vector, returns the zero matrix.

impl<T> Mat2<T>

pub fn affine(self) -> Transform2<T>

where T: Zero,

Converts to a Transform2 matrix.

pub fn translate(self, trans: impl Into<Vec2<T>>) -> Transform2<T>

Adds a translation to the matrix.

impl<T> Mat2<T>

pub fn from_row_major(mat: [[T; 2]; 2]) -> Mat2<T>

Imports the matrix from a row-major layout.

pub fn from_column_major(mat: [[T; 2]; 2]) -> Mat2<T>

Imports the matrix from a column-major layout.

pub fn into_row_major(self) -> [[T; 2]; 2]

Exports the matrix as a row-major array.

pub fn into_column_major(self) -> [[T; 2]; 2]

Exports the matrix as a column-major array.

impl<T> Mat2<T>

pub fn compose(x: Vec2<T>, y: Vec2<T>) -> Mat2<T>

Composes the matrix from basis vectors.

pub fn x(self) -> Vec2<T>

Gets the transformed X basis vector.

pub fn y(self) -> Vec2<T>

Gets the transformed Y basis vector.

impl<T: Scalar> Mat2<T>

pub fn determinant(self) -> T

Computes the determinant.

pub fn trace(self) -> T

Computes the trace.

pub fn inverse(self) -> Mat2<T>

Computes the inverse matrix.

pub fn transpose(self) -> Mat2<T>

Returns the transposed matrix.

pub fn adjugate(self) -> Mat2<T>

Computes the adjugate matrix.

Trait Implementations

impl<T: Clone> Clone for Mat2<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Mat2<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Mat2<T>

fn default() -> Mat2<T>

Returns the “default value” for a type.

impl<T: Hash> Hash for Mat2<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Mat2<T>> for Transform2<T>

type Output = Transform2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Mat2<T>) -> Transform2<T>

Performs the * operation.

impl<T: Copy + Mul<Output = T>> Mul<T> for Mat2<T>

type Output = Mat2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Mat2<T>

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Transform2<T>> for Mat2<T>

type Output = Transform2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Transform2<T>) -> Transform2<T>

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul<Vec2<T>> for Mat2<T>

type Output = Vec2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2<T>) -> Vec2<T>

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> Mul for Mat2<T>

type Output = Mat2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Mat2<T>) -> Mat2<T>

Performs the * operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> MulAssign<Mat2<T>> for Transform2<T>

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

Performs the *= operation.

impl<T: Copy + MulAssign> MulAssign<T> for Mat2<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Copy + Add<Output = T> + Mul<Output = T>> MulAssign for Mat2<T>

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

Performs the *= operation.

impl<T: PartialEq> PartialEq for Mat2<T>

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

impl<T: Eq> Eq for Mat2<T>

impl<T> StructuralPartialEq for Mat2<T>