Enum all_is_cubes::block::Block

#[non_exhaustive]
pub enum Block {
    Indirect(URef<BlockDef>),
    Atom(BlockAttributes, Rgba),
    Recur {
        attributes: BlockAttributes,
        offset: GridPoint,
        resolution: u8,
        space: URef<Space>,
    },
    Rotated(GridRotation, Box<Block>),
}

A Block is something that can exist in the grid of a Space; it occupies one unit cube of space and has a specified appearance and behavior.

In general, when a block appears multiple times from an in-game perspective, that may or may not be the the same copy; Blocks are “by value”. However, some blocks are defined by reference to shared mutable data, in which case changes to that data should take effect everywhere a Block having that same reference occurs.

To obtain the concrete appearance and behavior of a block, use Block::evaluate to obtain an EvaluatedBlock value, preferably with caching.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Indirect(URef<BlockDef>)

A block whose definition is stored in a Universe.

Tuple Fields of Indirect

0: URef<BlockDef>

Atom(BlockAttributes, Rgba)

A block that is a single-colored unit cube. (It may still be be transparent or non-solid to physics.)

Tuple Fields of Atom

0: BlockAttributes1: Rgba

Recur

A block that is composed of smaller blocks, defined by the referenced Space.

Fields of Recur

attributes: BlockAttributesoffset: GridPoint

Which portion of the space will be used, specified by the most negative corner.

resolution: u8

The side length of the cubical volume of sub-blocks (voxels) used for this block.

space: URef<Space>

Rotated(GridRotation, Box<Block>)

Identical to another block, but with rotated coordinates.

Specifically, the given rotation specifies how the contained block’s coordinate system is rotated into this block’s.

Tuple Fields of Rotated

0: GridRotation1: Box<Block>

Implementations

impl Block

pub const fn builder() -> BlockBuilder<NeedsColorOrVoxels>

Returns a new BlockBuilder which may be used to construct a Block value from various inputs with convenient syntax.

pub fn rotate(self, rotation: GridRotation) -> Self

Rotates this block by the specified rotation.

Compared to direct use of the Block::Rotated variant, this will:

• Avoid constructing chains of Block::Rotated(Block::Rotated(...)).
• Not rotate blocks that should never appear rotated (including atom blocks).

use all_is_cubes::block::{AIR, Block};
use all_is_cubes::content::make_some_voxel_blocks;
use all_is_cubes::math::{Face::*, GridRotation};
use all_is_cubes::universe::Universe;

let mut universe = Universe::new();
let [block] = make_some_voxel_blocks(&mut universe);
let clockwise = GridRotation::CLOCKWISE;

// Basic rotation
let rotated = block.clone().rotate(clockwise);
assert_eq!(rotated, Block::Rotated(clockwise, Box::new(block.clone())));

// Multiple rotations are combined
let double = rotated.clone().rotate(clockwise);
assert_eq!(double, Block::Rotated(clockwise * clockwise, Box::new(block.clone())));
// AIR is never rotated
assert_eq!(AIR, AIR.rotate(clockwise));

pub fn unspecialize(self) -> Self

Standardizes any characteristics of this block which may be presumed to be specific to its usage in its current location, so that it can be used elsewhere or compared with others. Currently, this means removing rotation, but in the there may be additional or customizable changes (hence the abstract name).

use all_is_cubes::block::Block;
use all_is_cubes::content::make_some_voxel_blocks;
use all_is_cubes::math::{Face::*, GridRotation};
use all_is_cubes::universe::Universe;

let mut universe = Universe::new();
let [block] = make_some_voxel_blocks(&mut universe);
let clockwise = GridRotation::from_basis([PZ, PY, NX]);
let rotated = block.clone().rotate(clockwise);
assert_ne!(&block, &rotated);
assert_eq!(block, rotated.clone().unspecialize());
assert_eq!(block, rotated.clone().unspecialize().unspecialize());

pub fn evaluate(&self) -> Result<EvaluatedBlock, EvalBlockError>

Converts this Block into a “flattened” and snapshotted form which contains all information needed for rendering and physics, and does not require URef access to other objects.

pub fn listen(
    &self,
    listener: impl Listener<BlockChange> + Send + Sync + 'static
) -> Result<(), EvalBlockError>

Registers a listener for mutations of any data sources which may affect this block’s Block::evaluate result.

Note that this does not listen for mutations of the Block value itself — which would be impossible since it is an enum and all its fields are public. In contrast, BlockDef does perform such tracking.

This may fail under the same conditions as Block::evaluate; it returns the same error type so that callers which both evaluate and listen don’t need to handle this separately.

Trait Implementations

impl AsRef<Block> for BlockDef

fn as_ref(&self) -> &Block

Performs the conversion.

impl Clone for Block

fn clone(&self) -> Block

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Block

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

Formats the value using the given formatter.

impl<'a> From<&'a Block> for Cow<'a, Block>

fn from(block: &'a Block) -> Self

Performs the conversion.

impl From<Block> for Cow<'_, Block>

fn from(block: Block) -> Self

Performs the conversion.

impl<C: BuilderContentIndependent> From<BlockBuilder<C>> for Block

Allows implicitly converting BlockBuilder to the block it would build.

fn from(builder: BlockBuilder<C>) -> Self

Performs the conversion.

impl From<Rgb> for Block

Convert a color to a block with default attributes.

fn from(color: Rgb) -> Self

Performs the conversion.

impl From<Rgba> for Block

Convert a color to a block with default attributes.

fn from(color: Rgba) -> Self

Performs the conversion.

impl Hash for Block

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 PartialEq<Block> for Block

fn eq(&self, other: &Block) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Block) -> bool

This method tests for !=.

impl<'a> PixelColor for &'a Block

type Raw = ()

Raw data type.

impl<'a> VoxelColor<'a> for &'a Block

fn into_blocks(self) -> VoxelBrush<'a>

Returns a corresponding VoxelBrush, the most general form of blocky drawing.

fn depth_range(self) -> RangeInclusive<GridCoordinate>

Returns the range of Z coordinates that the blocks painted by this color value occupy.

impl Eq for Block

impl StructuralEq for Block

impl StructuralPartialEq for Block