Enum Face7 

#[repr(u8)]
pub enum Face7 {
    Within = 0,
    NX = 1,
    NY = 2,
    NZ = 3,
    PX = 4,
    PY = 5,
    PZ = 6,
}

Identifies a face of a cube or an orthogonal unit vector, except for Within meaning “zero distance and undefined direction”.

This is essentially Option<Face6>, except with Face-specific methods provided. The two enums use the same discriminant numbering.

Serialization stability warning

This type implements [serde::Serialize] and [serde::Deserialize], but serialization support is still experimental (as is the game data model in general). We do not guarantee that future versions of all-is-cubes will be able to deserialize data which is serialized by this version.

Additionally, the serialization schema is designed with serde_json in mind. It is not guaranteed that using a different data format crate, which may use a different subset of the information exposed via [serde::Serialize], will produce stable results.

Variants

Within = 0

The interior volume of a cube, or an undefined direction. Corresponds to the vector (0, 0, 0).

NX = 1

Negative X; the face whose normal vector is (-1, 0, 0).

NY = 2

Negative Y; the face whose normal vector is (0, -1, 0); downward.

NZ = 3

Negative Z; the face whose normal vector is (0, 0, -1).

PX = 4

Positive X; the face whose normal vector is (1, 0, 0).

PY = 5

Positive Y; the face whose normal vector is (0, 1, 0); upward.

PZ = 6

Positive Z; the face whose normal vector is (0, 0, 1).

Implementations

impl Face7

pub const ALL: [Face7; 7]

All the values of Face7, with Face7::Within listed first.

pub const fn from_discriminant(d: u8) -> Option<Self>

Inverse function of face as u8, converting the number to Face7.

pub const fn axis(self) -> Option<Axis>

Returns which axis this face’s normal vector is parallel to, or None if the face is Face7::Within.

pub fn is_positive(self) -> bool

Returns whether this face is a “positive” face: one whose unit vector’s nonzero coordinate is positive.

use all_is_cubes::math::Face7;

assert_eq!(Face7::PX.is_positive(), true);
assert_eq!(Face7::NX.is_positive(), false);
assert_eq!(Face7::Within.is_positive(), false);

pub fn is_negative(self) -> bool

Returns whether this face is a negative face: one whose unit vector’s nonzero coordinate is negative.

use all_is_cubes::math::Face7;

assert_eq!(Face7::PX.is_negative(), false);
assert_eq!(Face7::NX.is_negative(), true);
assert_eq!(Face7::Within.is_negative(), false);

pub const fn opposite(self) -> Face7

Returns the opposite face (maps PX to NX and so on).

pub const fn cross(self, other: Self) -> Self

Returns the face whose normal is the cross product of these faces’ normals.

pub fn normal_vector<S, U>(self) -> Vector3D<S, U>

where S: Zero + One + Neg<Output = S>,

Returns the vector normal to this face. Within is assigned the zero vector.

If a vector of a different length is desired, use Face6::vector() instead of multiplying this.

pub fn vector<S, U>(self, magnitude: S) -> Vector3D<S, U>

where S: Zero + Neg<Output = S>,

Returns an axis-aligned vector normal to this face, whose magnitude, and only nonzero component, is magnitude unless self == Face7::Within.

This is mathematically equivalent to multiplying Face7::normal_vector() by magnitude, but does not perform those multiplications, and may have better type inference.

Example

use all_is_cubes::math::{Face7, GridVector};

assert_eq!(Face7::PY.vector(3), GridVector::new(0, 3, 0));
assert_eq!(Face7::Within.vector(3), GridVector::new(0, 0, 0));

pub fn dot<S, U>(self, vector: Vector3D<S, U>) -> S

where S: Zero + Neg<Output = S>,

Dot product of this face as a unit vector and the given vector, implemented by selecting the relevant component.

use all_is_cubes::math::{Face7, FreeVector};

let sample_vector = FreeVector::new(1.0, 2.0, 5.0_f64);
for face in Face7::ALL {
    assert_eq!(face.dot(sample_vector), face.normal_vector().dot(sample_vector));
}

Trait Implementations

impl Clone for Face7

fn clone(&self) -> Face7

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Face7

impl Debug for Face7

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

Formats the value using the given formatter.

impl Eq for Face7

impl Exhaust for Face7

type Iter = ExhaustFace7Iter

Iterator type returned by Self::exhaust_factories(). See the trait documentation for what properties this iterator should have.

type Factory = ExhaustFace7Factory

Data which can be used to construct Self.

fn exhaust_factories() -> Self::Iter

Returns an iterator over factories for all values of this type.

fn from_factory(factory: Self::Factory) -> Self

Construct a concrete value of this type from a Self::Factory value produced by its Self::Iter.

fn exhaust() -> Iter<Self>

Returns an iterator over all values of this type.

impl From<Face6> for Face7

fn from(value: Face6) -> Self

Converts to this type from the input type.

impl Hash for Face7

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 Neg for Face7

type Output = Face7

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl PartialEq for Face7

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

impl TryFrom<Face7> for Face6

type Error = Faceless

The type returned in the event of a conversion error.

fn try_from(value: Face7) -> Result<Face6, Self::Error>

Performs the conversion.

impl TryFrom<Vector3D<i32, Cube>> for Face7

type Error = Vector3D<i32, Cube>

Returns the original vector on failure. (An error message would probably be too lacking context to be helpful.)

fn try_from(value: GridVector) -> Result<Self, Self::Error>

Recovers a Face7 from its corresponding unit normal vector. All other vectors are rejected.

use all_is_cubes::math::{Face7, GridVector};

// A Face7 may be converted from its normal vector.
for face in Face7::ALL {
    assert_eq!(Face7::try_from(face.normal_vector()), Ok(face));
}

// If the vector does not correspond to any Face7, it is returned.
let v = GridVector::new(1, 2, 3);
assert_eq!(Face7::try_from(v), Err(v));