Struct veloren_common::terrain::chonk::Chonk

pub struct Chonk<V, S: RectVolSize, M: Clone> {
    z_offset: i32,
    sub_chunks: Vec<Chunk<V, SubChunkSize<S>, M>>,
    below: V,
    above: V,
    meta: M,
    phantom: PhantomData<S>,
}

Fields

z_offset: i32

sub_chunks: Vec<Chunk<V, SubChunkSize<S>, M>>

below: V

above: V

meta: M

phantom: PhantomData<S>

Implementations

impl<V, S: RectVolSize, M: Clone> Chonk<V, S, M>

pub fn new(z_offset: i32, below: V, above: V, meta: M) -> Self

pub fn meta(&self) -> &M

pub fn meta_mut(&mut self) -> &mut M

pub fn get_min_z(&self) -> i32

pub fn get_max_z(&self) -> i32

pub fn sub_chunks_len(&self) -> usize

pub fn sub_chunk_groups(&self) -> usize

pub fn iter_changed(&self) -> impl Iterator<Item = (Vec3<i32>, &V)> + '_

Iterate through the voxels in this chunk, attempting to avoid those that are unchanged (i.e: match the below and above voxels). This is generally useful for performance reasons.

fn sub_chunk_idx(&self, z: i32) -> i32

fn sub_chunk_z(&self, z: i32) -> i32

fn sub_chunk_min_z(&self, z: i32) -> i32

pub fn defragment(&mut self)

where V: Clone + Eq + Hash,

Compress chunk by using more intelligent defaults.

impl Chonk<Block, TerrainChunkSize, TerrainChunkMeta>

pub fn water(sea_level: i32) -> TerrainChunk

Generate an all-water chunk at a specific sea level.

pub fn find_accessible_pos( &self, spawn_wpos: Vec2<i32>, ascending: bool ) -> Vec3<f32>

Find the highest or lowest accessible position within the chunk

Trait Implementations

impl<V, S: RectVolSize, M: Clone> BaseVol for Chonk<V, S, M>

type Error = ChonkError

type Vox = V

fn scaled_by(self, scale: Vec3<f32>) -> Scaled<Self>

where Self: Sized,

impl<V: Clone, S: Clone + RectVolSize, M: Clone + Clone> Clone for Chonk<V, S, M>

fn clone(&self) -> Chonk<V, S, M>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, S: Debug + RectVolSize, M: Debug + Clone> Debug for Chonk<V, S, M>

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

Formats the value using the given formatter.

impl<'de, V, S, M> Deserialize<'de> for Chonk<V, S, M>

where V: Deserialize<'de>, S: Deserialize<'de> + RectVolSize, M: Deserialize<'de> + Clone,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a, V, S: RectVolSize, M: Clone> IntoPosIterator for &'a Chonk<V, S, M>

type IntoIter = ChonkPosIter<V, S, M>

fn pos_iter( self, lower_bound: Vec3<i32>, upper_bound: Vec3<i32> ) -> Self::IntoIter

impl<'a, V, S: RectVolSize, M: Clone> IntoVolIterator<'a> for &'a Chonk<V, S, M>

type IntoIter = ChonkVolIter<'a, V, S, M>

fn vol_iter( self, lower_bound: Vec3<i32>, upper_bound: Vec3<i32> ) -> Self::IntoIter

impl<V, S: RectVolSize, M: Clone> ReadVol for Chonk<V, S, M>

fn get(&self, pos: Vec3<i32>) -> Result<&V, Self::Error>

Get a reference to the voxel at the provided position in the volume.

fn get_unchecked(&self, pos: Vec3<i32>) -> &V

Get a reference to the voxel at the provided position in the volume. Many volumes provide a fast path, provided the position is always in-bounds. Note that this function is still safe.

fn for_each_in(&self, aabb: Aabb<i32>, f: impl FnMut(Vec3<i32>, Self::Vox))

where Self::Vox: Copy,

Call provided closure with each block in the supplied Aabb Portions of the Aabb outside the volume are ignored

fn ray( &self, from: Vec3<f32>, to: Vec3<f32> ) -> Ray<'_, Self, fn(_: &Self::Vox) -> bool, fn(_: &Self::Vox, _: Vec3<i32>)>

where Self: Sized,

NOTE: By default, this ray will simply run from from to to without stopping. To make something interesting happen, call until or for_each.

impl<V, S: RectVolSize, M: Clone> RectRasterableVol for Chonk<V, S, M>

const RECT_SIZE: Vec2<u32> = S::RECT_SIZE

impl<V, S, M> Serialize for Chonk<V, S, M>

where V: Serialize, S: Serialize + RectVolSize, M: Serialize + Clone,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<V: Clone + PartialEq, S: RectVolSize, M: Clone> WriteVol for Chonk<V, S, M>

fn set(&mut self, pos: Vec3<i32>, block: Self::Vox) -> Result<V, Self::Error>

Set the voxel at the provided position in the volume to the provided value.