Struct veloren_voxygen::scene::terrain::Terrain

pub struct Terrain<V: RectRasterableVol = TerrainChunk> {
    atlas: AtlasAllocator,
    chunks: HashMap<Vec2<i32>, TerrainChunkData>,
    shadow_chunks: Vec<(Vec2<i32>, TerrainChunkData)>,
    mesh_send_tmp: Sender<MeshWorkerResponse>,
    mesh_recv: Receiver<MeshWorkerResponse>,
    mesh_todo: HashMap<Vec2<i32>, ChunkMeshState>,
    mesh_todos_active: Arc<AtomicU64>,
    mesh_recv_overflow: f32,
    pub(super) sprite_render_state: Arc<SpriteRenderState>,
    pub(super) sprite_globals: SpriteGlobalsBindGroup,
    atlas_textures: Arc<AtlasTextures<Locals, TerrainAtlasData>>,
    phantom: PhantomData<V>,
}

Fields

atlas: AtlasAllocator

This is always the current atlas into which data is being allocated. Once an atlas is too full to allocate the next texture, we always allocate a fresh texture and start allocating into that. Trying to keep more than one texture available for allocation doesn’t seem worth it, because our allocation patterns are heavily spatial (so all data allocated around the same time should have a very similar lifetime, even in pathological cases). As a result, fragmentation effects should be minimal.

TODO: Consider “moving GC” style allocation to deal with spatial fragmentation effects due to odd texture sizes, which in some cases might significantly reduce the number of textures we need for particularly difficult locations.

chunks: HashMap<Vec2<i32>, TerrainChunkData>

shadow_chunks: Vec<(Vec2<i32>, TerrainChunkData)>

Temporary storage for dead chunks that might still be shadowing chunks in view. We wait until either the chunk definitely cannot be shadowing anything the player can see, the chunk comes back into view, or for daylight to end, before removing it (whichever comes first).

Note that these chunks are not complete; for example, they are missing texture data (they still currently hold onto a reference to their backing texture, but it generally can’t be trusted for rendering purposes).

mesh_send_tmp: Sender<MeshWorkerResponse>

mesh_recv: Receiver<MeshWorkerResponse>

mesh_todo: HashMap<Vec2<i32>, ChunkMeshState>

mesh_todos_active: Arc<AtomicU64>

mesh_recv_overflow: f32

sprite_render_state: Arc<SpriteRenderState>

sprite_globals: SpriteGlobalsBindGroup

atlas_textures: Arc<AtlasTextures<Locals, TerrainAtlasData>>

As stated previously, this is always the very latest texture into which we allocate. Code cannot assume that this is the assigned texture for any particular chunk; look at the texture field in TerrainChunkData for that.

phantom: PhantomData<V>

Implementations

impl<V: RectRasterableVol> Terrain<V>

pub fn new( renderer: &mut Renderer, global_model: &GlobalModel, lod_data: &LodData, sprite_render_context: SpriteRenderContext, ) -> Self

fn make_atlas( renderer: &mut Renderer, ) -> Result<(AtlasAllocator, AtlasTextures<Locals, TerrainAtlasData>), RenderError>

fn remove_chunk_meta(&mut self, _pos: Vec2<i32>, chunk: &TerrainChunkData)

fn insert_chunk(&mut self, pos: Vec2<i32>, chunk: TerrainChunkData)

fn remove_chunk(&mut self, pos: Vec2<i32>)

pub fn light_at_wpos(&self, wpos: Vec3<i32>) -> f32

Find the light level (sunlight) at the given world position.

fn skip_remesh(old_block: Block, new_block: Block) -> (bool, bool)

Determine whether a given block change actually require remeshing.

Returns (skip_color, skip_lights) where

skip_color means no textures were recolored (i.e. this was a sprite only change).

skip_lights means no remeshing or relighting was required (i.e. the block opacity / lighting info / block kind didn’t change).

pub fn glow_at_wpos(&self, wpos: Vec3<i32>) -> f32

Find the glow level (light from lamps) at the given world position.

pub fn glow_normal_at_wpos(&self, wpos: Vec3<f32>) -> (Vec3<f32>, f32)

pub fn maintain( &mut self, renderer: &mut Renderer, scene_data: &SceneData<'_>, focus_pos: Vec3<f32>, loaded_distance: f32, camera: &Camera, ) -> (Aabb<f32>, Vec<Vec3<f32>>, Aabr<f32>, Vec<Vec3<f32>>, Aabr<f32>)

Maintain terrain data. To be called once per tick.

The returned visible bounding volumes take into account the current camera position (i.e: when underground, surface structures will be culled from the volume).

pub fn get(&self, chunk_key: Vec2<i32>) -> Option<&TerrainChunkData>

pub fn chunk_count(&self) -> usize

pub fn visible_chunk_count(&self) -> usize

pub fn shadow_chunk_count(&self) -> usize

pub fn render_shadows<'a>( &'a self, drawer: &mut TerrainShadowDrawer<'_, 'a>, focus_pos: Vec3<f32>, culling_mode: CullingMode, )

pub fn render_rain_occlusion<'a>( &'a self, drawer: &mut TerrainShadowDrawer<'_, 'a>, focus_pos: Vec3<f32>, )

pub fn chunks_for_point_shadows( &self, focus_pos: Vec3<f32>, ) -> impl Clone + Iterator<Item = (&Model<Vertex>, &BoundLocals)>

pub fn render<'a>( &'a self, drawer: &mut FirstPassDrawer<'a>, focus_pos: Vec3<f32>, culling_mode: CullingMode, )

pub fn render_sprites<'a>( &'a self, sprite_drawer: &mut SpriteDrawer<'_, 'a>, focus_pos: Vec3<f32>, cam_pos: Vec3<f32>, sprite_render_distance: f32, culling_mode: CullingMode, )

pub fn render_translucent<'a>( &'a self, drawer: &mut FirstPassDrawer<'a>, focus_pos: Vec3<f32>, )