Use packed light cookie atlases

Author: DoubleStyx

crates/renderide/shaders/modules/frame/globals.wgsl

@@ -7,7 +7,8 @@
 //! layout at pipeline creation for storage-backed frame resources.
 //!
 //! CPU packing must match [`crate::gpu::frame_globals::FrameGpuUniforms`],
-//! [`crate::backend::light_gpu::GpuLight`], and [`crate::backend::cluster_gpu`] cluster buffers.
+//! [`crate::backend::light_gpu::GpuLight`], [`crate::gpu::GpuLightCookieRect`], and
+//! [`crate::backend::cluster_gpu`] cluster buffers.
 
 #define_import_path renderide::frame::globals
 
@@ -26,12 +27,13 @@
 @group(0) @binding(10) var reflection_probe_specular_sampler: sampler;
 @group(0) @binding(11) var ibl_dfg_lut: texture_2d<f32>;
 @group(0) @binding(12) var<storage, read> reflection_probes: array<ft::GpuReflectionProbe>;
-@group(0) @binding(13) var light_cookie_2d_atlas: texture_2d_array<f32>;
-@group(0) @binding(14) var light_cookie_point_atlas: texture_2d_array<f32>;
+@group(0) @binding(13) var light_cookie_2d_atlas: texture_2d<f32>;
+@group(0) @binding(14) var light_cookie_point_atlas: texture_2d<f32>;
 @group(0) @binding(15) var light_cookie_sampler: sampler;
 @group(0) @binding(16) var<storage, read> shadow_views: array<ft::GpuShadowView>;
 @group(0) @binding(17) var shadow_atlas: texture_depth_2d_array;
 @group(0) @binding(18) var shadow_sampler: sampler_comparison;
+@group(0) @binding(19) var<storage, read> light_cookie_rects: array<ft::GpuLightCookieRect>;
 
 /// View index encoded in a material varying.
 fn view_index_from_layer(view_layer: u32) -> u32 {
@@ -183,7 +185,8 @@ fn retain_globals_additive(color: vec4<f32>) -> vec4<f32> {
         f32(cluster_light_indices[0u] & 255u) * 1e-10;
     let probe_touch = reflection_probes[0u].params.x * 1e-10;
     let cookie_touch =
-        textureSampleLevel(light_cookie_2d_atlas, light_cookie_sampler, vec2<f32>(0.5), 0, 0.0).r * 1e-10 +
-        textureSampleLevel(light_cookie_point_atlas, light_cookie_sampler, vec2<f32>(0.5), 0, 0.0).r * 1e-10;
+        textureSampleLevel(light_cookie_2d_atlas, light_cookie_sampler, vec2<f32>(0.5), 0.0).r * 1e-10 +
+        textureSampleLevel(light_cookie_point_atlas, light_cookie_sampler, vec2<f32>(0.5), 0.0).r * 1e-10 +
+        light_cookie_rects[0u].origin_scale.x * 1e-10;
     return color + vec4<f32>(vec3<f32>(f32(lit) * 1e-10 + cluster_touch + probe_touch + cookie_touch), 0.0);
 }

crates/renderide/shaders/modules/frame/types.wgsl

@@ -55,6 +55,10 @@ struct GpuShadowView {
     light_params: vec4<f32>,
 }
 
+struct GpuLightCookieRect {
+    origin_scale: vec4<f32>,
+}
+
 struct GpuReflectionProbe {
     /// World-space AABB minimum; `.w` stores the sanitized blend distance.
     box_min: vec4<f32>,

crates/renderide/shaders/modules/lighting/light_cookies.wgsl

@@ -39,12 +39,16 @@ fn wrap_cookie_uv(uv: vec2<f32>, bits: u32) -> vec2<f32> {
     );
 }
 
+fn atlas_cookie_uv(rect_index: u32, uv: vec2<f32>) -> vec2<f32> {
+    let rect = rg::light_cookie_rects[rect_index].origin_scale;
+    return rect.xy + uv * rect.zw;
+}
+
 fn sample_2d_cookie(light: ft::GpuLight, uv: vec2<f32>) -> f32 {
     return textureSample(
         rg::light_cookie_2d_atlas,
         rg::light_cookie_sampler,
-        wrap_cookie_uv(uv, light.cookie_reserved),
-        i32(light.cookie_layer),
+        atlas_cookie_uv(light.cookie_layer, wrap_cookie_uv(uv, light.cookie_reserved)),
     ).r;
 }
 
@@ -114,8 +118,12 @@ fn point_cookie_multiplier(light: ft::GpuLight, world_pos: vec3<f32>) -> f32 {
         dot(from_light, light.direction),
     ) * inverseSqrt(len_sq);
     let face_uv = cube_face_uv(local);
-    let layer = light.cookie_layer + u32(face_uv.z);
-    return textureSample(rg::light_cookie_point_atlas, rg::light_cookie_sampler, face_uv.xy, i32(layer)).r;
+    let rect_index = light.cookie_layer + u32(face_uv.z);
+    return textureSample(
+        rg::light_cookie_point_atlas,
+        rg::light_cookie_sampler,
+        atlas_cookie_uv(rect_index, face_uv.xy),
+    ).r;
 }
 
 fn multiplier(light: ft::GpuLight, world_pos: vec3<f32>) -> f32 {

crates/renderide/src/backend/facade/graph_access.rs

@@ -379,6 +379,20 @@ impl GraphExecutionBackend for BackendGraphAccess<'_> {
         );
     }
 
+    fn pre_record_sync_for_views(
+        &mut self,
+        device: &wgpu::Device,
+        uploads: GraphUploadSink<'_>,
+        view_layouts: &[PreRecordViewResourceLayout],
+    ) {
+        self.frame_resources.pre_record_sync_for_views(
+            device,
+            uploads,
+            self.asset_transfers,
+            view_layouts,
+        );
+    }
+
     fn view_blackboard_preparer(&self) -> Box<dyn GraphViewBlackboardPreparer + '_> {
         Box::new(BackendViewBlackboardPreparer {
             world_mesh_frame_planner: self.world_mesh_frame_planner,

crates/renderide/src/backend/frame_gpu.rs

@@ -119,7 +119,7 @@ struct FrameBindGroupInputs<'a> {
     reflection_probes: ReflectionProbeSpecularBindGroupResources<'a>,
     /// Integrated BRDF lookup texture view for binding 11.
     ibl_dfg_lut_view: &'a wgpu::TextureView,
-    /// Light-cookie atlas textures and sampler for bindings 13 through 15.
+    /// Light-cookie atlas textures, sampler, and rect metadata for bindings 13 through 15 and 19.
     light_cookies: &'a LightCookieAtlasResources,
     /// Shadow-map metadata, atlas texture, and comparison sampler for bindings 16 through 18.
     shadows: &'a ShadowAtlasResources,
@@ -128,7 +128,7 @@ struct FrameBindGroupInputs<'a> {
 fn frame_bind_group_entries<'a>(
     inputs: &FrameBindGroupInputs<'a>,
 ) -> Vec<wgpu::BindGroupEntry<'a>> {
-    let mut entries = Vec::with_capacity(19);
+    let mut entries = Vec::with_capacity(20);
     append_frame_and_cluster_entries(&mut entries, inputs);
     append_scene_snapshot_entries(&mut entries, inputs);
     append_reflection_probe_entries(&mut entries, inputs);
@@ -233,6 +233,10 @@ fn append_light_cookie_entries<'a>(
             binding: 15,
             resource: wgpu::BindingResource::Sampler(inputs.light_cookies.sampler()),
         },
+        wgpu::BindGroupEntry {
+            binding: 19,
+            resource: inputs.light_cookies.metadata_buffer().as_entire_binding(),
+        },
     ]);
 }
 
@@ -623,6 +627,25 @@ impl FrameGpuResources {
         self.light_cookies.has_requests()
     }
 
+    /// Current light-cookie atlas bind-resource version for per-view bind-group invalidation.
+    pub fn light_cookie_resources_version(&self) -> u64 {
+        self.light_cookies.version()
+    }
+
+    /// Synchronizes light-cookie atlas capacity and rect metadata before graph recording.
+    pub fn sync_light_cookie_resources(
+        &mut self,
+        device: &wgpu::Device,
+        uploads: GraphUploadSink<'_>,
+        assets: &dyn crate::render_graph::GraphAssetResources,
+    ) -> bool {
+        let changed = self.light_cookies.sync(device, uploads, assets);
+        if changed {
+            self.rebuild_bind_group(device);
+        }
+        changed
+    }
+
     /// Records light-cookie atlas updates.
     pub(in crate::backend) fn encode_light_cookie_atlas(
         &self,

crates/renderide/src/backend/frame_gpu/light_cookies.rs

@@ -8,6 +8,8 @@ mod atlas;
 mod blit;
 /// Texture format and sampler compatibility helpers.
 mod format;
+/// CPU-side packed atlas layout.
+mod packing;
 /// Render-graph pass wrapper for atlas updates.
 mod pass;
 /// Persistent GPU resources for light-cookie atlases.

crates/renderide/src/backend/frame_gpu/light_cookies/assignment.rs

@@ -9,7 +9,20 @@ use crate::shared::LightType;
 
 use super::POINT_COOKIE_FACE_COUNT;
 
-/// One requested light-cookie source assigned to an atlas layer.
+/// Fallback metadata row for white cookie sampling.
+pub(super) const LIGHT_COOKIE_FALLBACK_RECT_INDEX: u32 = 0;
+/// Maximum resident 2D cookies.
+pub(super) const COOKIE_2D_RECT_CAP: u32 = 64;
+/// Maximum resident point-light cookie cubemaps.
+pub(super) const POINT_COOKIE_CUBEMAP_CAP: u32 = 16;
+/// First metadata row reserved for point-light cubemap face cookies.
+pub(super) const POINT_COOKIE_RECT_BASE: u32 =
+    LIGHT_COOKIE_FALLBACK_RECT_INDEX + 1 + COOKIE_2D_RECT_CAP;
+/// Total light-cookie metadata rows bound for all atlas kinds.
+pub(super) const LIGHT_COOKIE_RECT_CAPACITY: usize =
+    (POINT_COOKIE_RECT_BASE + POINT_COOKIE_CUBEMAP_CAP * POINT_COOKIE_FACE_COUNT) as usize;
+
+/// One requested light-cookie source assigned to atlas metadata rows.
 #[derive(Clone, Copy, Debug)]
 pub(super) struct LightCookieRequest {
     /// Packed host texture handle.
@@ -18,7 +31,7 @@ pub(super) struct LightCookieRequest {
     pub(super) asset_id: i32,
     /// Unpacked host texture kind.
     pub(super) kind: HostTextureAssetKind,
-    /// 2D atlas layer or first point face layer.
+    /// 2D atlas rect index or first point face rect index.
     pub(super) layer: u32,
 }
 
@@ -37,10 +50,10 @@ pub(super) struct LightCookieAssignment {
     pub(super) wrap_bits: u32,
 }
 
-/// Atlas slot state for a packed host texture handle.
+/// Atlas metadata slot state for a packed host texture handle.
 #[derive(Clone, Copy, Debug)]
 struct LightCookieSlot {
-    /// Atlas layer assigned to this packed handle.
+    /// Atlas metadata row assigned to this packed handle.
     layer: u32,
     /// Whether this slot is referenced by the current frame's packed lights.
     requested_this_frame: bool,
@@ -89,12 +102,7 @@ impl LightCookieAtlasState {
     }
 
     /// Assigns a cookie atlas binding for one resolved light.
-    pub(super) fn assign(
-        &mut self,
-        assignment: LightCookieAssignment,
-        two_d_layers: u32,
-        point_layers: u32,
-    ) -> LightCookieBinding {
+    pub(super) fn assign(&mut self, assignment: LightCookieAssignment) -> LightCookieBinding {
         match (assignment.light_type, assignment.kind) {
             (
                 LightType::Spot,
@@ -105,7 +113,6 @@ impl LightCookieAtlasState {
                 assignment.packed_id,
                 assignment.asset_id,
                 assignment.kind,
-                two_d_layers,
                 LIGHT_COOKIE_KIND_SPOT_2D,
                 assignment.wrap_bits,
             ),
@@ -118,35 +125,30 @@ impl LightCookieAtlasState {
                 assignment.packed_id,
                 assignment.asset_id,
                 assignment.kind,
-                two_d_layers,
                 LIGHT_COOKIE_KIND_DIRECTIONAL_2D,
                 assignment.wrap_bits,
             ),
-            (LightType::Point, HostTextureAssetKind::Cubemap) => self.assign_point(
-                assignment.packed_id,
-                assignment.asset_id,
-                assignment.kind,
-                point_layers,
-            ),
+            (LightType::Point, HostTextureAssetKind::Cubemap) => {
+                self.assign_point(assignment.packed_id, assignment.asset_id, assignment.kind)
+            }
             _ => LightCookieBinding::NONE,
         }
     }
 
-    /// Assigns a 2D cookie layer.
+    /// Assigns a 2D cookie metadata row.
     fn assign_2d(
         &mut self,
         packed_id: i32,
         asset_id: i32,
         kind: HostTextureAssetKind,
-        layers: u32,
         cookie_kind: u32,
         wrap_bits: u32,
     ) -> LightCookieBinding {
         let Some(layer) = assign_cookie_layer(
             &mut self.two_d_slots,
             packed_id,
-            1,
-            layers,
+            LIGHT_COOKIE_FALLBACK_RECT_INDEX + 1,
+            POINT_COOKIE_RECT_BASE,
             1,
             &mut self.two_d_overflow_logged,
             "2D",
@@ -171,19 +173,18 @@ impl LightCookieAtlasState {
         }
     }
 
-    /// Assigns six 2D-array layers for a point-light cubemap cookie.
+    /// Assigns six metadata rows for a point-light cubemap cookie.
     fn assign_point(
         &mut self,
         packed_id: i32,
         asset_id: i32,
         kind: HostTextureAssetKind,
-        layers: u32,
     ) -> LightCookieBinding {
         let Some(layer) = assign_cookie_layer(
             &mut self.point_slots,
             packed_id,
-            1,
-            layers,
+            POINT_COOKIE_RECT_BASE,
+            LIGHT_COOKIE_RECT_CAPACITY as u32,
             POINT_COOKIE_FACE_COUNT,
             &mut self.point_overflow_logged,
             "point",
@@ -219,7 +220,7 @@ impl LightCookieAtlasState {
     }
 }
 
-/// Assigns or reuses one atlas layer block.
+/// Assigns or reuses one atlas metadata row block.
 fn assign_cookie_layer(
     slots: &mut HashMap<i32, LightCookieSlot>,
     packed_id: i32,