Struct BoxStyle 

pub struct BoxStyle { /* private fields */ }

Set of blocks used to draw 3D boxes of any size, allowing corners and edges to have different blocks than faces and the interior.

Boxes have walls exactly 1 cube thick. Thus, a BoxStyle has 64 parts (blocks), identified by the BoxPart type:

• interior volume,
• 6 faces,
• 12 edges,
• 8 corners, and
• 38 more parts for the case where the box to be drawn is only one block thick, thus requiring a block to be both faces simultaneously on one or more axes.

Each part of the box can be absent (None), which means that when drawn, the existing block in that place is unchanged.

This can be considered a 3-dimensional analogue of the “9-patch image” concept, or as a voxel “tile set” (but one with no “inside corner” pieces).

BoxStyle’s data is kept behind a reference-counted pointer, so BoxStyle is small and cheap to clone.

Implementations

impl BoxStyle

pub fn from_fn<F>(f: F) -> BoxStyle

where F: FnMut(BoxPart) -> Option<Block>,

Construct a BoxStyle by asking a function for each part.

The order of calls to the function is unspecified and subject to change.

pub fn from_nine_and_thin(multiblock: &Block) -> BoxStyle

Construct a BoxStyle from a 2D 4×4×1 multiblock whose components on each axis are in the order [lower, middle, upper, lower & upper]; that is, this layout of blocks:

┊ ┏━━━━━━━━━━━━━┓┏━━━┓
3 ┃             ┃┃   ┃
┊ ┗━━━━━━━━━━━━━┛┗━━━┛
┃ ┏━━━━━━━━━━━━━┓┏━━━┓
2 ┃             ┃┃   ┃
┃ ┃             ┃┃   ┃
┊ ┃             ┃┃   ┃
1 ┃             ┃┃   ┃
┊ ┃             ┃┃   ┃
┃ ┃             ┃┃   ┃
0 ┃             ┃┃   ┃
┃ ┗━━━━━━━━━━━━━┛┗━━━┛
  ━━0━━┈┈1┈┈━━2━━┈┈3┈┈

The resolution is one quarter of the input. The Z axis is filled with all the same blocks. TODO: Make it sensitive to the input dimensions as defined by multiblock metadata instead.

pub fn from_composited_corner_and_edge( corner_block: Block, line_section_block: Block, ) -> BoxStyle

Construct a BoxStyle made up of one type of corner block and one type of edge block.

• corner_block will be composited with the line sections at all eight corners of the box. It should be oriented as the lower_bounds corner of the box; the other seven corners will be mirrored across the relevant axis.
• line_section_block should be a block which is a line segment at the origin and extending in the +Z direction. It should be symmetric about the X-Y=0 plane, and will be rotated and mirrored to make the other forms.

pub fn with(self, part: BoxPart, block: Option<Block>) -> BoxStyle

Replace a single part of this and return the modified style.

pub fn map(self, block_fn: impl FnMut(BoxPart, Block) -> Block) -> BoxStyle

Applies the given function to every block present in this. Does not affect absent blocks.

pub fn create_box(&self, bounds: GridAab) -> SpaceTransaction

Returns a transaction that places an axis-aligned box of blocks from this BoxStyle, within and up to the bounds of the given GridAab.

• The lines will lie just inside of bounds.

pub fn cube_at(&self, bounds: GridAab, cube: Cube) -> Option<&Block>

Returns the block that is the part of this box at the specified cube when the box bounds are bounds.

Trait Implementations

impl Clone for BoxStyle

fn clone(&self) -> BoxStyle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BoxStyle

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

Formats the value using the given formatter.

impl Index<BoxPart> for BoxStyle

type Output = Option<Block>

The returned type after indexing.

fn index(&self, index: BoxPart) -> &<BoxStyle as Index<BoxPart>>::Output

Performs the indexing (container[index]) operation.

impl IndexMut<BoxPart> for BoxStyle

fn index_mut( &mut self, index: BoxPart, ) -> &mut <BoxStyle as Index<BoxPart>>::Output

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