//! Chunk streaming: a worker pool generates, lights and meshes chunk columns //! around the player, closest first. The game thread owns the world and only //! hands immutable `Arc` snapshots to workers; results carry a sequence number //! so stale work is dropped. use crate::fast_hash::{FxHashMap, FxHashSet}; use crate::{ chunk::{Chunk, SECTIONS}, light::{LightChanges, LightTables, apply_lighting, apply_relighting, light_chunk}, mesher::{MeshTables, Mesher, Region, SectionMesh, borrow}, world::World, }; use horizon_core::biome::BiomeZoom; use horizon_world::block_render::FaceVisibility; use horizon_world::worldgen::decoration_order::DecorationOrder; use std::{ collections::{BinaryHeap, HashSet}, sync::{ Arc, Condvar, Mutex, RwLock, atomic::{AtomicBool, Ordering}, mpsc, }, thread, }; /// A chunk under generation, opaque to the streamer. pub type Proto = Box; /// Chunk generation in vanilla's stages: a neighbour-independent proto chunk /// (biomes, noise, surface, carvers), decoration of a 3x3 neighbourhood /// (FEATURES, which may write into neighbours), then conversion of a chunk /// whose eight neighbours are decorated into a final column. Implementations /// must be thread-safe; each worker thread owns one `Worker`. pub trait ChunkGenerator: Send + Sync + 'static { type Worker: Send + 'static; fn worker(&self) -> Self::Worker; fn lod_sampler(self: Arc) -> Box where Self: Sized, { let worker = self.worker(); Box::new(GeneratorSampler { generator: self, worker, }) } /// An undecorated far-terrain column, without allocating gameplay chunks. fn lod_surface( &self, _worker: &mut Self::Worker, _x: i32, _z: i32, ) -> Option { None } /// A previously saved final chunk, bypassing generation. fn load(&self, _x: i32, _z: i32) -> Option { None } /// What a loaded chunk needs from the generator before the game uses it, /// on the worker that loaded it. fn prepare_loaded(&self, _worker: &mut Self::Worker, _chunk: &Chunk) {} fn proto(&self, worker: &mut Self::Worker, x: i32, z: i32) -> Proto; fn decorates(&self) -> bool { false } /// Decorate `region[4]`; the region is row-major (dz, dx) around it. fn decorate(&self, _worker: &mut Self::Worker, _region: &mut [Proto; 9]) {} fn finish(&self, proto: Proto) -> Chunk; /// Whether `proto` has been decorated (a saved one can come back decorated). fn is_decorated(&self, _proto: &Proto) -> bool { false } /// What to save of a proto chunk dropped before it became final. fn saved_proto(&self, _proto: &Proto) -> Option { None } /// Put a saved proto chunk's state back onto `proto`, generated again. fn restore_proto(&self, _proto: &mut Proto, _saved: crate::save::SavedProto) {} /// Save proto chunks decoration wrote to, so that they come back as they /// were: generating them again would lose those writes. fn save_protos(&self, _protos: &[&Proto]) {} /// Save a column that finished after the player moved away: its /// neighbours' decoration is done, so it can't be generated again. fn save_finished(&self, _chunk: Chunk) {} } pub type LodDetail = ((i32, i32), Arc<[crate::lod::Column; 256]>); /// Independent, thread-owned far-terrain sampling state. pub trait LodSampler: Send { /// Independent sampling state; native detail generation stays with the owner. fn fork(&self) -> Option> { None } fn request_detail(&mut self, _chunks: &[(i32, i32)], _center: [i32; 2]) {} fn drain_details(&mut self) -> Vec { Vec::new() } fn sample(&mut self, x: i32, z: i32) -> Option; fn column(&mut self, x: i32, z: i32) -> crate::lod::Column { crate::lod::Column::from_surface(self.sample(x, z)) } fn reduced_column(&mut self, x: i32, z: i32, _width: i32) -> crate::lod::Column { self.column(x, z) } fn grid(&mut self, x: i32, z: i32, stride: i32, side: usize) -> Vec { let mut columns = Vec::with_capacity(side * side); for dz in 0..side { for dx in 0..side { columns.push(self.reduced_column( x + dx as i32 * stride, z + dz as i32 * stride, stride, )); } } columns } } pub trait LodSource: Send + Sync { fn sampler(self: Arc) -> Box; } struct GeneratorSampler { generator: Arc, worker: G::Worker, } impl LodSampler for GeneratorSampler { fn sample(&mut self, x: i32, z: i32) -> Option { self.generator.lod_surface(&mut self.worker, x, z) } } impl LodSource for G { fn sampler(self: Arc) -> Box { ChunkGenerator::lod_sampler(self) } } /// The generator's saving, for the streamer (which doesn't know its type). trait Saves: LodSource { fn save_protos(&self, protos: &[&Proto]); fn save_finished(&self, chunk: Chunk); } impl Saves for G { fn save_protos(&self, protos: &[&Proto]) { ChunkGenerator::save_protos(self, protos); } fn save_finished(&self, chunk: Chunk) { ChunkGenerator::save_finished(self, chunk); } } /// Per-job mesher inputs that change with the dimension or the options. #[derive(Clone, Copy)] struct MeshSettings { nether: bool, zoom: BiomeZoom, blend_radius: i32, smooth_lighting: bool, cutout_leaves: bool, } enum Job { Generate(i32, i32), Decorate(i32, i32, Box<[Proto; 9]>), Finish(Proto), Light(i32, i32, Box, u64, bool), Mesh(i32, i32, i32, Box, u64, MeshSettings), /// Proto chunks checked out to be saved (`ChunkGenerator::save_protos`), /// off the main thread like vanilla's IOWorker. Save(Vec<((i32, i32), Proto)>), } pub enum Done { Generated(Chunk), /// A proto chunk, and whether it was decorated (loaded so from the save). Proto(i32, i32, Proto, bool), Decorated(i32, i32, Box<[Proto; 9]>), Lit(i32, i32, Vec, u64), Meshed(i32, i32, i32, SectionMesh, u64), Saved(Vec<((i32, i32), Proto)>), } struct Queued { priority: i64, /// The column the job is for and what it adds to the column's distance /// (`Streaming::submit`): the priority is computed again from them when /// the centre moves (`Streaming::requeue`). None for saves, which go first. at: Option<(i32, i32)>, bias: i64, order: u64, job: Job, } impl PartialEq for Queued { fn eq(&self, o: &Self) -> bool { self.priority == o.priority && self.order == o.order } } impl Eq for Queued {} impl PartialOrd for Queued { fn partial_cmp(&self, o: &Self) -> Option { Some(self.cmp(o)) } } impl Ord for Queued { fn cmp(&self, o: &Self) -> std::cmp::Ordering { // BinaryHeap is a max-heap: lower priority value = more urgent. o.priority .cmp(&self.priority) .then(o.order.cmp(&self.order)) } } struct Shared { queue: Mutex>, ready: Condvar, stop: AtomicBool, /// What meshing reads (block models and sprites), swapped when resource /// packs reload; each mesh job takes the current one. context: RwLock>, } pub struct Streaming { shared: Arc, results: mpsc::Receiver, threads: Vec>, order: u64, generating: FxHashSet<(i32, i32)>, generation_scan: GenerationScan, /// Proto chunks: `None` while checked out to a decoration or save job. protos: FxHashMap<(i32, i32), Option>, decorated: FxHashSet<(i32, i32)>, decorating: usize, /// Save jobs in flight. saving: usize, /// Vanilla's decoration order around the player, and the centre and /// radius it was last ranked for. decoration_order: DecorationOrder, order_area: Option<((i32, i32), i32)>, /// What the queued jobs' priorities were computed from (`requeue`): the /// centre, the loading screen, the band, and the extra areas. queue_basis: (((i32, i32), bool, Option), Vec<((i32, i32), i32)>), finishing: FxHashSet<(i32, i32)>, decorates: bool, lighting: FxHashMap<(i32, i32), u64>, meshing: FxHashMap<(i32, i32, i32), u64>, /// Chunks whose light is current. lit: FxHashSet<(i32, i32)>, /// Columns whose sections have been meshed at least once. meshed: FxHashSet<(i32, i32)>, /// Dirty sections of loaded columns past the render distance, meshed once /// the player comes closer, and the area they were set aside for. waiting: FxHashSet<(i32, i32, i32)>, waiting_area: ((i32, i32), i32, usize), /// Proto chunks decoration wrote to since they were generated or saved. written: FxHashSet<(i32, i32)>, saves: Arc, /// Results received while `save` waited, for the next `update`. deferred: Vec, sequence: u64, pub center: (i32, i32), pub radius: i32, /// `/forceload`ed chunks: kept loaded whatever the distance. pub forced: HashSet<(i32, i32)>, /// No work is scheduled while paused (title screen). pub paused: bool, /// The level loading screen is up: work goes ring by ring (`Ranges::rings`). pub loading: bool, /// Dimension flags: sky light, Nether face shading. pub sky_light: bool, pub nether_shading: bool, /// `BiomeManager`'s zoom seed (the hashed world seed) and `biomeBlendRadius`. pub biome_zoom: BiomeZoom, pub biome_blend: i32, /// The `ao` and `cutoutLeaves` options. pub smooth_lighting: bool, pub cutout_leaves: bool, /// Incremental relighting of block edits on lit chunks (see `light::relight`). light_tables: Arc, /// Applied edits by sequence, replayed onto light jobs snapshotted before them. light_log: Vec<(u64, (i32, i32, i32))>, light_edit_sequence: u64, /// Edit sequence at each in-flight light job's snapshot. light_snapshots: FxHashMap<(i32, i32), u64>, pub generated_total: u64, pub meshed_total: u64, /// Chunks come from a server (`insert_remote`/`forget`): nothing is /// generated and columns are only unloaded when the server says so. pub remote: bool, /// More areas to keep loaded (centre chunk, radius), e.g. around the /// players of a server. Each is a square, like vanilla's ticket levels: /// chunks finish out to `radius + 1` (Chebyshev) and generation reaches /// past that as around the player. They are generated and kept but not meshed. pub extra: Vec<((i32, i32), i32)>, /// `extra`'s squares as a grid, made again when `extra` changes. cover: Option, /// Mesh the sections for drawing (false on a server thread). pub mesh: bool, /// The pregeneration band (`set_band`). band: Option, /// The columns and the next row the band's decoration ranks were given /// for (`set_band`). band_ranked: Option<(i32, i32, i32)>, } /// Snapshot only after a scan found no missing candidates. Public range fields /// and `World::chunks` can change without going through Streaming, so compare /// their values and structural membership token rather than a frame timeout. #[derive(Default)] struct GenerationScan { exhausted: bool, center: (i32, i32), radius: i32, extra: Vec<((i32, i32), i32)>, forced: HashSet<(i32, i32)>, band: Option, chunk_revision: u64, } impl GenerationScan { fn unchanged(&self, ranges: &Ranges<'_>, world: &World) -> bool { self.exhausted && self.center == ranges.center && self.radius == ranges.radius && self.extra == ranges.extra && self.forced == *ranges.forced && self.band.as_ref() == ranges.band && self.chunk_revision == world.chunks.membership_revision() } fn remember(&mut self, ranges: Ranges<'_>, world: &World) { self.exhausted = true; self.center = ranges.center; self.radius = ranges.radius; self.extra.clear(); self.extra.extend_from_slice(ranges.extra); self.forced.clone_from(ranges.forced); self.band = ranges.band.copied(); self.chunk_revision = world.chunks.membership_revision(); } } struct GenerationInputs<'a> { ranges: Ranges<'a>, world: &'a World, generating: &'a FxHashSet<(i32, i32)>, protos: &'a FxHashMap<(i32, i32), Option>, finishing: &'a FxHashSet<(i32, i32)>, decorates: bool, remote: bool, loading: bool, } impl GenerationScan { /// None means the scan was skipped; Some preserves the original candidate /// ordering and bounded batch, including an empty exhausted scan. fn candidates( &mut self, input: GenerationInputs<'_>, capacity: usize, ) -> Option> { // Generation (load or proto), closest first, bounded in flight. let (margin, reach) = Ranges::margins(input.decorates); if input.remote || input.generating.len() >= capacity || self.unchanged(&input.ranges, input.world) { return None; } { let mut wanted = Vec::new(); // Each area's square of columns, as one run per row. Players' // areas overlap (a server's players often stand together), so // the runs of a row are merged and each column is looked at once. let mut runs: Vec<(i32, i32, i32)> = Vec::new(); for (center, radius) in std::iter::once((input.ranges.center, input.ranges.radius)) .chain(input.ranges.extra.iter().copied()) { let r = radius + margin.max(reach + 1); runs.extend((center.1 - r..=center.1 + r).map(|z| (z, center.0 - r, center.0 + r))); } if let Some(band) = input.ranges.band { let r = margin.max(reach + 1); runs.extend((band.z0 - r..=band.z1 + r).map(|z| (z, band.x0 - r, band.x1 + r))); } runs.sort_unstable(); let mut runs = runs.into_iter().peekable(); while let Some((z, x0, mut x1)) = runs.next() { while let Some((_, _, next_x1)) = runs.next_if(|&(nz, nx0, _)| nz == z && nx0 <= x1.saturating_add(1)) { x1 = x1.max(next_x1); } for x in x0..=x1 { if !input.ranges.requested(x, z, input.decorates) || input.world.chunks.contains_key(&(x, z)) || input.generating.contains(&(x, z)) || input.protos.contains_key(&(x, z)) || input.finishing.contains(&(x, z)) { continue; } wanted.push((input.ranges.priority(x, z, input.loading), x, z)); } } // Forced chunks and their generation neighbourhood. let reach = margin - 1; for &(fx, fz) in input.ranges.forced { for dz in -reach..=reach { for dx in -reach..=reach { let (x, z) = (fx + dx, fz + dz); if input.world.chunks.contains_key(&(x, z)) || input.generating.contains(&(x, z)) || input.protos.contains_key(&(x, z)) || input.finishing.contains(&(x, z)) { continue; } wanted.push((input.ranges.priority(x, z, input.loading), x, z)); } } } if wanted.is_empty() { let ranges = Ranges { center: input.ranges.center, radius: input.ranges.radius, extra: input.ranges.extra, forced: input.ranges.forced, cover: input.ranges.cover, band: input.ranges.band, }; self.remember(ranges, input.world); } else { // A bounded batch may leave candidates behind. Keep scanning // as capacity opens, even if no range or membership changed. self.exhausted = false; } wanted.sort_unstable(); wanted.dedup(); wanted.truncate(capacity - input.generating.len()); Some(wanted) } } } pub struct WorkerContext { pub assets: Arc, pub render: Arc, pub tables: Arc, pub biomes: Arc, pub light: Arc, } impl Streaming { pub fn new( generator: Arc, context: Arc, threads: usize, ) -> Self { let shared = Arc::new(Shared { queue: Mutex::new(BinaryHeap::new()), ready: Condvar::new(), stop: AtomicBool::new(false), context: RwLock::new(context.clone()), }); let (send, results) = mpsc::channel(); let light_tables = context.light.clone(); let saves: Arc = generator.clone(); let threads = (0..threads.max(1)) .map(|i| { let shared = shared.clone(); let send = send.clone(); let generator = generator.clone(); let light = context.light.clone(); thread::Builder::new() .name(format!("horizon-worker-{i}")) .spawn(move || { // Ticks and frames come first (horizon_threads). horizon_threads::behind_server(); let mut worker = generator.worker(); // The face visibility table and its occlusion cache stay with // the worker across mesh jobs, like vanilla's per-thread cache: // cloning it per job copied every state and face shape. let mut faces: Option<(Arc, FaceVisibility)> = None; loop { let job = { let mut queue = shared.queue.lock().unwrap(); loop { if shared.stop.load(Ordering::Relaxed) { return; } if let Some(job) = queue.pop() { break job.job; } queue = shared.ready.wait(queue).unwrap(); } }; let done = match job { Job::Generate(x, z) => match generator.load(x, z) { Some(chunk) => { generator.prepare_loaded(&mut worker, &chunk); Done::Generated(chunk) } None => { let proto = generator.proto(&mut worker, x, z); let decorated = generator.is_decorated(&proto); Done::Proto(x, z, proto, decorated) } }, Job::Decorate(x, z, mut region) => { generator.decorate(&mut worker, &mut region); Done::Decorated(x, z, region) } Job::Finish(proto) => Done::Generated(generator.finish(proto)), Job::Save(protos) => { let refs: Vec<&Proto> = protos.iter().map(|(_, p)| p).collect(); generator.save_protos(&refs); Done::Saved(protos) } Job::Light(x, z, region, seq, sky) => { Done::Lit(x, z, light_chunk(&borrow(®ion), &light, sky), seq) } Job::Mesh(x, sy, z, region, seq, settings) => { let context = shared.context.read().unwrap().clone(); let visibility = match faces.take() { Some((tables, visibility)) if Arc::ptr_eq(&tables, &context.tables) => { visibility } _ => context.tables.visibility.clone(), }; let mut mesher = Mesher { nether_shading: settings.nether, zoom: settings.zoom, blend_radius: settings.blend_radius, smooth_lighting: settings.smooth_lighting, cutout_leaves: settings.cutout_leaves, assets: &context.assets, render: &context.render, tables: &context.tables, biomes: &context.biomes, visibility, }; let mut mesh = mesher.mesh(&borrow(®ion), sy); mesh.sort_solid(); faces = Some((context.tables.clone(), mesher.visibility)); Done::Meshed(x, sy, z, mesh, seq) } }; if send.send(done).is_err() { return; } } }) .expect("spawn worker") }) .collect(); Self { shared, results, threads, order: 0, generating: Default::default(), generation_scan: GenerationScan::default(), protos: Default::default(), decorated: Default::default(), decorating: 0, saving: 0, decoration_order: DecorationOrder::default(), order_area: None, queue_basis: Default::default(), finishing: Default::default(), decorates: generator.decorates(), lighting: Default::default(), meshing: Default::default(), lit: Default::default(), meshed: Default::default(), waiting: Default::default(), waiting_area: ((0, 0), 0, 0), written: Default::default(), saves, deferred: Vec::new(), sequence: 0, center: (0, 0), radius: 8, forced: HashSet::new(), paused: false, loading: false, sky_light: true, nether_shading: false, biome_zoom: BiomeZoom::new(0), biome_blend: 2, smooth_lighting: true, cutout_leaves: true, light_tables, light_log: Vec::new(), light_edit_sequence: 0, light_snapshots: Default::default(), generated_total: 0, meshed_total: 0, remote: false, extra: Vec::new(), cover: None, mesh: true, band: None, band_ranked: None, } } /// Shares generation resources, but gives distant work its own worker state. pub fn lod_source(&self) -> Arc { self.saves.clone() } /// Resource packs reloaded (`LevelRenderer.allChanged`): mesh with the new /// models and sprites, and rebuild every loaded section. Meshes in flight /// were made with the old resources; their results are dropped. pub fn reload_resources(&mut self, world: &mut World, context: Arc) { *self.shared.context.write().unwrap() = context; self.meshing.clear(); for &(x, z) in world.chunks.keys() { if self.lit.contains(&(x, z)) { for sy in 0..SECTIONS as i32 { world.dirty_sections.insert((x, sy, z)); } } } } /// A column received from a server, with the light it sent /// (`ClientPacketListener.handleLevelChunkWithLight`): nothing is /// relit, and it and its neighbours remesh (`enableChunkLight`). pub fn insert_remote(&mut self, world: &mut World, chunk: Chunk) { let key = (chunk.x, chunk.z); self.lighting.remove(&key); self.light_snapshots.remove(&key); world.chunks.insert(key, Arc::new(chunk)); self.lit.insert(key); self.generated_total += 1; for dz in -1..=1 { for dx in -1..=1 { for sy in 0..SECTIONS as i32 { world.dirty_sections.insert((key.0 + dx, sy, key.1 + dz)); } } } } /// A server's light update for a resident column: the sections whose /// light changed and their neighbours remesh /// (`setSectionDirtyWithNeighbors`). pub fn light_updated(world: &mut World, x: i32, z: i32, sections: &[usize]) { for &sy in sections { for dz in -1..=1 { for dy in -1..=1 { for dx in -1..=1 { let s = sy as i32 + dy; if (0..SECTIONS as i32).contains(&s) { world.dirty_sections.insert((x + dx, s, z + dz)); } } } } } } /// A column the server unloaded (ClientboundForgetLevelChunkPacket). pub fn forget(&mut self, world: &mut World, x: i32, z: i32) -> Option> { self.lit.remove(&(x, z)); self.meshed.remove(&(x, z)); self.lighting.remove(&(x, z)); // By key, not by a pass over every pending section: a moved or // shrunk storage forgets thousands of columns in one frame. for sy in 0..SECTIONS as i32 { self.meshing.remove(&(x, sy, z)); self.waiting.remove(&(x, sy, z)); } world.dirty_sections.take_column(x, z); world.chunks.remove(&(x, z)) } /// Queue a job for the column `at`, nearest first: its distance (`distance`) /// times four plus `bias`, which orders a column's jobs. A job without a /// column (a save) goes ahead of every other. fn submit(&mut self, at: Option<(i32, i32)>, bias: i64, job: Job) { self.order += 1; let priority = at.map_or(i64::MIN, |(x, z)| self.distance(x, z) * 4 + bias); self.shared.queue.lock().unwrap().push(Queued { priority, at, bias, order: self.order, job, }); self.shared.ready.notify_one(); } /// Rank the queued jobs again when what their priorities were computed /// from changed: the centre, the extra areas, the band, or the loading /// screen (ring order, `Ranges::rings`, whose values are far above the /// distances used after it). Vanilla's chunk task queue follows the /// current ticket levels in the same way. Without it, generation queued /// while the loading screen was up waited behind every job queued after /// it, and with it the decoration of the chunks around the player: at /// render distance 32 nothing was decorated until every proto chunk had /// been generated. fn requeue(&mut self) { let basis = (self.center, self.loading, self.band); if self.queue_basis.0 == basis && self.queue_basis.1 == self.extra { return; } self.queue_basis = (basis, self.extra.clone()); let mut queue = self.shared.queue.lock().unwrap(); rank_again(&mut queue, |x, z| self.distance(x, z)); } fn receive_decorated(&mut self, x: i32, z: i32, region: [Proto; 9]) { self.generation_scan.exhausted = false; self.decorating -= 1; self.decorated.insert((x, z)); for (i, proto) in region.into_iter().enumerate() { let key = (x + (i % 3) as i32 - 1, z + (i / 3) as i32 - 1); self.protos.insert(key, Some(proto)); self.written.insert(key); } } /// Saved proto chunks come back; those now out of range are dropped by /// the next `update`. fn receive_saved(&mut self, protos: Vec<((i32, i32), Proto)>) { self.generation_scan.exhausted = false; self.saving -= 1; for (key, proto) in protos { self.protos.insert(key, Some(proto)); } } /// Check out the proto chunks at `keys` and save them on a worker. fn save_checked_out(&mut self, keys: impl IntoIterator) { let protos: Vec<((i32, i32), Proto)> = keys .into_iter() .filter_map(|k| Some((k, self.protos.get_mut(&k)?.take()?))) .collect(); if !protos.is_empty() { self.saving += 1; // Ahead of every other job: a column generated again meanwhile // would not find them saved. self.submit(None, 0, Job::Save(protos)); } } fn receive_generated(&mut self, mut chunk: Chunk, world: &mut World) { self.generation_scan.exhausted = false; let key = (chunk.x, chunk.z); self.generating.remove(&key); self.finishing.remove(&key); self.decorated.insert(key); // A column that finished after the player moved away is dropped // whole: its block entities and saved entities too, or they would // stay in the world (and the entities spawn again, duplicated, when // the column loads later). A generated one is saved first: its // neighbours were decorated around it, so generating it again would // not give it back. if !self.ranges().chunk_kept(key.0, key.1, self.decorates) { if chunk.fresh { self.saves.save_finished(chunk); } return; } // Generated columns are saved like edited ones, as vanilla saves // every chunk it generates. if chunk.fresh { world.modified.insert(key); } world .block_entities .load_chunk(std::mem::take(&mut chunk.block_entities)); world .block_names .extend(std::mem::take(&mut chunk.block_names)); let entities = std::mem::take(&mut chunk.entities); if !entities.is_empty() { world.loaded_entities.push(((chunk.x, chunk.z), entities)); } self.generated_total += 1; // A chunk saved with its light needs no light job; its unlit // neighbours still light themselves from it. let loaded = chunk.light_loaded; world.chunks.insert(key, Arc::new(chunk)); if loaded { self.lit.insert(key); for sy in 0..SECTIONS as i32 { world.dirty_sections.insert((key.0, sy, key.1)); } } for dz in -1..=1 { for dx in -1..=1 { let n = (key.0 + dx, key.1 + dz); if !loaded || world.chunks.get(&n).is_some_and(|c| !c.light_loaded) { world.dirty_light.insert(n); } } } } /// The order jobs around the player run in, lowest first. fn distance(&self, x: i32, z: i32) -> i64 { self.ranges().priority(x, z, self.loading) } fn region(world: &World, x: i32, z: i32) -> Option> { let mut region: Region = Default::default(); for dz in 0..3 { for dx in 0..3 { region[dz][dx] = Some( world .chunks .get(&(x + dx as i32 - 1, z + dz as i32 - 1))? .clone(), ); } } Some(Box::new(region)) } pub fn is_lit(&self, x: i32, z: i32) -> bool { self.lit.contains(&(x, z)) } /// `ChunkMap.getLatestStatus` for the loading screen's chunk map: the /// furthest step this column has reached, `None` before it is asked for. pub fn latest_status( &self, world: &World, x: i32, z: i32, ) -> Option { use crate::level_loading::Status; let key = (x, z); Some(if self.lit.contains(&key) { Status::Full } else if world.chunks.contains_key(&key) { Status::InitializeLight } else if self.decorated.contains(&key) || self.finishing.contains(&key) { Status::Features } else if self.protos.contains_key(&key) { Status::Terrain } else if self.generating.contains(&key) { Status::Empty } else { return None; }) } pub fn is_meshing(&self, section: (i32, i32, i32)) -> bool { self.meshing.contains_key(§ion) } pub fn pending(&self) -> usize { self.shared.queue.lock().unwrap().len() } /// Whether any chunk is queued or on its way from generation to a mesh. pub fn busy(&self) -> bool { !(self.generating.is_empty() && self.decorating == 0 && self.finishing.is_empty() && self.lighting.is_empty() && self.meshing.is_empty() && self.pending() == 0) } /// How much work each stage holds: queued jobs, then what is in flight or /// waiting at each step from generation to meshing. pub fn stages(&self) -> [(&'static str, usize); 7] { [ ("queued", self.pending()), ("generating", self.generating.len()), ( "protos", self.protos.values().filter(|p| p.is_some()).count(), ), ("decorating", self.decorating), ("finishing", self.finishing.len()), ("lighting", self.lighting.len()), ("meshing", self.meshing.len()), ] } /// Advance streaming: collect finished work, then schedule more. /// Returns meshes ready for upload and columns that were unloaded. pub fn update( &mut self, world: &mut World, ) -> (Vec<((i32, i32, i32), SectionMesh)>, Vec>) { let mut uploads = Vec::new(); if self.paused { return (uploads, Vec::new()); } ExtraCover::refresh(&mut self.cover, &self.extra); self.requeue(); self.relight_edits(world); let deferred = std::mem::take(&mut self.deferred); let received = std::iter::from_fn(|| self.results.try_recv().ok()); for done in deferred.into_iter().chain(received.collect::>()) { match done { Done::Proto(x, z, proto, decorated) => { self.generation_scan.exhausted = false; self.generating.remove(&(x, z)); if self.in_range(x, z, 4) || self.near_finished(x, z, 2) { self.protos.insert((x, z), Some(proto)); if decorated || !self.decorates { self.decorated.insert((x, z)); } } } Done::Decorated(x, z, region) => self.receive_decorated(x, z, *region), Done::Generated(chunk) => self.receive_generated(chunk, world), Done::Saved(protos) => self.receive_saved(protos), Done::Lit(x, z, sections, seq) => { if self.lighting.get(&(x, z)) != Some(&seq) { continue; } self.lighting.remove(&(x, z)); let snapshot = self.light_snapshots.remove(&(x, z)).unwrap_or(u64::MAX); if let Some(chunk) = world.chunks.get_mut(&(x, z)) { let chunk = Arc::make_mut(chunk); // Keep blocks edited since the snapshot; take only light. // A chunk relit (a neighbour loaded or changed) remeshes // only around the light that changed, as vanilla's light // updates dirty only their sections (#270). let first = self.lit.insert((x, z)); let mut changed = LightChanges::default(); if first { apply_lighting(chunk, sections); } else { apply_relighting(chunk, sections, &mut changed); } chunk.lit = true; if first { for dz in -1..=1 { for dx in -1..=1 { for sy in 0..SECTIONS as i32 { world.dirty_sections.insert((x + dx, sy, z + dz)); } } } } else { Self::mark_light_changes(world, &changed); } self.replay_light_edits(world, x, z, snapshot); } } Done::Meshed(x, sy, z, mesh, seq) => { if self.meshing.get(&(x, sy, z)) != Some(&seq) { continue; } // Its column unloaded while it was meshed: nothing would // ever remove the uploaded section. if !world.chunks.contains_key(&(x, z)) { self.meshing.remove(&(x, sy, z)); continue; } self.meshing.remove(&(x, sy, z)); self.meshed_total += 1; uploads.push(((x, sy, z), mesh)); } } } // Unload far columns. let far: Vec<_> = world .chunks .keys() .copied() .filter(|&(x, z)| !self.remote && self.ranges().unloaded(x, z, self.decorates)) .collect(); for key in &far { self.decorated.remove(key); } let mut removed = Vec::with_capacity(far.len()); for key in &far { if let Some(chunk) = world.chunks.remove(key) { removed.push(chunk); } self.lit.remove(key); self.meshed.remove(key); self.lighting.remove(key); self.light_snapshots.remove(key); } if !far.is_empty() { let far: HashSet<(i32, i32)> = far.iter().copied().collect(); self.meshing.retain(|k, _| !far.contains(&(k.0, k.2))); self.waiting.retain(|k| !far.contains(&(k.0, k.2))); world .dirty_sections .retain_columns(|x, z| !far.contains(&(x, z))); } // Drop far proto chunks that are not checked out. let (center, r4) = (self.center, i64::from(self.radius + 4)); let ranges = self.ranges(); let far: Vec<(i32, i32)> = self .protos .iter() .filter(|&(&(x, z), p)| { p.is_some() && i64::from(x - center.0).pow(2) + i64::from(z - center.1).pow(2) > r4 * r4 && !ranges.in_extra(x, z, 4) && !ranges.in_band(x, z, 4) && !ranges .forced .iter() .any(|f| (x - f.0).abs() <= 3 && (z - f.1).abs() <= 3) }) .map(|(k, _)| *k) .collect(); if !far.is_empty() { self.generation_scan.exhausted = false; } // Those decoration wrote to are saved first (see // `ChunkGenerator::save_protos`), and dropped once back. let mut written = Vec::new(); for key in far { if self.written.remove(&key) { written.push(key); } else { self.protos.remove(&key); } } self.save_checked_out(written); let (protos, finishing) = (&self.protos, &self.finishing); self.decorated.retain(|k| { protos.contains_key(k) || finishing.contains(k) || world.chunks.contains_key(k) }); // Finalize chunks whose neighbourhood is decorated. let candidates: Vec<(i32, i32)> = self.protos.keys().copied().collect(); for (x, z) in candidates { if world.chunks.contains_key(&(x, z)) || self.finishing.contains(&(x, z)) || !self.in_range(x, z, 1) { continue; } let ready = (-1..=1).all(|dz| { (-1..=1).all(|dx| { self.decorated.contains(&(x + dx, z + dz)) || world.chunks.contains_key(&(x + dx, z + dz)) }) }); if ready && let Some(Some(_)) = self.protos.get(&(x, z)) { let proto = self .protos .remove(&(x, z)) .flatten() .expect("present proto"); self.finishing.insert((x, z)); self.written.remove(&(x, z)); self.submit(Some((x, z)), 0, Job::Finish(proto)); } } // Decorate chunks whose 3x3 proto neighbourhood is available, in // vanilla's order: decoration is order dependent where write regions // overlap (see `DecorationOrder`). let workers = self.threads.len(); if self.decorates && self.order_area != Some((self.center, self.radius)) { let (decorated, chunks) = (&self.decorated, &world.chunks); // The render distance is the server view distance in singleplayer. self.decoration_order .reassign(self.center, self.radius, |x, z| { decorated.contains(&(x, z)) || chunks.contains_key(&(x, z)) }); self.order_area = Some((self.center, self.radius)); let ranges = Ranges { center: self.center, radius: self.radius, extra: &self.extra, forced: &self.forced, cover: ExtraCover::matching(&self.cover, &self.extra), band: self.band.as_ref(), }; let (protos, generating) = (&self.protos, &self.generating); self.decoration_order.retain(|x, z| { ranges.in_range(x, z, 4) || ranges.near_finished(x, z, 2) || protos.contains_key(&(x, z)) || generating.contains(&(x, z)) }); } if self.decorates && self.decorating < workers * 2 { let wants = |s: &Self, x: i32, z: i32| { !s.decorated.contains(&(x, z)) && !world.chunks.contains_key(&(x, z)) && (s.in_range(x, z, 2) || s.near_finished(x, z, 1)) }; // A wanted chunk holds back higher-ranked ones only if it can be // decorated: its 3x3 neighbourhood is (or will be) generated as // protos, none of them already final. let waits_for = |s: &Self, x: i32, z: i32| { wants(s, x, z) && (-1..=1).all(|dz| { (-1..=1).all(|dx| { let n = (x + dx, z + dz); !world.chunks.contains_key(&n) && (s.protos.contains_key(&n) || s.generating.contains(&n) || s.ranges().requested(n.0, n.1, true)) }) }) }; let keys: Vec<(i32, i32)> = self .protos .iter() .filter(|(k, p)| p.is_some() && wants(self, k.0, k.1)) .map(|(k, _)| *k) .collect(); let mut wanted: Vec<(u64, i64, i32, i32)> = keys .into_iter() .map(|(x, z)| (0, self.distance(x, z), x, z)) .collect(); // Chunks no ticket reached (forced and extra areas) go last, nearest first. wanted.sort_unstable_by_key(|w| w.1); for w in &mut wanted { w.0 = self.decoration_order.rank_or_append(w.2, w.3); } wanted.sort_unstable(); for (_, _, x, z) in wanted { if self.decorating >= workers * 2 { break; } if self .decoration_order .blocked(x, z, |nx, nz| waits_for(self, nx, nz)) { continue; } let keys: Vec<(i32, i32)> = (0..9).map(|i| (x + (i % 3) - 1, z + (i / 3) - 1)).collect(); // A final neighbour cannot receive writes: skip decoration. Only // worlds saved before proto chunks were saved get here (their // final chunks' neighbours are generated again). if keys.iter().any(|k| world.chunks.contains_key(k)) { self.decorated.insert((x, z)); continue; } if !keys .iter() .all(|k| matches!(self.protos.get(k), Some(Some(_)))) { continue; } let region: Vec = keys .iter() .map(|k| { self.protos .insert(*k, None) .flatten() .expect("present proto") }) .collect(); let region: Box<[Proto; 9]> = match region.try_into() { Ok(r) => Box::new(r), Err(_) => continue, }; self.decorating += 1; self.submit(Some((x, z)), 1, Job::Decorate(x, z, region)); } } self.schedule_generation(world, workers); // Lighting once all neighbours exist. let light: Vec<_> = world.dirty_light.iter().copied().collect(); for (x, z) in light { if !world.chunks.contains_key(&(x, z)) { world.dirty_light.remove(&(x, z)); continue; } let Some(region) = Self::region(world, x, z) else { continue; }; world.dirty_light.remove(&(x, z)); self.sequence += 1; self.lighting.insert((x, z), self.sequence); self.light_snapshots .insert((x, z), self.light_edit_sequence); self.submit( Some((x, z)), 1, Job::Light(x, z, region, self.sequence, self.sky_light), ); } // A server draws nothing: its sections are never meshed. if !self.mesh { world.dirty_sections.clear(); return (uploads, removed); } // Meshing once the column and its neighbours are lit, and the column // is within the render distance (`in_view_distance`, the columns // vanilla draws). Sections set aside past it come back // when the player moves: a column that loads with its light gets no // other request (#228). let area = (self.center, self.radius, self.forced.len()); if self.waiting_area != area { self.waiting_area = area; let ranges = Ranges { center: self.center, radius: self.radius, extra: &self.extra, forced: &self.forced, cover: ExtraCover::matching(&self.cover, &self.extra), band: self.band.as_ref(), }; self.waiting.retain(|&(x, sy, z)| { let back = ranges.in_view(x, z); if back { world.dirty_sections.insert((x, sy, z)); } !back }); } // Column by column: the checks below hold for all of a column's // sections, and columns waiting for light cost one look per frame. let columns: Vec<_> = world.dirty_sections.columns().collect(); for ((x, z), sections) in columns { if !world.chunks.contains_key(&(x, z)) { world.dirty_sections.take_column(x, z); continue; } if !self.ranges().in_view(x, z) { world.dirty_sections.take_column(x, z); for sy in section_indexes(sections) { self.waiting.insert((x, sy, z)); } continue; } // A neighbour being lit dirties this column again when its light // job finishes (new chunks relight their eight neighbours), so // wait for it rather than mesh once per neighbour. Columns still // in `dirty_light` here can't be lit yet (a neighbour of theirs is // missing): waiting for them could last until the player comes // back. let ready = (-1..=1).all(|dz| { (-1..=1).all(|dx| { let n = (x + dx, z + dz); self.lit.contains(&n) && !self.lighting.contains_key(&n) }) }); if !ready { continue; } let Some(region) = Self::region(world, x, z) else { continue; }; world.dirty_sections.take_column(x, z); for sy in section_indexes(sections) { let first = self.meshed.insert((x, z)); self.sequence += 1; self.meshing.insert((x, sy, z), self.sequence); self.submit( Some((x, z)), if first { 2 } else { 0 }, Job::Mesh( x, sy, z, region.clone(), self.sequence, MeshSettings { nether: self.nether_shading, zoom: self.biome_zoom, blend_radius: self.biome_blend, smooth_lighting: self.smooth_lighting, cutout_leaves: self.cutout_leaves, }, ), ); } } (uploads, removed) } fn schedule_generation(&mut self, world: &World, workers: usize) { let input = GenerationInputs { ranges: Ranges { center: self.center, radius: self.radius, extra: &self.extra, forced: &self.forced, cover: ExtraCover::matching(&self.cover, &self.extra), band: self.band.as_ref(), }, world, generating: &self.generating, protos: &self.protos, finishing: &self.finishing, decorates: self.decorates, remote: self.remote, loading: self.loading, }; if let Some(wanted) = self.generation_scan.candidates(input, workers * 3) { for (_, x, z) in wanted { self.generating.insert((x, z)); self.submit(Some((x, z)), 0, Job::Generate(x, z)); } } } /// Relight block edits on lit chunks in place (vanilla's incremental light /// engine) instead of recomputing the 3x3 chunks around each edit. fn relight_edits(&mut self, world: &mut World) { if world.light_edits.is_empty() { return; } let edits = std::mem::take(&mut world.light_edits); let positions: Vec<(i32, i32, i32)> = edits .iter() .filter(|(_, old, new)| self.light_tables.differs(*old, *new)) .map(|(p, _, _)| *p) .collect(); if positions.is_empty() { return; } let mut changed = LightChanges::default(); crate::light::relight( &mut world.chunks, &self.light_tables, self.sky_light, &positions, false, &mut changed, ); Self::mark_light_changes(world, &changed); if !self.light_snapshots.is_empty() { for p in positions { self.light_edit_sequence += 1; self.light_log.push((self.light_edit_sequence, p)); } } } /// A light job computed from blocks older than some edits: redo those /// edits on top of its result. fn replay_light_edits(&mut self, world: &mut World, x: i32, z: i32, snapshot: u64) { let positions: Vec<(i32, i32, i32)> = self .light_log .iter() .filter(|(seq, p)| { *seq > snapshot && ((p.0 >> 4) - x).abs() <= 1 && ((p.2 >> 4) - z).abs() <= 1 }) .map(|(_, p)| *p) .collect(); if !positions.is_empty() { let mut changed = LightChanges::default(); crate::light::relight( &mut world.chunks, &self.light_tables, self.sky_light, &positions, true, &mut changed, ); Self::mark_light_changes(world, &changed); } let oldest = self.light_snapshots.values().copied().min(); match oldest { Some(oldest) => self.light_log.retain(|(seq, _)| *seq > oldest), None => self.light_log.clear(), } } /// Sections whose meshes sample a changed light value (faces and corners /// read light from neighbouring blocks). fn mark_light_changes(world: &mut World, changed: &LightChanges) { if let Some(log) = &mut world.light_log { for (x, sy, z) in changed.sections() { *log.entry((x, z)).or_default() |= 1 << sy; } } changed.dirty_sections(|section| { world.dirty_sections.insert(section); }); } fn ranges(&self) -> Ranges<'_> { Ranges { center: self.center, radius: self.radius, extra: &self.extra, forced: &self.forced, cover: ExtraCover::matching(&self.cover, &self.extra), band: self.band.as_ref(), } } fn near_finished(&self, x: i32, z: i32, reach: i32) -> bool { self.ranges().near_finished(x, z, reach) } /// Save what generation holds outside the world: the proto chunks /// decoration wrote to. With `wait`, the decorations, columns and saves /// in flight are waited for first (their proto chunks are out in the /// jobs) and the protos are saved here, before the world's chunks; /// otherwise a worker saves them (vanilla's autosave hands its chunks to /// the IOWorker too), and those out in jobs are saved later, as they /// unload or at the next save. pub fn save(&mut self, world: &mut World, wait: bool) { if !wait { let written: Vec<(i32, i32)> = self.written.drain().collect(); self.save_checked_out(written); return; } let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30); while self.decorating > 0 || !self.finishing.is_empty() || self.saving > 0 { let left = deadline.saturating_duration_since(std::time::Instant::now()); match self.results.recv_timeout(left) { Ok(Done::Decorated(x, z, region)) => self.receive_decorated(x, z, *region), Ok(Done::Generated(chunk)) => self.receive_generated(chunk, world), Ok(Done::Saved(protos)) => self.receive_saved(protos), Ok(other) => self.deferred.push(other), Err(_) => { log::warn!("Horizon: chunk generation did not finish before saving"); break; } } } let protos: Vec<&Proto> = self .written .iter() .filter_map(|k| self.protos.get(k)?.as_ref()) .collect(); if !protos.is_empty() { self.saves.save_protos(&protos); } self.written.clear(); } /// Finish generation for a closing world without waiting on the event /// loop. No new generation is scheduled while the save screen is shown. /// Proto snapshots are checked out to workers before chunk writes, just as /// in `save(true)`, so older generation cannot overwrite the final chunks. pub fn poll_save(&mut self, world: &mut World) -> bool { let started = std::time::Instant::now(); while let Ok(done) = self.results.try_recv() { match done { Done::Decorated(x, z, region) => self.receive_decorated(x, z, *region), Done::Generated(chunk) => self.receive_generated(chunk, world), Done::Saved(protos) => self.receive_saved(protos), other => self.deferred.push(other), } if started.elapsed() >= std::time::Duration::from_millis(2) { return false; } } if self.decorating > 0 || !self.finishing.is_empty() || self.saving > 0 { return false; } let written: Vec<_> = self.written.drain().collect(); self.save_checked_out(written); self.saving == 0 } fn in_range(&self, x: i32, z: i32, margin: i32) -> bool { self.ranges().in_range(x, z, margin) } pub fn band(&self) -> Option { self.band } /// Generate, light and keep the chunks of `band` (none: stop), and let /// go of what earlier bands held as it falls out of range. The chunks a /// band reaches are ranked for decoration row by row, as they first come /// within reach, so that a task decorates in the same order however its /// work is timed and shared among the workers. pub fn set_band(&mut self, band: Option) { if self.band == band { return; } self.band = band; self.generation_scan.exhausted = false; let Some(band) = band else { return; }; // Decoration reaches two chunks past the band and generation three. const REACH: i32 = 4; let (x0, x1) = (band.x0 - REACH, band.x1 + REACH); let first = match self.band_ranked { Some((rx0, rx1, next)) if (rx0, rx1) == (x0, x1) => next, _ => band.z0 - REACH, }; let end = band.z1 + REACH; for z in first..=end { for x in x0..=x1 { self.decoration_order.rank_or_append(x, z); } } self.band_ranked = Some((x0, x1, end.max(first - 1) + 1)); } /// What holds up the columns `keys`, for a task that stopped advancing: /// how many are not loaded, loaded but unlit with a light job in flight, /// and unlit with none (those whose neighbours are all loaded are queued /// for light again). pub fn unstick_light(&mut self, world: &mut World, keys: &[(i32, i32)]) -> [usize; 3] { let mut counts = [0; 3]; for &key in keys { if !world.chunks.contains_key(&key) { counts[0] += 1; } else if self.lit.contains(&key) { } else if self.lighting.contains_key(&key) { counts[1] += 1; } else { counts[2] += 1; if Self::region(world, key.0, key.1).is_some() { world.dirty_light.insert(key); } } } counts } /// Wait up to `timeout` for a worker to finish a job; the next `update` /// takes it. A server pumps generation with this between its ticks. pub fn wait(&mut self, timeout: std::time::Duration) { if let Ok(done) = self.results.recv_timeout(timeout) { self.deferred.push(done); } } } /// `ChunkTrackingView.isInViewDistance`: whether the column (x, z) is drawn /// at this render distance around `center`, the camera's column /// (`SectionOcclusionGraph.isInViewDistance`). Each axis gets a column of /// slack, so this reaches past the circle of `radius` columns. pub fn in_view_distance(center: (i32, i32), radius: i32, x: i32, z: i32) -> bool { let gap = |d: i32| i64::from((d.abs() - 1).max(0)); let (dx, dz) = (gap(x - center.0), gap(z - center.1)); dx * dx + dz * dz < i64::from(radius) * i64::from(radius) } /// The areas kept loaded: circles around the player and `extra`, and forced chunks. struct Ranges<'a> { center: (i32, i32), radius: i32, extra: &'a [((i32, i32), i32)], forced: &'a HashSet<(i32, i32)>, /// `extra` as a grid, when one was made for it: `in_extra` without a /// scan of every area. cover: Option<&'a ExtraCover>, band: Option<&'a Band>, } /// The chunks a pregeneration task (`/pregen`) wants lit now: rows `z0..=z1` /// of the columns `x0..=x1`, those within `circle` (a centre and a radius in /// chunks) when there is one. Like an extra area, it finishes its chunks and /// the ring around them, so that its own chunks can be lit, and generation /// reaches past that. A task moves it down a strip of columns a row at a /// time, so each chunk is generated once and only the rows in flight stay /// loaded. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Band { pub x0: i32, pub x1: i32, pub z0: i32, pub z1: i32, pub circle: Option<((i32, i32), i32)>, } impl Band { /// Whether (x, z) lies within `margin` (Chebyshev) of one of the band's /// chunks: the square of side `2 * margin + 1` around it meets the /// rectangle at a point inside the circle. pub fn within(&self, x: i32, z: i32, margin: i32) -> bool { let (x0, x1) = ( x.saturating_sub(margin).max(self.x0), x.saturating_add(margin).min(self.x1), ); let (z0, z1) = ( z.saturating_sub(margin).max(self.z0), z.saturating_add(margin).min(self.z1), ); if x0 > x1 || z0 > z1 { return false; } self.circle.is_none_or(|((cx, cz), r)| { let dx = i64::from(cx.clamp(x0, x1)) - i64::from(cx); let dz = i64::from(cz.clamp(z0, z1)) - i64::from(cz); dx * dx + dz * dz <= i64::from(r) * i64::from(r) }) } /// The band's chunks go after the players' (lower runs first), row by /// row, as the task wants them lit. fn priority(&self, x: i32, z: i32) -> i64 { const AFTER_PLAYERS: i64 = 1 << 40; AFTER_PLAYERS + (i64::from(z - self.z0 + 8).max(0) << 20) + i64::from(x - self.x0 + 8).max(0) } } /// For every column near the extra areas, how far it lies outside the /// nearest one's square (Chebyshev distance less its radius; 0 inside). A server has an area per player, and streaming asks of every /// loaded and wanted column whether one reaches it, several times a tick: /// with fifty players, a scan of fifty squares per question. struct ExtraCover { extra: Vec<((i32, i32), i32)>, x0: i32, z0: i32, width: u32, depth: u32, cells: Box<[i8]>, } impl ExtraCover { /// The largest margin the grid answers for; beyond it (and outside the /// grid) a column is further than that from every square. const REACH: i32 = 4; /// The largest grid, in columns (a mebibyte). const CELLS: u64 = 1 << 20; fn matching<'a>( cover: &'a Option, extra: &[((i32, i32), i32)], ) -> Option<&'a ExtraCover> { cover.as_ref().filter(|c| c.extra == extra) } /// Make the grid again if `extra` changed; none for one area or none /// (a scan is as quick), or areas too far apart. fn refresh(cover: &mut Option, extra: &[((i32, i32), i32)]) { if cover.as_ref().is_some_and(|c| c.extra == extra) { return; } *cover = Self::new(extra); } fn new(extra: &[((i32, i32), i32)]) -> Option { if extra.len() < 2 || extra.iter().any(|&(_, r)| !(0..=64).contains(&r)) { return None; } let k = i64::from(Self::REACH); let (mut x0, mut z0, mut x1, mut z1) = (i64::MAX, i64::MAX, i64::MIN, i64::MIN); for &((x, z), r) in extra { let (x, z, r) = (i64::from(x), i64::from(z), i64::from(r) + k); (x0, z0, x1, z1) = (x0.min(x - r), z0.min(z - r), x1.max(x + r), z1.max(z + r)); } let (width, depth) = ((x1 - x0 + 1) as u64, (z1 - z0 + 1) as u64); let fits = |lo: i64, hi: i64| lo >= i64::from(i32::MIN) && hi <= i64::from(i32::MAX); if width * depth > Self::CELLS || !fits(x0, x1) || !fits(z0, z1) { return None; } let (x0, z0, width, depth) = (x0 as i32, z0 as i32, width as u32, depth as u32); let mut cells = vec![(Self::REACH + 1) as i8; (width * depth) as usize].into_boxed_slice(); // Inside a square counts as 0: no margin asked for is below it. Each // row of a square is a run of one value with a slope at either end. let lower = |run: &mut [i8], v: i8| run.iter_mut().for_each(|c| *c = (*c).min(v)); for &((cx, cz), r) in extra { let reach = r + Self::REACH; for dz in -reach..=reach { let start = (cz + dz - z0) as usize * width as usize + (cx - x0) as usize; let row = &mut cells[start - reach as usize..=start + reach as usize]; let flat = dz.abs().max(r); let centre = reach as usize; lower( &mut row[centre - flat as usize..=centre + flat as usize], (flat - r) as i8, ); for d in flat + 1..=reach { let v = (d - r) as i8; lower(&mut row[centre - d as usize..=centre - d as usize], v); lower(&mut row[centre + d as usize..=centre + d as usize], v); } } } Some(Self { extra: extra.to_vec(), x0, z0, width, depth, cells, }) } /// Whether (x, z) is within `margin` of an area's square, for a /// `margin` up to `REACH`. fn within(&self, x: i32, z: i32, margin: i32) -> bool { let (dx, dz) = ( x.wrapping_sub(self.x0) as u32, z.wrapping_sub(self.z0) as u32, ); dx < self.width && dz < self.depth && i32::from(self.cells[(dz * self.width + dx) as usize]) <= margin } } impl Ranges<'_> { /// `distance`, or `rings` while the level loading screen is up. fn priority(&self, x: i32, z: i32, loading: bool) -> i64 { let own = if loading { self.rings(x, z) } else { self.distance(x, z) }; match self.band { Some(band) if band.within(x, z, 4) => own.min(band.priority(x, z)), _ => own, } } /// Ring by ring: the Chebyshev distance to the nearest centre first, then /// the squared distance. Vanilla's chunk tasks run by ticket level, which /// spreads one level per ring of chunks (`ChunkTaskPriorityQueue`), so /// `LevelLoadingScreen`'s chunk map fills squares around the spawn. fn rings(&self, x: i32, z: i32) -> i64 { let d = |c: (i32, i32)| { let (dx, dz) = (i64::from(x - c.0), i64::from(z - c.1)); let ring = dx.abs().max(dz.abs()); (ring * ring) << 20 | (dx * dx + dz * dz) }; self.extra .iter() .map(|(c, _)| d(*c)) .fold(d(self.center), i64::min) } fn distance(&self, x: i32, z: i32) -> i64 { let d = |c: (i32, i32)| { let (dx, dz) = (i64::from(x - c.0), i64::from(z - c.1)); dx * dx + dz * dz }; self.extra .iter() .map(|(c, _)| d(*c)) .fold(d(self.center), i64::min) } /// How far past the view distance chunks are generated, and how far around /// a finished chunk (`near_finished`): decorated chunks need their /// neighbours generated too. fn margins(decorates: bool) -> (i32, i32) { if decorates { (3, 2) } else { (1, 1) } } /// Chunks generation asks for: loaded from the save, or generated as protos. fn requested(&self, x: i32, z: i32, decorates: bool) -> bool { let (margin, reach) = Self::margins(decorates); self.in_range(x, z, margin) || self.near_finished(x, z, reach) } /// Finished columns kept when they arrive: within two of the view distance /// or next to a finished chunk, and every column generation asked for (a /// saved one loads finished; dropping it had it asked for and loaded again /// every frame). fn chunk_kept(&self, x: i32, z: i32, decorates: bool) -> bool { self.in_range(x, z, 2) || self.near_finished(x, z, 1) || self.requested(x, z, decorates) } /// Columns unloaded: past every column kept. fn unloaded(&self, x: i32, z: i32, decorates: bool) -> bool { !self.in_range(x, z, 3) && !self.near_finished(x, z, Self::margins(decorates).1) } /// Whether a chunk finished here (`in_range(_, _, 1)`) lies within `reach` /// chunks of (x, z) on both axes: its decoration needs its 3x3 neighbours /// decorated, which need their own 3x3 neighbours generated. The ranges are /// circles, so a fixed margin alone misses the corners of those squares /// (render distance 2 never finished the chunks next to the player). fn near_finished(&self, x: i32, z: i32, reach: i32) -> bool { let gap = |d: i32| i64::from((d.abs() - reach).max(0)); let (dx, dz) = (gap(x - self.center.0), gap(z - self.center.1)); let r = i64::from(self.radius + 1); // The extra areas are squares: their finished square grown by `reach`. dx * dx + dz * dz <= r * r || self.in_extra(x, z, 1 + reach) || self.in_band(x, z, 1 + reach) } fn in_range(&self, x: i32, z: i32, margin: i32) -> bool { self.in_main_range(x, z, margin) || self.in_extra(x, z, margin) || self.in_band(x, z, margin) } /// Within `margin` of the pregeneration band. fn in_band(&self, x: i32, z: i32, margin: i32) -> bool { self.band.is_some_and(|b| b.within(x, z, margin)) } /// Within `margin` of an extra area's square (Chebyshev distance, as /// vanilla's ticket levels spread). fn in_extra(&self, x: i32, z: i32, margin: i32) -> bool { if let Some(cover) = self.cover && (0..=ExtraCover::REACH).contains(&margin) { return cover.within(x, z, margin); } self.extra .iter() .any(|&(c, radius)| (x - c.0).abs().max((z - c.1).abs()) <= radius + margin) } /// The columns meshed for drawing: those vanilla draws around the /// player (`in_view_distance`), and forced ones. fn in_view(&self, x: i32, z: i32) -> bool { in_view_distance(self.center, self.radius, x, z) || self.forced.contains(&(x, z)) } fn in_main_range(&self, x: i32, z: i32, margin: i32) -> bool { let r = i64::from(self.radius + margin); let (dx, dz) = (i64::from(x - self.center.0), i64::from(z - self.center.1)); if dx * dx + dz * dz <= r * r { return true; } let reach = (margin - 1).max(0); self.forced .iter() .any(|f| (x - f.0).abs() <= reach && (z - f.1).abs() <= reach) } } impl Drop for Streaming { fn drop(&mut self) { // Saves in flight hold proto chunks nothing else would save. let deadline = std::time::Instant::now() + std::time::Duration::from_secs(30); while self.saving > 0 { let left = deadline.saturating_duration_since(std::time::Instant::now()); match self.results.recv_timeout(left) { Ok(Done::Saved(_)) => self.saving -= 1, Ok(_) => {} Err(_) => break, } } self.shared.stop.store(true, Ordering::Relaxed); self.shared.ready.notify_all(); for t in self.threads.drain(..) { let _ = t.join(); } } } /// The section indexes set in a column's bits, lowest first. fn section_indexes(mut bits: u32) -> impl Iterator { std::iter::from_fn(move || { (bits != 0).then(|| { let sy = bits.trailing_zeros() as i32; bits &= bits - 1; sy }) }) } /// The queued jobs' priorities computed again from each one's column /// `distance` (`Streaming::submit`). fn rank_again(queue: &mut BinaryHeap, distance: impl Fn(i32, i32) -> i64) { if queue.is_empty() { return; } let mut jobs = std::mem::take(queue).into_vec(); for job in &mut jobs { if let Some((x, z)) = job.at { job.priority = distance(x, z) * 4 + job.bias; } } *queue = BinaryHeap::from(jobs); } #[cfg(test)] mod tests { use super::*; #[test] fn queued_jobs_follow_the_centre_and_the_loading_screen() { let forced = HashSet::new(); let ranges = |center| Ranges { center, radius: 32, extra: &[], forced: &forced, cover: None, band: None, }; let generate = |x, z, priority, order| Queued { priority, at: Some((x, z)), bias: 0, order, job: Job::Generate(x, z), }; let loading = ranges((0, 0)); let queued = || { BinaryHeap::from(vec![ // Queued while the loading screen was up: ring order. generate(3, 1, loading.priority(3, 1, true) * 4, 1), // Queued after it closed: plain distances, far below any ring past the first. generate(20, 0, loading.priority(20, 0, false) * 4, 2), Queued { priority: i64::MIN, at: None, bias: 0, order: 3, job: Job::Save(Vec::new()), }, ]) }; let pops = |mut queue: BinaryHeap| { std::iter::from_fn(move || queue.pop()) .map(|q| q.at) .collect::>() }; assert_eq!( pops(queued()), [None, Some((20, 0)), Some((3, 1))], "the stale order" ); let mut queue = queued(); rank_again(&mut queue, |x, z| loading.priority(x, z, false)); assert_eq!(pops(queue), [None, Some((3, 1)), Some((20, 0))]); // The player moved: the job near the new centre goes first. let mut queue = BinaryHeap::from(vec![generate(3, 1, 0, 1), generate(20, 0, 1, 2)]); let moved = ranges((19, 0)); rank_again(&mut queue, |x, z| moved.priority(x, z, false)); assert_eq!(queue.pop().and_then(|q| q.at), Some((20, 0))); } #[test] fn view_distance_is_vanillas_shape() { // ChunkTrackingView.isInViewDistance at render distance 12: a column // of slack on each axis, so 533 columns rather than the 441 of a // circle of radius 12. let count = |r: i32| { (-40..=40) .flat_map(|x| (-40..=40).map(move |z| (x, z))) .filter(|&(x, z)| in_view_distance((5, -7), r, x + 5, z - 7)) .count() }; assert_eq!(count(12), 533); assert_eq!(count(2), 25); for (x, z, inside) in [(12, 0, true), (13, 0, false), (9, 9, true), (10, 9, false)] { assert_eq!(in_view_distance((0, 0), 12, x, z), inside, "({x}, {z})"); assert_eq!( in_view_distance((0, 0), 12, -z, -x), inside, "({}, {})", -z, -x ); } } struct GenerationFixture { world: World, center: (i32, i32), radius: i32, extra: Vec<((i32, i32), i32)>, forced: HashSet<(i32, i32)>, generating: FxHashSet<(i32, i32)>, protos: FxHashMap<(i32, i32), Option>, finishing: FxHashSet<(i32, i32)>, decorates: bool, remote: bool, } impl GenerationFixture { fn new(radius: i32, decorates: bool) -> Self { Self { world: World::new(horizon_world::registry::BlockStateId(0), 0), center: (0, 0), radius, extra: Vec::new(), forced: HashSet::new(), generating: Default::default(), protos: Default::default(), finishing: Default::default(), decorates, remote: false, } } fn input(&self) -> GenerationInputs<'_> { GenerationInputs { ranges: Ranges { center: self.center, radius: self.radius, extra: &self.extra, forced: &self.forced, cover: None, band: None, }, world: &self.world, generating: &self.generating, protos: &self.protos, finishing: &self.finishing, decorates: self.decorates, remote: self.remote, loading: false, } } fn fill(&mut self) { // Scheduler only reads membership. Share one real empty column to // keep a radius-32 fixture small; chunk content is never consulted. let chunk = Arc::new(Chunk::empty(0, 0)); for (_, x, z) in baseline_candidates(self.input(), usize::MAX) { self.world.chunks.insert((x, z), chunk.clone()); } } fn fill_steady(&mut self) { let chunk = Arc::new(Chunk::empty(0, 0)); for (_, x, z) in baseline_candidates(self.input(), usize::MAX) { if self.input().ranges.in_range(x, z, 1) { self.world.chunks.insert((x, z), chunk.clone()); } else { // Generation's outer neighbour margin remains proto; // only columns in the finish range become resident. self.protos.insert((x, z), Some(Box::new(()))); } } } fn assert_same(&self, gate: &mut GenerationScan, capacity: usize) -> bool { let expected = baseline_candidates(self.input(), capacity); let result = gate.candidates(self.input(), capacity); assert_eq!(result.as_deref().unwrap_or(&[]), expected); result.is_some() } } // Original scheduling scan, without snapshot bookkeeping, for differential // correctness and timing. Keep this independent of the production gate. fn baseline_candidates(input: GenerationInputs<'_>, capacity: usize) -> Vec<(i64, i32, i32)> { if input.remote || input.generating.len() >= capacity { return Vec::new(); } let margin: i32 = if input.decorates { 3 } else { 1 }; let reach = if input.decorates { 2 } else { 1 }; let mut wanted = Vec::new(); let areas: Vec<_> = std::iter::once((input.ranges.center, input.ranges.radius)) .chain(input.ranges.extra.iter().copied()) .collect(); let missing = |x, z| { !input.world.chunks.contains_key(&(x, z)) && !input.generating.contains(&(x, z)) && !input.protos.contains_key(&(x, z)) && !input.finishing.contains(&(x, z)) }; for (center, radius) in areas { let r = radius + margin.max(reach + 1); for dz in -r..=r { for dx in -r..=r { let (x, z) = (center.0 + dx, center.1 + dz); if (input.ranges.in_range(x, z, margin) || input.ranges.near_finished(x, z, reach)) && missing(x, z) { wanted.push((input.ranges.distance(x, z), x, z)); } } } } for &(fx, fz) in input.ranges.forced { for dz in -(margin - 1)..=(margin - 1) { for dx in -(margin - 1)..=(margin - 1) { let (x, z) = (fx + dx, fz + dz); if missing(x, z) { wanted.push((input.ranges.distance(x, z), x, z)); } } } } wanted.sort_unstable(); wanted.dedup(); wanted.truncate(capacity - input.generating.len()); wanted } #[test] fn generation_gate_tracks_public_ranges_and_exact_membership() { for decorates in [false, true] { let mut f = GenerationFixture::new(2, decorates); f.fill(); let mut gate = GenerationScan::default(); assert!(f.assert_same(&mut gate, 6)); assert!(!f.assert_same(&mut gate, 6)); // Light/mesh state and block content do not affect generation. f.world.dirty_light.insert((0, 0)); f.world.dirty_sections.insert((0, 0, 0)); Arc::make_mut(f.world.chunks.get_mut(&(0, 0)).unwrap()).lit = true; assert!(!f.assert_same(&mut gate, 6)); // Same-count removal/replacement must not leave a hole unnoticed. let chunk = f.world.chunks.remove(&(0, 0)).unwrap(); f.world.chunks.insert((100, 100), chunk.clone()); assert!(f.assert_same(&mut gate, 6)); f.world.chunks.remove(&(100, 100)); f.world.chunks.insert((0, 0), chunk); assert!(f.assert_same(&mut gate, 6)); assert!(!f.assert_same(&mut gate, 6)); f.center = (1, -1); assert!(f.assert_same(&mut gate, 6)); f.fill(); f.assert_same(&mut gate, 6); f.radius += 1; assert!(f.assert_same(&mut gate, 6)); f.fill(); f.assert_same(&mut gate, 6); f.extra.push(((20, -20), 2)); assert!(f.assert_same(&mut gate, 6)); f.fill(); f.assert_same(&mut gate, 6); f.forced.insert((40, 40)); assert!(f.assert_same(&mut gate, 6)); f.fill(); f.assert_same(&mut gate, 6); f.extra.clear(); f.forced.clear(); assert!(f.assert_same(&mut gate, 6)); f.remote = true; assert!(!f.assert_same(&mut gate, 6)); f.world.chunks.clear(); f.remote = false; assert!(f.assert_same(&mut gate, 6)); f.fill(); f.assert_same(&mut gate, 6); f.world = World::new(horizon_world::registry::BlockStateId(0), 1); assert!(f.assert_same(&mut gate, 6)); } } #[test] fn generation_gate_preserves_batches_stage_transitions_and_retries() { for decorates in [false, true] { let mut f = GenerationFixture::new(2, decorates); let mut gate = GenerationScan::default(); let mut scheduled = FxHashSet::default(); loop { let expected = baseline_candidates(f.input(), 3); let batch = gate.candidates(f.input(), 3).unwrap_or_default(); assert_eq!(batch, expected); if batch.is_empty() { break; } for (_, x, z) in batch { assert!(scheduled.insert((x, z)), "duplicate scheduling"); f.generating.insert((x, z)); } if f.generating.len() == 3 { assert!(!f.assert_same(&mut gate, 3)); // capacity pressure } else { f.assert_same(&mut gate, 3); } for key in std::mem::take(&mut f.generating) { // load miss -> proto -> checked out decoration -> finish. f.protos.insert(key, None); } gate.exhausted = false; // Done::Proto/Decorated invalidation } assert!(!scheduled.is_empty()); assert!(!f.assert_same(&mut gate, 3)); let key = (0, 0); f.protos.remove(&key); f.finishing.insert(key); assert!(!f.assert_same(&mut gate, 3)); // eligibility unchanged f.finishing.remove(&key); f.world.chunks.insert(key, Arc::new(Chunk::empty(0, 0))); gate.exhausted = false; // Done::Generated assert!(f.assert_same(&mut gate, 3)); assert!(!f.assert_same(&mut gate, 3)); // A discarded/pruned proto must be requested again, even without // any range or loaded-membership change. let key = scheduled.iter().copied().find(|k| *k != (0, 0)).unwrap(); f.protos.remove(&key); gate.exhausted = false; assert!(f.assert_same(&mut gate, 3)); assert_eq!(baseline_candidates(f.input(), 3).len(), 1); } } #[test] fn generation_scan_looks_at_overlapping_areas_once() { // A server's players: many areas around one spot, some apart, one // touching another only at a corner, and part of the land present. for decorates in [false, true] { let mut f = GenerationFixture::new(10, decorates); for i in 0..40 { f.extra.push(((i % 7 - 3, i / 7 - 3), 19)); } f.extra.push(((200, -150), 19)); f.extra.push(((243, -107), 19)); f.extra.push(((-60, 5), 4)); f.forced.insert((90, 90)); let chunk = Arc::new(Chunk::empty(0, 0)); for x in -40i32..40 { for z in -40i32..40 { match (x * 7 + z * 13).rem_euclid(5) { 0 => drop(f.world.chunks.insert((x, z), chunk.clone())), 1 => drop(f.protos.insert((x, z), None)), 2 if x % 3 == 0 => drop(f.generating.insert((x, z))), _ => {} } } } assert!(baseline_candidates(f.input(), usize::MAX).len() > 1000); for capacity in [usize::MAX, f.generating.len() + 7] { let mut gate = GenerationScan::default(); assert!(f.assert_same(&mut gate, capacity)); } } } #[test] #[ignore = "reproducible actual generation scheduler benchmark; run with --ignored --nocapture"] fn generation_scan_benchmark() { use std::{hint::black_box, time::Instant}; let mut f = GenerationFixture::new(32, true); f.fill_steady(); let mut gate = GenerationScan::default(); f.assert_same(&mut gate, 12); assert!(!f.assert_same(&mut gate, 12)); const FRAMES: usize = 2000; let measure = |optimized: bool, dynamic: bool| { let mut samples = Vec::new(); let mut scans = 0; let mut jobs = 0; for repetition in 0..9 { let mut fixture = GenerationFixture::new(32, true); fixture.fill_steady(); let saved = fixture.world.chunks.get(&(0, 0)).unwrap().clone(); let mut gate = GenerationScan::default(); gate.candidates(fixture.input(), 12); let start = Instant::now(); let mut count = 0; let mut scheduled = 0; for frame in 0..FRAMES { // Remove a column, queue generation, then accept a saved // load completion. Both schedulers see identical events. if dynamic && frame % 32 == 0 { fixture.world.chunks.remove(&(0, 0)); } if dynamic && frame % 32 == 1 { fixture.generating.remove(&(0, 0)); fixture.world.chunks.insert((0, 0), saved.clone()); gate.exhausted = false; // Done::Generated } let result = if optimized { let result = gate.candidates(black_box(fixture.input()), 12); count += usize::from(result.is_some()); result.unwrap_or_default() } else { count += 1; baseline_candidates(black_box(fixture.input()), 12) }; let expected_jobs = usize::from(dynamic && frame % 32 == 0); assert_eq!(result.len(), expected_jobs); for (_, x, z) in black_box(result) { assert_eq!((x, z), (0, 0)); fixture.generating.insert((x, z)); scheduled += 1; } } if repetition != 0 { samples.push(start.elapsed().as_secs_f64() * 1e9 / FRAMES as f64); } assert!(fixture.generating.is_empty()); assert_eq!(fixture.world.chunks.len(), f.world.chunks.len()); scans = count; jobs = scheduled; } samples.sort_by(f64::total_cmp); (samples[samples.len() / 2], scans, jobs) }; println!( "radius=32 decorates=true positions/frame=5041 loaded_keys={} proto_keys={} frames/sample={FRAMES} warmup=1 measured=8", f.world.chunks.len(), f.protos.len() ); for dynamic in [false, true] { let (before, baseline_scans, before_jobs) = measure(false, dynamic); let (after, optimized_scans, after_jobs) = measure(true, dynamic); assert_eq!(before_jobs, after_jobs); println!( "dynamic={dynamic}: baseline={before:.1}ns/frame optimized={after:.1}ns/frame speedup={:.2}x scans={baseline_scans}/{optimized_scans} jobs={before_jobs}/{after_jobs}", before / after ); } } /// The ranges `Streaming::update` checks at each step, from generation to /// light, must let every chunk the player spawns on finish and light: the /// 3x3 columns around the player need their own 3x3 neighbours finished, /// each of those its 3x3 neighbours decorated, and each of those its 3x3 /// neighbours generated and kept. Render distance 2 once stopped short. #[test] fn spawn_neighbourhood_completes_at_every_distance() { let forced = HashSet::new(); for decorates in [true, false] { let (margin, reach) = Ranges::margins(decorates); for radius in 2..=32 { let r = Ranges { center: (5, -7), radius, extra: &[], forced: &forced, cover: None, band: None, }; let square = |x: i32, z: i32, n: i32| { (-n..=n).flat_map(move |dz| (-n..=n).map(move |dx| (x + dx, z + dz))) }; let generated = |x, z| { r.requested(x, z, decorates) && (x - r.center.0).abs() <= radius + margin.max(reach + 1) && (z - r.center.1).abs() <= radius + margin.max(reach + 1) }; let proto_kept = |x, z| r.in_range(x, z, 4) || r.near_finished(x, z, 2); let decorated = |x, z| !decorates || r.in_range(x, z, 2) || r.near_finished(x, z, 1); let chunk_kept = |x, z| r.chunk_kept(x, z, decorates); let unloaded = |x, z| r.unloaded(x, z, decorates); let finishes = |x: i32, z: i32| { r.in_range(x, z, 1) && chunk_kept(x, z) && !unloaded(x, z) && square(x, z, 1).all(|(nx, nz)| { decorated(nx, nz) && (!decorates || square(nx, nz, 1) .all(|(gx, gz)| generated(gx, gz) && proto_kept(gx, gz))) && generated(nx, nz) && proto_kept(nx, nz) }) }; let (cx, cz) = r.center; for (x, z) in square(cx, cz, 1) { for (nx, nz) in square(x, z, 1) { assert!( finishes(nx, nz), "radius {radius} (decorates: {decorates}): ({nx}, {nz}) never finishes" ); } } } } } /// A column generation asks for is kept when it arrives finished (loaded /// from the save) and is not unloaded right after: either way it would be /// asked for and loaded again on the next frame, forever (8 such columns /// after a teleport at render distance 16 held 8 of the in-flight slots). /// #770: while the loading screen is up, chunks go ring by ring (a /// square front, as vanilla's ticket levels), nearest first in a ring. #[test] fn loading_goes_ring_by_ring() { let forced = HashSet::new(); let r = Ranges { center: (2, -1), radius: 12, extra: &[], forced: &forced, cover: None, band: None, }; let at = |dx: i32, dz: i32| (2 + dx, -1 + dz); let key = |(x, z): (i32, i32), loading| r.priority(x, z, loading); // The corner of ring 3 comes before the edge of ring 4 only while loading. assert!(key(at(3, 3), true) < key(at(0, 4), true)); assert!(key(at(3, 3), false) > key(at(0, 4), false)); // Inside a ring, nearest first; rings never interleave. assert!(key(at(0, 3), true) < key(at(2, -3), true)); assert!(key(at(-3, -3), true) < key(at(4, 0), true)); for dx in -20..=20 { for dz in -20..=20 { assert_eq!(key(at(dx, dz), false), r.distance(2 + dx, -1 + dz)); } } } #[test] fn requested_columns_stay_loaded() { let forced = HashSet::new(); for decorates in [true, false] { for radius in 2..=32 { let r = Ranges { center: (5, -7), radius, extra: &[((radius * 2 + 9, 3), 4)], forced: &forced, cover: None, band: None, }; let span = radius * 3 + 20; for x in -span..=span { for z in -span..=span { if r.requested(x, z, decorates) { assert!( r.chunk_kept(x, z, decorates), "radius {radius} (decorates: {decorates}): ({x}, {z}) is asked for but dropped" ); } if r.chunk_kept(x, z, decorates) { assert!( !r.unloaded(x, z, decorates), "radius {radius} (decorates: {decorates}): ({x}, {z}) is kept then unloaded" ); } } } } } } /// A server player's area (`lan_update_streaming`: the server view /// distance + 1) finishes vanilla's FULL square: PLAYER_LOADING tickets at /// level 31 out to the view distance, FULL (33) two chunks past it. Every /// chunk the player tracks has its 3x3 neighbourhood finished, so it can /// be lit and sent, and generation reaches vanilla's FEATURES (34) and /// TERRAIN (35) rings. #[test] fn server_player_areas_finish_vanillas_full_square() { let forced = HashSet::new(); for view in 2..=32 { let extra = [((40, -9), view + 1)]; let r = Ranges { // The window's own area, far away. center: (-400, 300), radius: 2, extra: &extra, forced: &forced, cover: None, band: None, }; let level = |x: i32, z: i32| 31 + ((x - 40).abs().max((z + 9).abs()) - view).max(0); for x in 40 - view - 8..=40 + view + 8 { for z in -9 - view - 8..=-9 + view + 8 { assert_eq!( r.in_range(x, z, 1), level(x, z) <= 33, "view {view}: ({x}, {z})" ); assert_eq!( r.requested(x, z, true), level(x, z) <= 35, "view {view}: ({x}, {z})" ); assert_eq!( r.unloaded(x, z, true), level(x, z) > 35, "view {view}: ({x}, {z})" ); // ChunkTrackingView.contains, at any view distance the player may ask for. let tracked = |v: i64| { let gap = |d: i32| i64::from(((d).abs() - 2).max(0)); gap(x - 40).pow(2) + gap(z + 9).pow(2) < v * v }; if tracked(i64::from(view)) { for (dx, dz) in (-1..=1).flat_map(|dx| (-1..=1).map(move |dz| (dx, dz))) { assert!( r.in_range(x + dx, z + dz, 1), "view {view}: ({x}, {z}) tracked, not lit" ); } } } } } } } #[cfg(test)] mod cover_tests { use super::*; fn areas(seed: &mut u64, n: usize, spread: i32) -> Vec<((i32, i32), i32)> { let mut next = |m: i32| { *seed ^= *seed << 13; *seed ^= *seed >> 7; *seed ^= *seed << 17; (*seed % (2 * m as u64 + 1)) as i32 - m }; (0..n) .map(|_| ((next(spread), next(spread)), 2 + next(14).abs())) .collect() } /// Every question streaming asks gets the same answer with the grid. /// /// A debug build checks every fourth cell of each row, shifted by row and case so the cases still cover every /// cell's position relative to the areas: the full check took 20 of the ~30 s of the crate's tests. /// `cargo test --release -p horizon-client --lib the_grid_answers_as_the_scan` checks every cell. #[test] fn the_grid_answers_as_the_scan() { let stride = if cfg!(debug_assertions) { 4 } else { 1 }; let mut seed = 0x9E37_79B9_7F4A_7C15u64; let forced: HashSet<(i32, i32)> = [(40, -40)].into(); for case in 0..60 { let extra = areas(&mut seed, 2 + case % 20, [4, 30, 120][case % 3]); let cover = ExtraCover::new(&extra).expect("a grid"); let ranges = |cover| Ranges { center: (3, -2), radius: 10, extra: &extra, forced: &forced, cover, band: None, }; let (scan, grid) = (ranges(None), ranges(Some(&cover))); let span = [4, 30, 120][case % 3] + 40; for z in -span..=span { let first = -span + (z + case as i32).rem_euclid(stride); for x in (first..=span).step_by(stride as usize) { for m in 0..=ExtraCover::REACH + 2 { assert_eq!( scan.in_extra(x, z, m), grid.in_extra(x, z, m), "case {case} ({x}, {z}) {m}" ); } for d in [false, true] { assert_eq!(scan.unloaded(x, z, d), grid.unloaded(x, z, d)); assert_eq!(scan.requested(x, z, d), grid.requested(x, z, d)); assert_eq!(scan.chunk_kept(x, z, d), grid.chunk_kept(x, z, d)); } } } } } #[test] fn a_stale_or_impossible_grid_is_not_used() { let mut cover = None; ExtraCover::refresh(&mut cover, &[((0, 0), 11), ((5, 5), 11)]); assert!(ExtraCover::matching(&cover, &[((0, 0), 11), ((5, 5), 11)]).is_some()); assert!(ExtraCover::matching(&cover, &[((0, 0), 11), ((5, 6), 11)]).is_none()); // Too far apart for a mebibyte of grid, and one area alone: scans. assert!(ExtraCover::new(&[((0, 0), 11), ((100_000, 0), 11)]).is_none()); assert!(ExtraCover::new(&[((0, 0), 11)]).is_none()); assert!(ExtraCover::new(&[((i32::MAX - 1, 0), 11), ((i32::MAX - 3, 0), 11)]).is_none()); assert!(ExtraCover::new(&[((0, i32::MAX - 1), 11), ((0, i32::MAX - 3), 11)]).is_none()); assert!(ExtraCover::new(&[((0, i32::MIN + 1), 11), ((0, i32::MIN + 3), 11)]).is_none()); } /// cargo test --release -p horizon-client --lib cover_tests::cover_cost -- --ignored --nocapture #[test] #[ignore] fn cover_cost() { let forced = HashSet::new(); for players in [10usize, 25, 50] { // The benchmark's bots: most near spawn, a fifth flying outwards. let extra: Vec<_> = (0..players) .map(|i| { let a = i as f64 * 2.399; let d = if i % 5 == 0 { 30.0 } else { 3.0 }; (((a.cos() * d) as i32, (a.sin() * d) as i32), 11) }) .collect(); let cover = ExtraCover::new(&extra).unwrap(); let ranges = |cover| Ranges { center: (0, 0), radius: 10, extra: &extra, forced: &forced, cover, band: None, }; // The columns streaming asks about: everything kept, and the // generation scan's ring past it. let columns: Vec<(i32, i32)> = (-60..=60) .flat_map(|z| (-60..=60).map(move |x| (x, z))) .filter(|&(x, z)| { ranges(None).requested(x, z, true) || !ranges(None).unloaded(x, z, true) }) .collect(); let rounds = 100; let time = |r: &Ranges| { let t = std::time::Instant::now(); let mut n = 0usize; for _ in 0..rounds { for &(x, z) in &columns { n += usize::from(r.unloaded(x, z, true)); n += usize::from(r.requested(x, z, true)); n += usize::from(r.in_range(x, z, 1)); } } std::hint::black_box(n); t.elapsed().as_secs_f64() * 1e3 / f64::from(rounds) }; let t = std::time::Instant::now(); for _ in 0..rounds { std::hint::black_box(ExtraCover::new(std::hint::black_box(&extra))); } let build = t.elapsed().as_secs_f64() * 1e3 / f64::from(rounds); println!( "{players} players, {} columns, 3 questions each: scan {:.3} ms, grid {:.3} ms (+ {build:.3} ms to build)", columns.len(), time(&ranges(None)), time(&ranges(Some(&cover))), ); } } }