Struct Atom 

pub struct Atom {
    pub color: Rgba,
    pub emission: Rgb,
    pub collision: BlockCollision,
}

Data of Primitive::Atom. The definition of a single block that has uniform material properties rather than spatially varying ones; a single voxel.

All properties of an atom are intensive properties.

Fields

color: Rgba

The color exhibited by diffuse reflection from this block.

The RGB components of this color are the reflectance: the fraction of incoming light that is reflected rather than absorbed.

The alpha (α) component of this color specifies the opacity of this block, that is, the fraction of light that is reflected or absorbed rather than transmitted.

Whenever α is neither 1 nor 0 (and, trivially, in those cases too), the reflectance and opacity should be interpreted as being of a unit thickness of this material. Thus, they may be modified by the length of material through which a light ray passes, either due to viewing angle or due to using this block as a voxel in a Primitive::Recur.

This transformation is best understood in terms of transmittance T, defined as 1 − α. The transmittance of a given thickness of material, T_d, is defined in terms of the transmittance of a unit thickness, T₁, as:

T_d = (T₁)^d.

Therefore,

α_d = 1 − (1 − α₁)^d.

emission: Rgb

Light emitted (not reflected) by the block.

This quantity is the emitted portion of the luminance of this material, in unspecified units where 1.0 is the display white level (except for the effects of tone mapping). In the future this may be redefined in terms of a physical unit, but with the same dimensions.

Because we are describing a volume, not a surface, the physical interpretation of this value depends on the opacity of the material. If self.color.alpha() is 1.0, then this light escaping a surface must have been emitted at the surface; if the alpha is 0.0, then it must have been emitted throughout the volume; and in intermediate cases, then the light emitted within the volume must be greater per unit volume to compensate for internal absorption. Still, these are not distinct cases but form a continuum.

The emission E_d of a particular thickness d of this material is

E_d = E₁ · ∫₀^d (T₁)^x dx

where E₁ = self.emission and T₁ = 1.0 - self.color.alpha(). When integrated, this becomes

E_d = E₁ · d

when α = 0 (T = 1) and

E_d = E₁ · (T_d - 1) / (T₁ - 1)

otherwise.

collision: BlockCollision

The effect on a Body of colliding with this block.

The default value is BlockCollision::Hard.

Trait Implementations

impl<'arbitrary> Arbitrary<'arbitrary> for Atom

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 Atom

fn clone(&self) -> Atom

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Atom

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

Formats the value using the given formatter.

impl From<Atom> for Block

fn from(value: Atom) -> Self

Converts to this type from the input type.

impl From<Atom> for Primitive

fn from(value: Atom) -> Self

Converts to this type from the input type.

impl From<Rgb01> for Atom

fn from(color: Rgb01) -> Self

Construct an Atom with the given reflectance color, and default attributes.

impl From<Rgba> for Atom

fn from(color: Rgba) -> Self

Construct an Atom with the given reflectance color, and default attributes.

impl Hash for Atom

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 Atom

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

fn visit_handles(&self, _: &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 Atom

impl StructuralPartialEq for Atom