Struct ChunkedMeshCache 

pub struct ChunkedMeshCache { /* private fields */ }

Thread-safe chunked incremental mesh cache.

Divides the SDF evaluation space into a uniform grid of chunks. Each chunk is independently cached and can be marked dirty when the underlying SDF changes — either globally or within a specific region.

Implementations

impl ChunkedMeshCache

pub fn new(config: ChunkedCacheConfig) -> Self

Create a new chunked mesh cache.

pub fn get_chunk(&self, coord: &ChunkCoord) -> Option<Arc<Mesh>>

Get the chunk mesh at the given coordinate, if cached and valid.

pub fn set_chunk(&self, coord: ChunkCoord, mesh: Mesh, sdf_hash: u64)

Insert or update a chunk mesh.

Uses FIFO eviction: when at capacity, the oldest-inserted chunk is removed first — deterministic and cache-friendly compared to random.

pub fn invalidate_all(&self)

Mark all chunks as dirty (e.g. the SDF changed globally).

pub fn invalidate_region(&self, min: Vec3, max: Vec3)

Mark chunks overlapping a world-space bounding box as dirty.

pub fn dirty_chunks(&self) -> Vec<ChunkCoord>

Get the coordinates of all currently dirty chunks.

pub fn update_sdf_hash(&self, new_hash: u64) -> Vec<ChunkCoord>

Update the global SDF hash. Returns the list of chunks that were invalidated (those whose stored hash differs from new_hash).

pub fn cached_chunks(&self) -> Vec<ChunkCoord>

Get all cached chunk coordinates.

pub fn chunk_count(&self) -> usize

Number of cached chunks.

pub fn memory_usage(&self) -> usize

Total approximate memory usage of all cached chunk meshes (bytes).

pub fn world_to_chunk(&self, pos: Vec3) -> ChunkCoord

Convert a world-space position to its containing chunk coordinate.

pub fn chunk_bounds(&self, coord: &ChunkCoord) -> (Vec3, Vec3)

Get the axis-aligned bounding box (min, max) for a chunk coordinate.

pub fn chunks_in_bounds(&self, min: Vec3, max: Vec3) -> Vec<ChunkCoord>

Compute all chunk coordinates required to cover the given bounding box.

pub fn persist_dirty(&self) -> Result<usize, IoError>

Persist all dirty chunks to disk as individual .abm files.

Requires cache_dir to be set in the configuration. Returns the number of chunks written.

pub fn load_chunk( &self, coord: &ChunkCoord, ) -> Result<Option<Arc<Mesh>>, IoError>

Load a single chunk from the disk cache. Returns None if the file does not exist. A chunk that is not cached yet is added at the back of the FIFO order, evicting the oldest chunk when the cache is full.

pub fn clear(&self)

Clear all cached chunks.

pub fn merge_all(&self) -> Mesh

Merge all cached chunk meshes into a single combined Mesh.

Vertex positions are preserved in world space. Index offsets are adjusted so the resulting mesh is self-consistent.

Chunks are concatenated in ascending (x, y, z) order of their ChunkCoord, so the same set of chunks always gives the same vertex and index order, whatever the insertion order and from one run to the next (until 5.0.0 the order was that of the internal HashMap, which changes between runs).