Struct PatternBits 

pub struct PatternBits(pub [i8; 9]);

PatternBits represents a tile’s pattern as a 3x3 grid of i8 values for doing autotiling in 2D with Vector2<i32> positions. The center of the 3x3 grid is called the pattern’s terrain. The 8 values around the outside of the grid are called the pattern’s peering bits.

The peering bits of this pattern determine whether it is permitted to use this pattern adjacent to other patterns. A pattern is only legal if all three peering bits along each edge match the bits on the nearest edge of the adjacent pattern.

In the case of diagonal connections, only only bit must match in each pattern: the corner bit that is nearest to the other pattern.

For the details of how peering bits constrain where this pattern may be used, see the implementation of TilePattern.

Tuple Fields

0: [i8; 9]

Implementations

impl PatternBits

pub fn center(&self) -> i8

The pattern’s terrain ID that can be used to categorize this pattern, and to determine which peering bits are the most important for pattern sorting. Patterns that have more peering bits that match its terrain are given higher priority when sorting and appear earlier in the list.

pub fn center_terrain_count(&self) -> usize

The number of bits in the pattern that match the terrain ID. This count is at most 9 and at least 1 because the center bit always matches itself.

pub fn unique_terrain_count(&self) -> usize

The number of distinct distinct values in this pattern. This count is at most 9 and at least 1, for the case where every bit is the same.

Trait Implementations

impl Clone for PatternBits

fn clone(&self) -> PatternBits

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PatternBits

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

Formats the value using the given formatter.

impl Default for PatternBits

fn default() -> PatternBits

Returns the “default value” for a type.

impl From<NineI8> for PatternBits

fn from(value: NineI8) -> Self

Converts to this type from the input type.

impl Hash for PatternBits

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 Index<Matrix<usize, Const<2>, Const<1>, ArrayStorage<usize, 2, 1>>> for PatternBits

type Output = i8

The returned type after indexing.

fn index( &self, index: Matrix<usize, Const<2>, Const<1>, ArrayStorage<usize, 2, 1>>, ) -> &<PatternBits as Index<Matrix<usize, Const<2>, Const<1>, ArrayStorage<usize, 2, 1>>>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<Matrix<usize, Const<2>, Const<1>, ArrayStorage<usize, 2, 1>>> for PatternBits

fn index_mut( &mut self, index: Matrix<usize, Const<2>, Const<1>, ArrayStorage<usize, 2, 1>>, ) -> &mut <PatternBits as Index<Matrix<usize, Const<2>, Const<1>, ArrayStorage<usize, 2, 1>>>>::Output

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

impl Ord for PatternBits

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for PatternBits

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

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl TilePattern for PatternBits

type Offset = Vector2Offset

A pattern is capable of being adjacent to other patterns in several directions. The pattern’s offset type is the type of the offset between a pattern’s position and the position of an adjacent pattern.

type Diagonal = Vector2Diagonal

A pattern may connect to another pattern by touching their corners. This creates a diagonal connection where the patterns are touching but not adjacent, and in some contexts there may be rules regarding which patterns may be diagonally connected to which other patterns.

fn is_legal(&self, offset: &Vector2Offset, to: &PatternBits) -> bool

True if this pattern may be adjacent the given other pattern of this type when that other pattern is positioned at offset relative to this pattern.

fn is_legal_diagonal( &self, diagonal: &Vector2Diagonal, to: &PatternBits, ) -> bool

True if this pattern may be diagonal to the given other pattern when that other pattern is positioned at offset relative to this pattern.

impl Copy for PatternBits

impl Eq for PatternBits

impl StructuralPartialEq for PatternBits