Struct GridMatrix 

pub struct GridMatrix {
    pub x: Vector3D<i32, Cube>,
    pub y: Vector3D<i32, Cube>,
    pub z: Vector3D<i32, Cube>,
    pub w: Vector3D<i32, Cube>,
}

A 4×3 affine transformation matrix in GridCoordinates.

Fields

x: Vector3D<i32, Cube>

First column

y: Vector3D<i32, Cube>

Second column

z: Vector3D<i32, Cube>

Third column

w: Vector3D<i32, Cube>

Fourth column (translation)

Implementations

impl GridMatrix

pub const ZERO: GridMatrix

The zero matrix, which transforms all points to zero.

pub const fn new( x0: i32, x1: i32, x2: i32, y0: i32, y1: i32, y2: i32, z0: i32, z1: i32, z2: i32, w0: i32, w1: i32, w2: i32, ) -> GridMatrix

Note: This takes the elements in a column-major ordering, so the argument order is transposed relative to a conventional textual display of a matrix.

pub fn from_translation(offset: impl Into<Vector3D<i32, Cube>>) -> GridMatrix

Construct a translation matrix.

pub fn from_scale(scale: i32) -> GridMatrix

Construct a uniform scaling matrix.

Note that since this is an integer matrix, there is no possibility of scaling less than 1 other than 0!

pub fn from_origin( origin: impl Into<Point3D<i32, Cube>>, x: Face7, y: Face7, z: Face7, ) -> GridMatrix

Construct a transformation to a translated and rotated coordinate system from an origin in the target coordinate system and basis vectors expressed as Face7s.

Skews or scaling cannot be performed using this constructor.

use all_is_cubes::math::{Face7::*, GridMatrix, GridPoint};

let transform = GridMatrix::from_origin([10, 10, 10], PX, PZ, NY);
assert_eq!(
    transform.transform_point(GridPoint::new(1, 2, 3)),
    GridPoint::new(11, 7, 12),
);

pub fn to_free(self) -> Transform3D<f64, Cube, Cube>

Convert this integer-valued matrix to an equivalent float-valued matrix.

pub fn transform_cube(&self, cube: Cube) -> Cube

Equivalent to temporarily applying an offset of [0.5, 0.5, 0.5] while transforming cube as per GridMatrix::transform_point, despite the fact that integer arithmetic is being used.

This operation thus transforms the standard positive-octant unit cube identified by its most negative corner the same way as the GridAab::single_cube containing that cube.

use all_is_cubes::math::{Cube, Face7::*, GridMatrix, GridPoint};

// Translation without rotation has the usual definition.
let matrix = GridMatrix::from_translation([10, 0, 0]);
assert_eq!(matrix.transform_cube(Cube::new(1, 1, 1)), Cube::new(11, 1, 1));

// With a rotation or reflection, the results are different.
// TODO: Come up with a better example and explanation.
let reflected = GridMatrix::from_origin([10, 0, 0], NX, PY, PZ);
assert_eq!(reflected.transform_point(GridPoint::new(1, 5, 5)), GridPoint::new(9, 5, 5));
assert_eq!(reflected.transform_cube(Cube::new(1, 5, 5)), Cube::new(8, 5, 5));

pub fn decompose(self) -> Option<Gridgid>

Decomposes a matrix into its rotation and translation components, stored in a Gridgid. Returns None if the matrix has any scaling or skew.

use all_is_cubes::math::{Face6::*, Gridgid, GridMatrix, GridRotation, GridVector};

assert_eq!(
    GridMatrix::new(
        0, -1,  0,
        1,  0,  0,
        0,  0,  1,
        7,  3, -8,
    ).decompose(),
    Some(Gridgid {
        rotation: GridRotation::from_basis([NY, PX, PZ]),
        translation: GridVector::new(7, 3, -8),
    }),
);

pub fn transform_vector(&self, vec: Vector3D<i32, Cube>) -> Vector3D<i32, Cube>

Transform (rotate and scale) the given vector. The translation part of this matrix is ignored.

pub fn transform_point(&self, point: Point3D<i32, Cube>) -> Point3D<i32, Cube>

Transform the given point by this matrix.

pub fn concat(&self, other: &GridMatrix) -> GridMatrix

use all_is_cubes::math::{GridMatrix, GridPoint};

let transform_1 = GridMatrix::new(
    0, -1, 0,
    1, 0, 0,
    0, 0, 1,
    0, 0, 0,
);
let transform_2 = GridMatrix::from_translation([10, 20, 30]);

// Demonstrate the directionality of concatenation.
assert_eq!(
    transform_1.concat(&transform_2).transform_point(GridPoint::new(0, 3, 0)),
    transform_1.transform_point(transform_2.transform_point(GridPoint::new(0, 3, 0))),
);

pub fn inverse_transform(&self) -> Option<GridMatrix>

Invert this matrix. Returns None if it is not invertible.

Trait Implementations

impl Clone for GridMatrix

fn clone(&self) -> GridMatrix

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GridMatrix

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

Formats the value using the given formatter.

impl From<Gridgid> for GridMatrix

fn from(value: Gridgid) -> GridMatrix

Converts to this type from the input type.

impl Hash for GridMatrix

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

where __H: Hasher,

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 Mul for GridMatrix

type Output = GridMatrix

The resulting type after applying the * operator.

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

Performs the * operation.

impl One for GridMatrix

fn one() -> GridMatrix

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl PartialEq for GridMatrix

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

impl Eq for GridMatrix

impl StructuralPartialEq for GridMatrix