Struct building_blocks_storage::chunk::map::ChunkMap

pub struct ChunkMap<N, T, Bldr, Store> {
    pub indexer: ChunkIndexer<N>,
    // some fields omitted
}

A lattice map made up of same-shaped Array chunks. For each level of detail, it takes a value at every possible PointN, because accesses made outside of the stored chunks will return some ambient value specified on creation.

ChunkMap is generic over the type used to actually store the Chunks. You can use any storage that implements ChunkReadStorage or ChunkWriteStorage. Being a lattice map, ChunkMapLodView will implement various access traits, depending on the capabilities of the chunk storage.

If the chunk storage implements ChunkReadStorage, then ChunkMapLodView will implement:

• Get
• ForEach
• ReadExtent

If the chunk storage implements ChunkWriteStorage, then ChunkMapLodView will implement:

• GetMut
• ForEachMut
• WriteExtent

Fields

indexer: ChunkIndexer<N>

Translates from lattice coordinates to chunk key space.

Implementations

impl<N, T, Bldr, Store> ChunkMap<N, T, Bldr, Store> where
    PointN<N>: IntegerPoint<N>,
    ChunkKey<N>: Copy,
    T: Clone,
    Bldr: ChunkMapBuilder<N, T>,
    Bldr::Chunk: FillExtent<N, Item = T> + IndexedArray<N>,
    Store: ChunkWriteStorage<N, Bldr::Chunk>, 

pub fn downsample_chunk<Samp>(
    &mut self,
    sampler: &Samp,
    src_chunk_key: ChunkKey<N>,
    dst_lod: u8
) where
    Samp: ChunkDownsampler<N, T, Bldr::Chunk, Bldr::Chunk>, 

Downsamples the chunk at src_chunk_key into the specified destination level dst_lod.

pub fn downsample_external_chunk<Samp, Src>(
    &mut self,
    sampler: &Samp,
    src_chunk_key: ChunkKey<N>,
    src_chunk: &Src,
    dst_lod: u8
) where
    Samp: ChunkDownsampler<N, T, Src, Bldr::Chunk>, 

Downsamples all of src_chunk into the overlapping chunk at level dst_lod.

pub fn downsample_ambient_chunk(
    &mut self,
    src_chunk_key: ChunkKey<N>,
    dst_lod: u8
)

Fill the destination samples with the ambient value.

impl<T, Bldr, Store> ChunkMap<[i32; 3], T, Bldr, Store> where
    T: Clone,
    Bldr: ChunkMapBuilder<[i32; 3], T>,
    Bldr::Chunk: FillExtent<[i32; 3], Item = T> + IndexedArray<[i32; 3]>,
    Store: ChunkWriteStorage<[i32; 3], Bldr::Chunk>, 

pub fn downsample_chunks_with_index<Samp>(
    &mut self,
    num_lods: u8,
    index: &OctreeChunkIndex,
    sampler: &Samp,
    extent: &Extent3i
) where
    Samp: ChunkDownsampler<[i32; 3], T, Bldr::Chunk, Bldr::Chunk>, 

Downsamples all chunks that both:

1. overlap extent
2. are present in index

Destination chunks up to num_lods will be considered.

pub fn downsample_chunks_with_lod0_and_index<Samp, Lod0Ch, Lod0ChBorrow>(
    &mut self,
    num_lods: u8,
    get_lod0_chunk: impl Fn(Point3i) -> Option<Lod0Ch>,
    index: &OctreeChunkIndex,
    sampler: &Samp,
    extent: &Extent3i
) where
    Lod0Ch: Borrow<Lod0ChBorrow>,
    Samp: ChunkDownsampler<[i32; 3], T, Bldr::Chunk, Bldr::Chunk> + ChunkDownsampler<[i32; 3], T, Lod0ChBorrow, Bldr::Chunk>, 

Same as downsample_chunks_with_index, but allows passing in a closure that fetches LOD0 chunks. This is mostly a workaround so we can downsample multichannel chunks from LOD0.

impl<N, T, Bldr, Store> ChunkMap<N, T, Bldr, Store>

pub fn take_storage(self) -> Store

Consumes self and returns the backing chunk storage.

pub fn storage(&self) -> &Store

Borrows the internal chunk storage.

pub fn storage_mut(&mut self) -> &mut Store

Borrows the internal chunk storage.

pub fn builder(&self) -> &Bldr

pub fn lod_view(&self, lod: u8) -> ChunkMapLodView<&Self>

Get an immutable view of a single level of detail lod in order to use the access traits.

pub fn lod_view_mut(&mut self, lod: u8) -> ChunkMapLodView<&mut Self>

Get a mutable view of a single level of detail lod in order to use the access traits.

impl<N, T, Bldr, Store> ChunkMap<N, T, Bldr, Store> where
    Bldr: ChunkMapBuilder<N, T>, 

pub fn chunk_shape(&self) -> PointN<N>

pub fn ambient_value(&self) -> T

impl<N, T, Bldr, Store> ChunkMap<N, T, Bldr, Store> where
    PointN<N>: IntegerPoint<N>,
    Bldr: ChunkMapBuilder<N, T>,
    Store: ChunkReadStorage<N, Bldr::Chunk>, 

pub fn get_chunk(&self, key: ChunkKey<N>) -> Option<&Bldr::Chunk>

Borrow the chunk at key.

In debug mode only, asserts that key is valid.

pub fn clone_point(&self, lod: u8, p: PointN<N>) -> T where
    T: Clone,
    <Bldr::Chunk as Chunk>::Array: Get<PointN<N>, Item = T>, 

Get the values at point p in level of detail lod.

pub fn get_point<'a, Ref>(&'a self, lod: u8, p: PointN<N>) -> Ref where
    <Bldr::Chunk as Chunk>::Array: GetRef<'a, PointN<N>, Item = Ref>,
    Ref: MultiRef<'a, Data = T>, 

Get a reference to the values at point p in level of detail lod.

pub fn visit_chunks(
    &self,
    lod: u8,
    extent: &ExtentN<N>,
    visitor: impl FnMut(Either<&Bldr::Chunk, (&ExtentN<N>, AmbientExtent<N, T>)>)
)

Call visitor on all chunks that overlap extent. Vacant chunks will be represented by an AmbientExtent.

pub fn visit_occupied_chunks(
    &self,
    lod: u8,
    extent: &ExtentN<N>,
    visitor: impl FnMut(&Bldr::Chunk)
)

Call visitor on all occupied chunks that overlap extent.

impl<N, T, Bldr, Store> ChunkMap<N, T, Bldr, Store> where
    PointN<N>: IntegerPoint<N>,
    Bldr: ChunkMapBuilder<N, T>,
    Store: ChunkWriteStorage<N, Bldr::Chunk>, 

pub fn write_chunk(&mut self, key: ChunkKey<N>, chunk: Bldr::Chunk)

Overwrite the Chunk at key with chunk. Drops the previous value.

In debug mode only, asserts that key is valid and chunk’s shape is valid.

pub fn replace_chunk(
    &mut self,
    key: ChunkKey<N>,
    chunk: Bldr::Chunk
) -> Option<Bldr::Chunk>

Replace the Chunk at key with chunk, returning the old value.

In debug mode only, asserts that key is valid and chunk’s shape is valid.

pub fn get_mut_chunk(&mut self, key: ChunkKey<N>) -> Option<&mut Bldr::Chunk>

Mutably borrow the chunk at key.

In debug mode only, asserts that key is valid.

pub fn get_mut_chunk_or_insert_with(
    &mut self,
    key: ChunkKey<N>,
    create_chunk: impl FnOnce() -> Bldr::Chunk
) -> &mut Bldr::Chunk

Mutably borrow the chunk at key. If the chunk doesn’t exist, create_chunk is called to insert one.

In debug mode only, asserts that key is valid.

pub fn get_mut_chunk_or_insert_ambient(
    &mut self,
    key: ChunkKey<N>
) -> &mut Bldr::Chunk

Mutably borrow the chunk at key. If the chunk doesn’t exist, a new chunk is created with the ambient value.

In debug mode only, asserts that key is valid.

pub fn get_mut_point<'a, Mut>(&'a mut self, lod: u8, p: PointN<N>) -> Mut where
    <Bldr::Chunk as Chunk>::Array: GetMut<'a, PointN<N>, Item = Mut>, 

Get a mutable reference to the values at point p in level of detail lod.

pub fn visit_mut_chunks(
    &mut self,
    lod: u8,
    extent: &ExtentN<N>,
    visitor: impl FnMut(&mut Bldr::Chunk)
)

Call visitor on all chunks that overlap extent. Vacant chunks will be created first with ambient value.

pub fn visit_occupied_mut_chunks(
    &mut self,
    lod: u8,
    extent: &ExtentN<N>,
    visitor: impl FnMut(&mut Bldr::Chunk)
)

Call visitor on all occupied chunks that overlap extent.

pub fn delete_chunk(&mut self, key: ChunkKey<N>)

pub fn pop_chunk(&mut self, key: ChunkKey<N>) -> Option<Bldr::Chunk>

impl<N, T, Bldr, Store> ChunkMap<N, T, Bldr, Store> where
    for<'r> ChunkMapLodView<&'r mut Self>: FillExtent<N, Item = T>, 

pub fn fill_extent(&mut self, lod: u8, extent: &ExtentN<N>, value: T)

Fill all of extent with the same value.

impl<'a, N, T, Bldr, Store> ChunkMap<N, T, Bldr, Store> where
    PointN<N>: IntegerPoint<N>,
    Store: IterChunkKeys<'a, N>, 

pub fn bounding_extent(&'a self, lod: u8) -> ExtentN<N>

The smallest extent that bounds all chunks in level of detail lod.

impl<N, T, Bldr, Compr> ChunkMap<N, T, Bldr, CompressibleChunkStorage<N, Compr>> where
    ChunkKey<N>: Clone + Eq + Hash,
    PointN<N>: IntegerPoint<N>,
    Bldr: ChunkMapBuilder<N, T> + Clone,
    Compr: Compression<Data = Bldr::Chunk>, 

pub fn reader<'a>(
    &'a self,
    local_cache: &'a LocalChunkCache<N, Bldr::Chunk>
) -> CompressibleChunkMapReader<'a, N, T, Bldr, Compr>

Construct a reader for this map.