diff --git a/crates/horizon-client/examples/light_parity.rs b/crates/horizon-client/examples/light_parity.rs index 29488130e..f660189a2 100644 --- a/crates/horizon-client/examples/light_parity.rs +++ b/crates/horizon-client/examples/light_parity.rs @@ -206,7 +206,7 @@ fn incremental( sky_light: bool, edits: usize, ) { - use horizon_client::light::relight; + use horizon_client::light::{LightChanges, relight}; use std::sync::Arc; let mut world: HashMap<(i32, i32), Arc> = HashMap::new(); let inner: Vec<(i32, i32)> = { @@ -285,7 +285,14 @@ fn incremental( if old == state || !tables.differs(old, state) { continue; } - relight(&mut world, tables, sky_light, &[(x, y, z)], false); + relight( + &mut world, + tables, + sky_light, + &[(x, y, z)], + false, + &mut LightChanges::default(), + ); for dz in -1..=1 { for dx in -1..=1 { let (kx, kz) = (cx + dx, cz + dz); diff --git a/crates/horizon-client/src/light.rs b/crates/horizon-client/src/light.rs index 2ef7af301..d7ea7d7fd 100644 --- a/crates/horizon-client/src/light.rs +++ b/crates/horizon-client/src/light.rs @@ -14,6 +14,7 @@ //! most 15 blocks, so the 48-wide region determines the centre exactly. //! `relight_block` applies vanilla's incremental decrease/increase passes //! directly to resident chunks after a block change. +use crate::fast_hash::FxHashMap; use crate::{ blocks::BlockFacts, chunk::{Chunk, HEIGHT, Light, MIN_Y, SECTIONS, index}, @@ -464,10 +465,8 @@ pub fn apply_lighting(chunk: &mut Chunk, lights: Vec) { } /// `apply_lighting` for a chunk lit before: writes only the sections whose -/// light changed and returns the block positions that changed. -pub fn apply_relighting(chunk: &mut Chunk, lights: Vec) -> Vec<(i32, i32, i32)> { - let mut changed = Vec::new(); - let (bx, bz) = (chunk.x * 16, chunk.z * 16); +/// light changed and adds the cells that changed to `changed`. +pub fn apply_relighting(chunk: &mut Chunk, lights: Vec, changed: &mut LightChanges) { for (sy, (section, light)) in chunk.sections.iter_mut().zip(lights).enumerate() { let old = §ion.light; if let (Light::Uniform(a), Light::Uniform(b)) = (old, &light) @@ -475,18 +474,18 @@ pub fn apply_relighting(chunk: &mut Chunk, lights: Vec) -> Vec<(i32, i32, { continue; } - let before = changed.len(); + let mut classes = 0; for i in 0..4096 { if old.get(i) != light.get(i) { - let y = MIN_Y + sy as i32 * 16 + (i >> 8) as i32; - changed.push((bx + (i & 15) as i32, y, bz + (i >> 4 & 15) as i32)); + let (x, y, z) = (i as i32 & 15, (i >> 8) as i32, (i >> 4) as i32 & 15); + classes |= 1 << LightChanges::class(x, y, z); } } - if changed.len() > before { + if classes != 0 { + changed.add((chunk.x, sy as i32, chunk.z), classes); Arc::make_mut(section).light = light; } } - changed } /// `DataLayer.get`: the nibble at index `i` (`y << 8 | z << 4 | x`), low first. @@ -607,6 +606,90 @@ impl LightWorld for HashMap<(i32, i32), Arc, S } } type Pos = (i32, i32, i32); +/// Changed light by section, as vanilla's light engine reports it to +/// `LevelRenderer` (`setSectionDirty`) instead of cell by cell: for each +/// section (x, section index, z), a bit per class of position the changed +/// cells take in it, `3 * 3 * 3` classes for the low face, the inside and the +/// high face of each axis. Meshes sample light one block across a face, so the +/// class says which neighbouring sections a change dirties too. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct LightChanges { + sections: FxHashMap, +} +impl LightChanges { + /// A cell whose stored light changed. + #[inline] + pub fn push(&mut self, (x, y, z): Pos) { + let key = (x >> 4, (y - MIN_Y) >> 4, z >> 4); + *self.sections.entry(key).or_default() |= 1 << Self::class(x, y, z); + } + /// Cells of section `key` (x, section index, z) in the given classes. + fn add(&mut self, key: Pos, classes: u32) { + *self.sections.entry(key).or_default() |= classes; + } + /// The class of a cell in its section: per axis 0 on the low face, 1 + /// inside, 2 on the high face. + fn class(x: i32, y: i32, z: i32) -> u32 { + let axis = |v: i32| match v & 15 { + 0 => 0, + 15 => 2, + _ => 1, + }; + axis(x) + 3 * axis(y) + 9 * axis(z) + } + pub fn is_empty(&self) -> bool { + self.sections.is_empty() + } + /// The sections (x, section index, z) holding changed cells. + pub fn sections(&self) -> impl Iterator + '_ { + self.sections.keys().copied() + } + /// Every section (x, section index, z) whose cells lie within one block + /// of a changed cell, section indexes outside `0..SECTIONS` left out (a + /// section next to several changed ones comes once for each). + pub fn dirty_sections(&self, mut out: impl FnMut(Pos)) { + // Per class, the bit set of neighbour offsets (dx, dy, dz in -1..=1, + // bit (dx + 1) + 3 (dy + 1) + 9 (dz + 1)) its cells reach. + const REACH: [u32; 27] = { + let mut reach = [0; 27]; + let mut class = 0; + while class < 27 { + let axis = [class % 3, class / 3 % 3, class / 9]; + let mut offset = 0; + while offset < 27 { + let d = [offset % 3, offset / 3 % 3, offset / 9]; + // Every class reaches its own section (d = 1, offset 0); + // the low face also -1 (d = 0), the high face +1 (d = 2). + if (d[0] == 1 || d[0] == axis[0]) + && (d[1] == 1 || d[1] == axis[1]) + && (d[2] == 1 || d[2] == axis[2]) + { + reach[class] |= 1 << offset; + } + offset += 1; + } + class += 1; + } + reach + }; + for (&(x, sy, z), &classes) in &self.sections { + let mut offsets = 0; + let mut rest = classes; + while rest != 0 { + offsets |= REACH[rest.trailing_zeros() as usize]; + rest &= rest - 1; + } + while offsets != 0 { + let o = offsets.trailing_zeros() as i32; + offsets &= offsets - 1; + let s = sy + o / 3 % 3 - 1; + if (0..SECTIONS as i32).contains(&s) { + out((x + o % 3 - 1, s, z + o / 9 - 1)); + } + } + } + } +} fn level(world: &impl LightWorld, sky: bool, p: Pos) -> Option { world .light(p.0, p.1, p.2) @@ -645,8 +728,8 @@ pub fn lowest_sky_source(world: &impl LightWorld, tables: &LightTables, x: i32, /// Vanilla's `checkBlock` + `runLightUpdates` for changed positions on /// resident, lit chunks: clear the light that may have come through or from /// the old states (decrease pass), then re-seed sources and propagate back in -/// from the brighter boundary (increase pass). Returns every position whose -/// stored light changed, for remeshing. `force` clears around each position +/// from the brighter boundary (increase pass). Adds every position whose +/// stored light changed to `changed`, for remeshing. `force` clears around each position /// as if it had been fully lit, for light computed from outdated blocks. pub fn relight( world: &mut impl LightWorld, @@ -654,16 +737,9 @@ pub fn relight( sky_light: bool, positions: &[Pos], force: bool, -) -> Vec { - let mut changed = Vec::new(); - relight_layer( - world, - tables, - false, - positions.to_vec(), - force, - &mut changed, - ); + changed: &mut LightChanges, +) { + relight_layer(world, tables, false, positions.to_vec(), force, changed); if sky_light { let mut seeds = positions.to_vec(); let mut columns: HashMap<(i32, i32), i32> = HashMap::new(); @@ -686,11 +762,8 @@ pub fn relight( y -= 1; } } - relight_layer(world, tables, true, seeds, force, &mut changed); + relight_layer(world, tables, true, seeds, force, changed); } - changed.sort_unstable(); - changed.dedup(); - changed } fn relight_layer( world: &mut impl LightWorld, @@ -698,7 +771,7 @@ fn relight_layer( sky: bool, seeds: Vec, force: bool, - changed: &mut Vec, + changed: &mut LightChanges, ) { let mut decrease: VecDeque<(Pos, u8)> = VecDeque::new(); let mut cleared: Vec = Vec::new(); @@ -894,7 +967,14 @@ mod tests { ]; for ((x, y, z), state) in edits { Arc::make_mut(w.get_mut(&(0, 0)).unwrap()).set(x, y, z, state); - relight(&mut w, &tables(), true, &[(x, y, z)], false); + relight( + &mut w, + &tables(), + true, + &[(x, y, z)], + false, + &mut LightChanges::default(), + ); } let region: [[Option<&Chunk>; 3]; 3] = std::array::from_fn(|dz| { std::array::from_fn(|dx| w.get(&(dx as i32 - 1, dz as i32 - 1)).map(|c| &**c)) @@ -940,7 +1020,16 @@ mod tests { assert_eq!(edited_snapshot.sections[0].light(index(8, MIN_Y, 8)), 0xF0); let mut world = HashMap::from([((0, 0), Arc::new(current))]); // Streaming replays edits made after the job snapshot with force=true. - relight(&mut world, &tables(), true, &[(8, MIN_Y, 8)], true); + let mut changed = LightChanges::default(); + relight( + &mut world, + &tables(), + true, + &[(8, MIN_Y, 8)], + true, + &mut changed, + ); + assert!(!changed.is_empty()); let region = [[None; 3], [None, Some(&*world[&(0, 0)]), None], [None; 3]]; let fresh = light_chunk(®ion, &tables(), true); for (section, light) in world[&(0, 0)].sections.iter().zip(fresh) { @@ -963,7 +1052,9 @@ mod tests { let sections: Vec<_> = chunk.sections.iter().map(Arc::as_ptr).collect(); // The same light again: nothing changes and no section is copied. let light = lit(&chunk); - assert!(apply_relighting(&mut chunk, light).is_empty()); + let mut changed = LightChanges::default(); + apply_relighting(&mut chunk, light, &mut changed); + assert!(changed.is_empty()); assert_eq!( sections, chunk.sections.iter().map(Arc::as_ptr).collect::>() @@ -971,8 +1062,8 @@ mod tests { let before = chunk.clone(); chunk.set(3, MIN_Y + 20, 5, STONE); let light = lit(&chunk); - let changed = apply_relighting(&mut chunk, light); - let mut expected = Vec::new(); + apply_relighting(&mut chunk, light, &mut changed); + let mut expected = LightChanges::default(); for (sy, (old, new)) in before.sections.iter().zip(&chunk.sections).enumerate() { for i in 0..4096 { if old.light(i) != new.light(i) { @@ -992,6 +1083,57 @@ mod tests { assert!(copied <= 3, "{copied} sections copied"); } + #[test] + fn changes_dirty_the_sections_within_a_block_of_each_cell() { + // Cells inside sections, on each face and corner, at the bottom and + // top of the world, on negative coordinates. + let mut cells = Vec::new(); + for x in [-17, -16, -1, 0, 7, 15, 16, 31] { + for y in [ + MIN_Y, + MIN_Y + 15, + MIN_Y + 16, + 70, + 79, + 80, + MIN_Y + HEIGHT - 1, + ] { + for z in [-33, -32, 5, 15] { + cells.push((x, y, z)); + } + } + } + for n in [1, 2, cells.len()] { + for start in 0..cells.len().min(8) { + let some: Vec = cells.iter().copied().cycle().skip(start).take(n).collect(); + let mut changes = LightChanges::default(); + some.iter().for_each(|&c| changes.push(c)); + let mut dirty = std::collections::BTreeSet::new(); + changes.dirty_sections(|s| { + dirty.insert(s); + }); + let mut expected = std::collections::BTreeSet::new(); + for &(x, y, z) in &some { + for (dx, dy, dz) in (-1..=1) + .flat_map(|a| (-1..=1).flat_map(move |b| (-1..=1).map(move |c| (a, b, c)))) + { + let s = (y + dy - MIN_Y) >> 4; + if (0..SECTIONS as i32).contains(&s) { + expected.insert(((x + dx) >> 4, s, (z + dz) >> 4)); + } + } + } + assert_eq!(dirty, expected, "{some:?}"); + let sections: std::collections::BTreeSet<_> = changes.sections().collect(); + let own: std::collections::BTreeSet<_> = some + .iter() + .map(|&(x, y, z)| (x >> 4, (y - MIN_Y) >> 4, z >> 4)) + .collect(); + assert_eq!(sections, own); + } + } + } + #[test] fn stored_layers_fill_the_column_as_vanilla_reads_them() { // Section 10's sky layer is 7 on its bottom row and 3 above; no diff --git a/crates/horizon-client/src/streaming.rs b/crates/horizon-client/src/streaming.rs index 6acdcafd2..ca1af4388 100644 --- a/crates/horizon-client/src/streaming.rs +++ b/crates/horizon-client/src/streaming.rs @@ -5,7 +5,7 @@ use crate::fast_hash::{FxHashMap, FxHashSet}; use crate::{ chunk::{Chunk, SECTIONS}, - light::{LightTables, apply_lighting, apply_relighting, light_chunk}, + light::{LightChanges, LightTables, apply_lighting, apply_relighting, light_chunk}, mesher::{MeshTables, Mesher, Region, SectionMesh, borrow}, world::World, }; @@ -748,12 +748,12 @@ impl Streaming { // only around the light that changed, as vanilla's light // updates dirty only their sections (#270). let first = self.lit.insert((x, z)); - let changed = if first { + let mut changed = LightChanges::default(); + if first { apply_lighting(chunk, sections); - Vec::new() } else { - apply_relighting(chunk, sections) - }; + apply_relighting(chunk, sections, &mut changed); + } chunk.lit = true; if first { for dz in -1..=1 { @@ -1125,12 +1125,14 @@ impl Streaming { if positions.is_empty() { return; } - let changed = crate::light::relight( + 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() { @@ -1152,12 +1154,14 @@ impl Streaming { .map(|(_, p)| *p) .collect(); if !positions.is_empty() { - let changed = crate::light::relight( + 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); } @@ -1169,31 +1173,15 @@ impl Streaming { } /// Sections whose meshes sample a changed light value (faces and corners /// read light from neighbouring blocks). - fn mark_light_changes(world: &mut World, changed: &[(i32, i32, i32)]) { + fn mark_light_changes(world: &mut World, changed: &LightChanges) { if let Some(log) = &mut world.light_log { - for &(x, y, z) in changed { - *log.entry((x >> 4, z >> 4)).or_default() |= 1 << ((y - crate::chunk::MIN_Y) >> 4); - } - } - let mut last = None; - for &(x, y, z) in changed { - for dz in -1..=1 { - for dy in -1..=1 { - for dx in -1..=1 { - let s = ( - (y + dy - crate::chunk::MIN_Y) >> 4, - (x + dx) >> 4, - (z + dz) >> 4, - ); - if last == Some(s) || !(0..SECTIONS as i32).contains(&s.0) { - continue; - } - last = Some(s); - world.dirty_sections.insert((s.1, s.0, s.2)); - } - } + 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 {