Enum CompositeOperator 

#[non_exhaustive]
pub enum CompositeOperator {
    Over,
    In,
    Out,
    Atop,
}

Compositing operators, mostly as per Porter-Duff.

The “source” block is the Composite’s stored block, and the “destination” block is the block the modifier is attached to.

TODO: Document behavior of collision and selectable properties.

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.

Over

Porter-Duff “over”. If both source and destination are opaque, the source is taken; otherwise the destination is taken.

In

Porter-Duff “in”. If both source and destination are opaque, the source is taken; otherwise the result is transparent. Thus the destination acts as a mask constraining where the source is present; the source is “in” the destination. The destination’s color is not used.

Out

Porter-Duff “out”. If both source and destination are opaque, the result is transparent; otherwise the source is taken. Thus the destination acts as a mask removing portions of the source. The destination’s color is not used.

Atop

Porter-Duff “atop”. If both source and destination are opaque, the source is taken; otherwise the destination is taken. Thus the source is painted onto the destination’s substance.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for CompositeOperator

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

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

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of 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 try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

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

impl Clone for CompositeOperator

fn clone(&self) -> CompositeOperator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompositeOperator

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompositeOperator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CompositeOperator

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 CompositeOperator

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for CompositeOperator

impl Eq for CompositeOperator

impl StructuralPartialEq for CompositeOperator