Struct gamemath::Mat2

pub struct Mat2 {
    pub rows: [Vec2<f32>; 2],
}

A 2x2-component Euclidean matrix useful for linear algebra computation in game development and 2D rendering.

Fields

rows: [Vec2<f32>; 2]

The two rows of the matrix, represented by an array of two Vec2<f32> objects.

Implementations

impl Mat2

pub fn identity() -> Mat2

Constructs a 2x2 identity matrix.

Examples

use gamemath::{Mat2, Vec2};

let m = Mat2::identity();

assert_eq!(m[0], Vec2::new(1.0, 0.0));
assert_eq!(m[1], Vec2::new(0.0, 1.0));

pub fn transposed(&self) -> Mat2

Extracts and returns a transposed representation of the calling Mat2 object.

Examples

use gamemath::Mat2;

let m: Mat2 = ((0.0, 1.0),
               (2.0, 3.0)).into();

assert_eq!(m.transposed(), ((0.0, 2.0),
                            (1.0, 3.0)).into());

pub fn transpose(&mut self)

Performs a transpose operation on the calling Mat2 object.

Examples

use gamemath::Mat2;

let mut m: Mat2 = ((0.0, 1.0),
                   (3.0, 4.0)).into();

m.transpose();

assert_eq!(m, ((0.0, 3.0),
               (1.0, 4.0)).into());

pub fn rotation(radians: f32) -> Mat2

Constructs a 2x2 rotation matrix from a radians value.

Examples

use gamemath::{Mat2, Vec2};

let m = Mat2::rotation(1.0);

assert_eq!(m[0], Vec2::new(0.5403023,  -0.84147096,));
assert_eq!(m[1], Vec2::new(0.84147096,  0.54030230,));

pub fn rotated(&self, radians: f32) -> Mat2

Calculates and returns a Mat2 object representing the calling Mat2 object rotated by a radians value.

Examples

use gamemath::Mat2;

let m = Mat2::identity().rotated(1.0);

assert_eq!(m, ((0.5403023,  -0.84147096,),
               (0.84147096,  0.54030230,)).into());

pub fn rotate(&mut self, radians: f32)

Rotates the calling Mat2 object by a radians value.

Examples

use gamemath::Mat2;

let mut m = Mat2::identity();

m.rotate(1.0);

assert_eq!(m, ((0.5403023,  -0.84147096,),
               (0.84147096,  0.54030230,)).into());

pub fn scaled(&self, factor: Vec2<f32>) -> Mat2

Calculates and returns a Mat2 object representing the calling Mat2 object scaled by a Vec2<f32>.

Examples

use gamemath::{Mat2, Vec2};

let m = Mat2::identity();

assert_eq!(m.scaled(Vec2::new(3.0, 6.0)), ((3.0, 0.0),
                                           (0.0, 6.0)).into());

pub fn scale(&mut self, factor: Vec2<f32>)

Performs the scale operation on the calling Mat2 object, scaling it by a Vec2<f32>.

Examples

use gamemath::{Mat2, Vec2};

let mut m = Mat2::identity();

m.scale(Vec2::new(5.0, 2.0));

assert_eq!(m, ((5.0, 0.0),
               (0.0, 2.0)).into());

Trait Implementations

impl Add for Mat2

type Output = Mat2

The resulting type after applying the + operator.

fn add(self, right: Mat2) -> Mat2

Performs the + operation.

impl AddAssign for Mat2

fn add_assign(&mut self, right: Mat2)

Performs the += operation.

impl Clone for Mat2

fn clone(&self) -> Mat2

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Mat2

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

Formats the value using the given formatter.

impl Default for Mat2

fn default() -> Mat2

Returns the “default value” for a type.

impl From<[[f32; 2]; 2]> for Mat2

fn from(slice: [[f32; 2]; 2]) -> Mat2

Converts to this type from the input type.

impl From<[Vec2<f32>; 2]> for Mat2

fn from(slice: [Vec2<f32>; 2]) -> Mat2

Converts to this type from the input type.

impl From<[f32; 4]> for Mat2

fn from(slice: [f32; 4]) -> Mat2

Converts to this type from the input type.

impl From<((f32, f32), (f32, f32))> for Mat2

fn from(tuple: ((f32, f32), (f32, f32))) -> Mat2

Converts to this type from the input type.

impl From<(Vec2<f32>, Vec2<f32>, Vec2<f32>)> for Mat2

fn from(tuple: (Vec2<f32>, Vec2<f32>, Vec2<f32>)) -> Mat2

Converts to this type from the input type.

impl From<(f32, f32, f32, f32)> for Mat2

fn from(tuple: (f32, f32, f32, f32)) -> Mat2

Converts to this type from the input type.

impl From<f32> for Mat2

fn from(value: f32) -> Mat2

Converts to this type from the input type.

impl Index<(usize, usize)> for Mat2

type Output = f32

The returned type after indexing.

fn index(&self, index: (usize, usize)) -> &f32

Performs the indexing (container[index]) operation.

impl Index<usize> for Mat2

type Output = Vec2<f32>

The returned type after indexing.

fn index(&self, index: usize) -> &Vec2<f32>

Performs the indexing (container[index]) operation.

impl IndexMut<(usize, usize)> for Mat2

fn index_mut(&mut self, index: (usize, usize)) -> &mut f32

Performs the mutable indexing (container[index]) operation.

impl IndexMut<usize> for Mat2

fn index_mut(&mut self, index: usize) -> &mut Vec2<f32>

Performs the mutable indexing (container[index]) operation.

impl Mul<Vec2<f32>> for Mat2

type Output = Vec2<f32>

The resulting type after applying the * operator.

fn mul(self, vec: Vec2<f32>) -> Vec2<f32>

Performs the * operation.

impl Mul for Mat2

type Output = Mat2

The resulting type after applying the * operator.

fn mul(self, right: Mat2) -> Mat2

Performs the * operation.

impl MulAssign for Mat2

fn mul_assign(&mut self, right: Mat2)

Performs the *= operation.

impl PartialEq for Mat2

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

type Output = Mat2

The resulting type after applying the - operator.

fn sub(self, right: Mat2) -> Mat2

Performs the - operation.

impl SubAssign for Mat2

fn sub_assign(&mut self, right: Mat2)

Performs the -= operation.

impl Copy for Mat2

impl StructuralPartialEq for Mat2