Merge pull request #993 from ludovic111/perf/lod-buried-gaps

🤖 Agent: merged after verify passed and CI parity passed on the stack head (#995; local 98/98). perf-frame-9's terrain LOD follow-ups: band and black cliffs fixed, far quads −36 %, per-frame budgets, LOD cap on non-Apple integrated GPUs. LODs off matches main (screenshots, FPS).
This commit is contained in:
Ludovic Marie
2026-10-19 14:37:56 +02:00
committed by GitHub
+168 -17
View File
@@ -302,8 +302,34 @@ fn mesh_columns_with_edges(
count += neighbors[side].len();
start
});
let prepared: Vec<Vec<Segment<'_>>> = columns
let stride = key.size() / CELLS as i32;
let [ox, _, oz] = key.origin();
// A cell meets full-detail or finer terrain: it is meshed in smaller steps.
let cell_step = |x: usize, z: usize| {
let (wx, wz) = (ox + x as i32 * stride, oz + z as i32 * stride);
let overlaps = covered_bounds.is_some_and(|[x0, z0, x1, z1]| {
wx < x1 && wx + stride > x0 && wz < z1 && wz + stride > z0
});
let mut step = if overlaps { stride.min(16) } else { stride };
for other in finer {
let [x, _, z] = other.origin();
if wx < x + other.size() && x < wx + stride && wz < z + other.size() && z < wz + stride
{
step = step.min(other.size());
}
}
step
};
let filled = fill_buried_gaps(
columns,
neighbors,
stride,
|x, z| cell_step(x, z) == stride,
|span| material(span, Direction::Up).fluid != 0,
);
let prepared: Vec<Vec<Segment<'_>>> = filled
.iter()
.map(|column| &**column)
.chain(neighbors.iter().flatten().map(|edge| &edge.column))
.map(|column| {
let materials: Vec<_> = column
@@ -342,8 +368,6 @@ fn mesh_columns_with_edges(
})
.collect();
let mut faces = Faces::new();
let stride = key.size() / CELLS as i32;
let [ox, _, oz] = key.origin();
let finer_keys: FxHashSet<_> = finer.iter().copied().collect();
let mut finer_levels: Vec<_> = finer.iter().map(|key| key.level).collect();
finer_levels.sort_unstable();
@@ -362,20 +386,7 @@ fn mesh_columns_with_edges(
for z in 0..CELLS {
for x in 0..CELLS {
let (wx, wz) = (ox + x as i32 * stride, oz + z as i32 * stride);
let overlaps = covered_bounds.is_some_and(|[x0, z0, x1, z1]| {
wx < x1 && wx + stride > x0 && wz < z1 && wz + stride > z0
});
let mut step = if overlaps { stride.min(16) } else { stride };
for other in finer {
let [x, _, z] = other.origin();
if wx < x + other.size()
&& x < wx + stride
&& wz < z + other.size()
&& z < wz + stride
{
step = step.min(other.size());
}
}
let step = cell_step(x, z);
let column = &prepared[z * CELLS + x];
let own_sky = column.last().map_or(0, |top| top.span.light & 0xff);
for dz in (0..stride).step_by(step as usize) {
@@ -636,6 +647,102 @@ mod refinement_tests {
}
}
/// The tile's columns with the gaps no neighbour's open air reaches filled
/// with the material below them, or the fluid above them (kelp and seagrass
/// leave gaps in water): a cave seen from nowhere adds no faces. A
/// gap is open when a neighbouring column's top lies below the gap's top, so
/// that column's open air looks into it. Unknown neighbours, and cells that
/// `whole` rejects (they meet full-detail or finer terrain), count as open;
/// those cells keep their gaps.
fn fill_buried_gaps<'a>(
columns: &'a [Column],
neighbors: &[Vec<EdgeColumn>; 4],
stride: i32,
whole: impl Fn(usize, usize) -> bool,
mut fluid: impl FnMut(&Span) -> bool,
) -> Vec<std::borrow::Cow<'a, Column>> {
use std::borrow::Cow;
let top = |column: &Column| {
column
.spans
.iter()
.rev()
.find(|span| span.min < span.max)
.map_or(i16::MIN, |span| span.max)
};
let tops: Vec<_> = (0..CELLS * CELLS)
.map(|i| {
if whole(i % CELLS, i / CELLS) {
top(&columns[i])
} else {
i16::MIN
}
})
.collect();
let edge = |side: usize, cell: usize| {
let (start, end) = (cell as i32 * stride, (cell as i32 + 1) * stride);
neighbors[side]
.iter()
.filter(|edge| edge.start < end && start < edge.end)
.map(|edge| top(&edge.column))
.min()
.unwrap_or(i16::MIN)
};
columns
.iter()
.enumerate()
.map(|(i, column)| {
let (x, z) = (i % CELLS, i / CELLS);
if column.spans.len() < 2 || !whole(x, z) {
return Cow::Borrowed(column);
}
let open = [
if x > 0 { tops[i - 1] } else { edge(0, z) },
if x + 1 < CELLS {
tops[i + 1]
} else {
edge(1, z)
},
if z > 0 { tops[i - CELLS] } else { edge(2, x) },
if z + 1 < CELLS {
tops[i + CELLS]
} else {
edge(3, x)
},
]
.into_iter()
.min()
.unwrap_or(i16::MIN);
let buried = |below: &Span, above: &Span| below.max < above.min && above.min <= open;
if !column
.spans
.windows(2)
.any(|pair| buried(&pair[0], &pair[1]))
{
return Cow::Borrowed(column);
}
let mut filled = Column {
surface: column.surface,
spans: Vec::with_capacity(column.spans.len()),
};
for &span in &column.spans {
let mut span = span;
if let Some(below) = filled.spans.last_mut()
&& buried(below, &span)
{
if fluid(&span) {
span.min = below.max;
} else {
below.max = span.min;
}
}
filled.push(span);
}
Cow::Owned(filled)
})
.collect()
}
/// Adds the parts of `segment`'s side not hidden by `neighbor`, the column
/// it faces. Parts above the neighbour's top face open air: reduced columns
/// and the seals at full-detail edges expose sides that were buried (their
@@ -1012,6 +1119,50 @@ mod tests {
assert!(cave[0].iter().all(|v| v.light == 0));
}
#[test]
fn caves_no_neighbor_sees_into_add_no_faces() {
let mut columns = columns();
for column in &mut columns {
column.spans = vec![span(0, 20, 1)];
}
let cave = 5 * CELLS + 5;
columns[cave].spans = vec![span(0, 8, 1), span(12, 20, 1)];
let at = |mesh: &SectionMesh, y: f32| {
mesh.solid
.as_chunks::<4>()
.0
.iter()
.filter(|q| q.iter().all(|v| v.pos[1] == y))
.count()
};
// Closed on every side: filled, no floor or ceiling.
let closed = mesh(&columns);
assert_eq!((at(&closed, 8.0), at(&closed, 12.0)), (0, 0));
assert!(
closed
.solid
.iter()
.all(|v| v.pos[1] == 0.0 || v.pos[1] == 20.0)
);
// A lower neighbour's open air looks in: the cave stays.
columns[cave + 1].spans = vec![span(0, 10, 1)];
let open = mesh(&columns);
assert_eq!((at(&open, 8.0), at(&open, 12.0)), (1, 1));
// Kelp leaves a gap in water: water fills it, without inner faces.
for column in &mut columns {
column.spans = vec![span(0, 5, 1), span(5, 10, 2)];
}
columns[cave].spans = vec![span(0, 5, 1), span(5, 7, 2), span(8, 10, 2)];
let water = mesh(&columns);
assert!(
water
.translucent
.iter()
.all(|v| v.pos[1] != 7.0 && v.pos[1] != 8.0)
);
let uniform = mesh(&vec![columns[0].clone(); CELLS * CELLS]);
assert_eq!(water.translucent.len(), uniform.translucent.len());
}
#[test]
fn greedy_faces_preserve_material_and_light_boundaries() {
let mut columns = columns();
columns[0].spans = vec![span(0, 1, 1)];