@woosh/meep-engine 3.60.6 → 3.60.8

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_build_world_light_clusters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js"],"names":[],"mappings":"AAoDA;;;;GAIG;AACH,sEAFW,eAAe,QAMzB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAClB,MAAM,EAArE,OAAO,0BAA0B,EAAE,kBAAkB;IACrC,MAAM,EAAtB,MAAM;IAEU,aAAa,EAA7B,MAAM;IACU,MAAM,EAAtB,MAAM;IAEqB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACU,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CA6H1C;8BAlLY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"graph_build_world_light_clusters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js"],"names":[],"mappings":"AAsCA;;;;GAIG;AACH,gEAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,8DAHW,MAAM,GACJ,MAAM,CAKlB;AA4BD;;;;GAIG;AACH,sEAFW,eAAe,QAMzB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAXsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;IAClB,MAAM,EAArE,OAAO,0BAA0B,EAAE,kBAAkB;IACrC,MAAM,EAAtB,MAAM;IAEU,aAAa,EAA7B,MAAM;IACU,MAAM,EAAtB,MAAM;IAEqB,YAAY,EAAvC,UAAU,MAAM,CAAC;IACU,YAAY,EAAvC,UAAU,MAAM,CAAC;IACf;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAgI1C;8BAtNY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/light/world_cluster/graph_build_world_light_clusters.js

@@ -17,7 +17,6 @@ import {
     WORLD_LIGHT_CLUSTER_CULL_SETTINGS,
     WORLD_LIGHT_CLUSTER_GRID_SIZE,
     WORLD_LIGHT_CLUSTER_LIGHT_CAPACITY,
-    WORLD_LIGHT_CLUSTER_MAX_CASCADES,
     WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL,
 } from "./WORLD_LIGHT_CLUSTER.js";
 
@@ -37,18 +36,51 @@ const PROXIES_DESCRIPTOR = BufferResourceDescriptor.from(
     GPUBufferUsage.STORAGE,
 );
 
-const LOOKUP_DESCRIPTOR = BufferResourceDescriptor.from(
-    WORLD_LIGHT_CLUSTER_MAX_CASCADES * WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE * LIGHT_CLUSTER_METADATA.aligned_size,
-    GPUBufferUsage.STORAGE,
-);
+/**
+ * Bytes of the cluster lookup over a clipmap of so many cascades.
+ * @param {number} cascade_count
+ * @returns {number}
+ */
+export function world_light_clusters_lookup_size(cascade_count) {
+    return cascade_count * WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE * LIGHT_CLUSTER_METADATA.aligned_size;
+}
 
-const DATA_DESCRIPTOR = BufferResourceDescriptor.from(
-    COLLECTION_U32_STRUCT_WRITE.size
-    + WORLD_LIGHT_CLUSTER_MAX_CASCADES * WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE * WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL * u32.size,
-    GPUBufferUsage.STORAGE,
-    0,
-    16,
-);
+/**
+ * Bytes of the cluster data over a clipmap of so many cascades: the larger of the two, which a host
+ * checks against the device's `maxStorageBufferBindingSize` for the cascades it builds.
+ * @param {number} cascade_count
+ * @returns {number}
+ */
+export function world_light_clusters_data_size(cascade_count) {
+    return COLLECTION_U32_STRUCT_WRITE.size
+        + cascade_count * WORLD_LIGHT_CLUSTER_CELLS_PER_CASCADE * WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL * u32.size;
+}
+
+/**
+ * The lookup's and the data's descriptors by cascade count, made once a count: a clipmap's count is
+ * its structure, so a frame meets the one it met before.
+ * @type {Map<number, {lookup: BufferResourceDescriptor, data: BufferResourceDescriptor}>}
+ */
+const descriptors_by_cascade_count = new Map();
+
+/**
+ * @param {number} cascade_count
+ * @returns {{lookup: BufferResourceDescriptor, data: BufferResourceDescriptor}}
+ */
+function descriptors_for(cascade_count) {
+    let descriptors = descriptors_by_cascade_count.get(cascade_count);
+
+    if (descriptors === undefined) {
+        descriptors = {
+            lookup: BufferResourceDescriptor.from(world_light_clusters_lookup_size(cascade_count), GPUBufferUsage.STORAGE),
+            data: BufferResourceDescriptor.from(world_light_clusters_data_size(cascade_count), GPUBufferUsage.STORAGE, 0, 16),
+        };
+
+        descriptors_by_cascade_count.set(cascade_count, descriptors);
+    }
+
+    return descriptors;
+}
 
 /**
  * Offer the pipelines {@link graph_build_world_light_clusters} dispatches — see {@link PipelineEnquiry}.
@@ -68,8 +100,8 @@ export function enquire_build_world_light_clusters_pipelines(enquiry) {
  * @param {object} options
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
  * @param {import("../GPULightCollection.js").GPULightCollection} options.lights
- * @param {number} options.levels graph handle of a uniform that starts with the clipmap's cascade windows,
- *   a `CLIPMAP_LEVEL_ARRAY`
+ * @param {number} options.levels graph handle of a buffer that starts with the clipmap's cascade windows,
+ *   `cascade_count` `CLIPMAP_LEVEL_STRUCT`s, finest first, read as storage
  * @param {number} options.cascade_count active cascade count
  * @param {number} options.border cells of its own past each face of a cascade's window that its cluster
  *   cells cover too
@@ -193,8 +225,11 @@ export function graph_build_world_light_clusters({
     assign_data.levels = assign_pass.read(levels);
     assign_data.culled_lights = assign_pass.read(cull_data.culled_lights);
     assign_data.proxies = assign_pass.read(cull_data.proxies);
-    assign_data.lookup = assign_pass.create("World cluster / lookup", LOOKUP_DESCRIPTOR);
-    assign_data.data = assign_pass.create("World cluster / data", DATA_DESCRIPTOR);
+    // a clipmap of no cascade still binds a lookup and data, of one cascade
+    const descriptors = descriptors_for(Math.max(cascade_count, 1));
+
+    assign_data.lookup = assign_pass.create("World cluster / lookup", descriptors.lookup);
+    assign_data.data = assign_pass.create("World cluster / data", descriptors.data);
 
     return {
         lookup: assign_data.lookup,

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_world_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js"],"names":[],"mappings":"AAqBA,oEAA4E;AAI5E;;GAEG;AACH,4CAFU,YAAY,CAOW;AAmIjC;;;;;;;GAOG;AACH,iDAFU,aAAa,CAMpB;6BAvK0B,mCAAmC;8BAJlC,+BAA+B"}
+{"version":3,"file":"shader_world_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js"],"names":[],"mappings":"AAqBA,oEAA4E;AAI5E;;GAEG;AACH,4CAFU,YAAY,CAOW;AAoIjC;;;;;;;GAOG;AACH,iDAFU,aAAa,CAMpB;6BAxK0B,mCAAmC;8BAJlC,+BAA+B"}

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js

@@ -1,6 +1,6 @@
 import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
-import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_STRUCT } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { CLIPMAP_LEVEL_STRUCT } from "../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
@@ -38,7 +38,8 @@ const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate("settings", WORLD_CLUSTER_ASSIGN_SETTINGS);
 
 resources.createGroup()
-    .addUniform("levels", CLIPMAP_LEVEL_ARRAY)
+    // read from the front of whatever buffer holds the clipmap's windows, however many it has
+    .addStorageBuffer("levels", WebGPUArray.from(CLIPMAP_LEVEL_STRUCT), false)
     .addStorageBuffer("culled_lights", COLLECTION_U32_STRUCT_READ, false)
     .addStorageBuffer("proxies", WebGPUArray.from(CLUSTER_LIGHT_PROXY), false)
     .addStorageBuffer("world_cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT, true)

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#302@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#304@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/postprocess/dof/raymarch/chunk_dof_lds_coc_cache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared 88x88 f16-packed Circle-of-Confusion (CoC) workgroup LDS cache (8x8 tile + 40-pixel apron)
+ * for Depth-of-Field raymarch and slice compute passes.
+ *
+ * Expects `tColorCoc: texture_2d<f32>` in scope.
+ *
+ * ```wgsl
+ * fn dof_load_coc(p: vec2<i32>, dims: vec2<i32>) -> f32
+ * fn dof_populate_lds_coc(tile_blurred: bool, region_origin: vec2<i32>, lid: u32, dims: vec2<i32>)
+ * fn dof_read_coc(xt: vec2<i32>, region_origin: vec2<i32>) -> f32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dof_lds_coc_cache: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_dof_lds_coc_cache.d.ts.map

package/src/shade/renderer/postprocess/dof/raymarch/chunk_dof_lds_coc_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_dof_lds_coc_cache.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/raymarch/chunk_dof_lds_coc_cache.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;GAaG;AACH,sCAFU,SAAS,CAyDjB;0BAhFwB,uCAAuC"}

package/src/shade/renderer/postprocess/dof/raymarch/chunk_dof_lds_coc_cache.js

@@ -0,0 +1,81 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { DOF_LDS_APRON, DOF_LDS_WORKGROUP } from "../DOF_CONFIG.js";
+
+// ── Workgroup-LDS cache geometry (derived; see DOF_LDS_* in DOF_CONFIG) ──
+const WG = DOF_LDS_WORKGROUP;          // 8 — workgroup side
+const APRON = DOF_LDS_APRON;           // 40 — cached skirt, full-res px
+const REGION = WG + 2 * APRON;         // 88 — cached square side (even)
+const ROW_U32 = REGION / 2;            // 44 — u32 per cached row (2 f16/u32)
+const LDS_U32 = REGION * ROW_U32;      // 3872 — total u32 (× 4 B = 15 488 B)
+const WG_THREADS = WG * WG;            // 64 — threads per workgroup
+
+/**
+ * Shared 88x88 f16-packed Circle-of-Confusion (CoC) workgroup LDS cache (8x8 tile + 40-pixel apron)
+ * for Depth-of-Field raymarch and slice compute passes.
+ *
+ * Expects `tColorCoc: texture_2d<f32>` in scope.
+ *
+ * ```wgsl
+ * fn dof_load_coc(p: vec2<i32>, dims: vec2<i32>) -> f32
+ * fn dof_populate_lds_coc(tile_blurred: bool, region_origin: vec2<i32>, lid: u32, dims: vec2<i32>)
+ * fn dof_read_coc(xt: vec2<i32>, region_origin: vec2<i32>) -> f32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_dof_lds_coc_cache = CodeChunk.from(
+    //language=WGSL
+    `
+const WG: i32 = ${WG};
+const APRON: i32 = ${APRON};
+const REGION: i32 = ${REGION};
+const ROW_U32: i32 = ${ROW_U32};
+const LDS_U32: u32 = ${LDS_U32}u;
+const WG_THREADS: u32 = ${WG_THREADS}u;
+
+// Workgroup CoC cache: the REGION×REGION (tile + apron) signed-CoC field, two
+// f16 packed per u32. The CoC texture is rgba16float, so packing its already-
+// f16 .a channel round-trips losslessly — the cached march stays bit-identical
+// to the texture march (and to the fragment reference).
+var<workgroup> lds_coc: array<u32, LDS_U32>;
+
+// Clamped CoC fetch used by the cooperative load.
+fn dof_load_coc(p: vec2<i32>, dims: vec2<i32>) -> f32 {
+    return textureLoad(tColorCoc, clamp(p, vec2<i32>(0), dims - vec2<i32>(1)), 0).a;
+}
+
+// Cooperative load: pack the tile+apron CoC field into shared memory. Each
+// u32 slot holds two horizontally-adjacent texels of the REGION grid; every
+// slot is written by exactly one thread, so there is no read-modify-write
+// race. Skipped entirely for an in-focus tile (the load is the bulk of the
+// cost the cache is meant to remove).
+fn dof_populate_lds_coc(tile_blurred: bool, region_origin: vec2<i32>, lid: u32, dims: vec2<i32>) {
+    if (tile_blurred) {
+        for (var s: u32 = lid; s < LDS_U32; s = s + WG_THREADS) {
+            let si = i32(s);
+            let ry = si / ROW_U32;
+            let jx = si % ROW_U32;
+            let gy = region_origin.y + ry;
+            let gx = region_origin.x + 2 * jx;
+            let c0 = dof_load_coc(vec2<i32>(gx,     gy), dims);
+            let c1 = dof_load_coc(vec2<i32>(gx + 1, gy), dims);
+            lds_coc[s] = pack2x16float(vec2<f32>(c0, c1));
+        }
+    }
+    // Unconditional barrier (uniform control flow): every thread reaches it, so
+    // the cache is fully published before any thread reads it.
+    workgroupBarrier();
+}
+
+// CoC at a clamped pixel coordinate: the workgroup cache when inside the apron,
+// a texture load for the rare far tap (|offset| in (APRON, MAXR]).
+fn dof_read_coc(xt: vec2<i32>, region_origin: vec2<i32>) -> f32 {
+    let rc = xt - region_origin;
+    if (rc.x >= 0 && rc.x < REGION && rc.y >= 0 && rc.y < REGION) {
+        let pair = unpack2x16float(lds_coc[rc.y * ROW_U32 + (rc.x >> 1)]);
+        return select(pair.x, pair.y, (rc.x & 1) != 0);
+    }
+    return textureLoad(tColorCoc, xt, 0).a;
+}
+`
+);

package/src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dof_raymarch_compute.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.js"],"names":[],"mappings":"AA0OA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,0CAFU,aAAa,CAMpB;8BAxQ2B,kCAAkC"}
+{"version":3,"file":"shader_dof_raymarch_compute.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.js"],"names":[],"mappings":"AA+LA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,0CAFU,aAAa,CAMpB;8BA7N2B,kCAAkC"}

package/src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.js

@@ -6,7 +6,8 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { chunk_dof_aperture_shape } from "../chunk_dof_aperture_shape.js";
 import { chunk_dof_sample_offset } from "../chunk_dof_sample_offset.js";
-import { DOF_FOCUS_CUTOFF, DOF_LDS_APRON, DOF_LDS_WORKGROUP, DOF_MAX_COC_RADIUS, DOF_TILE_SIZE } from "../DOF_CONFIG.js";
+import { DOF_FOCUS_CUTOFF, DOF_LDS_WORKGROUP, DOF_MAX_COC_RADIUS, DOF_TILE_SIZE } from "../DOF_CONFIG.js";
+import { chunk_dof_lds_coc_cache } from "./chunk_dof_lds_coc_cache.js";
 import { DOF_SETTINGS_STRUCT } from "./DOF_SETTINGS_STRUCT.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -26,13 +27,7 @@ resources.createGroup()
     .addStorageTexture("tOut", "rgba16float", "2d", "write-only")
 ;
 
-// ── Workgroup-LDS cache geometry (derived; see DOF_LDS_* in DOF_CONFIG) ──
 const WG = DOF_LDS_WORKGROUP;          // 8 — workgroup side
-const APRON = DOF_LDS_APRON;           // 40 — cached skirt, full-res px
-const REGION = WG + 2 * APRON;         // 88 — cached square side (even)
-const ROW_U32 = REGION / 2;            // 44 — u32 per cached row (2 f16/u32)
-const LDS_U32 = REGION * ROW_U32;      // 3872 — total u32 (× 4 B = 15 488 B)
-const WG_THREADS = WG * WG;            // 64 — threads per workgroup
 
 const body = CodeChunk.from(
     //language=WGSL
@@ -42,24 +37,6 @@ const CUTOFF: f32 = ${DOF_FOCUS_CUTOFF};
 const TILE_SIZE: i32 = ${DOF_TILE_SIZE};
 const MAX_STEPS: u32 = 64u;   // bitmask width (vec2<u32>); >= max STEPS (ultra = 48)
 
-const WG: i32 = ${WG};
-const APRON: i32 = ${APRON};
-const REGION: i32 = ${REGION};
-const ROW_U32: i32 = ${ROW_U32};
-const LDS_U32: u32 = ${LDS_U32}u;
-const WG_THREADS: u32 = ${WG_THREADS}u;
-
-// Workgroup CoC cache: the REGION×REGION (tile + apron) signed-CoC field, two
-// f16 packed per u32. The CoC texture is rgba16float, so packing its already-
-// f16 .a channel round-trips losslessly — the cached march stays bit-identical
-// to the texture march (and to the fragment reference).
-var<workgroup> lds_coc: array<u32, LDS_U32>;
-
-// Clamped CoC fetch used by the cooperative load.
-fn dof_load_coc(p: vec2<i32>, dims: vec2<i32>) -> f32 {
-    return textureLoad(tColorCoc, clamp(p, vec2<i32>(0), dims - vec2<i32>(1)), 0).a;
-}
-
 @compute @workgroup_size(${WG}, ${WG}, 1)
 fn main(
     @builtin(global_invocation_id) gid: vec3<u32>,
@@ -84,21 +61,7 @@ fn main(
     // race. Skipped entirely for an in-focus tile (the load is the bulk of the
     // cost the cache is meant to remove).
     let region_origin = tile_origin - vec2<i32>(APRON);
-    if (tile_blurred) {
-        for (var s: u32 = lid; s < LDS_U32; s = s + WG_THREADS) {
-            let si = i32(s);
-            let ry = si / ROW_U32;
-            let jx = si % ROW_U32;
-            let gy = region_origin.y + ry;
-            let gx = region_origin.x + 2 * jx;
-            let c0 = dof_load_coc(vec2<i32>(gx,     gy), dims);
-            let c1 = dof_load_coc(vec2<i32>(gx + 1, gy), dims);
-            lds_coc[s] = pack2x16float(vec2<f32>(c0, c1));
-        }
-    }
-    // Unconditional barrier (uniform control flow): every thread reaches it, so
-    // the cache is fully published before any thread reads it.
-    workgroupBarrier();
+    dof_populate_lds_coc(tile_blurred, region_origin, lid, dims);
 
     let pixel = vec2<i32>(gid.xy);
     if (pixel.x >= dims.x || pixel.y >= dims.y) {
@@ -163,14 +126,7 @@ fn main(
             let x = coord + dir * r;
             let xt = vec2<i32>(clamp(x, vec2<f32>(0.0), dims_f - 1.0));
 
-            let rc = xt - region_origin;          // cache coord
-            var s_coc: f32;
-            if (rc.x >= 0 && rc.x < REGION && rc.y >= 0 && rc.y < REGION) {
-                let pair = unpack2x16float(lds_coc[rc.y * ROW_U32 + (rc.x >> 1)]);
-                s_coc = select(pair.x, pair.y, (rc.x & 1) != 0);
-            } else {
-                s_coc = textureLoad(tColorCoc, xt, 0).a;
-            }
+            let s_coc = dof_read_coc(xt, region_origin);
             let reach = abs(s_coc);
 
             let cover = saturate(rho * reach - r + 1.0);
@@ -224,6 +180,7 @@ fn main(
 }
     `,
     [
+        chunk_dof_lds_coc_cache,
         chunk_dof_sample_offset,
         chunk_dof_aperture_shape,
         chunk_stbn_sample_vec2,

package/src/shade/renderer/postprocess/dof/raymarch/shader_dof_slice_compute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dof_slice_compute.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/raymarch/shader_dof_slice_compute.js"],"names":[],"mappings":"AAuPA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uCAFU,aAAa,CAMpB;8BA5Q2B,kCAAkC"}
+{"version":3,"file":"shader_dof_slice_compute.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/raymarch/shader_dof_slice_compute.js"],"names":[],"mappings":"AA+MA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uCAFU,aAAa,CAMpB;8BApO2B,kCAAkC"}

package/src/shade/renderer/postprocess/dof/raymarch/shader_dof_slice_compute.js

@@ -7,13 +7,13 @@ import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderReso
 import { chunk_dof_aperture_shape } from "../chunk_dof_aperture_shape.js";
 import {
     DOF_FOCUS_CUTOFF,
-    DOF_LDS_APRON,
     DOF_LDS_WORKGROUP,
     DOF_MAX_COC_RADIUS,
     DOF_SLICE_DIRECTIONS,
     DOF_SLICE_SLOPES,
     DOF_TILE_SIZE,
 } from "../DOF_CONFIG.js";
+import { chunk_dof_lds_coc_cache } from "./chunk_dof_lds_coc_cache.js";
 import { DOF_SETTINGS_STRUCT } from "./DOF_SETTINGS_STRUCT.js";
 
 const resources = new ShaderResourceSetDescriptor();
@@ -33,13 +33,7 @@ resources.createGroup()
     .addStorageTexture("tOut", "rgba16float", "2d", "write-only")
 ;
 
-// ── Workgroup-LDS cache geometry (shared with the 2D compute march) ──
 const WG = DOF_LDS_WORKGROUP;          // 8 — workgroup side
-const APRON = DOF_LDS_APRON;           // 40 — cached skirt, full-res px
-const REGION = WG + 2 * APRON;         // 88 — cached square side (even)
-const ROW_U32 = REGION / 2;            // 44 — u32 per cached row (2 f16/u32)
-const LDS_U32 = REGION * ROW_U32;      // 3872 — total u32 (× 4 B = 15 488 B)
-const WG_THREADS = WG * WG;            // 64 — threads per workgroup
 
 const D = DOF_SLICE_DIRECTIONS;        // aperture directions over [0, π)
 const M = DOF_SLICE_SLOPES;            // aperture radii ("slopes") per direction
@@ -52,37 +46,14 @@ const CUTOFF: f32 = ${DOF_FOCUS_CUTOFF};
 const TILE_SIZE: i32 = ${DOF_TILE_SIZE};
 const MAX_STEPS: u32 = 64u;   // per-(slope) bitmask width (vec2<u32>); >= max N
 
-const WG: i32 = ${WG};
-const APRON: i32 = ${APRON};
-const REGION: i32 = ${REGION};
-const ROW_U32: i32 = ${ROW_U32};
-const LDS_U32: u32 = ${LDS_U32}u;
-const WG_THREADS: u32 = ${WG_THREADS}u;
-
 const D: u32 = ${D}u;          // directions over [0, π)
 const M: u32 = ${M}u;          // slopes per direction
 
-// Workgroup CoC cache: the REGION×REGION (tile + apron) signed-CoC field, two
-// f16 packed per u32 (the rgba16float source round-trips losslessly). Same as
-// the 2D compute march; the slice march reads it once per step and tests every
-// slope against that one read.
-var<workgroup> lds_coc: array<u32, LDS_U32>;
-
-// Clamped CoC fetch used by the cooperative load.
-fn dof_load_coc(p: vec2<i32>, dims: vec2<i32>) -> f32 {
-    return textureLoad(tColorCoc, clamp(p, vec2<i32>(0), dims - vec2<i32>(1)), 0).a;
-}
-
 // CoC at a march position: the workgroup cache when inside the apron, a texture
 // load for the rare far tap (|offset| in (APRON, MAXR]).
 fn slice_read_coc(pos: vec2<f32>, region_origin: vec2<i32>, dims: vec2<i32>, dims_f: vec2<f32>) -> f32 {
     let xt = vec2<i32>(clamp(pos, vec2<f32>(0.0), dims_f - 1.0));
-    let rc = xt - region_origin;
-    if (rc.x >= 0 && rc.x < REGION && rc.y >= 0 && rc.y < REGION) {
-        let pair = unpack2x16float(lds_coc[rc.y * ROW_U32 + (rc.x >> 1)]);
-        return select(pair.x, pair.y, (rc.x & 1) != 0);
-    }
-    return textureLoad(tColorCoc, xt, 0).a;
+    return dof_read_coc(xt, region_origin);
 }
 
 @compute @workgroup_size(${WG}, ${WG}, 1)
@@ -101,19 +72,7 @@ fn main(
 
     // Cooperative load (skipped for an in-focus tile); unconditional barrier.
     let region_origin = tile_origin - vec2<i32>(APRON);
-    if (tile_blurred) {
-        for (var s: u32 = lid; s < LDS_U32; s = s + WG_THREADS) {
-            let si = i32(s);
-            let ry = si / ROW_U32;
-            let jx = si % ROW_U32;
-            let gy = region_origin.y + ry;
-            let gx = region_origin.x + 2 * jx;
-            let c0 = dof_load_coc(vec2<i32>(gx,     gy), dims);
-            let c1 = dof_load_coc(vec2<i32>(gx + 1, gy), dims);
-            lds_coc[s] = pack2x16float(vec2<f32>(c0, c1));
-        }
-    }
-    workgroupBarrier();
+    dof_populate_lds_coc(tile_blurred, region_origin, lid, dims);
 
     let pixel = vec2<i32>(gid.xy);
     if (pixel.x >= dims.x || pixel.y >= dims.y) {
@@ -238,6 +197,7 @@ fn main(
 }
     `,
     [
+        chunk_dof_lds_coc_cache,
         chunk_dof_aperture_shape,
         chunk_stbn_sample_vec2,
         chunk_rgb_to_luminance,

package/src/shade/renderer/postprocess/gtao/chunk_integrate_lighting_sample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_integrate_lighting_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/chunk_integrate_lighting_sample.js"],"names":[],"mappings":"AAIA,gEA6CC;0BAhDyB,oCAAoC"}
+{"version":3,"file":"chunk_integrate_lighting_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/chunk_integrate_lighting_sample.js"],"names":[],"mappings":"AAIA,gEAgDC;0BAnDyB,oCAAoC"}

package/src/shade/renderer/postprocess/gtao/chunk_integrate_lighting_sample.js

@@ -34,7 +34,10 @@ fn horizon_integrate_lighting_sample(
     }
         
     // see "Horizon-Based Indirect Lighting (HBIL)" equation 18
-    let occlusion = integrate_solid_angle(_integrant, h0, h1);
+    // integrate_solid_angle integrates from its first angle to its second. The band this sample blocks runs from
+    // the new horizon, nearer the view ray, out to the previous one, so in that order it comes out positive; the
+    // other way round both terms flip, and a caller's choice of integrant can only undo that for the tangent's.
+    let occlusion = integrate_solid_angle(_integrant, h1, h0);
          
     let sample_color = textureLoad(tColor, tex_coord_i, 0).rgb  ;
     

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_shader_gtao_with_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js"],"names":[],"mappings":"AA0YA,+DAkCG;4BA5ZyB,6BAA6B"}
+{"version":3,"file":"fragment_shader_gtao_with_irradiance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js"],"names":[],"mappings":"AA2YA,+DAkCG;4BA7ZyB,6BAA6B"}

package/src/shade/renderer/postprocess/gtao/fragment_shader_gtao_with_irradiance.js

@@ -210,7 +210,8 @@ fn main(
         // centre that is the view-space N.xy along the slice and N.z this read before the slices followed the ray.
         let slice_tangent_ws = normalize(orthoWorldDir);
         let light_integrant_front = 0.5 * vec2(dot(view_normal_ws, slice_tangent_ws), dot(view_normal_ws, view_direction_ws));
-        // The back-side integrant has a flipped X component because the slice direction is flipped.
+        // Sample 0 lies along the tangent and sample 1 against it, so the back side, sample 1's, has the tangent's
+        // term flipped.
         let light_integrant_back = vec2(-light_integrant_front.x, light_integrant_front.y);
         
         var sliceLighting: vec3<f32>;
@@ -281,7 +282,7 @@ fn main(
                     sampleHorizonVec0,   // ref_direction
                     horizonCos0,         // h0 (previous horizon)
                     shc0,                // h1 (new horizon)
-                    light_integrant_back
+                    light_integrant_front
                 );
                               
                 sliceLighting += s0;
@@ -295,7 +296,7 @@ fn main(
                     sampleHorizonVec1,   // ref_direction
                     horizonCos1,         // h0 (previous horizon)
                     shc1,                // h1 (new horizon)
-                    light_integrant_front
+                    light_integrant_back
                 );
                 
                 sliceLighting += s1;
@@ -327,10 +328,10 @@ fn main(
         let localVisibility = visibilityProjLength * ( iarc0 + iarc1 );
         
         visibility += localVisibility;
-        
-        // unfudged, like the bent normal below: the fudge corrects the visibility integral only
-        sliceLighting *= projectedNormalVecLength;
-        
+
+        // Not weighted by projectedNormalVecLength, as the visibility and the bent normal are: those integrate
+        // against the projected normal made unit, and put its length back. The lighting's integrant dots the
+        // whole normal with directions in the slice, which already is the projected normal, length and all.
         lighting += sliceLighting;
         
         // see "Algorithm 2 Extension that computes bent normals b."

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -51,7 +51,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#210@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#212@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_nss_luma_derivative.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kDAoBE;0BAhCwB,oCAAoC"}
+{"version":3,"file":"chunk_nss_luma_derivative.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,kDAkBE;0BA/BwB,oCAAoC"}

package/src/shade/renderer/postprocess/nss/chunk_nss_luma_derivative.js

@@ -1,6 +1,6 @@
-import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { chunk_rgb_to_luminance } from "../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_nss_tonemap } from "./chunk_nss_tonemap.js";
 
 /**
  * Computes a per-pixel "luminance derivative" — the delta between the
@@ -16,10 +16,8 @@ export const chunk_nss_luma_derivative = CodeChunk.from(
     //language=WGSL
     `
 fn nss_luma_derivative(current_rgb: vec3<f32>, history_rgb: vec3<f32>) -> f32 {
-    let current_finite = select(vec3<f32>(0.0), clamp(current_rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), current_rgb == current_rgb);
-    let lc = rgb_to_luminance(current_finite);
-    let history_finite = select(vec3<f32>(0.0), clamp(history_rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), history_rgb == history_rgb);
-    let lh = rgb_to_luminance(history_finite);
+    let lc = rgb_to_luminance(nss_sanitize_hdr(current_rgb));
+    let lh = rgb_to_luminance(nss_sanitize_hdr(history_rgb));
 
     // tonemap the luma to compress HDR before differencing — same trick TAA
     // uses to keep specular highlights from saturating the variance metric.
@@ -29,7 +27,7 @@ fn nss_luma_derivative(current_rgb: vec3<f32>, history_rgb: vec3<f32>) -> f32 {
     return saturate(abs(lc_t - lh_t) * 4.0);
 }
     `, [
-        F16_MAX_DEFINITION,
+        chunk_nss_tonemap,
         chunk_rgb_to_luminance,
     ]
 );

package/src/shade/renderer/postprocess/nss/chunk_nss_tonemap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Shared HDR sanitization and max-channel Karis tonemapping (`c / (1 + max(r, g, b))`) and its
+ * inverse for Neural Super Sampling (NSS).
+ *
+ * ```wgsl
+ * const NSS_EXPOSURE: f32 = 7.38905609893;
+ * fn nss_sanitize_hdr(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_inv(rgb: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_nss_tonemap: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_nss_tonemap.d.ts.map

package/src/shade/renderer/postprocess/nss/chunk_nss_tonemap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_nss_tonemap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/chunk_nss_tonemap.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,gCAFU,SAAS,CAwCjB;0BAtDwB,oCAAoC"}

package/src/shade/renderer/postprocess/nss/chunk_nss_tonemap.js

@@ -0,0 +1,56 @@
+import { F16_MAX_DEFINITION } from "../../shader/chunk/math/F16_MAX_DEFINITION.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * Shared HDR sanitization and max-channel Karis tonemapping (`c / (1 + max(r, g, b))`) and its
+ * inverse for Neural Super Sampling (NSS).
+ *
+ * ```wgsl
+ * const NSS_EXPOSURE: f32 = 7.38905609893;
+ * fn nss_sanitize_hdr(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32>
+ * fn nss_tonemap_inv(rgb: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_nss_tonemap = CodeChunk.from(
+    //language=WGSL
+    `
+const NSS_EXPOSURE: f32 = 7.38905609893; // e^2
+
+fn nss_sanitize_hdr(rgb: vec3<f32>) -> vec3<f32> {
+    return select(vec3<f32>(0.0), clamp(rgb, vec3<f32>(0.0), vec3<f32>(F16_MAX)), rgb == rgb);
+}
+
+// Karis tonemap (max-of-channels).
+// The guard is a FINITE clamp, not just a non-negative one: this target is rgba16float, so shading
+// above its range stores as +Inf and rgb / (1.0 + m) is Inf/Inf = NaN, which goes straight into the
+// next frame's history and stays there. NaN fails every comparison including with itself, which is
+// what the componentwise test in nss_sanitize_hdr is.
+fn nss_tonemap(rgb: vec3<f32>) -> vec3<f32> {
+    let finite = nss_sanitize_hdr(rgb);
+    let m = max(max(finite.r, finite.g), finite.b);
+    return finite / (1.0 + m);
+}
+
+// Karis tonemap (max-of-channels), applied to EXPOSURE-scaled colour.
+// ARM's training distribution: Tonemap(EXPOSURE * raw) -> network input.
+fn nss_tonemap_exposure(rgb: vec3<f32>) -> vec3<f32> {
+    let scaled = nss_sanitize_hdr(rgb) * NSS_EXPOSURE;
+    let m = max(max(scaled.r, scaled.g), scaled.b);
+    return scaled / (1.0 + m);
+}
+
+// Karis inverse — clamp to dodge the inf at m == 1.0.
+fn nss_tonemap_inv(rgb: vec3<f32>) -> vec3<f32> {
+    let c = clamp(rgb, vec3<f32>(0.0), vec3<f32>(0.99999));
+    let m = max(max(c.r, c.g), c.b);
+    return c / (1.0 - m);
+}
+`,
+    [
+        F16_MAX_DEFINITION,
+    ]
+);

package/src/shade/renderer/postprocess/nss/shader_nss_postprocess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_nss_postprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_postprocess.js"],"names":[],"mappings":"AAiSA,mDAIG;8BAnS2B,+BAA+B"}
+{"version":3,"file":"shader_nss_postprocess.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_postprocess.js"],"names":[],"mappings":"AA6QA,mDAIG;8BAhR2B,+BAA+B"}