Struct GridMatrix

Source

pub struct GridMatrix {
    pub x: GridVector,
    pub y: GridVector,
    pub z: GridVector,
    pub w: GridVector,
}

Expand description

A 4×3 affine transformation matrix in GridCoordinates.

Fields§

§x: GridVector

First column

§y: GridVector

Second column

§z: GridVector

Third column

§w: GridVector

Fourth column (translation)

Implementations§

Source §

impl GridMatrix

Source

pub const ZERO: Self

The zero matrix, which transforms all points to zero.

Source

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

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.

Source

pub fn from_translation(offset: impl Into<GridVector>) -> Self

Construct a translation matrix.

Source

pub fn from_scale(scale: GridCoordinate) -> Self

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!

Source

pub fn from_origin( origin: impl Into<GridPoint>, x: Face7, y: Face7, z: Face7, ) -> Self

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),
);

Source

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

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

Source

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));

Source

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),
    }),
);

Source

pub fn transform_vector(&self, vec: GridVector) -> GridVector

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

Source

pub fn transform_point(&self, point: GridPoint) -> GridPoint

Transform the given point by this matrix.

Source

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

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))),
);