b591c9dc64
WeatherEffectRenderer reads level.getHeight(MOTION_BLOCKING, x, z) for every column within the weather radius. Horizon scanned each column block by block from 10 blocks above the radius down to the ground, with a string search per block, every frame: about half a millisecond of CPU per frame in rain on a Ryzen, more on laptops (#899). Client chunks now keep a MOTION_BLOCKING map next to their WORLD_SURFACE one, built on the first read and dropped by writes that can move it, from the facts world generation already uses (blocks_motion_in_heightmap or a fluid). This is also vanilla's rule where the scan differed: slabs, stairs and other motion-blocking blocks without a full collision box now stop rain, and a roof more than 20 blocks above the camera does too. Tiling a column at each texture repeat no longer allocates two vectors per column. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
332 lines
13 KiB
Rust
332 lines
13 KiB
Rust
//! Resident client world: streamed chunk columns plus the bookkeeping the game
|
|
//! loop needs to relight and remesh after edits.
|
|
use crate::chunk::{Chunk, MIN_Y, SECTIONS};
|
|
use horizon_core::random::LegacyRandom;
|
|
use horizon_world::registry::BlockStateId;
|
|
use std::{
|
|
collections::{HashMap, HashSet},
|
|
sync::Arc,
|
|
};
|
|
|
|
/// Sections (x, section index, z) waiting to be remeshed, kept by column
|
|
/// (a bit per section index), so the mesh scheduler looks at each column once
|
|
/// rather than at every section of it.
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct DirtySections {
|
|
columns: crate::fast_hash::FxHashMap<(i32, i32), u32>,
|
|
}
|
|
const _: () = assert!(SECTIONS <= 32);
|
|
impl DirtySections {
|
|
pub fn insert(&mut self, (x, sy, z): (i32, i32, i32)) {
|
|
debug_assert!((0..SECTIONS as i32).contains(&sy));
|
|
*self.columns.entry((x, z)).or_default() |= 1 << sy;
|
|
}
|
|
pub fn contains(&self, &(x, sy, z): &(i32, i32, i32)) -> bool {
|
|
(0..SECTIONS as i32).contains(&sy)
|
|
&& self.columns.get(&(x, z)).is_some_and(|m| m & 1 << sy != 0)
|
|
}
|
|
/// The dirty section indexes of column (x, z), as bits, removed.
|
|
pub fn take_column(&mut self, x: i32, z: i32) -> u32 {
|
|
self.columns.remove(&(x, z)).unwrap_or(0)
|
|
}
|
|
/// Keep the columns `keep` accepts.
|
|
pub fn retain_columns(&mut self, mut keep: impl FnMut(i32, i32) -> bool) {
|
|
self.columns.retain(|&(x, z), _| keep(x, z));
|
|
}
|
|
/// The columns holding dirty sections, with their section bits.
|
|
pub fn columns(&self) -> impl Iterator<Item = ((i32, i32), u32)> + '_ {
|
|
self.columns.iter().map(|(&c, &m)| (c, m))
|
|
}
|
|
pub fn clear(&mut self) {
|
|
self.columns.clear();
|
|
}
|
|
pub fn is_empty(&self) -> bool {
|
|
self.columns.is_empty()
|
|
}
|
|
/// How many sections are dirty.
|
|
pub fn len(&self) -> usize {
|
|
self.columns.values().map(|m| m.count_ones() as usize).sum()
|
|
}
|
|
}
|
|
pub struct World {
|
|
pub fast_lava: bool,
|
|
pub chunks: crate::chunk_map::ChunkMap,
|
|
pub random: LegacyRandom,
|
|
pub revision: u64,
|
|
pub health_rules: crate::health::HealthRules,
|
|
pub air: BlockStateId,
|
|
/// Sections whose geometry changed and need remeshing.
|
|
pub dirty_sections: DirtySections,
|
|
/// Chunks whose light must be recomputed.
|
|
pub dirty_light: crate::fast_hash::FxHashSet<(i32, i32)>,
|
|
/// Edits on lit chunks (position, old state, new state), relit
|
|
/// incrementally by streaming.
|
|
pub light_edits: Vec<((i32, i32, i32), u32, u32)>,
|
|
/// Saved entities of chunks that just loaded, spawned by the game.
|
|
pub loaded_entities: Vec<((i32, i32), Vec<horizon_world::nbt::Tag>)>,
|
|
/// Chunks changed since the last save.
|
|
pub modified: HashSet<(i32, i32)>,
|
|
/// Block entities, and the order they tick in.
|
|
pub block_entities: crate::block_entities::BlockEntities,
|
|
/// Each chest's `ContainerOpenersCounter`: opener count and largest
|
|
/// interaction range.
|
|
pub chest_openers: HashMap<(i32, i32, i32), (i32, f64)>,
|
|
/// `BaseContainerBlockEntity.name`: custom names of container block entities.
|
|
pub block_names: HashMap<(i32, i32, i32), String>,
|
|
/// States (by id) whose writes are recorded in `watched_writes` (sculk
|
|
/// blocks, which need a block entity).
|
|
pub watched: Vec<bool>,
|
|
/// Writes of watched states: position, previous and new state.
|
|
pub watched_writes: Vec<((i32, i32, i32), u32, u32)>,
|
|
/// `ChunkAccess.inhabitedTime` of resident chunks: ticks a player spent
|
|
/// within spawning range (local difficulty).
|
|
pub inhabited: HashMap<(i32, i32), i64>,
|
|
pub game_time: i64,
|
|
pub day_time: i64,
|
|
pub weather: Weather,
|
|
/// Every block position written since the log was last drained, kept
|
|
/// only while the world is open to the network (see `lan`).
|
|
pub block_log: Option<Vec<(i32, i32, i32)>>,
|
|
/// The sections whose light changed since the log was last drained, as
|
|
/// a bit per section of each column, kept while `block_log` is
|
|
/// (`ChunkHolder.sectionLightChanged`).
|
|
pub light_log: Option<crate::fast_hash::FxHashMap<(i32, i32), u32>>,
|
|
/// The villager POIs of each section (`PoiManager`'s sections).
|
|
pub pois: crate::poi_sections::PoiSections<crate::mobs::villager_brain::Poi>,
|
|
}
|
|
/// ServerLevel weather state (advanceWeatherCycle).
|
|
#[derive(Clone, Copy, Debug, Default)]
|
|
pub struct Weather {
|
|
pub clear_time: i32,
|
|
pub rain_time: i32,
|
|
pub thunder_time: i32,
|
|
pub raining: bool,
|
|
pub thundering: bool,
|
|
pub rain_level: (f32, f32),
|
|
pub thunder_level: (f32, f32),
|
|
}
|
|
impl Weather {
|
|
pub fn tick(&mut self, random: &mut horizon_core::random::LegacyRandom) {
|
|
use horizon_core::random::RandomSource;
|
|
let mut uniform =
|
|
|min: i32, max: i32| min + random.next_int_bound(max - min + 1).unwrap_or(0);
|
|
if self.clear_time > 0 {
|
|
self.clear_time -= 1;
|
|
self.thunder_time = if self.thundering { 0 } else { 1 };
|
|
self.rain_time = if self.raining { 0 } else { 1 };
|
|
self.thundering = false;
|
|
self.raining = false;
|
|
} else {
|
|
if self.thunder_time > 0 {
|
|
self.thunder_time -= 1;
|
|
if self.thunder_time == 0 {
|
|
self.thundering = !self.thundering;
|
|
}
|
|
} else if self.thundering {
|
|
self.thunder_time = uniform(3600, 15600);
|
|
} else {
|
|
self.thunder_time = uniform(12000, 180000);
|
|
}
|
|
if self.rain_time > 0 {
|
|
self.rain_time -= 1;
|
|
if self.rain_time == 0 {
|
|
self.raining = !self.raining;
|
|
}
|
|
} else if self.raining {
|
|
self.rain_time = uniform(12000, 24000);
|
|
} else {
|
|
self.rain_time = uniform(12000, 180000);
|
|
}
|
|
}
|
|
self.thunder_level.0 = self.thunder_level.1;
|
|
self.thunder_level.1 =
|
|
(self.thunder_level.1 + if self.thundering { 0.01 } else { -0.01 }).clamp(0.0, 1.0);
|
|
self.rain_level.0 = self.rain_level.1;
|
|
self.rain_level.1 =
|
|
(self.rain_level.1 + if self.raining { 0.01 } else { -0.01 }).clamp(0.0, 1.0);
|
|
}
|
|
/// Level.getRainLevel / getThunderLevel (thunder scales with rain).
|
|
pub fn levels(&self, partial: f32) -> (f32, f32) {
|
|
let rain = self.rain_level.0 + (self.rain_level.1 - self.rain_level.0) * partial;
|
|
let thunder =
|
|
self.thunder_level.0 + (self.thunder_level.1 - self.thunder_level.0) * partial;
|
|
(rain, thunder * rain)
|
|
}
|
|
}
|
|
impl World {
|
|
pub fn new(air: BlockStateId, seed: i64) -> Self {
|
|
Self {
|
|
chunks: Default::default(),
|
|
random: LegacyRandom::new(seed),
|
|
revision: 0,
|
|
health_rules: crate::health::HealthRules::default(),
|
|
air,
|
|
fast_lava: false,
|
|
dirty_sections: Default::default(),
|
|
dirty_light: Default::default(),
|
|
light_edits: Vec::new(),
|
|
loaded_entities: Vec::new(),
|
|
modified: HashSet::new(),
|
|
block_entities: Default::default(),
|
|
chest_openers: HashMap::new(),
|
|
block_names: HashMap::new(),
|
|
watched: Vec::new(),
|
|
watched_writes: Vec::new(),
|
|
inhabited: HashMap::new(),
|
|
game_time: 0,
|
|
day_time: 1000,
|
|
weather: Weather::default(),
|
|
block_log: None,
|
|
light_log: None,
|
|
pois: Default::default(),
|
|
}
|
|
}
|
|
/// A controlled blockstate scene for the native scene probes: material
|
|
/// layers, a stepped pyramid and the model gallery. Not generated terrain.
|
|
pub fn test_scene(
|
|
assets: &crate::assets::Assets,
|
|
render: &crate::assets::RenderAssets,
|
|
radius: i32,
|
|
) -> crate::Result<Self> {
|
|
let air = assets
|
|
.registry
|
|
.default_state("minecraft:air")
|
|
.ok_or("missing air state")?;
|
|
let mut world = Self::new(air, 0);
|
|
for cz in -radius..=radius {
|
|
for cx in -radius..=radius {
|
|
world
|
|
.chunks
|
|
.insert((cx, cz), Arc::new(Chunk::empty(cx, cz)));
|
|
for z in 0..16 {
|
|
for x in 0..16 {
|
|
for y in 0..4 {
|
|
let layer = match y {
|
|
0 => 0,
|
|
1 | 2 => 1,
|
|
_ if (cx + cz) & 1 == 0 => 2,
|
|
_ => 3,
|
|
};
|
|
world.set(
|
|
cx * 16 + x,
|
|
y,
|
|
cz * 16 + z,
|
|
assets.material_states[layer],
|
|
)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for y in 4..11 {
|
|
for z in -10_i32..=10 {
|
|
for x in -10_i32..=10 {
|
|
if x.abs().max(z.abs()) <= 10 - (y - 4) {
|
|
world.set(
|
|
x,
|
|
y,
|
|
z,
|
|
assets.material_states[if y & 1 == 0 { 4 } else { 5 }],
|
|
)?;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (position, state) in &render.model_placements {
|
|
world.set(position.x, position.y, position.z, *state)?;
|
|
}
|
|
world.revision = 0;
|
|
Ok(world)
|
|
}
|
|
/// Resident storage write; marks the touched sections (and neighbours on
|
|
/// section borders) for remeshing and the surrounding chunks for relighting.
|
|
/// Neighbour updates, drops and block entities belong to the gameplay layer.
|
|
pub fn set(&mut self, x: i32, y: i32, z: i32, state: BlockStateId) -> crate::Result<()> {
|
|
let Some(chunk) = self.chunks.get_mut(&(x >> 4, z >> 4)) else {
|
|
return Err("write outside resident chunks".into());
|
|
};
|
|
if y < MIN_Y || y >= MIN_Y + (SECTIONS as i32) * 16 {
|
|
return Err("write outside world height".into());
|
|
}
|
|
let previous = Arc::make_mut(chunk).set(x & 15, y, z & 15, state.0);
|
|
if previous != state.0 {
|
|
self.block_entities
|
|
.state_changed((x, y, z), previous, state.0);
|
|
let watches = |id: u32| self.watched.get(id as usize).copied().unwrap_or(false);
|
|
if watches(previous) || watches(state.0) {
|
|
self.watched_writes.push(((x, y, z), previous, state.0));
|
|
}
|
|
self.revision = self.revision.wrapping_add(1);
|
|
if let Some(log) = &mut self.block_log {
|
|
log.push((x, y, z));
|
|
}
|
|
self.modified.insert((x >> 4, z >> 4));
|
|
let sy = (y - MIN_Y) >> 4;
|
|
for dz in -1..=1 {
|
|
for dy in -1..=1 {
|
|
for dx in -1..=1 {
|
|
let (bx, by, bz) = (x + dx, y + dy, z + dz);
|
|
let s = (by - MIN_Y) >> 4;
|
|
if !(0..SECTIONS as i32).contains(&s) {
|
|
continue;
|
|
}
|
|
self.dirty_sections.insert((bx >> 4, s, bz >> 4));
|
|
}
|
|
}
|
|
}
|
|
let _ = sy;
|
|
if self.chunks.get(&(x >> 4, z >> 4)).is_some_and(|c| c.lit) {
|
|
self.light_edits.push(((x, y, z), previous, state.0));
|
|
} else {
|
|
for dz in -1..=1 {
|
|
for dx in -1..=1 {
|
|
self.dirty_light.insert(((x >> 4) + dx, (z >> 4) + dz));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
/// `getHeight(Heightmap.Types.WORLD_SURFACE, x, z)`: one above the highest
|
|
/// block that isn't `air`, or `MIN_Y` (also where the chunk isn't loaded).
|
|
pub fn world_surface(&self, x: i32, z: i32, air: impl Fn(BlockStateId) -> bool) -> i32 {
|
|
self.chunks.get(&(x >> 4, z >> 4)).map_or(MIN_Y, |chunk| {
|
|
chunk.world_surface(x, z, |v| air(BlockStateId(v)))
|
|
})
|
|
}
|
|
/// `getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)`: one above the
|
|
/// highest block where `blocks` (motion blocking or holding a fluid),
|
|
/// or `MIN_Y` (also where the chunk isn't loaded).
|
|
pub fn motion_blocking(&self, x: i32, z: i32, blocks: impl Fn(BlockStateId) -> bool) -> i32 {
|
|
self.chunks.get(&(x >> 4, z >> 4)).map_or(MIN_Y, |chunk| {
|
|
chunk.motion_blocking(x & 15, z & 15, |v| blocks(BlockStateId(v)))
|
|
})
|
|
}
|
|
pub fn block(&self, x: i32, y: i32, z: i32) -> BlockStateId {
|
|
self.chunks
|
|
.get(&(x >> 4, z >> 4))
|
|
.map_or(self.air, |chunk| chunk.block(x & 15, y, z & 15))
|
|
}
|
|
/// The block entities to tick this tick, in order (`BlockEntities::tickers`).
|
|
pub fn block_entity_tickers(&mut self) -> Vec<(crate::block_entities::Pos, u32)> {
|
|
let (chunks, air) = (&self.chunks, self.air);
|
|
self.block_entities.tickers(|(x, y, z)| {
|
|
chunks
|
|
.get(&(x >> 4, z >> 4))
|
|
.map_or(air, |chunk| chunk.block(x & 15, y, z & 15))
|
|
.0
|
|
})
|
|
}
|
|
pub fn light(&self, x: i32, y: i32, z: i32) -> u8 {
|
|
self.chunks
|
|
.get(&(x >> 4, z >> 4))
|
|
.map_or(0xF0, |chunk| chunk.light(x & 15, y, z & 15))
|
|
}
|
|
pub fn is_air(&self, state: BlockStateId) -> bool {
|
|
state == self.air
|
|
}
|
|
pub fn loaded(&self, x: i32, z: i32) -> bool {
|
|
self.chunks.contains_key(&(x >> 4, z >> 4))
|
|
}
|
|
}
|