Enum all_is_cubes::block::Primitive

#[non_exhaustive]
pub enum Primitive {
    Indirect(Handle<BlockDef>),
    Atom(Atom),
    Recur {
        attributes: BlockAttributes,
        space: Handle<Space>,
        offset: GridPoint,
        resolution: Resolution,
    },
    Air,
    Text {
        text: Text,
        offset: GridVector,
    },
}

The possible fundamental representations of a Block’s shape.

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 (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(Handle<BlockDef>)

A block whose definition is stored elsewhere in a Universe.

Note that this is a handle to a Block, not a Primitive; the referenced BlockDef may have its own Modifiers, and thus the result of evaluating a primitive with no modifiers is not necessarily free of the effects of modifiers.

Atom(Atom)

A block of totally uniform properties.

Recur

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

Fields

attributes: BlockAttributes

space: Handle<Space>

The space from which voxels are taken.

offset: GridPoint

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

resolution: Resolution

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

Air

An invisible, unselectable, inert block used as “no block”; the primitive of AIR.

This is essentially a specific Primitive::Atom. There are a number of algorithms which treat this block specially or which return it (e.g. outside the bounds of a Space), so it exists here to make it an explicit element of the data model — so that if it is, say, serialized and loaded in a future version, it is still recognized as AIR. Additionally, it’s cheaper to compare this way.

Text

A piece of text rendered as voxels.

To combine the text with other shapes, use Modifier::Composite.

Fields

text: Text

The text to draw, and the font and text-layout-dependent positioning.

offset: GridVector

Translation, in whole cubes, of the region of the text to draw.

For text within a single block, this should be zero. For multi-block text, this should be equal to the difference between the adjacent blocks’ positions.

Implementations

impl Primitive

pub const fn from_color(color: Rgba) -> Primitive

Construct a Primitive from a reflectance color.

This function is equivalent to Block::from(color) but it can be used in const contexts.

Trait Implementations

impl<'a> Arbitrary<'a> for Primitive

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

impl Clone for Primitive

fn clone(&self) -> Primitive

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Primitive

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

Formats the value using the given formatter.

impl From<&'static Primitive> for Block

fn from(r: &'static Primitive) -> Self

Constructs a Block which references the given static Primitive.

This performs no allocation.

impl From<Atom> for Primitive

fn from(value: Atom) -> Self

Converts to this type from the input type.

impl From<Handle<BlockDef>> for Primitive

fn from(block_def_handle: Handle<BlockDef>) -> Self

Convert a Handle<BlockDef> into a Primitive::Indirect that refers to it.

impl From<Primitive> for Block

fn from(primitive: Primitive) -> Self

Constructs a Block that owns the given Primitive.

This operation creates a heap allocation for the Primitive.

impl Hash for Primitive

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

fn eq(&self, other: &Primitive) -> 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 !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl VisitHandles for Primitive

fn visit_handles(&self, visitor: &mut dyn HandleVisitor)

For each Handle contained within self that is reachable without traversing another Handle, call visitor with a reference to it.

impl Eq for Primitive

impl StructuralPartialEq for Primitive