Merge pull request #817 from ludovic111/perf/surface-rules
🤖 Agent: merged the shared ore-vein richness sample (surface −8% alone, −14% with #801; byte-identical, 19 worldgen harnesses pass).
This commit is contained in:
@@ -15,6 +15,8 @@ pub struct MaterialDensitySources<S: MaterialSurfaceQueries> {
|
||||
surface: S,
|
||||
expected: DensityVolume,
|
||||
densities: Vec<BoundDensity>,
|
||||
/// Eagerly sampled volumes, shared by bindings of the same density root.
|
||||
buffers: Vec<Vec<f32>>,
|
||||
retained_samples: usize,
|
||||
plane: DensityVolume,
|
||||
sampler: Arc<dyn DensitySampler>,
|
||||
@@ -23,7 +25,7 @@ pub struct MaterialDensitySources<S: MaterialSurfaceQueries> {
|
||||
}
|
||||
struct BoundDensity {
|
||||
sampler: Arc<dyn DensitySampler>,
|
||||
buffer: Option<Vec<f32>>,
|
||||
buffer: Option<usize>,
|
||||
}
|
||||
impl<S: MaterialSurfaceQueries> MaterialDensitySources<S> {
|
||||
pub fn sampler_context_mut(&mut self) -> &mut SamplerContext {
|
||||
@@ -50,6 +52,7 @@ impl<S: MaterialSurfaceQueries> MaterialDensitySources<S> {
|
||||
surface,
|
||||
expected,
|
||||
densities: Vec::new(),
|
||||
buffers: Vec::new(),
|
||||
retained_samples: 0,
|
||||
plane,
|
||||
sampler,
|
||||
@@ -71,13 +74,23 @@ impl<S: MaterialSurfaceQueries> MaterialSurfaceQueries for MaterialDensitySource
|
||||
{
|
||||
return Err(DecodeError::Field("material density storage bound"));
|
||||
}
|
||||
let buffer = if eager {
|
||||
let mut buffer = vec![0.0; self.expected.size()];
|
||||
sampler.sample_volume(&mut self.context, &mut buffer, self.expected)?;
|
||||
self.retained_samples += buffer.len();
|
||||
Some(buffer)
|
||||
} else {
|
||||
None
|
||||
let shared = self
|
||||
.densities
|
||||
.iter()
|
||||
.find(|bound| bound.buffer.is_some() && Arc::ptr_eq(&bound.sampler, &sampler))
|
||||
.and_then(|bound| bound.buffer);
|
||||
let buffer = match (eager, shared) {
|
||||
(false, _) => None,
|
||||
// Sampling a root over the same volume and context is deterministic,
|
||||
// so a second binding (iron and copper veins' richness) reuses it.
|
||||
(true, Some(buffer)) => Some(buffer),
|
||||
(true, None) => {
|
||||
let mut buffer = vec![0.0; self.expected.size()];
|
||||
sampler.sample_volume(&mut self.context, &mut buffer, self.expected)?;
|
||||
self.retained_samples += buffer.len();
|
||||
self.buffers.push(buffer);
|
||||
Some(self.buffers.len() - 1)
|
||||
}
|
||||
};
|
||||
let index = self.densities.len();
|
||||
self.densities.push(BoundDensity { sampler, buffer });
|
||||
@@ -89,9 +102,9 @@ impl<S: MaterialSurfaceQueries> MaterialSurfaceQueries for MaterialDensitySource
|
||||
.get(index)
|
||||
.ok_or(MaterialRuleError::MissingDensityProvider)?;
|
||||
let position = [position.x, position.y, position.z];
|
||||
if let Some(buffer) = &source.buffer {
|
||||
if let Some(index) = self.expected.index_of_block(position) {
|
||||
return Ok(buffer[index]);
|
||||
if let Some(buffer) = source.buffer {
|
||||
if let Some(index) = block_index(self.expected, position) {
|
||||
return Ok(self.buffers[buffer][index]);
|
||||
}
|
||||
}
|
||||
Ok(source.sampler.sample_value(&mut self.context, position)?)
|
||||
@@ -145,3 +158,121 @@ impl<S: MaterialSurfaceQueries> MaterialSurfaceQueries for MaterialDensitySource
|
||||
self.surface.band(position)
|
||||
}
|
||||
}
|
||||
|
||||
/// `DensityVolume::index_of_block` without its per-axis divisions for the
|
||||
/// unit-step volumes the material stage samples (one or two lookups per block).
|
||||
#[inline]
|
||||
fn block_index(volume: DensityVolume, position: [i32; 3]) -> Option<usize> {
|
||||
if volume.steps() != [1; 3] {
|
||||
return volume.index_of_block(position);
|
||||
}
|
||||
let [mx, my, mz] = volume.minimum();
|
||||
let [sx, sy, sz] = volume.sizes();
|
||||
let x = position[0].wrapping_sub(mx) as u32 as usize;
|
||||
let y = position[1].wrapping_sub(my) as u32 as usize;
|
||||
let z = position[2].wrapping_sub(mz) as u32 as usize;
|
||||
(x < sx && y < sy && z < sz).then(|| y + (x + z * sx) * sy)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use horizon_core::density::SampleError;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
|
||||
struct Surface;
|
||||
impl MaterialSurfaceQueries for Surface {
|
||||
fn surface_depth(&mut self, _: i32, _: i32) -> i32 {
|
||||
0
|
||||
}
|
||||
fn surface_secondary(&mut self, _: i32, _: i32) -> f64 {
|
||||
0.0
|
||||
}
|
||||
}
|
||||
/// Position-dependent values; counts bulk samples.
|
||||
#[derive(Debug, Default)]
|
||||
struct Counted(AtomicUsize);
|
||||
impl DensitySampler for Counted {
|
||||
fn sample_value(&self, _: &mut SamplerContext, p: [i32; 3]) -> Result<f32, SampleError> {
|
||||
Ok((p[0] * 10_000 + p[1] * 100 + p[2]) as f32)
|
||||
}
|
||||
fn sample_volume(
|
||||
&self,
|
||||
context: &mut SamplerContext,
|
||||
buffer: &mut [f32],
|
||||
volume: DensityVolume,
|
||||
) -> Result<(), SampleError> {
|
||||
self.0.fetch_add(1, Ordering::Relaxed);
|
||||
for z in 0..volume.sizes()[2] {
|
||||
for x in 0..volume.sizes()[0] {
|
||||
for y in 0..volume.sizes()[1] {
|
||||
let [mx, my, mz] = volume.minimum();
|
||||
let p = [mx + x as i32, my + y as i32, mz + z as i32];
|
||||
buffer[volume.index([x, y, z]).unwrap()] = self.sample_value(context, p)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
fn sources() -> MaterialDensitySources<Surface> {
|
||||
let volume = DensityVolume::new([16, 24, 16], [32, -64, -16], [1; 3]).unwrap();
|
||||
MaterialDensitySources::new(
|
||||
Surface,
|
||||
volume,
|
||||
Arc::new(Counted::default()),
|
||||
SamplerContext::default(),
|
||||
)
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn eager_bindings_of_one_root_share_a_single_sample() {
|
||||
let mut sources = sources();
|
||||
let shared = Arc::new(Counted::default());
|
||||
let other = Arc::new(Counted::default());
|
||||
let a = sources.bind_density(shared.clone(), true).unwrap();
|
||||
let lazy = sources.bind_density(shared.clone(), false).unwrap();
|
||||
let b = sources.bind_density(shared.clone(), true).unwrap();
|
||||
let c = sources.bind_density(other.clone(), true).unwrap();
|
||||
assert_eq!(shared.0.load(Ordering::Relaxed), 1);
|
||||
assert_eq!(other.0.load(Ordering::Relaxed), 1);
|
||||
assert_eq!([a, lazy, b, c], [0, 1, 2, 3]);
|
||||
for p in [[32, -64, -16], [47, -41, -1], [40, -50, -9], [48, 0, 0]] {
|
||||
let position = BlockPos::new(p[0], p[1], p[2]);
|
||||
let expected = (p[0] * 10_000 + p[1] * 100 + p[2]) as f32;
|
||||
for index in [a, lazy, b, c] {
|
||||
assert_eq!(sources.density(index, position).unwrap(), expected);
|
||||
}
|
||||
}
|
||||
assert_eq!(shared.0.load(Ordering::Relaxed), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn block_index_matches_index_of_block() {
|
||||
let unit = DensityVolume::new([16, 24, 16], [i32::MAX - 7, -64, -16], [1; 3]).unwrap();
|
||||
let strided = DensityVolume::new([5, 3, 5], [-8, -64, 0], [4, 8, 4]).unwrap();
|
||||
for volume in [unit, strided] {
|
||||
let [mx, my, mz] = volume.minimum();
|
||||
for dx in [-1, 0, 1, 4, 7, 8, 15, 16, 17, 20] {
|
||||
for dy in [-9, -1, 0, 8, 16, 23, 24] {
|
||||
for dz in [-1, 0, 3, 15, 16, 20] {
|
||||
let p = [
|
||||
mx.wrapping_add(dx),
|
||||
my.wrapping_add(dy),
|
||||
mz.wrapping_add(dz),
|
||||
];
|
||||
assert_eq!(block_index(volume, p), volume.index_of_block(p), "{p:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
for p in [
|
||||
[i32::MIN, 0, 0],
|
||||
[i32::MAX, i32::MAX, i32::MAX],
|
||||
[0, i32::MIN, 0],
|
||||
] {
|
||||
assert_eq!(block_index(volume, p), volume.index_of_block(p), "{p:?}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user