Struct Layer

pub struct Layer<C: Chunk> { /* private fields */ }

The entry point to access the chunks of a layer.

It exposes various convenience accessors, like iterating over areas in chunk or world coordinates.

Implementations

impl<C: Chunk> Layer<C>

pub fn new(value: C::Dependencies) -> Self

Create a new layer, manually specifying the dependencies. This is useful if you want to share dependencies with another layer.

impl<C: Chunk> Layer<C>

pub fn ensure_loaded_in_bounds(&self, chunk_bounds: Bounds)

Eagerly compute all chunks in the given bounds (in world coordinates). Load all dependencies’ chunks and then compute our chunks. May recursively cause the dependencies to load their deps and so on.

pub fn clear(&self, chunk_bounds: Bounds)

Eagerly unload all chunks in the given bounds (in world coordinates).

pub fn incoherent_override_cache(&self, index: GridPoint<C>, val: C)

Manually (without calling compute) set a chunk in the cache.

This violates all the nice properties like the fact that layers depending on this one will not even load this chunk if they have computed all their chunks that depend on this one. They may later have to recompute, and then see the new value, which may lead to recomputed chunks being different from non-recomputed chunks.

TLDR: only call this if you have called clear on everything that depended on this one.

pub fn get_or_compute(&self, index: GridPoint<C>) -> C

Get a chunk or generate it if it wasn’t already cached.

pub fn get_range(&self, range: Bounds) -> impl Iterator<Item = C> + '_

Get an iterator over all chunks that touch the given bounds (in world coordinates)

pub fn get_grid_range( &self, range: Bounds<GridIndex<C>>, ) -> impl Iterator<Item = C> + '_

Get an iterator over chunks as given by the bounds (in chunk grid indices). Chunks will be generated on the fly.

pub fn get_moore_neighborhood(&self, index: GridPoint<C>) -> [[C; 3]; 3]

Get a 3x3 array of chunks around a specific chunk

Trait Implementations

impl<C: Chunk> Clone for Layer<C>

where C::LayerStore<(RollingGrid<C>, C::Dependencies)>: Clone,

fn clone(&self) -> Self

Shallowly clone the layer. The clones will share the caches with this copy of the layer.

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

Performs copy-assignment from source.

impl<C: Chunk> Default for Layer<C>

where C::Dependencies: Default,

fn default() -> Self

Create an entirely new layer and its dependencies. The dependencies will not be connected to any other dependencies of the same type.

impl<C: Chunk + Debug> Dependencies for Layer<C>

fn debug(&self) -> Vec<&dyn DynLayer>

For runtime debugging of your layers, you should return references to each of the layer types within your dependencies.

impl<C: Chunk> Deref for Layer<C>

type Target = <C as Chunk>::Dependencies

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<C: Chunk + Debug> DynLayer for Layer<C>

fn iter_all_loaded( &self, ) -> Box<dyn Iterator<Item = (Bounds, Box<dyn Debug + 'static>)> + '_>

Iterate only over the chunks that have been generated already and not unloaded yet to make space for new ones.

fn deps(&self) -> Vec<&dyn DynLayer>

Iterate over the dependency layers of this layer.

fn ident(&self) -> (usize, TypeId)

A unique identifier for this layer, useful for the use as map keys.

fn name(&self) -> String

A shortened version of the type name of the layer and its generic parameters.