Enum Resolution

Source

#[non_exhaustive]
#[repr(u8)]pub enum Resolution {
    R1 = 0,
    R2 = 1,
    R4 = 2,
    R8 = 3,
    R16 = 4,
    R32 = 5,
    R64 = 6,
    R128 = 7,
}

Expand description

Scale factor between a Block and its component voxels.

This resolution cubed is the number of voxels making up a block.

Resolutions are always powers of 2. This ensures that the arithmetic is well-behaved (no division by zero, exact floating-point representation, and the potential of fixed-point representation), and that it is always possible to subdivide a block further (up to the limit) without shifting the existing voxel boundaries.

Note that while quite high resolutions are permitted, this does not mean that it is practical to routinely use full blocks at that resolution. For example, 64 × 64 × 64 = 262,144 voxels, occupying several megabytes just for color data. High resolutions are permitted for special purposes that do not necessarily use the full cube volume:

Thin blocks (e.g. 128 × 128 × 1) can display high resolution text and other 2D images.
Multi-block structures can be defined using Modifier::Zoom; their total size is limited by the resolution limit.

Variants (Non-exhaustive)§

This enum is marked as 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.

§

Enum Resolution Copy item path

Variants (Non-exhaustive)§

R1 = 0

R2 = 1

R4 = 2

R8 = 3

R16 = 4

R32 = 5

R64 = 6

R128 = 7

Implementations§

impl Resolution

pub const MAX: Resolution = Resolution::R128

pub const fn double(self) -> Option<Resolution>

pub const fn halve(self) -> Option<Resolution>

pub const fn log2(self) -> u8

§Example

pub const fn recip_f32(self) -> f32

pub const fn recip_f64(self) -> f64

Trait Implementations§

impl<'arbitrary> Arbitrary<'arbitrary> for Resolution

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Resolution, Error>

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Resolution, Error>

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

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

impl Clone for Resolution

fn clone(&self) -> Resolution

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

impl Debug for Resolution

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

impl<'de> Deserialize<'de> for Resolution

fn deserialize<D>( deserializer: D, ) -> Result<Resolution, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

impl Display for Resolution

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

impl Div for Resolution

type Output = Option<Resolution>

fn div(self, rhs: Resolution) -> <Resolution as Div>::Output

impl Exhaust for Resolution

type Iter = ExhaustResolutionIter

type Factory = ExhaustResolutionFactory

fn exhaust_factories() -> <Resolution as Exhaust>::Iter

fn from_factory(factory: <Resolution as Exhaust>::Factory) -> Resolution

fn exhaust() -> Iter<Self>

impl Hash for Resolution

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

impl Mul for Resolution

type Output = Option<Resolution>

fn mul(self, rhs: Resolution) -> <Resolution as Mul>::Output

impl Ord for Resolution

fn cmp(&self, other: &Resolution) -> Ordering

fn max(self, other: Self) -> Selfwhere Self: Sized,

fn min(self, other: Self) -> Selfwhere Self: Sized,

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized,

impl PartialEq for Resolution

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

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

impl PartialOrd for Resolution

fn partial_cmp(&self, other: &Resolution) -> Option<Ordering>

fn lt(&self, other: &Rhs) -> bool

fn le(&self, other: &Rhs) -> bool

fn gt(&self, other: &Rhs) -> bool

fn ge(&self, other: &Rhs) -> bool

impl Serialize for Resolution

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where S: Serializer,

impl TryFrom<i128> for Resolution

type Error = IntoResolutionError<i128>

fn try_from( value: i128, ) -> Result<Resolution, <Resolution as TryFrom<i128>>::Error>

impl TryFrom<i16> for Resolution

type Error = IntoResolutionError<i16>

fn try_from( value: i16, ) -> Result<Resolution, <Resolution as TryFrom<i16>>::Error>

impl TryFrom<i32> for Resolution

type Error = IntoResolutionError<i32>

fn try_from( value: i32, ) -> Result<Resolution, <Resolution as TryFrom<i32>>::Error>

impl TryFrom<i64> for Resolution

type Error = IntoResolutionError<i64>

fn try_from( value: i64, ) -> Result<Resolution, <Resolution as TryFrom<i64>>::Error>

impl TryFrom<isize> for Resolution

type Error = IntoResolutionError<isize>

fn try_from( value: isize, ) -> Result<Resolution, <Resolution as TryFrom<isize>>::Error>

Enum Resolution

fn deserialize<D>( deserializer: D, ) -> Result<Resolution, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

fn hash<H>(&self, state: &mut H)
where __H: Hasher,

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

fn max(self, other: Self) -> Self
where Self: Sized,

fn min(self, other: Self) -> Self
where Self: Sized,

fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer,

impl<T> Any for T
where T: 'static + ?Sized,

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

impl<T> CloneToUninit for T
where T: Clone,

impl<Q, K> Comparable<K> for Q
where Q: Ord + ?Sized, K: Borrow<Q> + ?Sized,

impl<T> DynEq for T
where T: Any + Eq,

impl<T> DynHash for T
where T: DynEq + Hash,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

impl<T, U> Into<U> for T
where U: From<T>,