Struct ChunkedSpaceMesh

pub struct ChunkedSpaceMesh<M, const CHUNK_SIZE: GridCoordinate>
where
    M: DynamicMeshTypes,
{ /* private fields */ }

The large-scale and updatable form of SpaceMesh: subdivides a Space into chunks which are individually recomputed as the space changes or its contained blocks do.

Each chunk, a ChunkMesh, owns a data value of type M::RenderData, which is initialized using Default. This value may be a reference to a corresponding GPU buffer, for example. It will usually need to be an Option of something.

Additionally, to allow instanced rendering of complex blocks that would be overly large if repeatedly copied into chunk meshes, render data is maintained for each individual block that chunks may decide to omit from their meshes; it is accessed through block_instance_mesh().

ChunkedSpaceMesh manages all this data but does not demand a particular sequence of rendering operations; it is your responsibility to render the chunk meshes and instances which you can obtain by calling one of the iteration methods.

Implementations

impl<M, const CHUNK_SIZE: GridCoordinate> ChunkedSpaceMesh<M, CHUNK_SIZE>

where M: DynamicMeshTypes, M::Vertex: GfxVertex<TexPoint = <M::Tile as Tile>::Point> + PartialEq, M::Alloc: Send + Sync, M::Tile: Tile + PartialEq + Send + Sync,

pub fn new( space: Handle<Space>, texture_allocator: M::Alloc, interactive: bool, ) -> Self

Constructs a new ChunkedSpaceMesh that will maintain a mesh representation of the contents of the given space, within a requested viewing distance (specified later).

If interactive is true, will prioritize getting a rough view of the world over a fully detailed one, by using placeholder block meshes on the first pass.

pub fn space(&self) -> &Handle<Space>

Returns the handle to the Space this watches.

pub fn chunk_chart(&self) -> &ChunkChart<CHUNK_SIZE>

Returns a ChunkChart for the view distance used by the most recent Self::update().

pub fn iter_chunks(&self) -> impl Iterator<Item = &ChunkMesh<M, CHUNK_SIZE>>

Iterates over all ChunkMeshes owned by this ChunkedSpaceMesh, in arbitrary order.

pub fn iter_in_view<'a>( &'a self, camera: &'a Camera, ) -> impl DoubleEndedIterator<Item = InViewChunkRef<'a, M, CHUNK_SIZE>> + 'a

Iterates over the ChunkMeshes that are in view from the given camera, in front-to-back order. (Use .rev() to iterate in back-to-front order.)

Uses camera’s position, rotation, and options to decide which chunks to return.

pub fn chunk( &self, position: ChunkPos<CHUNK_SIZE>, ) -> Option<&ChunkMesh<M, CHUNK_SIZE>>

Retrieves a ChunkMesh for the specified chunk position, if one exists.

Call this while drawing, after Self::update() has updated/created chunks.

pub fn block_instance_mesh( &self, block_index: BlockIndex, ) -> Option<&InstanceMesh<M>>

Retrieves the mesh for a block which should be rendered according to ChunkMesh::block_instances().

pub fn count_block_instances(&self, camera: &Camera) -> usize

Calculates how many ChunkMesh::block_instances() are present in chunks visible from the camera.

pub fn update<F>( &mut self, camera: &Camera, deadline: Deadline<M::Instant>, render_data_updater: F, ) -> CsmUpdateInfo

where F: Fn(RenderDataUpdate<'_, M>) + Send + Sync,

Recompute meshes of blocks that need it and the nearest chunks that need it.

• camera’s view position is used to choose what to update and for depth ordering; its graphics options are used for triangulation and view distance.
• deadline is the approximate time at which this should stop.
• render_data_updater is called for every re-meshed or depth-sorted chunk or block. It may be called concurrently from multiple threads.

Returns performance information and the chunk the camera is located in.

pub fn job_queue(&self) -> &MeshJobQueue<M>

Returns a handle to the job queue, which may be used by background tasks (which you supply) to make progress in generating meshes separately from the Self::update() operation.

pub fn view_chunk(&self) -> ChunkPos<CHUNK_SIZE>

Returns the chunk in which the camera from the most recent Self::update() was located. This may be used as the origin point to iterate over chunks in view.

Trait Implementations

impl<M, const CHUNK_SIZE: GridCoordinate> Debug for ChunkedSpaceMesh<M, CHUNK_SIZE>

where M: DynamicMeshTypes + Debug, M::Instant: Debug,

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

Formats the value using the given formatter.