Enum soft_edge::Axis

#[repr(u8)]
pub enum Axis {
    PosX,
    PosY,
    PosZ,
    NegX,
    NegY,
    NegZ,
}

Represents a single signed axis: +X, +Y, +Z, -X, -Y, or -Z.

These are used to enumerate the faces of the unit cube when deriving the exterior hull of an atom, and are also encoded into the bit representation used by Face.

Note that on the unit cube, you won’t actually find any negative coordinates; the negative axes are used to represent the faces in the direction of the negatives, and so are also sometimes called “zero axes” because they represent the face where the corresponding coordinate is zero.

Variants

PosX

PosY

PosZ

NegX

NegY

NegZ

Implementations

impl Axis

pub fn from_adjacent_coords(p0: &Point3<i32>, p1: &Point3<i32>) -> Option<Self>

Construct an axis from adjacent integer coordinates, if they are exactly adjacent.

This is useful for when you’re dealing with adjacent atoms and need to find the axis between them so you can join their faces along that axis, for example.

The axis returned corresponds to the vector from p0 towards p1. Returns None if the points are non-adjacent.

pub fn to_offset(self) -> Vector3<i32>

Convert this axis to its representative integer unit vector.

pub unsafe fn from_u8_unchecked(byte: u8) -> Self

Safety

This byte must be a valid Axis (one of the six byte values defined in the enum.)

pub fn to_face_set(self) -> VertexSet

What vertices on our atom are members of the face on this axis?

pub fn is_parallel(self, other: Axis) -> bool

Are these two axes parallel? (+X/-X, +Y/-Y, +Z/-Z, pairs of same-sign axes are also acceptible +X/+X, -Y/-Y, etc.)

pub fn opposite(self) -> Axis

Get the same axis in the opposite direction. (+X => -X, -Z => +Z)

pub fn is_negative(self) -> bool

Does this axis represent a negative/zero axis?

Returns true if self is NegX, NegY, or NegZ.

pub fn is_positive(self) -> bool

Does this axis represent a positive/nonzero axis?

Returns true if self is PosX, PosY, or PosZ.

pub fn to_face_center(self) -> Exact

Get the centroid of the face on this axis.

pub fn to_index(self) -> usize

Convenient helper for conversion to usize.

pub fn generator() -> impl Iterator<Item = Self>

Create an iterator over all six axes.

pub fn requires_winding_flip(self) -> bool

True if the face set for this axis requires a winding flip.

This is likely not useful to you as a user, and is used internally inside the exterior hull generation algorithm. But it is still useful to document for external understanding:

Winding order of exterior faces and face sets

As a refresher, this is our vertex numbering scheme:

  v3      v7
    *----*
v2 /| v6/|
  *----* |   +Y
  | *--|-*   ^ ^ +Z
  |/v1 |/v5  |/
  *----*     +--> +X
 v0    v4

We want all face windings to be in CCW order. Due to the fact that this order produces a Z-pattern on each face set - e.g. 0, 1, 2, 3, 0, 2, 4, 6, 1, 3, 5, 7, when sorted - the exterior facet generation code will flip the first two vertices: 1, 0, 2, 3, 2, 0, 4, 6, etc., producing what should ideally be a CCW-wound quad.

Unfortunately this is not always the case. Note that the NegY axis’s face set, when sorted, produces 0, 1, 4, 5 for its Z-pattern, and 1, 0, 4, 5 for its wound-pattern. Which, when viewed from below, is a clockwise winding, not counter-clockwise. As such, unless a better descriptor of why stuff must be flipped, we’ll need to just straight up flip NegY to compensate.

Axes that need to be flipped:

• NegX
• PosY
• NegZ

Axes that do not need to be flipped:

• PosX
• NegY
• PosZ

It seems like the reason that we need things to be flipped differently on the Y axis is that this ordering is naturally right-handed, and our “world” coordinate system is left-handed. This is just my hypothesis though, and frankly, as is, this flipping is strictly done because it makes things work.

Trait Implementations

impl Clone for Axis

fn clone(&self) -> Axis

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Axis

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

Formats the value using the given formatter.

impl Hash for Axis

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, 

Feeds a slice of this type into the given Hasher.

impl Ord for Axis

fn cmp(&self, other: &Axis) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Axis> for Axis

fn eq(&self, other: &Axis) -> 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 !=.

impl PartialOrd<Axis> for Axis

fn partial_cmp(&self, other: &Axis) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Axis

impl Eq for Axis

impl StructuralEq for Axis

impl StructuralPartialEq for Axis