Merge pull request #659 from ludovic111/perf/collision-scan
🤖 Agent: merged. Verify passed. Integration proof (main + #1041 #1043 #1021 #1020 #1032 #659 #1029 #1066), 2026-10-21: 97 of 100 harnesses passed on the desktop. world_reopen and save_roundtrip need a display there; they pass on the Mac mini with #1041/#1043. dedicated_server is a pre-existing flake: it fails on plain main too, and is pass/fail in 2 runs on the integration.
This commit is contained in:
@@ -425,6 +425,16 @@ impl Aabb {
|
||||
),
|
||||
)
|
||||
}
|
||||
/// `AABB.intersects(minX, minY, minZ, maxX, maxY, maxZ)`: `intersects`
|
||||
/// with a box given by its corners, `min` below `max` on every axis.
|
||||
pub fn intersects_corners(self, min: Vec3, max: Vec3) -> bool {
|
||||
self.min.x < max.x
|
||||
&& self.max.x > min.x
|
||||
&& self.min.y < max.y
|
||||
&& self.max.y > min.y
|
||||
&& self.min.z < max.z
|
||||
&& self.max.z > min.z
|
||||
}
|
||||
pub fn intersects(self, other: Self) -> bool {
|
||||
self.min.x < other.max.x
|
||||
&& self.max.x > other.min.x
|
||||
|
||||
@@ -125,10 +125,16 @@ impl VoxelShape {
|
||||
.clone()
|
||||
}
|
||||
pub fn block() -> Self {
|
||||
Self::block_ref().clone()
|
||||
}
|
||||
fn block_ref() -> &'static Self {
|
||||
static BLOCK: OnceLock<VoxelShape> = OnceLock::new();
|
||||
BLOCK
|
||||
.get_or_init(|| Self::from_cube([1, 1, 1], &[true]).expect("valid unit cube"))
|
||||
.clone()
|
||||
BLOCK.get_or_init(|| Self::from_cube([1, 1, 1], &[true]).expect("valid unit cube"))
|
||||
}
|
||||
/// `shape == Shapes.block()`: the same as `same_identity(&block())`
|
||||
/// without cloning the shared unit cube.
|
||||
pub fn is_block(&self) -> bool {
|
||||
self.same_identity(Self::block_ref())
|
||||
}
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.bounds.is_none()
|
||||
@@ -283,7 +289,9 @@ impl VoxelShape {
|
||||
}
|
||||
}
|
||||
result.coords = Arc::new(coords);
|
||||
result.boxes = Arc::new(result.decompose());
|
||||
// The same occupancy decomposes into the same boxes, over coordinates
|
||||
// moved by the same additions.
|
||||
result.boxes = Arc::new(self.boxes.iter().map(|b| b.move_by(offset)).collect());
|
||||
result.bounds = self.bounds.map(|bounds| bounds.move_by(offset));
|
||||
result
|
||||
}
|
||||
@@ -548,4 +556,45 @@ mod tests {
|
||||
);
|
||||
assert!(VoxelShape::from_grid(std::array::from_fn(|_| vec![0.0, 1.0]), &[]).is_err());
|
||||
}
|
||||
#[test]
|
||||
fn moved_boxes_are_the_moved_shapes_decomposition() {
|
||||
let stair = VoxelShape::from_cube(
|
||||
[2, 2, 2],
|
||||
&[true, true, false, false, true, true, true, true],
|
||||
)
|
||||
.unwrap();
|
||||
let slab = VoxelShape::from_grid([vec![0.0, 1.0], vec![0.0, 0.5], vec![0.0, 1.0]], &[true])
|
||||
.unwrap();
|
||||
let offsets = [
|
||||
Vec3::new(3.0, -64.0, -7.0),
|
||||
Vec3::new(-0.0, 0.0, -0.0),
|
||||
Vec3::new(1.0e-9, 319.999, -30_000_000.0),
|
||||
Vec3::new(f64::from(i32::MAX), f64::from(i32::MIN), 0.1),
|
||||
];
|
||||
for shape in [VoxelShape::block(), stair, slab] {
|
||||
for offset in offsets {
|
||||
let moved = shape.moved(offset);
|
||||
let [nx, ny, nz] = shape.sizes();
|
||||
let occupied: Vec<bool> = (0..nx * ny * nz)
|
||||
.map(|i| {
|
||||
shape.is_full(
|
||||
(i / (ny * nz)) as i32,
|
||||
(i / nz % ny) as i32,
|
||||
(i % nz) as i32,
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
let rebuilt = VoxelShape::from_grid(
|
||||
Axis::ALL.map(|axis| moved.coordinates(axis).to_vec()),
|
||||
&occupied,
|
||||
)
|
||||
.unwrap();
|
||||
assert_eq!(moved.boxes(), rebuilt.boxes());
|
||||
assert_eq!(moved.bounds(), rebuilt.bounds());
|
||||
}
|
||||
}
|
||||
assert!(VoxelShape::block().is_block());
|
||||
assert!(!VoxelShape::block().moved(Vec3::ZERO).is_block());
|
||||
assert!(!VoxelShape::block().fresh_identity().is_block());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -111,7 +111,8 @@ impl<'r> BlockCollisionRegistry<'r> {
|
||||
scan_flags.push(
|
||||
u8::from(large)
|
||||
| (u8::from(state.name == "minecraft:moving_piston") << 1)
|
||||
| (u8::from(empty) << 2),
|
||||
| (u8::from(empty) << 2)
|
||||
| (u8::from(contextual.contains_key(&id)) << 3),
|
||||
);
|
||||
if cached.cached_shape(id)?.is_none() {
|
||||
if let Some(rule) =
|
||||
@@ -183,7 +184,12 @@ impl<'r> BlockCollisionRegistry<'r> {
|
||||
+ LiquidCollisionWorld<Error = E>
|
||||
+ PowderSnowWorld<Error = E>,
|
||||
{
|
||||
match self.contextual.get(&state) {
|
||||
// Most states have no contextual rule: their flag spares the lookup.
|
||||
let contextual = self
|
||||
.scan_flags
|
||||
.get(state.0 as usize)
|
||||
.is_none_or(|flags| flags & 8 != 0);
|
||||
match contextual.then(|| self.contextual.get(&state)).flatten() {
|
||||
Some(ContextualRule::Scaffolding(rule)) => Ok(rule.shape(context, position)),
|
||||
Some(ContextualRule::Liquid(rule)) => rule
|
||||
.shape(world, position, context)
|
||||
|
||||
@@ -83,6 +83,8 @@ pub struct BlockCollisionScan<'w, 'c, W: BlockCollisionWorld> {
|
||||
start: BlockPos,
|
||||
sizes: [usize; 3],
|
||||
index: usize,
|
||||
/// The cell at `index`, relative to `start` (x fastest, then y, then z).
|
||||
cursor: [usize; 3],
|
||||
count: usize,
|
||||
budget: usize,
|
||||
chunk: Option<(ChunkPos, W::Chunk)>,
|
||||
@@ -131,6 +133,7 @@ impl<'w, 'c, W: BlockCollisionWorld> BlockCollisionScan<'w, 'c, W> {
|
||||
start,
|
||||
sizes: sizes.map(|s| s as usize),
|
||||
index: 0,
|
||||
cursor: [0; 3],
|
||||
count,
|
||||
budget: candidate_budget,
|
||||
chunk: None,
|
||||
@@ -144,12 +147,17 @@ impl<'w, 'c, W: BlockCollisionWorld> BlockCollisionScan<'w, 'c, W> {
|
||||
return Err(CollisionScanError::VisitBudget);
|
||||
}
|
||||
let [width, height, _] = self.sizes;
|
||||
let relative = [
|
||||
self.index % width,
|
||||
self.index / width % height,
|
||||
self.index / width / height,
|
||||
];
|
||||
let relative = self.cursor;
|
||||
self.index += 1;
|
||||
self.cursor[0] += 1;
|
||||
if self.cursor[0] == width {
|
||||
self.cursor[0] = 0;
|
||||
self.cursor[1] += 1;
|
||||
if self.cursor[1] == height {
|
||||
self.cursor[1] = 0;
|
||||
self.cursor[2] += 1;
|
||||
}
|
||||
}
|
||||
let kind = relative
|
||||
.into_iter()
|
||||
.zip(self.sizes)
|
||||
@@ -199,13 +207,10 @@ impl<'w, 'c, W: BlockCollisionWorld> BlockCollisionScan<'w, 'c, W> {
|
||||
.context_shape(block, p, &self.context)
|
||||
.map_err(CollisionScanError::World)?;
|
||||
let offset = Vec3::new(f64::from(p.x), f64::from(p.y), f64::from(p.z));
|
||||
let moved = if shape.same_identity(&VoxelShape::block()) {
|
||||
let moved = if shape.is_block() {
|
||||
// Native adds one in floating point, including at i32::MAX.
|
||||
let unit = Aabb::new(
|
||||
offset,
|
||||
Vec3::new(offset.x + 1.0, offset.y + 1.0, offset.z + 1.0),
|
||||
);
|
||||
if !self.bounds.intersects(unit) {
|
||||
let top = Vec3::new(offset.x + 1.0, offset.y + 1.0, offset.z + 1.0);
|
||||
if !self.bounds.intersects_corners(offset, top) {
|
||||
continue;
|
||||
}
|
||||
shape.moved(offset)
|
||||
|
||||
@@ -7,6 +7,7 @@ use horizon_world::{
|
||||
BlockCollisionScan, BlockCollisionWorld, CollisionBlock, CollisionScanError,
|
||||
},
|
||||
collision_context::CollisionContext,
|
||||
registry::BlockStateId,
|
||||
};
|
||||
use std::io;
|
||||
|
||||
@@ -106,3 +107,85 @@ fn invalid_or_excessive_domains_fail_before_world_queries() {
|
||||
));
|
||||
assert_eq!(world.calls, 0);
|
||||
}
|
||||
|
||||
/// Records every cell the scan reads; every block passes the edge filters
|
||||
/// and has an empty shape.
|
||||
struct Recording {
|
||||
cells: Vec<BlockPos>,
|
||||
}
|
||||
impl BlockCollisionWorld for Recording {
|
||||
type Error = io::Error;
|
||||
type Chunk = ();
|
||||
fn collision_chunk(&mut self, _: ChunkPos) -> io::Result<Option<()>> {
|
||||
Ok(Some(()))
|
||||
}
|
||||
fn collision_block(&mut self, _: (), p: BlockPos) -> io::Result<CollisionBlock> {
|
||||
self.cells.push(p);
|
||||
Ok(CollisionBlock {
|
||||
state: BlockStateId(0),
|
||||
large_collision_shape: true,
|
||||
moving_piston: true,
|
||||
empty_shape: true,
|
||||
})
|
||||
}
|
||||
fn is_suffocating(&mut self, _: (), _: CollisionBlock, _: BlockPos) -> io::Result<bool> {
|
||||
unreachable!()
|
||||
}
|
||||
fn context_shape(
|
||||
&mut self,
|
||||
_: CollisionBlock,
|
||||
_: BlockPos,
|
||||
_: &CollisionContext<'_>,
|
||||
) -> io::Result<VoxelShape> {
|
||||
unreachable!()
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cells_follow_the_cursor_order_without_corners() {
|
||||
let boxes = [
|
||||
Aabb::new(Vec3::new(0.2, 64.0, 0.3), Vec3::new(0.8, 65.95, 0.9)),
|
||||
Aabb::new(Vec3::new(-17.5, -3.25, 31.0), Vec3::new(-15.0, -3.25, 33.5)),
|
||||
Aabb::new(Vec3::new(5.0, 5.0, 5.0), Vec3::new(5.0, 5.0, 5.0)),
|
||||
Aabb::new(Vec3::new(-0.3, 0.0, -0.3), Vec3::new(0.3, 0.9, 0.3)),
|
||||
];
|
||||
for bounds in boxes {
|
||||
let mut world = Recording { cells: Vec::new() };
|
||||
let hits = BlockCollisionScan::new(
|
||||
&mut world,
|
||||
CollisionContext::empty(false),
|
||||
bounds,
|
||||
false,
|
||||
1_000_000,
|
||||
)
|
||||
.unwrap()
|
||||
.count();
|
||||
assert_eq!(hits, 0);
|
||||
// Cursor3D: x fastest, then y, then z, skipping the 8 corners.
|
||||
let (min, max) = (bounds.min_position(), bounds.max_position());
|
||||
let start = BlockPos::containing(Vec3::new(min.x - 1.0e-7, min.y - 1.0e-7, min.z - 1.0e-7))
|
||||
.offset(-1, -1, -1);
|
||||
let end = BlockPos::containing(Vec3::new(max.x + 1.0e-7, max.y + 1.0e-7, max.z + 1.0e-7))
|
||||
.offset(1, 1, 1);
|
||||
let sizes = [
|
||||
end.x - start.x + 1,
|
||||
end.y - start.y + 1,
|
||||
end.z - start.z + 1,
|
||||
];
|
||||
let mut expected = Vec::new();
|
||||
for i in 0..sizes[0] * sizes[1] * sizes[2] {
|
||||
let r = [
|
||||
i % sizes[0],
|
||||
i / sizes[0] % sizes[1],
|
||||
i / sizes[0] / sizes[1],
|
||||
];
|
||||
let edges = (0..3)
|
||||
.filter(|&a| r[a] == 0 || r[a] == sizes[a] - 1)
|
||||
.count();
|
||||
if edges < 3 {
|
||||
expected.push(start.offset(r[0], r[1], r[2]));
|
||||
}
|
||||
}
|
||||
assert_eq!(world.cells, expected);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user