From 963d5cedd3671d1c04569b89d98940cd7d9187f9 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Fri, 23 Oct 2026 14:02:12 +0200 Subject: [PATCH] Shader packs: keep the opaque depth and G-buffer only for packs that read them The world target made the opaque depth, normal and material textures for every scaled or anti-aliased frame, packs or not: 12 bytes a pixel nobody read. They now follow what the pack reads, and Post::generation tells the stages to bind again when its targets change (a recreated target of the same size, or a shadow map made after the stages bound). Co-Authored-By: Claude Opus 5.5 --- crates/horizon-client/src/gfx.rs | 12 +- crates/horizon-client/src/gfx/java_stages.rs | 11 +- crates/horizon-client/src/gfx/pack_stages.rs | 10 +- crates/horizon-client/src/gfx/world_post.rs | 199 +++++++++++-------- 4 files changed, 140 insertions(+), 92 deletions(-) diff --git a/crates/horizon-client/src/gfx.rs b/crates/horizon-client/src/gfx.rs index 255f4dd0a..6a154d0de 100644 --- a/crates/horizon-client/src/gfx.rs +++ b/crates/horizon-client/src/gfx.rs @@ -3707,9 +3707,15 @@ impl Renderer { } else { self.world_post.shadow_active = false; } - let scaled = - self.world_post - .prepare(&self.device, [self.config.width, self.config.height], pack); + let scaled = self.world_post.prepare( + &self.device, + [self.config.width, self.config.height], + pack, + world_post::Extras { + opaque_depth, + gbuffer, + }, + ); let (world_view, world_depth) = match &scaled { Some((color, depth)) => (color, depth), None => (&view_target, &self.depth), diff --git a/crates/horizon-client/src/gfx/java_stages.rs b/crates/horizon-client/src/gfx/java_stages.rs index 5079a8f03..14d25745e 100644 --- a/crates/horizon-client/src/gfx/java_stages.rs +++ b/crates/horizon-client/src/gfx/java_stages.rs @@ -244,6 +244,8 @@ struct Common { struct Bound { folder: usize, size: [u32; 2], + /// `world_post`'s targets it binds (`Post::generation`). + post_generation: u64, targets: BTreeMap, depth: wgpu::TextureView, opaque_depth: wgpu::TextureView, @@ -382,11 +384,9 @@ impl JavaStages { ) -> &wgpu::BindGroup { let dimension = (frame.dimension[0] as i32).clamp(-1, 1); let folder = self.folder_for[(dimension + 1) as usize].unwrap_or(0); - if self - .bound - .as_ref() - .is_none_or(|b| b.folder != folder || b.size != size) - { + if self.bound.as_ref().is_none_or(|b| { + b.folder != folder || b.size != size || b.post_generation != post.generation() + }) { self.bound = Some(self.bind(device, queue, folder, color, depth, size, post)); } let now = std::time::Instant::now(); @@ -669,6 +669,7 @@ impl JavaStages { Bound { folder: folder_index, size, + post_generation: post.generation(), targets, depth, opaque_depth, diff --git a/crates/horizon-client/src/gfx/pack_stages.rs b/crates/horizon-client/src/gfx/pack_stages.rs index f80a64ce1..a067812e8 100644 --- a/crates/horizon-client/src/gfx/pack_stages.rs +++ b/crates/horizon-client/src/gfx/pack_stages.rs @@ -129,12 +129,12 @@ pub struct PackStages { shadow_sampler: wgpu::Sampler, noise_view: wgpu::TextureView, passes: Vec, - /// Built for this world target size. + /// Built for this world target size and `world_post` generation. targets: Vec, /// `world_post`'s bindings of the last stage's output. output: Option, world_size: [u32; 2], - shadow_size: u32, + post_generation: u64, started: std::time::Instant, last: Option, frames: u32, @@ -330,7 +330,7 @@ impl PackStages { targets: Vec::new(), output: None, world_size: [0, 0], - shadow_size: 0, + post_generation: u64::MAX, started: std::time::Instant::now(), last: None, frames: 0, @@ -355,11 +355,11 @@ impl PackStages { eye_light: [u8; 2], ) -> &wgpu::BindGroup { if self.world_size != size - || self.shadow_size != post.shadow_resolution + || self.post_generation != post.generation() || self.targets.len() != self.passes.len() { self.world_size = size; - self.shadow_size = post.shadow_resolution; + self.post_generation = post.generation(); self.targets.clear(); for pass in &self.passes { let target_size = size.map(|v| ((v as f32 * pass.scale).round() as u32).max(1)); diff --git a/crates/horizon-client/src/gfx/world_post.rs b/crates/horizon-client/src/gfx/world_post.rs index f592e8a1f..cb3e4b41c 100644 --- a/crates/horizon-client/src/gfx/world_post.rs +++ b/crates/horizon-client/src/gfx/world_post.rs @@ -102,20 +102,33 @@ struct GbufferUniform { env: [f32; 4], } +/// What the frame's shader pack reads beyond the world's colour and depth: +/// `Post` keeps these targets only while one does. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub struct Extras { + pub opaque_depth: bool, + pub gbuffer: bool, +} + struct WorldTarget { size: [u32; 2], + extras: Extras, color: wgpu::TextureView, depth_tex: wgpu::Texture, depth: wgpu::TextureView, - opaque_depth_tex: wgpu::Texture, - opaque_depth: wgpu::TextureView, - normal: wgpu::TextureView, - material: wgpu::TextureView, - gbuffer_group: wgpu::BindGroup, + /// With `extras.opaque_depth` or `extras.gbuffer` (which reads it). + opaque_depth: Option<(wgpu::Texture, wgpu::TextureView)>, + gbuffer: Option, group: wgpu::BindGroup, opaque_captured: bool, } +struct Gbuffer { + normal: wgpu::TextureView, + material: wgpu::TextureView, + group: wgpu::BindGroup, +} + struct ShadowTarget { resolution: u32, depth: wgpu::TextureView, @@ -136,6 +149,8 @@ pub struct Post { pub antialias: bool, target: Option, shadow: Option, + /// Bumped whenever a target is made: bindings of the old ones are stale. + generation: u64, fallback_shadow: wgpu::TextureView, fallback_color: wgpu::TextureView, pub shadow_view: Mat4, @@ -363,6 +378,7 @@ impl Post { antialias: false, target: None, shadow: None, + generation: 0, fallback_shadow, fallback_color, shadow_view: Mat4::IDENTITY, @@ -374,12 +390,14 @@ impl Post { } /// The world's colour and depth targets this frame, or `None` to draw - /// it straight to the screen. `pack`: a shader pack runs this frame. + /// it straight to the screen. `pack`: a shader pack runs this frame, + /// reading `extras`. pub fn prepare( &mut self, device: &wgpu::Device, window: [u32; 2], pack: bool, + extras: Extras, ) -> Option<(wgpu::TextureView, wgpu::TextureView)> { if self.scale == 1.0 && !self.antialias && !pack { self.target = None; @@ -387,7 +405,12 @@ impl Post { return None; } let size = window.map(|v| ((v as f32 * self.scale).round() as u32).clamp(1, 8192)); - if self.target.as_ref().is_none_or(|t| t.size != size) { + if self + .target + .as_ref() + .is_none_or(|t| t.size != size || t.extras != extras) + { + self.generation += 1; let extent = wgpu::Extent3d { width: size[0], height: size[1], @@ -419,63 +442,69 @@ impl Post { | wgpu::TextureUsages::COPY_SRC, ); let depth = depth_tex.create_view(&Default::default()); - let opaque_depth_tex = make_tex( - "Opaque world depth", - wgpu::TextureFormat::Depth32Float, - wgpu::TextureUsages::RENDER_ATTACHMENT - | wgpu::TextureUsages::TEXTURE_BINDING - | wgpu::TextureUsages::COPY_DST, - ); - let opaque_depth = opaque_depth_tex.create_view(&Default::default()); - let normal = make_tex( - "World G-buffer normal", - wgpu::TextureFormat::Rgba8Unorm, - wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, - ) - .create_view(&Default::default()); - let material = make_tex( - "World G-buffer material", - wgpu::TextureFormat::Rgba8Unorm, - wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::TEXTURE_BINDING, - ) - .create_view(&Default::default()); - let gbuffer_group = device.create_bind_group(&wgpu::BindGroupDescriptor { - label: Some("Horizon gbuffer"), - layout: &self.gbuffer_layout, - entries: &[ - wgpu::BindGroupEntry { - binding: 0, - resource: wgpu::BindingResource::TextureView(&color), - }, - wgpu::BindGroupEntry { - binding: 1, - resource: wgpu::BindingResource::TextureView(&depth), - }, - wgpu::BindGroupEntry { - binding: 2, - resource: wgpu::BindingResource::TextureView(&opaque_depth), - }, - wgpu::BindGroupEntry { - binding: 3, - resource: wgpu::BindingResource::Sampler(&self.nearest), - }, - wgpu::BindGroupEntry { - binding: 4, - resource: self.gbuffer_uniform.as_entire_binding(), - }, - ], + let opaque_depth = (extras.opaque_depth || extras.gbuffer).then(|| { + let tex = make_tex( + "Opaque world depth", + wgpu::TextureFormat::Depth32Float, + wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST, + ); + let view = tex.create_view(&Default::default()); + (tex, view) }); + let gbuffer = opaque_depth + .as_ref() + .filter(|_| extras.gbuffer) + .map(|(_, opaque)| { + let color_target = |label| { + make_tex( + label, + wgpu::TextureFormat::Rgba8Unorm, + wgpu::TextureUsages::RENDER_ATTACHMENT + | wgpu::TextureUsages::TEXTURE_BINDING, + ) + .create_view(&Default::default()) + }; + let group = device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("Horizon gbuffer"), + layout: &self.gbuffer_layout, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: wgpu::BindingResource::TextureView(&color), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&depth), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: wgpu::BindingResource::TextureView(opaque), + }, + wgpu::BindGroupEntry { + binding: 3, + resource: wgpu::BindingResource::Sampler(&self.nearest), + }, + wgpu::BindGroupEntry { + binding: 4, + resource: self.gbuffer_uniform.as_entire_binding(), + }, + ], + }); + Gbuffer { + normal: color_target("World G-buffer normal"), + material: color_target("World G-buffer material"), + group, + } + }); let group = self.bind(device, &color); self.target = Some(WorldTarget { size, + extras, color, depth_tex, depth, - opaque_depth_tex, opaque_depth, - normal, - material, - gbuffer_group, + gbuffer, group, opaque_captured: false, }); @@ -523,6 +552,7 @@ impl Post { }) .create_view(&Default::default()); self.shadow = Some(ShadowTarget { resolution, depth }); + self.generation += 1; } let light_dir = if sun_dir.y >= -0.05 { sun_dir.normalize_or_zero() @@ -557,16 +587,19 @@ impl Post { /// right before translucent water and weather draw. pub fn capture_opaque_depth(&mut self, encoder: &mut wgpu::CommandEncoder) { let Some(t) = &mut self.target else { return }; + let Some((opaque, _)) = &t.opaque_depth else { + return; + }; encoder.copy_texture_to_texture( t.depth_tex.as_image_copy(), - t.opaque_depth_tex.as_image_copy(), + opaque.as_image_copy(), t.depth_tex.size(), ); t.opaque_captured = true; } /// Reconstruct the G-buffer `normal` and `material` textures after the - /// world pass finishes. + /// world pass finishes (with `Extras::gbuffer`). pub fn build_gbuffer( &mut self, queue: &wgpu::Queue, @@ -575,15 +608,11 @@ impl Post { eye_light: [u8; 2], wetness: f32, ) { - let Some(t) = &mut self.target else { return }; - if !t.opaque_captured { - encoder.copy_texture_to_texture( - t.depth_tex.as_image_copy(), - t.opaque_depth_tex.as_image_copy(), - t.depth_tex.size(), - ); - t.opaque_captured = true; + if !self.target.as_ref().is_some_and(|t| t.opaque_captured) { + self.capture_opaque_depth(encoder); } + let Some(t) = &self.target else { return }; + let Some(gbuffer) = &t.gbuffer else { return }; let [w, h] = t.size.map(|v| v.max(1) as f32); let uniform = GbufferUniform { inverse_view: frame.inverse_view, @@ -599,7 +628,7 @@ impl Post { queue.write_buffer(&self.gbuffer_uniform, 0, bytemuck::bytes_of(&uniform)); let attachments = [ Some(wgpu::RenderPassColorAttachment { - view: &t.normal, + view: &gbuffer.normal, resolve_target: None, depth_slice: None, ops: wgpu::Operations { @@ -608,7 +637,7 @@ impl Post { }, }), Some(wgpu::RenderPassColorAttachment { - view: &t.material, + view: &gbuffer.material, resolve_target: None, depth_slice: None, ops: wgpu::Operations { @@ -623,7 +652,7 @@ impl Post { ..Default::default() }); pass.set_pipeline(&self.gbuffer_pipeline); - pass.set_bind_group(0, &t.gbuffer_group, &[]); + pass.set_bind_group(0, &gbuffer.group, &[]); pass.draw(0..3, 0..1); } @@ -632,25 +661,37 @@ impl Post { self.target.as_ref().map(|t| t.size) } - /// The depth before translucent geometry (`capture_opaque_depth`). + /// Changes whenever `prepare` or `prepare_shadow` makes new targets: + /// bindings made from the views below must be made again. + pub fn generation(&self) -> u64 { + self.generation + } + + /// The depth before translucent geometry (`capture_opaque_depth`), or + /// the world's depth when nothing reads it. pub fn opaque_depth(&self) -> &wgpu::TextureView { - self.target - .as_ref() - .map_or(&self.fallback_shadow, |t| &t.opaque_depth) + match &self.target { + Some(WorldTarget { + opaque_depth: Some((_, view)), + .. + }) => view, + Some(t) => &t.depth, + None => &self.fallback_shadow, + } } /// Reconstructed world-space normals (`scene_normal`). pub fn normal(&self) -> &wgpu::TextureView { - self.target - .as_ref() - .map_or(&self.fallback_color, |t| &t.normal) + self.gbuffer().map_or(&self.fallback_color, |g| &g.normal) } /// Reconstructed material and light (`scene_material`). pub fn material(&self) -> &wgpu::TextureView { - self.target - .as_ref() - .map_or(&self.fallback_color, |t| &t.material) + self.gbuffer().map_or(&self.fallback_color, |g| &g.material) + } + + fn gbuffer(&self) -> Option<&Gbuffer> { + self.target.as_ref()?.gbuffer.as_ref() } /// The sun/moon shadow map (`shadow_depth` of api 2 packs).