diff --git a/crates/horizon-assets/src/blockstate/choice.rs b/crates/horizon-assets/src/blockstate/choice.rs index d871b1c66..af528cb29 100644 --- a/crates/horizon-assets/src/blockstate/choice.rs +++ b/crates/horizon-assets/src/blockstate/choice.rs @@ -4,15 +4,15 @@ use crate::json::{Result, error}; use horizon_core::random::RandomSource; #[derive(Clone, Debug)] -enum Choice { - Single(Variant), +enum Choice { + Single(T), Weighted { - variants: Vec, + variants: Vec, ends: Vec, total: i32, }, } -impl Choice { +impl Choice { fn new(value: &VariantSet) -> Result { match value { VariantSet::Single(value) => Ok(Self::Single(value.clone())), @@ -41,7 +41,23 @@ impl Choice { } } } - fn select(&self, random: &mut impl RandomSource) -> &Variant { +} +impl Choice { + fn map(&self, f: &mut impl FnMut(&T) -> U) -> Choice { + match self { + Self::Single(value) => Choice::Single(f(value)), + Self::Weighted { + variants, + ends, + total, + } => Choice::Weighted { + variants: variants.iter().map(&mut *f).collect(), + ends: ends.clone(), + total: *total, + }, + } + } + fn select(&self, random: &mut impl RandomSource) -> &T { match self { Self::Single(value) => value, Self::Weighted { @@ -60,10 +76,11 @@ impl Choice { } /// Compile once per definition and share across its bound block states. Prefix /// sums avoid rebuilding weight totals or scanning all entries during selection. +/// `map` swaps each variant for what it stands for (its baked model). #[derive(Clone, Debug)] -pub struct CompiledChoices { - variants: Vec, - multipart: Vec, +pub struct CompiledChoices { + variants: Vec>, + multipart: Vec>, } impl CompiledChoices { pub fn new(definition: &BlockStateDefinition) -> Result { @@ -82,10 +99,19 @@ impl CompiledChoices { .collect::>()?, }) } +} +impl CompiledChoices { + /// The same choices, with `f` of each variant in its place. + pub fn map(&self, mut f: impl FnMut(&T) -> U) -> CompiledChoices { + CompiledChoices { + variants: self.variants.iter().map(|c| c.map(&mut f)).collect(), + multipart: self.multipart.iter().map(|c| c.map(&mut f)).collect(), + } + } /// The variant `particleMaterial` comes from: the first entry of a weighted /// list (`WeightedVariants`) and, for a multipart root, of its first /// selector whether or not that selector applies (`MultiPartModel`). - pub fn particle_variant(&self, selected: &SelectedModels) -> Option<&Variant> { + pub fn particle_variant(&self, selected: &SelectedModels) -> Option<&T> { let choice = match selected { SelectedModels::Variant(index) => self.variants.get(*index)?, SelectedModels::Multipart(_) => self.multipart.first()?, @@ -95,14 +121,23 @@ impl CompiledChoices { Choice::Weighted { variants, .. } => variants.first()?, }) } - /// Append selected variants without allocating intermediate part lists. A - /// multipart root consumes nextLong even for an empty selected subset, then - /// resets the same random source to that seed before each selected part. + /// Append selected variants without allocating intermediate part lists. pub fn collect<'a>( &'a self, selected: &SelectedModels, random: &mut impl RandomSource, - output: &mut Vec<&'a Variant>, + output: &mut Vec<&'a T>, + ) -> Result<()> { + self.for_each(selected, random, |v| output.push(v)) + } + /// Each selected variant, in order. A multipart root consumes nextLong + /// even for an empty selected subset, then resets the same random source + /// to that seed before each selected part. + pub fn for_each<'a>( + &'a self, + selected: &SelectedModels, + random: &mut impl RandomSource, + mut f: impl FnMut(&'a T), ) -> Result<()> { match selected { SelectedModels::Variant(index) => { @@ -110,7 +145,7 @@ impl CompiledChoices { .variants .get(*index) .ok_or_else(|| error("invalid variant selection"))?; - output.push(choice.select(random)); + f(choice.select(random)); } SelectedModels::Multipart(indices) => { if indices.iter().any(|index| *index >= self.multipart.len()) { @@ -119,7 +154,7 @@ impl CompiledChoices { let seed = random.next_long(); for index in indices { random.set_seed(seed); - output.push(self.multipart[*index].select(random)); + f(self.multipart[*index].select(random)); } } } diff --git a/crates/horizon-client/examples/chunk_load_bench.rs b/crates/horizon-client/examples/chunk_load_bench.rs new file mode 100644 index 000000000..c3ee6839e --- /dev/null +++ b/crates/horizon-client/examples/chunk_load_bench.rs @@ -0,0 +1,168 @@ +//! What a column costs to load, on real terrain: generates and lights the +//! columns around a point with the vanilla generator, as a world being explored +//! does, then meshes every section of the inner columns on this one thread, so a +//! change to generation or meshing shows as time per column and per section. +//! +//! cargo run --release -p horizon-client --example chunk_load_bench -- \ +//! .local/horizon-client/26.3 [--seed 1234] [--center CX CZ] [--radius 8] +//! [--threads N] [--rounds 3] +//! +//! The default centre is the village of `tools/perf_bench.py`. The generation +//! figure is wall time with N workers (the game's own pool); the mesh figure is +//! this thread's CPU time in `Mesher::mesh`, the best of `--rounds`, so other +//! work on the machine changes it less. The checksum of the meshes shows that an +//! A/B pair of builds made the same ones. +use horizon_client::{ + assets::Assets, + biome::Biomes, + blocks::BlockFacts, + chunk::HEIGHT, + light::LightTables, + mesher::{MeshTables, Mesher, Region, borrow}, + models, + spans::thread_cpu, + streaming::{Streaming, WorkerContext}, + vanillagen::VanillaTerrain, + world::World, +}; +use horizon_core::biome::{BiomeZoom, obfuscate_seed}; +use horizon_world::registry::BlockStateId; +use std::{ + hash::{DefaultHasher, Hash, Hasher}, + path::PathBuf, + sync::Arc, + thread, + time::{Duration, Instant}, +}; + +type Error = Box; + +fn flag(args: &[String], name: &str, default: T) -> T { + args.iter() + .position(|a| a == name) + .and_then(|i| args.get(i + 1)?.parse().ok()) + .unwrap_or(default) +} + +fn main() -> Result<(), Error> { + let args: Vec = std::env::args().collect(); + let root = PathBuf::from(args.get(1).ok_or("usage: chunk_load_bench ")?); + let seed: i64 = flag(&args, "--seed", 1234); + let radius: i32 = flag(&args, "--radius", 8); + let rounds: usize = flag(&args, "--rounds", 3); + let threads: usize = flag( + &args, + "--threads", + thread::available_parallelism().map_or(2, |n| n.get()), + ); + let center = args + .iter() + .position(|a| a == "--center") + .map(|i| -> Result<(i32, i32), Error> { + Ok(( + args.get(i + 1).ok_or("--center CX CZ")?.parse()?, + args.get(i + 2).ok_or("--center CX CZ")?.parse()?, + )) + }) + .transpose()? + .unwrap_or((-60, 10)); + + let assets = Arc::new(Assets::load(&root)?); + let render = Arc::new(assets.reload(&root)?); + let facts = BlockFacts::load(&root, assets.registry)?; + let visibility = models::load_visibility(&root, assets.registry)?; + let biomes = Arc::new(Biomes::load(&root)?); + let context = Arc::new(WorkerContext { + tables: Arc::new(MeshTables::new(&assets, &render, &facts, visibility)?), + light: Arc::new(LightTables::load(&root, assets.registry, &facts)?), + biomes: biomes.clone(), + assets: assets.clone(), + render, + }); + let terrain = VanillaTerrain::new(&root.join("worldgen"), assets.registry, &biomes, seed)?; + + // Generation and light, on the game's worker pool. Meshing is left out + // here and measured on its own below. + let mut streaming = Streaming::new(Arc::new(terrain), context.clone(), threads); + streaming.mesh = false; + streaming.center = center; + streaming.radius = radius; + let mut world = World::new(BlockStateId(0), 0); + let started = Instant::now(); + let mut quiet = 0; + while quiet < 100 { + let before = world.chunks.len(); + let _ = streaming.update(&mut world); + thread::sleep(Duration::from_millis(2)); + quiet = if streaming.pending() == 0 && before == world.chunks.len() { + quiet + 1 + } else { + 0 + }; + } + let generated = started.elapsed() - Duration::from_millis(2 * 100); + let columns = world.chunks.len(); + println!( + "generated and lit {columns} columns in {:.0} ms with {threads} workers ({:.2} ms per column)", + generated.as_secs_f64() * 1e3, + generated.as_secs_f64() * 1e3 / columns.max(1) as f64 + ); + + // Meshing every section of the columns whose neighbours are all loaded. + let inner = radius - 1; + let regions: Vec<(Region, i32)> = (center.0 - inner..=center.0 + inner) + .flat_map(|x| (center.1 - inner..=center.1 + inner).map(move |z| (x, z))) + .filter_map(|(x, z)| { + let region: Region = std::array::from_fn(|dz| { + std::array::from_fn(|dx| { + world + .chunks + .get(&(x + dx as i32 - 1, z + dz as i32 - 1)) + .cloned() + }) + }); + region + .iter() + .flatten() + .all(Option::is_some) + .then_some(region) + }) + .flat_map(|region| (0..HEIGHT / 16).map(move |sy| (region.clone(), sy))) + .collect(); + let mut best = Duration::MAX; + let (mut vertices, mut checksum) = (0, 0); + for _ in 0..rounds.max(1) { + let mut mesher = Mesher { + nether_shading: false, + zoom: BiomeZoom::new(obfuscate_seed(seed)), + blend_radius: 2, + smooth_lighting: true, + cutout_leaves: true, + assets: &context.assets, + render: &context.render, + tables: &context.tables, + biomes: &context.biomes, + visibility: context.tables.visibility.clone(), + }; + vertices = 0; + let mut hash = DefaultHasher::new(); + let mut spent = Duration::ZERO; + for (region, sy) in ®ions { + let started = thread_cpu().ok_or("no thread CPU clock here")?; + let mesh = mesher.mesh(&borrow(region), *sy); + spent += thread_cpu().ok_or("no thread CPU clock here")? - started; + vertices += mesh.solid.len() + mesh.translucent.len(); + bytemuck::cast_slice::<_, u8>(&mesh.solid).hash(&mut hash); + bytemuck::cast_slice::<_, u8>(&mesh.translucent).hash(&mut hash); + } + checksum = hash.finish(); + best = best.min(spent); + } + println!( + "meshed {} sections ({vertices} vertices, checksum {checksum:016x}) in {:.1} ms of CPU ({:.1} us per section)", + regions.len(), + best.as_secs_f64() * 1e3, + best.as_secs_f64() * 1e6 / regions.len().max(1) as f64 + ); + Ok(()) +} diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index 59140866a..4c8860773 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -715,6 +715,8 @@ impl Mesher<'_> { [center.x, center.z, base_y], ); let info = &self.tables.info; + let catalog = &self.render.model_catalog; + let mut models = Vec::new(); for y in 0..16 { for z in 0..16 { for x in 0..16 { @@ -744,13 +746,15 @@ impl Mesher<'_> { continue; } let world = BlockPos::new(center.x * 16 + x, base_y + y, center.z * 16 + z); - let Ok(models) = self.render.model_catalog.collect(BlockStateId(id), world) - else { + if catalog + .models_at(BlockStateId(id), world, &mut models) + .is_err() + { continue; - }; + } // ModelBlockRenderer: the first part decides smooth lighting // for all; light-emitting blocks are always lit flat. - let Some((_, first)) = models.first() else { + let Some(first) = models.first() else { continue; }; let ao = self.smooth_lighting && state.emission == 0 && first.ambient_occlusion; @@ -780,7 +784,7 @@ impl Mesher<'_> { ) .unwrap_or(true); } - for (_, model) in &models { + for model in &models { for face in &model.faces { if face.quad.cull.is_some_and(|d| !visible[d as usize]) { continue; diff --git a/crates/horizon-client/src/models/catalog.rs b/crates/horizon-client/src/models/catalog.rs index 73207ee7f..2e6326c40 100644 --- a/crates/horizon-client/src/models/catalog.rs +++ b/crates/horizon-client/src/models/catalog.rs @@ -41,9 +41,12 @@ pub struct BakedModel { } type VariantKey = (String, [u8; 3], bool); pub struct StateModels { - choices: Vec, - states: BTreeMap, - baked: BTreeMap, + /// Each definition's choices, a variant standing as its index in `baked`. + choices: Vec>, + /// By state id: its definition in `choices` and the models it selects. + states: Vec>, + /// Every transformed model once, with the variant it was baked from. + baked: Vec<(Variant, BakedModel)>, } fn key(variant: &Variant) -> VariantKey { (variant.model.clone(), variant.rotations, variant.uv_lock) @@ -85,7 +88,7 @@ impl StateModels { models: &crate::model_library::ParsedModels, ) -> Result { let mut choices = Vec::new(); - let mut states = BTreeMap::new(); + let mut states = vec![None; registry.len()]; let mut variants = BTreeSet::new(); let mut by_name: std::collections::HashMap<&str, Vec> = std::collections::HashMap::new(); @@ -178,7 +181,7 @@ impl StateModels { } for ((id, _), selected) in native_order.into_iter().zip(bound) { if let Some(selected) = selected { - states.insert(id, (choices.len(), selected)); + states[id.0 as usize] = Some((choices.len(), selected)); } } for choice in definition @@ -211,7 +214,8 @@ impl StateModels { models.block_library_or_missing(root, names)? } }; - let mut baked = BTreeMap::new(); + let mut baked = Vec::with_capacity(variants.len()); + let mut index = BTreeMap::new(); for (name, turns, lock) in variants { let model = library.resolve(&name)?; let particle = model @@ -233,16 +237,22 @@ impl StateModels { }) .collect::>()?; let cube = super::cube::cube_styles(&faces); - baked.insert( - (name, turns, lock), - BakedModel { - ambient_occlusion: model.ambient_occlusion, - particle, - faces, - cube, - }, - ); + index.insert((name.clone(), turns, lock), baked.len() as u32); + let variant = Variant { + model: name, + rotations: turns, + uv_lock: lock, + }; + let model = BakedModel { + ambient_occlusion: model.ambient_occlusion, + particle, + faces, + cube, + }; + baked.push((variant, model)); } + // Every variant of every definition was baked above. + let choices = choices.iter().map(|c| c.map(|v| index[&key(v)])).collect(); Ok(Self { choices, states, @@ -260,26 +270,47 @@ impl StateModels { /// `BlockStateModel.particleMaterial`: the particle sprite layer of the /// state's first variant (see `CompiledChoices::particle_variant`). pub fn particle(&self, state: BlockStateId) -> Option { - let (choice, selected) = self.states.get(&state)?; - let variant = self.choices[*choice].particle_variant(selected)?; - self.baked.get(&key(variant))?.particle + let (choice, selected) = self.state(state)?; + let model = self.choices[*choice].particle_variant(selected)?; + self.baked[*model as usize].1.particle } pub fn collect_seeded( &self, state: BlockStateId, seed: i64, ) -> Result> { - let (choice, selected) = self - .states - .get(&state) - .ok_or("unbound gallery block state")?; + let mut models = Vec::new(); + self.each_seeded(state, seed, |(variant, model)| { + models.push((variant, model)) + })?; + Ok(models) + } + /// The models a block draws at `position`, into `out` (cleared first): + /// `collect` for the mesher, which reuses one list for every block. + pub fn models_at<'a>( + &'a self, + state: BlockStateId, + position: BlockPos, + out: &mut Vec<&'a BakedModel>, + ) -> Result<()> { + out.clear(); + self.each_seeded(state, position_seed(position), |(_, model)| out.push(model)) + } + fn each_seeded<'a>( + &'a self, + state: BlockStateId, + seed: i64, + mut f: impl FnMut(&'a (Variant, BakedModel)), + ) -> Result<()> { + let (choice, selected) = self.state(state).ok_or("unbound gallery block state")?; let mut random = LegacyRandom::new(seed); - let mut variants = Vec::new(); - self.choices[*choice].collect(selected, &mut random, &mut variants)?; - variants - .into_iter() - .map(|v| Ok((v, self.baked.get(&key(v)).ok_or("unbaked block model")?))) - .collect() + self.choices[*choice].for_each(selected, &mut random, |&model| { + f(&self.baked[model as usize]); + })?; + Ok(()) + } + fn state(&self, state: BlockStateId) -> Option<&(usize, SelectedModels)> { + self.states.get(state.0 as usize)?.as_ref() } }