@woosh/meep-engine 3.60.5 → 3.60.7

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/material/GPUMaterialManager.d.ts

@@ -38,13 +38,16 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} options.view
      * @param {number} options.texture_viz_mesh
      * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
-    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, }: {
+    graph_viz_render({ graph, view, texture_viz_mesh, texture_viz_triangle, texture_normal, }: {
         graph: FrameGraph;
         view: GPUViewContext;
         texture_viz_mesh: number;
         texture_viz_triangle: number;
+        texture_normal: number;
     }): {
         g_pbr: number;
         g_normal: number;

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;OAQG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAiMnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAr4BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA4LnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAl4BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -467,6 +467,8 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} options.view
      * @param {number} options.texture_viz_mesh
      * @param {number} options.texture_viz_triangle
+     * @param {number} options.texture_normal the normal target to write, `rgba16uint` at the view's
+     *   resolution. The caller owns it so that it outlives the frame: reprojection reads last frame's.
      * @returns {{g_pbr: number, g_normal: number, g_albedo: number, g_emissive: number}} updated g-buffer
      */
     graph_viz_render({
@@ -474,9 +476,11 @@ export class GPUMaterialManager {
                          view,
                          texture_viz_mesh,
                          texture_viz_triangle,
+                         texture_normal,
                      }) {
 
         assert.defined(graph, 'graph');
+        assert.isNonNegativeInteger(texture_normal, 'texture_normal');
         assert.defined(view, 'view');
 
         /**
@@ -620,14 +624,7 @@ export class GPUMaterialManager {
                 usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
             })
         );
-        pass_data.g_normal = pass.create(
-            "g-buffer / Normal",
-            TextureResourceDescriptor.from({
-                format: 'rgba16uint',
-                resolution: view.resolution,
-                usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
-            })
-        );
+        pass_data.g_normal = pass.write(texture_normal);
         pass_data.g_albedo = pass.create(
             "g-buffer / Albedo",
             TextureResourceDescriptor.from({

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/GTAO.d.ts

@@ -27,21 +27,25 @@ export class GTAO {
      * @param {number} options.input_depth this frame's depth
      * @param {number} options.input_hzb hierarchical depth built from it
      * @param {number} options.input_normal G-buffer normals
+     * @param {number} options.input_normal_previous last frame's G-buffer normals, at the size last frame was
+     *   drawn at: which surface each history texel was written on
      * @param {number} options.input_velocity per-pixel velocity, in this frame's pixels
      * @param {number} options.input_occlusion depth-clip pass output: history confidence in r
      * @param {number} options.frame_index the renderer's frame counter: drives the noise, the history
      *   ping-pong, and whether the history follows on from the last frame drawn
      * @param {number} options.output G-buffer albedo; AO is blended into its alpha
      * @param {number[]} options.resolution this frame's render size
-     * @returns {{visibility:number, occlusion:number, bent_normals:number}} the accumulated visibility
-     *   moments, `output` after the composite, and the raw bent normals
+     * @returns {{visibility:number, occlusion:number, bent_normals:number}} the accumulated visibility and
+     *   bend (`rgba16float`), `output` after the composite, and the accumulated bent normals, octahedral in
+     *   `rg16uint` as `input_normal` is
      */
-    graph_pass({ graph, camera, input_depth, input_hzb, input_normal, input_velocity, input_occlusion, frame_index, output, resolution }: {
+    graph_pass({ graph, camera, input_depth, input_hzb, input_normal, input_normal_previous, input_velocity, input_occlusion, frame_index, output, resolution }: {
         graph: FrameGraph;
         camera: number;
         input_depth: number;
         input_hzb: number;
         input_normal: number;
+        input_normal_previous: number;
         input_velocity: number;
         input_occlusion: number;
         frame_index: number;

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

@@ -1 +1 @@
-{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AAQA;;GAEG;AAEH;IAqBI;;;OAGG;IACH,uCAUC;IA5BD;;;;OAIG;IACH,eAFU,OAAO,CAEI;IAyBrB;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAd+B,KAAK;QACT,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,WAAW,EAA3B,MAAM;QAEU,MAAM,EAAtB,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACN;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CA4GtE;;CACJ;8BA/KY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"GTAO.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/gtao/GTAO.js"],"names":[],"mappings":"AASA;;GAEG;AAEH;IAqBI;;;OAGG;IACH,uCAWC;IA7BD;;;;OAIG;IACH,eAFU,OAAO,CAEI;IA0BrB;;;;OAIG;IACH,0BAFW,eAAe,QAOzB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB+B,KAAK;QACT,MAAM,EAAtB,MAAM;QACU,WAAW,EAA3B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,qBAAqB,EAArC,MAAM;QAEU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACU,WAAW,EAA3B,MAAM;QAEU,MAAM,EAAtB,MAAM;QACY,UAAU,EAA5B,MAAM,EAAE;QACN;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,SAAS,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,CAAA;KAAC,CAqHtE;;CACJ;8BA3LY,OAAO,6CAA6C,EAAE,eAAe"}