@woosh/meep-engine 3.12.0 → 3.13.1

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

@@ -1,266 +1,269 @@
-import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
-import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
-import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-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_SETTINGS_STRUCT } from "./DOF_SETTINGS_STRUCT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // Full-res (colour.rgb, signed CoC radius) from the prefilter.
-    .addTexture("tColorCoc", "float")
-    // Spatio-temporal blue noise (NVIDIA STBN) for the aperture phase.
-    .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
-    // Dilated per-tile max |CoC| — the fast-path early-out source.
-    .addTexture("tTile", "float")
-    .addUniform("dof", DOF_SETTINGS_STRUCT)
-    // Defocused colour (rgb) + defocus amount (a) — same contract as the
-    // fragment march's render target, but written via textureStore.
-    .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
-    `
-const MAXR: f32 = ${DOF_MAX_COC_RADIUS};
-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>,
-    @builtin(local_invocation_index) lid: u32,
-    @builtin(workgroup_id) wid: vec3<u32>,
-) {
-    let dims = vec2<i32>(textureDimensions(tColorCoc));
-
-    // Tile fast-path decision, computed from the WORKGROUP id so it is the same
-    // value for every thread: the workgroup sits wholly inside one tile (the
-    // tile size is a multiple of the workgroup side), so all 64 pixels share
-    // it. A workgroup-uniform decision is what lets the cooperative load be
-    // skipped wholesale for an in-focus tile without leaving holes in the cache.
-    let tile_origin = vec2<i32>(wid.xy) * WG;
-    let wg_tile = tile_origin / TILE_SIZE;
-    let tile_max_coc = textureLoad(tTile, wg_tile, 0).r;
-    let tile_blurred = tile_max_coc >= CUTOFF;
-
-    // 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).
-    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();
-
-    let pixel = vec2<i32>(gid.xy);
-    if (pixel.x >= dims.x || pixel.y >= dims.y) {
-        return;
-    }
-
-    let center = textureLoad(tColorCoc, pixel, 0);
-    let center_rgb = center.rgb;
-    let center_coc = center.a;                  // signed full-res radius
-    let center_is_background = center_coc > CUTOFF;
-
-    // In-focus tile: the march would accumulate nothing but the sharp centre
-    // (mirrors the fragment reference's tile fast-path). The cache was not
-    // loaded for this tile, so this must return before any LDS read.
-    if (!tile_blurred) {
-        textureStore(tOut, pixel, vec4<f32>(center_rgb, 0.0));
-        return;
-    }
-
-    // Pixel-centre float coords — identical to the fragment march's
-    // @builtin(position).xy, so every per-pixel value matches the reference.
-    let coord = vec2<f32>(gid.xy) + 0.5;
-    let dims_f = vec2<f32>(dims);
-
-    // Per-pixel blue-noise aperture phase (STBN), static slice (post-TAA).
-    let rotation = stbn_sample_vec2(vec3<u32>(vec2<u32>(coord), 0u)).x;
-    let rot = rotation * 2.0 * PI;
-    let blades = dof.blade_count;
-    const aa = 1.0 / MAXR;
-    let SAMPLES = u32(dof.sample_count);
-    // Clamp to the bitmask's capacity (see Step 2a): b = MAX_STEPS - k
-    // underflows for k > 64. Preset step counts top out at 48.
-    let STEPS = min(u32(dof.step_count), MAX_STEPS);
-
-    var acc = vec3<f32>(0.0);
-    var wsum = 0.0;
-    var max_reach = select(0.0, abs(center_coc), abs(center_coc) > CUTOFF);
-
-    for (var i: u32 = 0u; i < SAMPLES; i = i + 1u) {
-        let o = dof_sample_offset(i, SAMPLES, rot);   // unit-disk aperture point
-        let rho = length(o);
-        if (rho < 1e-3) {
-            continue;
-        }
-        let dir = o / rho;
-        let shape = dof_aperture_shape(o, blades, dof.blade_rotation, aa);
-        if (shape <= 0.0) {
-            continue;
-        }
-
-        let step_len = (rho * MAXR) / f32(STEPS);
-
-        // Branchless nearest-hit via a register bitmask + firstLeadingBit
-        // (Stachowiak; see Step 2a). The CoC for each step is read from the
-        // workgroup cache when the tap lands inside the apron, and from the
-        // texture for the rare far tap (|offset| in (APRON, MAXR]).
-        var mask_lo: u32 = 0u;
-        var mask_hi: u32 = 0u;
-
-        for (var k: u32 = 1u; k <= STEPS; k = k + 1u) {
-            let r = f32(k) * step_len;            // full-res px from centre
-            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 reach = abs(s_coc);
-
-            let cover = saturate(rho * reach - r + 1.0);
-            // Occlusion gate: foreground floods over everything; background
-            // only blurs a background centre (no bleed across a discontinuity).
-            let accept = (s_coc < -CUTOFF) || (s_coc > CUTOFF && center_is_background);
-
-            if (cover > 0.5 && accept) {
-                let b = MAX_STEPS - k;            // k=1 -> bit 63 (MSB = nearest)
-                if (b < 32u) {
-                    mask_lo = mask_lo | (1u << b);
-                } else {
-                    mask_hi = mask_hi | (1u << (b - 32u));
-                }
-            }
-        }
-
-        // Nearest accepted cover = highest set bit; the high word holds the
-        // nearer steps (k <= 32) so test it first.
-        var found = false;
-        var samp = center_rgb;
-        var reach_used = 0.0;
-        var hb: u32 = 0xFFFFFFFFu;
-        if (mask_hi != 0u) {
-            hb = 32u + firstLeadingBit(mask_hi);
-        } else if (mask_lo != 0u) {
-            hb = firstLeadingBit(mask_lo);
-        }
-        if (hb != 0xFFFFFFFFu) {
-            let k = MAX_STEPS - hb;
-            let x = coord + dir * (f32(k) * step_len);
-            let xt = vec2<i32>(clamp(x, vec2<f32>(0.0), dims_f - 1.0));
-            let s = textureLoad(tColorCoc, xt, 0);   // rgb + reach at the hit
-            samp = s.rgb;
-            reach_used = abs(s.a);
-            found = true;
-        }
-
-        let hl = 1.0 + dof.highlight_boost * rgb_to_luminance(samp);
-        let w = shape * hl;
-        acc = acc + samp * w;
-        wsum = wsum + w;
-        if (found) {
-            max_reach = max(max_reach, reach_used);
-        }
-    }
-
-    let color = acc / max(wsum, 1e-4);
-    let defocus = saturate(max_reach - CUTOFF);
-    textureStore(tOut, pixel, vec4<f32>(color, defocus));
-}
-    `,
-    [
-        chunk_dof_sample_offset,
-        chunk_dof_aperture_shape,
-        chunk_stbn_sample_vec2,
-        chunk_rgb_to_luminance,
-        PI_DECLARATION,
-    ]
-);
-
-/**
- * DoF ray-march — compute form (Form-1 Phase B; see DOF_REFINEMENT_PLAN_02).
- * A compute port of the fragment {@link shader_dof_raymarch} writing a storage
- * texture. Same chunks, same 24-direction aperture sampling, same
- * `(defocused colour, defocus amount)` output contract; `coord = gid + 0.5`
- * reproduces the fragment's pixel-centre `@builtin(position)`, so per-pixel
- * results match the reference.
- *
- * Built incrementally so each blind (GPU-only) change is validated in
- * isolation against the fragment reference:
- *  - **Step 1**: bit-identical port — proves the compute/storage-texture
- *    FrameGraph integration.
- *  - **Step 2a**: the per-ray serial break-loop becomes a branchless register
- *    bitmask resolved by `firstLeadingBit` — same nearest-hit result, but every
- *    lane marches uniformly (no data-dependent break), the prerequisite for the
- *    cache.
- *  - **Step 2b** (here): each workgroup cooperatively loads its tile + apron
- *    CoC neighbourhood into `var<workgroup>` shared memory (two f16 packed per
- *    u32), and the inner march reads the cache instead of the texture. Because
- *    the CoC source is already `rgba16float`, the pack is lossless and the
- *    output stays bit-identical to the reference; the in-focus tile fast-path
- *    skips the load, and far taps beyond the apron fall back to a texture read.
- *    The win is the SAMPLES×STEPS per-pixel CoC taps collapsing to one
- *    cooperative load shared across the workgroup.
- *
- * Selected by `DepthOfField.march_mode === DOF_MARCH_MODE.COMPUTE`; the
- * fragment march stays the default and the GPU correctness oracle.
- *
- * @type {ComputeShader}
- */
-export const shader_dof_raymarch_compute = ComputeShader.from({
-    label: "DoF/RayMarchCompute",
-    resources,
-    body,
-});
+import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
+import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+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_SETTINGS_STRUCT } from "./DOF_SETTINGS_STRUCT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, under 64 bytes, read-only: immediate data rather than a uniform buffer. focus_state
+// beside it stays bound — the autofocus pass writes it on the GPU, so there is no CPU value.
+resources.setImmediate("dof", DOF_SETTINGS_STRUCT);
+resources.createGroup()
+    // Full-res (colour.rgb, signed CoC radius) from the prefilter.
+    .addTexture("tColorCoc", "float")
+    // Spatio-temporal blue noise (NVIDIA STBN) for the aperture phase.
+    .addTexture("tSTBN_vec2", "unfilterable-float", "3d")
+    // Dilated per-tile max |CoC| — the fast-path early-out source.
+    .addTexture("tTile", "float")
+    // Defocused colour (rgb) + defocus amount (a) — same contract as the
+    // fragment march's render target, but written via textureStore.
+    .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
+    `
+const MAXR: f32 = ${DOF_MAX_COC_RADIUS};
+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>,
+    @builtin(local_invocation_index) lid: u32,
+    @builtin(workgroup_id) wid: vec3<u32>,
+) {
+    let dims = vec2<i32>(textureDimensions(tColorCoc));
+
+    // Tile fast-path decision, computed from the WORKGROUP id so it is the same
+    // value for every thread: the workgroup sits wholly inside one tile (the
+    // tile size is a multiple of the workgroup side), so all 64 pixels share
+    // it. A workgroup-uniform decision is what lets the cooperative load be
+    // skipped wholesale for an in-focus tile without leaving holes in the cache.
+    let tile_origin = vec2<i32>(wid.xy) * WG;
+    let wg_tile = tile_origin / TILE_SIZE;
+    let tile_max_coc = textureLoad(tTile, wg_tile, 0).r;
+    let tile_blurred = tile_max_coc >= CUTOFF;
+
+    // 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).
+    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();
+
+    let pixel = vec2<i32>(gid.xy);
+    if (pixel.x >= dims.x || pixel.y >= dims.y) {
+        return;
+    }
+
+    let center = textureLoad(tColorCoc, pixel, 0);
+    let center_rgb = center.rgb;
+    let center_coc = center.a;                  // signed full-res radius
+    let center_is_background = center_coc > CUTOFF;
+
+    // In-focus tile: the march would accumulate nothing but the sharp centre
+    // (mirrors the fragment reference's tile fast-path). The cache was not
+    // loaded for this tile, so this must return before any LDS read.
+    if (!tile_blurred) {
+        textureStore(tOut, pixel, vec4<f32>(center_rgb, 0.0));
+        return;
+    }
+
+    // Pixel-centre float coords — identical to the fragment march's
+    // @builtin(position).xy, so every per-pixel value matches the reference.
+    let coord = vec2<f32>(gid.xy) + 0.5;
+    let dims_f = vec2<f32>(dims);
+
+    // Per-pixel blue-noise aperture phase (STBN), static slice (post-TAA).
+    let rotation = stbn_sample_vec2(vec3<u32>(vec2<u32>(coord), 0u)).x;
+    let rot = rotation * 2.0 * PI;
+    let blades = dof.blade_count;
+    const aa = 1.0 / MAXR;
+    let SAMPLES = u32(dof.sample_count);
+    // Clamp to the bitmask's capacity (see Step 2a): b = MAX_STEPS - k
+    // underflows for k > 64. Preset step counts top out at 48.
+    let STEPS = min(u32(dof.step_count), MAX_STEPS);
+
+    var acc = vec3<f32>(0.0);
+    var wsum = 0.0;
+    var max_reach = select(0.0, abs(center_coc), abs(center_coc) > CUTOFF);
+
+    for (var i: u32 = 0u; i < SAMPLES; i = i + 1u) {
+        let o = dof_sample_offset(i, SAMPLES, rot);   // unit-disk aperture point
+        let rho = length(o);
+        if (rho < 1e-3) {
+            continue;
+        }
+        let dir = o / rho;
+        let shape = dof_aperture_shape(o, blades, dof.blade_rotation, aa);
+        if (shape <= 0.0) {
+            continue;
+        }
+
+        let step_len = (rho * MAXR) / f32(STEPS);
+
+        // Branchless nearest-hit via a register bitmask + firstLeadingBit
+        // (Stachowiak; see Step 2a). The CoC for each step is read from the
+        // workgroup cache when the tap lands inside the apron, and from the
+        // texture for the rare far tap (|offset| in (APRON, MAXR]).
+        var mask_lo: u32 = 0u;
+        var mask_hi: u32 = 0u;
+
+        for (var k: u32 = 1u; k <= STEPS; k = k + 1u) {
+            let r = f32(k) * step_len;            // full-res px from centre
+            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 reach = abs(s_coc);
+
+            let cover = saturate(rho * reach - r + 1.0);
+            // Occlusion gate: foreground floods over everything; background
+            // only blurs a background centre (no bleed across a discontinuity).
+            let accept = (s_coc < -CUTOFF) || (s_coc > CUTOFF && center_is_background);
+
+            if (cover > 0.5 && accept) {
+                let b = MAX_STEPS - k;            // k=1 -> bit 63 (MSB = nearest)
+                if (b < 32u) {
+                    mask_lo = mask_lo | (1u << b);
+                } else {
+                    mask_hi = mask_hi | (1u << (b - 32u));
+                }
+            }
+        }
+
+        // Nearest accepted cover = highest set bit; the high word holds the
+        // nearer steps (k <= 32) so test it first.
+        var found = false;
+        var samp = center_rgb;
+        var reach_used = 0.0;
+        var hb: u32 = 0xFFFFFFFFu;
+        if (mask_hi != 0u) {
+            hb = 32u + firstLeadingBit(mask_hi);
+        } else if (mask_lo != 0u) {
+            hb = firstLeadingBit(mask_lo);
+        }
+        if (hb != 0xFFFFFFFFu) {
+            let k = MAX_STEPS - hb;
+            let x = coord + dir * (f32(k) * step_len);
+            let xt = vec2<i32>(clamp(x, vec2<f32>(0.0), dims_f - 1.0));
+            let s = textureLoad(tColorCoc, xt, 0);   // rgb + reach at the hit
+            samp = s.rgb;
+            reach_used = abs(s.a);
+            found = true;
+        }
+
+        let hl = 1.0 + dof.highlight_boost * rgb_to_luminance(samp);
+        let w = shape * hl;
+        acc = acc + samp * w;
+        wsum = wsum + w;
+        if (found) {
+            max_reach = max(max_reach, reach_used);
+        }
+    }
+
+    let color = acc / max(wsum, 1e-4);
+    let defocus = saturate(max_reach - CUTOFF);
+    textureStore(tOut, pixel, vec4<f32>(color, defocus));
+}
+    `,
+    [
+        chunk_dof_sample_offset,
+        chunk_dof_aperture_shape,
+        chunk_stbn_sample_vec2,
+        chunk_rgb_to_luminance,
+        PI_DECLARATION,
+    ]
+);
+
+/**
+ * DoF ray-march — compute form (Form-1 Phase B; see DOF_REFINEMENT_PLAN_02).
+ * A compute port of the fragment {@link shader_dof_raymarch} writing a storage
+ * texture. Same chunks, same 24-direction aperture sampling, same
+ * `(defocused colour, defocus amount)` output contract; `coord = gid + 0.5`
+ * reproduces the fragment's pixel-centre `@builtin(position)`, so per-pixel
+ * results match the reference.
+ *
+ * Built incrementally so each blind (GPU-only) change is validated in
+ * isolation against the fragment reference:
+ *  - **Step 1**: bit-identical port — proves the compute/storage-texture
+ *    FrameGraph integration.
+ *  - **Step 2a**: the per-ray serial break-loop becomes a branchless register
+ *    bitmask resolved by `firstLeadingBit` — same nearest-hit result, but every
+ *    lane marches uniformly (no data-dependent break), the prerequisite for the
+ *    cache.
+ *  - **Step 2b** (here): each workgroup cooperatively loads its tile + apron
+ *    CoC neighbourhood into `var<workgroup>` shared memory (two f16 packed per
+ *    u32), and the inner march reads the cache instead of the texture. Because
+ *    the CoC source is already `rgba16float`, the pack is lossless and the
+ *    output stays bit-identical to the reference; the in-focus tile fast-path
+ *    skips the load, and far taps beyond the apron fall back to a texture read.
+ *    The win is the SAMPLES×STEPS per-pixel CoC taps collapsing to one
+ *    cooperative load shared across the workgroup.
+ *
+ * Selected by `DepthOfField.march_mode === DOF_MARCH_MODE.COMPUTE`; the
+ * fragment march stays the default and the GPU correctness oracle.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_dof_raymarch_compute = ComputeShader.from({
+    label: "DoF/RayMarchCompute",
+    resources,
+    body,
+});

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":"AAoPA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uCAFU,aAAa,CAMpB;8BAzQ2B,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":"AAuPA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uCAFU,aAAa,CAMpB;8BA5Q2B,kCAAkC"}