Struct Cube 

#[repr(C)]
pub struct Cube {
    pub x: i32,
    pub y: i32,
    pub z: i32,
}

“A cube”, in this documentation, is a unit cube whose corners’ coordinates are integers. This type identifies such a cube by the coordinates of its most negative corner.

The valid coordinate range is that of GridCoordinate. Note, however, that in most applications, cubes with lower corner coordinates equal to GridCoordinate::MAX will not be valid, because their other corners are out of range. The Cube type does not enforce this, because it would be unergonomic to require fallible conversions there. Instead, the conversion from Cube to its bounding GridAab may panic. Generally, this should be avoided by checking the cube with GridAab::contains_cube() on some existing GridAab.

Considered in continuous space (real, or floating-point, coordinates), the ranges of coordinates a cube contains are half-open intervals: lower inclusive and upper exclusive.

Representation

This struct is guaranteed to be three i32 without padding, and so may be reinterpreted as any type of identical layout such as [i32; 3].

Why have a dedicated type for this?

• Primarily, to avoid confusion between points (zero size) and cubes (nonzero size) that causes off-by-one errors when rotating objects.
• To provide convenient methods for operations on cubes that aren’t natural operations on points.
• To reduce our dependence on external math libraries as part of our API.

Fields

x: i32

y: i32

z: i32

Implementations

impl Cube

pub const ORIGIN: Self

Equal to Cube::new(0, 0, 0).

Note that this is not a box centered on the coordinate origin.

pub const fn new( x: GridCoordinate, y: GridCoordinate, z: GridCoordinate, ) -> Self

Construct Cube { x, y, z } from the given coordinates.

pub fn containing(point: FreePoint) -> Option<Self>

Convert a point in space to the unit cube that encloses it.

Such cubes are defined to be half-open intervals on each axis; that is, an integer coordinate is counted as part of the cube extending positively from that coordinate.

If the point coordinates are outside of the numeric range of GridCoordinate, returns None.

use all_is_cubes::math::{FreePoint, Cube};

assert_eq!(Cube::containing(FreePoint::new(1.0, 1.5, -2.5)), Some(Cube::new(1, 1, -3)));

pub fn lower_bounds(self) -> GridPoint

Returns the corner of this cube with the most negative coordinates.

pub fn upper_bounds(self) -> GridPoint

Returns the corner of this cube with the most positive coordinates.

Panics if self has any coordinates equal to GridCoordinate::MAX. Generally, that should be avoided by checking the cube with GridAab::contains_cube() on some existing GridAab before calling this method.

pub fn midpoint(self) -> FreePoint

Returns the midpoint of this cube.

pub fn grid_aab(self) -> GridAab

Constructs a GridAab with a volume of 1, containing this cube.

Panics if self has any coordinates equal to GridCoordinate::MAX. Generally, that should be avoided by checking the cube with GridAab::contains_cube() on some existing GridAab before calling this method.

pub fn aab(self) -> Aab

Returns the bounding box in floating-point coordinates containing this cube.

use all_is_cubes::math::{Aab, Cube};

assert_eq!(
    Cube::new(10, 20, -30).aab(),
    Aab::new(10.0, 11.0, 20.0, 21.0, -30.0, -29.0)
);

pub fn checked_add(self, v: GridVector) -> Option<Self>

Componentwise GridCoordinate::checked_add().

pub fn map(self, f: impl FnMut(GridCoordinate) -> GridCoordinate) -> Self

Apply a function to each coordinate independently.

If a different return type is desired, use .lower_bounds().map(f) instead.

Trait Implementations

impl Add<Face6> for Cube

type Output = Cube

The resulting type after applying the + operator.

fn add(self, rhs: Face6) -> Self::Output

Performs the + operation.

impl Add<Vector3D<i32, Cube>> for Cube

type Output = Cube

The resulting type after applying the + operator.

fn add(self, rhs: GridVector) -> Self::Output

Performs the + operation.

impl AddAssign<Face6> for Cube

fn add_assign(&mut self, rhs: Face6)

Performs the += operation.

impl AddAssign<Vector3D<i32, Cube>> for Cube

fn add_assign(&mut self, rhs: GridVector)

Performs the += operation.

impl AsMut<[i32; 3]> for Cube

fn as_mut(&mut self) -> &mut [GridCoordinate; 3]

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<[i32; 3]> for Cube

fn as_ref(&self) -> &[GridCoordinate; 3]

Converts this type into a shared reference of the (usually inferred) input type.

impl Borrow<[i32; 3]> for Cube

fn borrow(&self) -> &[GridCoordinate; 3]

Immutably borrows from an owned value.

impl BorrowMut<[i32; 3]> for Cube

fn borrow_mut(&mut self) -> &mut [GridCoordinate; 3]

Mutably borrows from an owned value.

impl Clone for Cube

fn clone(&self) -> Cube

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cube

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

Formats the value using the given formatter.

impl Fmt<ConciseDebug> for Cube

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

Formats self as specified by fopt into destination fmt.

impl From<[i32; 3]> for Cube

fn from([x, y, z]: [GridCoordinate; 3]) -> Self

Converts to this type from the input type.

impl From<Cube> for [GridCoordinate; 3]

fn from(_: Cube) -> [GridCoordinate; 3]

Converts to this type from the input type.

impl From<Cube> for GridPoint

fn from(_: Cube) -> GridPoint

Converts to this type from the input type.

impl From<Point3D<i32, Cube>> for Cube

fn from(_: GridPoint) -> Self

Converts to this type from the input type.

impl Hash for Cube

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 Index<Axis> for Cube

type Output = i32

The returned type after indexing.

fn index(&self, index: Axis) -> &Self::Output

Performs the indexing (container[index]) operation.

impl IndexMut<Axis> for Cube

fn index_mut(&mut self, index: Axis) -> &mut Self::Output

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

impl PartialEq for Cube

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

type Output = Cube

The resulting type after applying the - operator.

fn sub(self, rhs: GridVector) -> Self::Output

Performs the - operation.

impl Sub for Cube

type Output = Vector3D<i32, Cube>

The resulting type after applying the - operator.

fn sub(self, rhs: Cube) -> Self::Output

Performs the - operation.

impl SubAssign<Vector3D<i32, Cube>> for Cube

fn sub_assign(&mut self, rhs: GridVector)

Performs the -= operation.

impl Zeroable for Cube

fn zeroed() -> Self

Calls zeroed.

impl Copy for Cube

impl Eq for Cube

impl Pod for Cube

impl StructuralPartialEq for Cube