From f7d042c6d0540a7b367694081ba3a3623e1d1304 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 16 Oct 2026 16:03:59 +0200 Subject: [PATCH] Skip section face groups that face away from the eye The mesher groups each section's solid quads by the axis side they face (Sodium's ModelQuadFacing) and records each group's nearest plane. When the eye is behind every plane of a group, back-face culling would discard all of it after vertex shading, so the renderer leaves the group out of the section's draws. Seen from the village path, 29-36% fewer solid quads reach the GPU at render distances 8-32; the picture is unchanged. Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 37 +-- crates/horizon-client/src/mesher.rs | 11 + crates/horizon-client/src/mesher/facing.rs | 272 ++++++++++++++++++ .../src/mesher/leaf_culling_tests.rs | 2 +- 4 files changed, 305 insertions(+), 17 deletions(-) create mode 100644 crates/horizon-client/src/mesher/facing.rs diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index c99b39c2a..1d74709a0 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -95,6 +95,8 @@ struct SectionGpu { start: u64, solid: u32, translucent: u32, + /// The solid quads by facing: back-facing groups are skipped. + faces: crate::mesher::FaceGroups, } /// A visible section this frame: key, squared distance, camera-relative origin. type Visible = (SectionKey, f64, [f32; 3]); @@ -1756,6 +1758,7 @@ impl Renderer { start, solid, translucent, + faces: mesh.faces, }, ); } @@ -2236,25 +2239,27 @@ impl Renderer { // as one list of indirect draws over the section arena. self.draws.clear(); self.draw_pages.clear(); - let draw = |s: &SectionGpu, i: usize, translucent: bool| { - let (quads, first) = if translucent { - (s.translucent, s.start + u64::from(s.solid) * 4) - } else { - (s.solid, s.start) - }; - (quads > 0).then_some(([quads * 6, 1, 0, first as u32, i as u32], s.page)) - }; - for (i, (key, _, _)) in visible.iter().enumerate() { - if let Some((d, page)) = draw(&self.sections[key], i, false) { - self.draws.push(d); - self.draw_pages.push(page); - } + // The eye, camera-relative: view bobbing moves it off the camera. + let eye = (frame.bob * crate::camera::view_matrix(frame.yaw, frame.pitch)) + .inverse() + .transform_point3(Vec3::ZERO); + for (i, (key, _, origin)) in visible.iter().enumerate() { + let s = &self.sections[key]; + // Only the solid groups that can face the eye. + s.faces.ranges(eye - Vec3::from(*origin), |first, quads| { + let first = s.start + u64::from(first) * 4; + self.draws.push([quads * 6, 1, 0, first as u32, i as u32]); + self.draw_pages.push(s.page); + }); } let solid_draws = self.draws.len() as u32; for (i, (key, _, _)) in visible.iter().enumerate().rev() { - if let Some((d, page)) = draw(&self.sections[key], i, true) { - self.draws.push(d); - self.draw_pages.push(page); + let s = &self.sections[key]; + if s.translucent > 0 { + let first = s.start + u64::from(s.solid) * 4; + self.draws + .push([s.translucent * 6, 1, 0, first as u32, i as u32]); + self.draw_pages.push(s.page); } } let translucent_draws = self.draws.len() as u32 - solid_draws; diff --git a/crates/horizon-client/src/mesher.rs b/crates/horizon-client/src/mesher.rs index cb436a947..7f1191126 100644 --- a/crates/horizon-client/src/mesher.rs +++ b/crates/horizon-client/src/mesher.rs @@ -3,6 +3,7 @@ //! `ModelBlockRenderer`/`BlockModelLighter` (smooth light, ambient occlusion, //! cardinal shading, tint sources, block offsets; see `lighting`). Fluids //! follow `FluidRenderer` (see `fluid`). +mod facing; mod fluid; mod lighting; use crate::{ @@ -12,6 +13,7 @@ use crate::{ chunk::{Chunk, MIN_Y}, models::catalog::BakedFace, }; +pub use facing::{FaceGroups, GROUPS as FACE_GROUPS}; use horizon_core::{ biome::BiomeZoom, geometry::Direction, position::BlockPos, random::position_seed, }; @@ -56,6 +58,8 @@ pub struct TerrainVertex { } pub struct SectionMesh { pub solid: Vec, + /// `solid`'s quads by the side they face (`facing`). + pub faces: FaceGroups, pub translucent: Vec, /// VisGraph: bit `a * 6 + b` is set when faces `a` and `b` (Direction /// order) are connected through non-opaque blocks. @@ -69,6 +73,7 @@ impl Default for SectionMesh { fn default() -> Self { Self { solid: Vec::new(), + faces: FaceGroups::default(), translucent: Vec::new(), visibility: ALL_VISIBLE, block_entities: Vec::new(), @@ -606,6 +611,12 @@ pub struct Mesher<'a> { impl Mesher<'_> { /// `region[dz][dx]` are the chunks around the meshed column (centre 1,1). pub fn mesh(&mut self, region: &[[Option<&Chunk>; 3]; 3], sy: i32) -> SectionMesh { + let mut out = self.tesselate(region, sy); + out.faces = facing::group(&mut out.solid); + out + } + /// The section's quads in model order, before `facing::group`. + pub(crate) fn tesselate(&mut self, region: &[[Option<&Chunk>; 3]; 3], sy: i32) -> SectionMesh { let mut out = SectionMesh::default(); let center = region[1][1].expect("centre chunk"); let section = ¢er.sections[sy as usize]; diff --git a/crates/horizon-client/src/mesher/facing.rs b/crates/horizon-client/src/mesher/facing.rs new file mode 100644 index 000000000..2440bf926 --- /dev/null +++ b/crates/horizon-client/src/mesher/facing.rs @@ -0,0 +1,272 @@ +//! Solid quads grouped by the side they face, as Sodium's `ModelQuadFacing` +//! does. A quad in the plane `x = p` facing +X is front-facing only while the +//! eye is at `x > p`, and terrain culls back faces, so when the eye is on the +//! back side of every quad of a group the renderer skips the group's draw: +//! the GPU would have discarded all of it after shading its vertices. The +//! picture is unchanged; the vertex work for those quads is gone. +use super::TerrainVertex; +use glam::Vec3; + +/// Groups in buffer order: the negative sides, quads not in an axis plane +/// (rotated model elements, sloped fluid tops), then the positive sides. +/// With the eye outside a section on every axis, one side per axis is +/// visible, so the drawn groups form one to three runs. +pub const GROUPS: usize = 7; +const UNALIGNED: usize = 3; +/// The group of a quad facing `-axis` (0 x, 1 y, 2 z) is `NEGATIVE[axis]`, of +/// one facing `+axis` `GROUPS - 1 - NEGATIVE[axis]`. +const NEGATIVE: [usize; 3] = [0, 2, 1]; +/// How far (blocks) the eye must be behind every plane of a group before +/// the group is skipped: rounding on the GPU never makes such a quad +/// front-facing. +const MARGIN: f32 = 1.0 / 16.0; + +/// The solid quads' groups, filled by `group`. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct FaceGroups { + /// Quads per group, in buffer order. + pub quads: [u32; GROUPS], + /// Per axis group, the plane nearest the side the group faces: the + /// lowest plane of a positive group and the highest of a negative one. + planes: [f32; GROUPS], +} + +impl Default for FaceGroups { + /// Everything unaligned: always drawn. + fn default() -> Self { + Self { + quads: [0; GROUPS], + planes: [0.0; GROUPS], + } + } +} + +impl FaceGroups { + /// Whether group `g` can hold a front-facing quad for an eye at `eye`, + /// relative to the section's minimum corner. + pub fn visible(&self, g: usize, eye: Vec3) -> bool { + if g == UNALIGNED { + return true; + } + let (axis, positive) = axis(g); + if positive { + eye[axis] > self.planes[g] - MARGIN + } else { + eye[axis] < self.planes[g] + MARGIN + } + } + /// The quad ranges (first quad, quad count) to draw for an eye at `eye` + /// relative to the section's minimum corner, adjacent groups merged. + pub fn ranges(&self, eye: Vec3, mut out: impl FnMut(u32, u32)) { + let mut first = 0; + let mut run: Option<(u32, u32)> = None; + for g in 0..GROUPS { + let quads = self.quads[g]; + if quads > 0 { + if self.visible(g, eye) { + run = Some(match run { + Some((start, len)) => (start, len + quads), + None => (first, quads), + }); + } else if let Some((start, len)) = run.take() { + out(start, len); + } + } + first += quads; + } + if let Some((start, len)) = run { + out(start, len); + } + } +} + +/// The axis and sign of axis group `g`. +fn axis(g: usize) -> (usize, bool) { + if g < UNALIGNED { + ( + NEGATIVE + .iter() + .position(|&n| n == g) + .expect("negative group"), + false, + ) + } else { + let n = GROUPS - 1 - g; + ( + NEGATIVE + .iter() + .position(|&m| m == n) + .expect("positive group"), + true, + ) + } +} + +/// The group of one quad, and its plane: an axis group only when all four +/// corners lie exactly in one axis plane. +fn facing(quad: &[TerrainVertex]) -> (usize, f32) { + let p = |i: usize| Vec3::from(quad[i].pos); + let normal = (p(1) - p(0)).cross(p(2) - p(0)); + for axis in 0..3 { + let [a, b] = [(axis + 1) % 3, (axis + 2) % 3]; + let plane = quad[0].pos[axis]; + if normal[axis] != 0.0 + && normal[a] == 0.0 + && normal[b] == 0.0 + && quad.iter().all(|v| v.pos[axis] == plane) + { + let negative = NEGATIVE[axis]; + let g = if normal[axis] > 0.0 { + GROUPS - 1 - negative + } else { + negative + }; + return (g, plane); + } + } + (UNALIGNED, 0.0) +} + +/// Reorder `solid` by group, keeping the order of quads within a group (so +/// coplanar quads such as a grass block's overlay still draw after their +/// base), and return the groups. +pub fn group(solid: &mut Vec) -> FaceGroups { + let mut groups = FaceGroups::default(); + for (g, plane) in groups.planes.iter_mut().enumerate() { + if g != UNALIGNED { + *plane = if axis(g).1 { f32::MAX } else { f32::MIN }; + } + } + let faces: Vec = solid + .as_chunks::<4>() + .0 + .iter() + .map(|quad| { + let (g, plane) = facing(quad); + groups.quads[g] += 1; + if g != UNALIGNED { + let nearest = &mut groups.planes[g]; + *nearest = if axis(g).1 { + nearest.min(plane) + } else { + nearest.max(plane) + }; + } + g as u8 + }) + .collect(); + if faces.windows(2).all(|w| w[0] <= w[1]) { + return groups; + } + let mut next = [0usize; GROUPS]; + let mut start = 0; + for g in 0..GROUPS { + next[g] = start; + start += groups.quads[g] as usize; + } + let mut sorted = vec![solid[0]; solid.len()]; + for (quad, &g) in solid.as_chunks::<4>().0.iter().zip(&faces) { + let at = next[g as usize] * 4; + sorted[at..at + 4].copy_from_slice(quad); + next[g as usize] += 1; + } + *solid = sorted; + groups +} + +#[cfg(test)] +mod tests { + use super::*; + + fn vertex(pos: [f32; 3], layer: u16) -> TerrainVertex { + TerrainVertex { + pos, + uv: [0.0; 2], + layer, + light: 0, + color: 0, + } + } + /// A unit quad in the plane `axis = plane`, wound to face `sign`, tagged + /// with `layer` so tests can follow it. + fn quad(axis: usize, plane: f32, sign: f32, layer: u16) -> Vec { + let corner = |u: f32, v: f32| { + let mut p = [0.0; 3]; + p[axis] = plane; + p[(axis + 1) % 3] = u; + p[(axis + 2) % 3] = v; + vertex(p, layer) + }; + let mut q = vec![ + corner(0.0, 0.0), + corner(1.0, 0.0), + corner(1.0, 1.0), + corner(0.0, 1.0), + ]; + if sign < 0.0 { + q.reverse(); + } + q + } + + #[test] + fn quads_group_by_the_side_their_winding_faces() { + for a in 0..3 { + for sign in [-1.0, 1.0] { + let q = quad(a, 4.0, sign, 0); + let (g, plane) = facing(&q); + assert_eq!(axis(g), (a, sign > 0.0), "axis {a} sign {sign}"); + assert_eq!(plane, 4.0); + let normal = (Vec3::from(q[1].pos) - Vec3::from(q[0].pos)) + .cross(Vec3::from(q[2].pos) - Vec3::from(q[0].pos)); + assert_eq!(normal[a].signum(), sign); + } + } + // A cross plant's diagonal quad faces no axis. + let diagonal = [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + [0.0, 1.0, 0.0], + ] + .map(|p| vertex(p, 0)); + assert_eq!(facing(&diagonal).0, UNALIGNED); + } + + #[test] + fn grouping_is_stable_and_skips_only_back_facing_groups() { + // +X at x = 3 and x = 7 (layers 1, 2), -X at x = 5 (3), an unaligned + // quad (4), a coplanar overlay on the x = 3 quad (5). + let diagonal = [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 1.0], + [1.0, 1.0, 1.0], + [0.0, 1.0, 0.0], + ] + .map(|p| vertex(p, 4)); + let mut solid = [ + quad(0, 3.0, 1.0, 1), + quad(0, 5.0, -1.0, 3), + diagonal.to_vec(), + quad(0, 7.0, 1.0, 2), + quad(0, 3.0, 1.0, 5), + ] + .concat(); + let groups = group(&mut solid); + let layers: Vec = solid.chunks(4).map(|q| q[0].layer).collect(); + assert_eq!(layers, [3, 4, 1, 2, 5]); + let ranges = |eye: Vec3| { + let mut out = Vec::new(); + groups.ranges(eye, |first, count| out.push((first, count))); + out + }; + // Between the planes: every group can face the eye. + assert_eq!(ranges(Vec3::new(4.0, 8.0, 8.0)), [(0, 5)]); + // Beyond x = 7: the -X quad at x = 5 faces away. + assert_eq!(ranges(Vec3::new(20.0, 8.0, 8.0)), [(1, 4)]); + // Before x = 3: every +X quad faces away. + assert_eq!(ranges(Vec3::new(-10.0, 8.0, 8.0)), [(0, 2)]); + // Within the margin of the nearest plane: still drawn. + assert_eq!(ranges(Vec3::new(3.0, 8.0, 8.0)), [(0, 5)]); + } +} diff --git a/crates/horizon-client/src/mesher/leaf_culling_tests.rs b/crates/horizon-client/src/mesher/leaf_culling_tests.rs index 42ed2b8b6..16ea98cef 100644 --- a/crates/horizon-client/src/mesher/leaf_culling_tests.rs +++ b/crates/horizon-client/src/mesher/leaf_culling_tests.rs @@ -40,7 +40,7 @@ fn leaf_culling_removes_only_internal_leaf_and_root_faces() { cutout_leaves, cull_leaves, } - .mesh(®ion, (0 - MIN_Y) / 16) + .tesselate(®ion, (0 - MIN_Y) / 16) .solid };