Merge pull request #1207 from pirut/claude/upstream-feature-speedups

🤖 Agent: merged after verify passed and the integration run on the desktop (main 34c3c1cf + the 14 contributor PRs: workspace tests 1,869/0, launcher 113, parity --changed 320/0).
This commit is contained in:
Ludovic Marie
2026-10-22 19:53:54 +02:00
committed by GitHub
6 changed files with 223 additions and 36 deletions
@@ -123,10 +123,12 @@ pub struct BiomeTemperature {
}
impl BiomeTemperature {
pub fn new(settings: BiomeTemperatureSettings) -> Self {
// Empty until used: a decoration region makes one per biome, and
// most biomes never ask for a temperature.
Self {
settings,
values: HashMap::with_capacity(1024),
order: VecDeque::with_capacity(1024),
values: HashMap::new(),
order: VecDeque::new(),
}
}
pub fn settings(&self) -> BiomeTemperatureSettings {
@@ -22,7 +22,7 @@ use horizon_core::{
},
};
use std::{
collections::{BTreeMap, BTreeSet},
collections::{BTreeMap, BTreeSet, HashMap},
sync::Arc,
};
@@ -58,7 +58,10 @@ impl From<RegionError> for PlacementQueryError {
}
}
pub struct TerrainRegion<'r, B: TerrainBlockStates> {
chunks: BTreeMap<(i32, i32), TerrainChunk<'r, B>>,
/// Ordered by X then Z.
chunks: Vec<TerrainChunk<'r, B>>,
/// Each chunk's index in `chunks`: every block access looks one up.
index: ChunkIndex,
min_y: i32,
height: i32,
generation: WorldGenerationContext,
@@ -68,6 +71,77 @@ pub struct TerrainRegion<'r, B: TerrainBlockStates> {
block_queries: Option<RegionBlockQueries>,
world_seed: Option<i64>,
}
/// Where each chunk of a region sits in its list: a grid over the chunks'
/// bounding box while it is small (the usual square of neighbours), else a
/// map (chunks spread far apart).
enum ChunkIndex {
Grid {
origin: (i32, i32),
columns: i64,
rows: i64,
/// Row by row from `origin`; `u32::MAX` where no chunk is.
cells: Vec<u32>,
},
Sparse(HashMap<(i32, i32), u32>),
}
impl ChunkIndex {
/// The largest grid, in chunk columns.
const GRID_CELLS: i64 = 1 << 20;
/// `None` when two chunks share a position.
fn new(positions: &[(i32, i32)]) -> Option<Self> {
let x0 = positions.iter().map(|p| p.0).min()?;
let z0 = positions.iter().map(|p| p.1).min()?;
let columns = i64::from(positions.iter().map(|p| p.0).max()?) - i64::from(x0) + 1;
let rows = i64::from(positions.iter().map(|p| p.1).max()?) - i64::from(z0) + 1;
if columns * rows > Self::GRID_CELLS {
let mut map = HashMap::with_capacity(positions.len());
for (i, &p) in positions.iter().enumerate() {
if map.insert(p, i as u32).is_some() {
return None;
}
}
return Some(Self::Sparse(map));
}
let mut cells = vec![u32::MAX; (columns * rows) as usize];
for (i, &(x, z)) in positions.iter().enumerate() {
let cell = (i64::from(z) - i64::from(z0)) * columns + (i64::from(x) - i64::from(x0));
let cell = &mut cells[cell as usize];
if *cell != u32::MAX {
return None;
}
*cell = i as u32;
}
Some(Self::Grid {
origin: (x0, z0),
columns,
rows,
cells,
})
}
fn get(&self, x: i32, z: i32) -> Option<usize> {
match self {
Self::Grid {
origin,
columns,
rows,
cells,
} => {
let (dx, dz) = (
i64::from(x) - i64::from(origin.0),
i64::from(z) - i64::from(origin.1),
);
if !(0..*columns).contains(&dx) || !(0..*rows).contains(&dz) {
return None;
}
match cells[(dz * columns + dx) as usize] {
u32::MAX => None,
i => Some(i as usize),
}
}
Self::Sparse(map) => map.get(&(x, z)).map(|&i| i as usize),
}
}
}
impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> {
pub fn new(
chunks: Vec<TerrainChunk<'r, B>>,
@@ -83,15 +157,16 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> {
}) {
return Err(RegionError::InvalidChunks);
}
let mut stored = BTreeMap::new();
for chunk in chunks {
let p = chunk.position();
if stored.insert((p.x, p.z), chunk).is_some() {
return Err(RegionError::InvalidChunks);
}
}
let mut chunks = chunks;
chunks.sort_by_key(|c| (c.position().x, c.position().z));
let positions: Vec<(i32, i32)> = chunks
.iter()
.map(|c| (c.position().x, c.position().z))
.collect();
let index = ChunkIndex::new(&positions).ok_or(RegionError::InvalidChunks)?;
Ok(Self {
chunks: stored,
chunks,
index,
sea_level: generator.sea_level,
game_time: 0,
next_tick_order: 0,
@@ -114,10 +189,7 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> {
mut self,
bindings: &super::block_feature::FeatureBlockBindings<'r>,
) -> Result<Self, RegionError> {
if !std::ptr::eq(
self.chunks.first_key_value().unwrap().1.registry(),
bindings.registry(),
) {
if !std::ptr::eq(self.chunks[0].registry(), bindings.registry()) {
return Err(RegionError::InvalidBindings);
}
self.block_queries = Some(RegionBlockQueries {
@@ -186,20 +258,25 @@ impl<'r, B: TerrainBlockStates> TerrainRegion<'r, B> {
}
/// Release the resident chunks, ordered by X then Z; match them by position.
pub fn into_chunks(self) -> Vec<TerrainChunk<'r, B>> {
self.chunks.into_values().collect()
self.chunks
}
pub fn chunks(&self) -> impl Iterator<Item = &TerrainChunk<'r, B>> {
self.chunks.values()
self.chunks.iter()
}
fn index(&self, x: i32, z: i32) -> Option<usize> {
self.index.get(x, z)
}
pub fn chunk(&self, x: i32, z: i32) -> Result<&TerrainChunk<'r, B>, RegionError> {
self.chunks
.get(&(x, z))
.ok_or(RegionError::MissingChunk([x, z]))
match self.index(x, z) {
Some(i) => Ok(&self.chunks[i]),
None => Err(RegionError::MissingChunk([x, z])),
}
}
pub fn chunk_mut(&mut self, x: i32, z: i32) -> Result<&mut TerrainChunk<'r, B>, RegionError> {
self.chunks
.get_mut(&(x, z))
.ok_or(RegionError::MissingChunk([x, z]))
match self.index(x, z) {
Some(i) => Ok(&mut self.chunks[i]),
None => Err(RegionError::MissingChunk([x, z])),
}
}
pub fn block(&self, [x, y, z]: [i32; 3]) -> Result<BlockStateId, RegionError> {
Ok(self.chunk(x >> 4, z >> 4)?.block(x, y, z))
@@ -302,12 +379,7 @@ impl<B: TerrainBlockStates> PlacementContext for TerrainRegion<'_, B> {
block: BlockStateId,
delay: i32,
) -> Result<(), PlacementQueryError> {
let registry = self
.chunks
.first_key_value()
.expect("nonempty region")
.1
.registry();
let registry = self.chunks[0].registry();
let state = registry
.state(block)
.ok_or(RegionError::InvalidTickState(block))?;
@@ -1129,4 +1129,41 @@ impl PlacementContext for World<'_> {
fn height(&mut self, kind: HeightmapType, x: i32, z: i32) -> Result<i32, PlacementQueryError> {
self.region.height(kind, x, z)
}
/// OreFeature's search for a column under its blob, without a trait call
/// per column. Defers to `height` when a heightmap still has to be primed.
fn any_height_at_least(
&mut self,
kind: HeightmapType,
[x0, z0]: [i32; 2],
size: i32,
y: i32,
) -> Result<Option<bool>, PlacementQueryError> {
let (x1, z1) = (x0.wrapping_add(size), z0.wrapping_add(size));
if size < 0 || x1 < x0 || z1 < z0 {
return Ok(None);
}
for cx in x0 >> 4..=x1 >> 4 {
for cz in z0 >> 4..=z1 >> 4 {
if !self
.region
.chunk(cx, cz)
.is_ok_and(|c| c.heightmap(kind).is_some())
{
return Ok(None);
}
}
}
for x in x0..=x1 {
for z in z0..=z1 {
let map = self.region.chunk(x >> 4, z >> 4)?.heightmap(kind).unwrap();
let floor = map
.first_available(x & 15, z & 15)
.map_err(|e| RegionError::from(super::terrain::TerrainError::from(e)))?;
if y <= floor {
return Ok(Some(true));
}
}
}
Ok(Some(false))
}
}
@@ -180,6 +180,27 @@ impl OreFeature {
let z_start = origin[2].wrapping_sub(spread_ceil).wrapping_sub(max_radius);
let size_xz = 2 * (spread_ceil + max_radius);
let size_y = 2 * (2 + max_radius);
if let Some(found) = world
.any_height_at_least(
HeightmapType::OceanFloorWg,
[x_start, z_start],
size_xz,
y_start,
)
.map_err(FeatureExecutionError::Query)?
{
return match found {
true => self.do_place(
world,
random,
[x0, x1, z0, z1, y0, y1],
[x_start, y_start, z_start],
size_xz,
size_y,
),
false => Ok(false),
};
}
for x in 0..=size_xz {
for z in 0..=size_xz {
let (px, pz) = (x_start.wrapping_add(x), z_start.wrapping_add(z));
@@ -243,7 +264,8 @@ impl OreFeature {
}
}
}
let mut tested = vec![false; (size_xz as usize) * (size_y as usize) * (size_xz as usize)];
let tested_len = (size_xz as usize) * (size_y as usize) * (size_xz as usize);
let mut tested = vec![0u64; tested_len.div_ceil(64)];
let mut placed = 0;
for [xx, yy, zz, r] in data {
if r < 0.0 {
@@ -280,16 +302,15 @@ impl OreFeature {
* i64::from(size_xz)
* i64::from(size_y);
// The sphere bounds keep indices inside the native BitSet.
let Some(bit) = usize::try_from(index)
.ok()
.and_then(|index| tested.get_mut(index))
let Some(index) = usize::try_from(index).ok().filter(|&i| i < tested_len)
else {
return Err(FeatureExecutionError::WorkLimit);
};
if *bit {
let (word, bit) = (&mut tested[index / 64], 1u64 << (index % 64));
if *word & bit != 0 {
continue;
}
*bit = true;
*word |= bit;
let p = [x, y, z];
if !world
.ensure_can_write(p)
@@ -351,6 +351,18 @@ pub trait PlacementContext {
/// World minimum, which can differ from the generator's minimum.
fn min_y(&mut self) -> Result<i32, PlacementQueryError>;
fn height(&mut self, kind: HeightmapType, x: i32, z: i32) -> Result<i32, PlacementQueryError>;
/// Whether any column of the square `x..=x + size`, `z..=z + size` has
/// `height(kind)` at least `y`, read faster than column by column; `None`
/// when the world can't (callers then ask `height` for each column).
fn any_height_at_least(
&mut self,
_kind: HeightmapType,
_corner: [i32; 2],
_size: i32,
_y: i32,
) -> Result<Option<bool>, PlacementQueryError> {
Ok(None)
}
}
impl PlacementContext for WorldGenerationContext {
fn max_y(&mut self) -> Result<i32, PlacementQueryError> {
@@ -385,3 +385,46 @@ fn retained_upgrade_status_allows_old_biome_reads() {
}
}
}
#[test]
fn spread_out_regions_route_like_dense_ones() {
// Chunks too far apart for a grid over their bounding box (fixtures put
// one at the far edge of the world beside the origin's neighbours).
let registry = registry();
let context = WorldGenerationContext::new(0, 16, 8);
let chunk =
|x, z| TerrainChunk::new(ChunkPos::new(x, z), 0, 16, &registry, Properties).unwrap();
for far in [4_194_304, -4_194_304] {
let mut region = TerrainRegion::new(
vec![chunk(0, 0), chunk(far, 0), chunk(1, -1), chunk(-1, 1)],
context,
)
.unwrap();
let x = far * 16 + 3;
region
.set_block_worldgen([x, 7, 5], BlockStateId(2))
.unwrap();
assert_eq!(region.block([x, 7, 5]).unwrap(), BlockStateId(2));
assert_eq!(region.block([3, 7, 5]).unwrap(), BlockStateId(0));
assert_eq!(region.block([16, 7, -1]).unwrap(), BlockStateId(0));
assert!(matches!(
region.block([x + 16, 7, 5]),
Err(RegionError::MissingChunk([_, 0]))
));
assert!(matches!(
region.block([0, 7, 16]),
Err(RegionError::MissingChunk([0, 1]))
));
let order: Vec<_> = region
.into_chunks()
.iter()
.map(|c| (c.position().x, c.position().z))
.collect();
let mut sorted = order.clone();
sorted.sort();
assert_eq!(order, sorted, "into_chunks is ordered by X then Z");
// A position twice is refused either way.
assert!(
TerrainRegion::new(vec![chunk(0, 0), chunk(far, 0), chunk(far, 0)], context).is_err()
);
}
}