@woosh/meep-engine 3.11.3 → 3.12.0

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

@@ -1,271 +1,270 @@
-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 {
-    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 { 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, written via textureStore.
-    .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
-
-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;   // 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;
-}
-
-@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));
-
-    // Workgroup-uniform tile decision (see the 2D march for the full rationale).
-    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 (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();
-
-    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;
-    let center_is_background = center_coc > CUTOFF;
-
-    if (!tile_blurred) {
-        textureStore(tOut, pixel, vec4<f32>(center_rgb, 0.0));
-        return;
-    }
-
-    let coord = vec2<f32>(gid.xy) + 0.5;
-    let dims_f = vec2<f32>(dims);
-
-    // Per-pixel blue-noise rotation of the whole direction set (static slice,
-    // post-TAA) — jitter within one angular cell so the D directions stay
-    // even but break the finite-direction banding.
-    let rotation = stbn_sample_vec2(vec3<u32>(vec2<u32>(coord), 0u)).x;
-    let jitter = rotation * PI / f32(D);
-
-    let blades = dof.blade_count;
-    const aa = 1.0 / MAXR;
-    let N = min(u32(dof.step_count), MAX_STEPS);
-    let step_len = MAXR / f32(N);          // fixed step (shared by all slopes)
-
-    // Area-uniform aperture radii ρ_m = sqrt((m+0.5)/M), precomputed once.
-    var rho: array<f32, M>;
-    for (var m: u32 = 0u; m < M; m = m + 1u) {
-        rho[m] = sqrt((f32(m) + 0.5) / f32(M));
-    }
-
-    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 di: u32 = 0u; di < D; di = di + 1u) {
-        let theta = f32(di) * PI / f32(D) + jitter;
-        let e = vec2<f32>(cos(theta), sin(theta));
-
-        for (var sidei: u32 = 0u; sidei < 2u; sidei = sidei + 1u) {
-            let dir = select(e, -e, sidei == 1u);
-
-            // One bitmask per slope; the per-step CoC read is shared across all
-            // slopes (the whole point of the slice form).
-            var mask_lo: array<u32, M>;
-            var mask_hi: array<u32, M>;
-            for (var m: u32 = 0u; m < M; m = m + 1u) {
-                mask_lo[m] = 0u;
-                mask_hi[m] = 0u;
-            }
-
-            for (var k: u32 = 1u; k <= N; k = k + 1u) {
-                let d_k = f32(k) * step_len;
-                let pos = coord + dir * d_k;
-                let coc = slice_read_coc(pos, region_origin, dims, dims_f);
-                let reach = abs(coc);
-                // Occlusion gate (surface-only, slope-independent → read once).
-                let accept = (coc < -CUTOFF) || (coc > CUTOFF && center_is_background);
-                if (accept) {
-                    let b = MAX_STEPS - k;          // nearest k -> highest bit
-                    for (var m: u32 = 0u; m < M; m = m + 1u) {
-                        if (rho[m] * reach - d_k + 1.0 > 0.5) {
-                            if (b < 32u) {
-                                mask_lo[m] = mask_lo[m] | (1u << b);
-                            } else {
-                                mask_hi[m] = mask_hi[m] | (1u << (b - 32u));
-                            }
-                        }
-                    }
-                }
-            }
-
-            // Resolve each slope's nearest hit; accumulate its aperture sample.
-            for (var m: u32 = 0u; m < M; m = m + 1u) {
-                let o = dir * rho[m];               // unit-disk aperture point
-                let shape = dof_aperture_shape(o, blades, dof.blade_rotation, aa);
-                if (shape <= 0.0) {
-                    continue;
-                }
-
-                var hb: u32 = 0xFFFFFFFFu;
-                if (mask_hi[m] != 0u) {
-                    hb = 32u + firstLeadingBit(mask_hi[m]);
-                } else if (mask_lo[m] != 0u) {
-                    hb = firstLeadingBit(mask_lo[m]);
-                }
-
-                // Not-found contributes the sharp centre (matches the reference's
-                // unconditional per-sub-ray fallback — keeps the denominator right).
-                var samp = center_rgb;
-                var reach_used = 0.0;
-                var found = false;
-                if (hb != 0xFFFFFFFFu) {
-                    let k = MAX_STEPS - hb;
-                    let pos = coord + dir * (f32(k) * step_len);
-                    let xt = vec2<i32>(clamp(pos, vec2<f32>(0.0), dims_f - 1.0));
-                    let s = textureLoad(tColorCoc, xt, 0);   // colour + reach at 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_aperture_shape,
-        chunk_stbn_sample_vec2,
-        chunk_rgb_to_luminance,
-        PI_DECLARATION,
-    ]
-);
-
-/**
- * DoF ray-march — 1-D directional-slice compute form (Form-1 Phase B, the real
- * Stachowiak GPC-2024 structure). The 2D Vogel gather ({@link
- * shader_dof_raymarch_compute}, measured slower than the fragment reference) is
- * reorganised so the aperture is sampled along `D` evenly-spaced directions
- * (jittered per pixel), each marched ± both ways, and along one direction the
- * **per-step CoC read is shared across the `M` aperture radii** — `D·2·N`
- * reads instead of `D·2·M·N`. Reuses the Step-2b workgroup CoC cache; the
- * per-slope nearest hit is the verified `firstLeadingBit` bitmask (Step 2a).
- *
- * NOT bit-identical to the reference (a different sampling of the disc): the
- * bokeh is a `D`-gon rather than the Vogel spiral. Validate visually + profile;
- * the win is the read-sharing across slopes. Single dispatch, register
- * accumulation (no cross-dispatch accumulator). All sub-rays contribute (found
- * → hit colour, else → sharp centre) exactly as the reference, so the weighted
- * average and the flood/occlusion behaviour match.
- *
- * Selected by `DepthOfField.march_mode === DOF_MARCH_MODE.SLICE`.
- *
- * @type {ComputeShader}
- */
-export const shader_dof_slice_compute = ComputeShader.from({
-    label: "DoF/SliceMarch",
-    resources,
-    body,
-    group_size: [WG, WG, 1],
-});
+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 {
+    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 { 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, written via textureStore.
+    .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
+
+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;   // 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;
+}
+
+@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));
+
+    // Workgroup-uniform tile decision (see the 2D march for the full rationale).
+    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 (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();
+
+    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;
+    let center_is_background = center_coc > CUTOFF;
+
+    if (!tile_blurred) {
+        textureStore(tOut, pixel, vec4<f32>(center_rgb, 0.0));
+        return;
+    }
+
+    let coord = vec2<f32>(gid.xy) + 0.5;
+    let dims_f = vec2<f32>(dims);
+
+    // Per-pixel blue-noise rotation of the whole direction set (static slice,
+    // post-TAA) — jitter within one angular cell so the D directions stay
+    // even but break the finite-direction banding.
+    let rotation = stbn_sample_vec2(vec3<u32>(vec2<u32>(coord), 0u)).x;
+    let jitter = rotation * PI / f32(D);
+
+    let blades = dof.blade_count;
+    const aa = 1.0 / MAXR;
+    let N = min(u32(dof.step_count), MAX_STEPS);
+    let step_len = MAXR / f32(N);          // fixed step (shared by all slopes)
+
+    // Area-uniform aperture radii ρ_m = sqrt((m+0.5)/M), precomputed once.
+    var rho: array<f32, M>;
+    for (var m: u32 = 0u; m < M; m = m + 1u) {
+        rho[m] = sqrt((f32(m) + 0.5) / f32(M));
+    }
+
+    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 di: u32 = 0u; di < D; di = di + 1u) {
+        let theta = f32(di) * PI / f32(D) + jitter;
+        let e = vec2<f32>(cos(theta), sin(theta));
+
+        for (var sidei: u32 = 0u; sidei < 2u; sidei = sidei + 1u) {
+            let dir = select(e, -e, sidei == 1u);
+
+            // One bitmask per slope; the per-step CoC read is shared across all
+            // slopes (the whole point of the slice form).
+            var mask_lo: array<u32, M>;
+            var mask_hi: array<u32, M>;
+            for (var m: u32 = 0u; m < M; m = m + 1u) {
+                mask_lo[m] = 0u;
+                mask_hi[m] = 0u;
+            }
+
+            for (var k: u32 = 1u; k <= N; k = k + 1u) {
+                let d_k = f32(k) * step_len;
+                let pos = coord + dir * d_k;
+                let coc = slice_read_coc(pos, region_origin, dims, dims_f);
+                let reach = abs(coc);
+                // Occlusion gate (surface-only, slope-independent → read once).
+                let accept = (coc < -CUTOFF) || (coc > CUTOFF && center_is_background);
+                if (accept) {
+                    let b = MAX_STEPS - k;          // nearest k -> highest bit
+                    for (var m: u32 = 0u; m < M; m = m + 1u) {
+                        if (rho[m] * reach - d_k + 1.0 > 0.5) {
+                            if (b < 32u) {
+                                mask_lo[m] = mask_lo[m] | (1u << b);
+                            } else {
+                                mask_hi[m] = mask_hi[m] | (1u << (b - 32u));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Resolve each slope's nearest hit; accumulate its aperture sample.
+            for (var m: u32 = 0u; m < M; m = m + 1u) {
+                let o = dir * rho[m];               // unit-disk aperture point
+                let shape = dof_aperture_shape(o, blades, dof.blade_rotation, aa);
+                if (shape <= 0.0) {
+                    continue;
+                }
+
+                var hb: u32 = 0xFFFFFFFFu;
+                if (mask_hi[m] != 0u) {
+                    hb = 32u + firstLeadingBit(mask_hi[m]);
+                } else if (mask_lo[m] != 0u) {
+                    hb = firstLeadingBit(mask_lo[m]);
+                }
+
+                // Not-found contributes the sharp centre (matches the reference's
+                // unconditional per-sub-ray fallback — keeps the denominator right).
+                var samp = center_rgb;
+                var reach_used = 0.0;
+                var found = false;
+                if (hb != 0xFFFFFFFFu) {
+                    let k = MAX_STEPS - hb;
+                    let pos = coord + dir * (f32(k) * step_len);
+                    let xt = vec2<i32>(clamp(pos, vec2<f32>(0.0), dims_f - 1.0));
+                    let s = textureLoad(tColorCoc, xt, 0);   // colour + reach at 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_aperture_shape,
+        chunk_stbn_sample_vec2,
+        chunk_rgb_to_luminance,
+        PI_DECLARATION,
+    ]
+);
+
+/**
+ * DoF ray-march — 1-D directional-slice compute form (Form-1 Phase B, the real
+ * Stachowiak GPC-2024 structure). The 2D Vogel gather ({@link
+ * shader_dof_raymarch_compute}, measured slower than the fragment reference) is
+ * reorganised so the aperture is sampled along `D` evenly-spaced directions
+ * (jittered per pixel), each marched ± both ways, and along one direction the
+ * **per-step CoC read is shared across the `M` aperture radii** — `D·2·N`
+ * reads instead of `D·2·M·N`. Reuses the Step-2b workgroup CoC cache; the
+ * per-slope nearest hit is the verified `firstLeadingBit` bitmask (Step 2a).
+ *
+ * NOT bit-identical to the reference (a different sampling of the disc): the
+ * bokeh is a `D`-gon rather than the Vogel spiral. Validate visually + profile;
+ * the win is the read-sharing across slopes. Single dispatch, register
+ * accumulation (no cross-dispatch accumulator). All sub-rays contribute (found
+ * → hit colour, else → sharp centre) exactly as the reference, so the weighted
+ * average and the flood/occlusion behaviour match.
+ *
+ * Selected by `DepthOfField.march_mode === DOF_MARCH_MODE.SLICE`.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_dof_slice_compute = ComputeShader.from({
+    label: "DoF/SliceMarch",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_nss_concat.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_concat.js"],"names":[],"mappings":"AA6DA,8CAKG;;8BA/D2B,+BAA+B;AAI7D;;;;;;;;;;;;;GAaG;AACH,4CAE+B;6BAtBF,mCAAmC"}
+{"version":3,"file":"shader_nss_concat.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/shader_nss_concat.js"],"names":[],"mappings":"AA6DA,8CAIG;;8BA9D2B,+BAA+B;AAI7D;;;;;;;;;;;;;GAaG;AACH,4CAE+B;6BAtBF,mCAAmC"}