@woosh/meep-engine 3.38.0 → 3.40.0

package/src/shade/playground/sh_exponential/sh_exp_playground_shaders.js

@@ -0,0 +1,270 @@
+import { chunk_get_ibl_radiance } from "../../renderer/deferred/indirect/chunk_get_ibl_radiance.js";
+import { chunk_sh_exp_p4q2_base_reflectance } from "../../renderer/shader/chunk/spherical_harmonics/exponential/chunk_sh_exp_p4q2_base_reflectance.js";
+import { SH_EXP_P4Q2_PROBE_STRUCT } from "../../renderer/shader/chunk/spherical_harmonics/exponential/SH_EXP_P4Q2_PROBE_STRUCT.js";
+import { chunk_D_GGX } from "../../renderer/shader/chunk/brdf/chunk_D_GGX.js";
+import { chunk_V_GGX_SmithCorrelated } from "../../renderer/shader/chunk/brdf/chunk_V_GGX_SmithCorrelated.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../renderer/shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../renderer/shader/type/WebGPUArray.js";
+import { f32, u32, vec4f } from "../../renderer/shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../renderer/shader/type/WebGPUStruct.js";
+import { SAMPLER_LINEAR_UPSCALE } from "../../renderer/texture/SAMPLER_LINEAR_UPSCALE.js";
+
+/**
+ * Rows of the sphere grid, top to bottom.
+ * @type {string[]}
+ */
+export const PLAYGROUND_ROWS = [
+    'reference (quadrature)',
+    'SH exponential, P4 Q2',
+    'engine IBL (split sum)',
+    'SH exponential − reference',
+];
+
+/**
+ * Step through the reference grid's cells: odd, so it visits every cell of a power-of-two grid once
+ * per pass, and large, so any run of consecutive steps is spread over the sphere and a partial sum
+ * is already a fair estimate of the whole.
+ *
+ * @type {number}
+ */
+export const REFERENCE_CELL_STRIDE = 7919;
+
+/**
+ * What both playground kernels read.
+ *
+ * - `right`, `up`, `back`: the orthographic camera's basis; `back` points at the viewer and is every
+ *   pixel's view direction;
+ * - `cell_size`: pixels per sphere cell, `columns` spheres per row, one per roughness;
+ * - `alpha_first_root`, `alpha_root_step`: column `c` is at roughness `first + step * c`, GGX alpha
+ *   its square — the paper's own sweep is 0.3 to 1 in steps of 0.1;
+ * - `slice_start`, `slice_count`: which reference cells this frame adds; `processed` how many will
+ *   have been added after it, of `cell_count`;
+ * - `exposure`, `error_gain`: display only.
+ *
+ * @type {WebGPUStruct}
+ */
+export const PLAYGROUND_VIEW_STRUCT = WebGPUStruct.from({
+    right: vec4f,
+    up: vec4f,
+    back: vec4f,
+    cell_size: u32,
+    columns: u32,
+    slice_start: u32,
+    slice_count: u32,
+    cell_count: u32,
+    processed: u32,
+    alpha_first_root: f32,
+    alpha_root_step: f32,
+    exposure: f32,
+    error_gain: f32,
+}, "SHExpPlaygroundView");
+
+/**
+ * The sphere a pixel of a cell sees: `w` is 1 on the sphere and 0 off it, `xyz` the world normal.
+ */
+const chunk_playground_sphere = CodeChunk.from(
+    //language=WGSL
+    `
+const SPHERE_RADIUS : f32 = 0.92;
+
+fn playground_sphere_normal(local: vec2<u32>) -> vec4<f32> {
+    let p = (vec2<f32>(local) + 0.5) / f32(view.cell_size) * 2.0 - 1.0;
+    // screen y grows downwards
+    let q = vec2<f32>(p.x, -p.y) / SPHERE_RADIUS;
+    let r2 = dot(q, q);
+
+    if (r2 >= 1.0) {
+        return vec4<f32>(0.0);
+    }
+
+    let normal = view.right.xyz * q.x + view.up.xyz * q.y + view.back.xyz * sqrt(1.0 - r2);
+
+    return vec4<f32>(normalize(normal), 1.0);
+}
+
+fn playground_alpha(column: u32) -> f32 {
+    let root = view.alpha_first_root + view.alpha_root_step * f32(column);
+    return root * root;
+}
+`);
+
+const accumulate_resources = new ShaderResourceSetDescriptor();
+
+accumulate_resources.createGroup()
+    .addUniform("view", PLAYGROUND_VIEW_STRUCT)
+    .addStorageBuffer("cells", WebGPUArray.from(vec4f), false)
+    .addStorageBuffer("accumulation", WebGPUArray.from(vec4f), true);
+
+/**
+ * Adds one slice of the reference quadrature to every sphere pixel: `E0` summed over
+ * `slice_count` cells of an octahedral grid made by `shader_sh_exp_environment_cells`, at a finer
+ * resolution than the encoder fits on. Spread over frames, so no invocation loops over the sphere.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_playground_accumulate_reference = ComputeShader.from({
+    label: "SH exponential playground / accumulate reference",
+    resources: accumulate_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let width = view.columns * view.cell_size;
+
+    if (id.x >= width || id.y >= view.cell_size) {
+        return;
+    }
+
+    let column = id.x / view.cell_size;
+    let local = vec2<u32>(id.x % view.cell_size, id.y);
+    let sphere = playground_sphere_normal(local);
+
+    if (sphere.w == 0.0) {
+        return;
+    }
+
+    let normal = sphere.xyz;
+    let view_direction = view.back.xyz;
+    let NoV = max(dot(normal, view_direction), 1e-4);
+    let alpha = playground_alpha(column);
+    let alpha2 = alpha * alpha;
+
+    var sum = vec3<f32>(0.0);
+
+    // a uniform trip count: the slice is the same for every pixel
+    for (var k = 0u; k < view.slice_count; k++) {
+        let cell = ((view.slice_start + k) * ${REFERENCE_CELL_STRIDE}u) % view.cell_count;
+        let light = cells[2u * cell].xyz;
+        let NoL = dot(normal, light);
+
+        if (NoL > 0.0) {
+            let half_vector = normalize(light + view_direction);
+            let NoH = saturate(dot(normal, half_vector));
+
+            sum += cells[2u * cell + 1u].xyz * (D_GGX(alpha2, NoH * NoH) * V_GGX_SmithCorrelated(alpha, NoL, NoV) * NoL);
+        }
+    }
+
+    let pixel = column * view.cell_size * view.cell_size + local.y * view.cell_size + local.x;
+
+    accumulation[pixel] += vec4<f32>(sum, 0.0);
+}
+`, [
+            chunk_playground_sphere,
+            chunk_D_GGX,
+            chunk_V_GGX_SmithCorrelated,
+        ]),
+});
+
+const view_resources = new ShaderResourceSetDescriptor();
+
+view_resources.createGroup()
+    .addUniform("view", PLAYGROUND_VIEW_STRUCT)
+    .addTexture("tEnvironment")
+    .addTexture("tSplitSum", "float")
+    .addSampler("sLinear", "filtering", SAMPLER_LINEAR_UPSCALE)
+    .addStorageBuffer("probe", SH_EXP_P4Q2_PROBE_STRUCT, false)
+    .addStorageBuffer("accumulation", WebGPUArray.from(vec4f), false)
+    .addStorageBuffer("values", WebGPUArray.from(vec4f), true)
+    .addStorageTexture("output", "rgba8unorm", "2d", "write-only");
+
+/**
+ * Draws the four rows of {@link PLAYGROUND_ROWS}, and writes the linear values of the first three
+ * into `values` (`[row][column][pixel]`, `w` = 1 on the sphere) for `verify()` to read.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_playground_view = ComputeShader.from({
+    label: "SH exponential playground / view",
+    resources: view_resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const BACKGROUND = vec3<f32>(0.035);
+
+fn tonemap(x: vec3<f32>) -> vec3<f32> {
+    return vec3<f32>(1.0) - exp(-max(x, vec3<f32>(0.0)) * view.exposure);
+}
+
+fn srgb_encode(x: vec3<f32>) -> vec3<f32> {
+    let low = x * 12.92;
+    let high = 1.055 * pow(x, vec3<f32>(1.0 / 2.4)) - 0.055;
+    return select(high, low, x <= vec3<f32>(0.0031308));
+}
+
+fn luminance(x: vec3<f32>) -> f32 {
+    return dot(x, vec3<f32>(0.2126, 0.7152, 0.0722));
+}
+
+@compute @workgroup_size(8, 8)
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let width = view.columns * view.cell_size;
+
+    if (id.x >= width || id.y >= 4u * view.cell_size) {
+        return;
+    }
+
+    let column = id.x / view.cell_size;
+    let row = id.y / view.cell_size;
+    let local = vec2<u32>(id.x % view.cell_size, id.y % view.cell_size);
+    let pixel = column * view.cell_size * view.cell_size + local.y * view.cell_size + local.x;
+    let slots = view.columns * view.cell_size * view.cell_size;
+
+    let sphere = playground_sphere_normal(local);
+
+    if (sphere.w == 0.0) {
+        if (row < 3u) {
+            values[row * slots + pixel] = vec4<f32>(0.0);
+        }
+
+        textureStore(output, id.xy, vec4<f32>(srgb_encode(BACKGROUND), 1.0));
+        return;
+    }
+
+    let normal = sphere.xyz;
+    let view_direction = view.back.xyz;
+    let alpha = playground_alpha(column);
+    let roughness = sqrt(alpha);
+
+    // the partial sum so far stands for the whole sphere: the cells it has seen are spread over it
+    let reference = accumulation[pixel].xyz * (f32(view.cell_count) / f32(max(view.processed, 1u)));
+    let sh_exp = sh_exp_p4q2_base_reflectance(probe, view_direction, normal, alpha);
+
+    var value = vec3<f32>(0.0);
+
+    if (row == 0u) {
+        value = reference;
+    } else if (row == 1u) {
+        value = sh_exp;
+    } else if (row == 2u) {
+        // the forward path's specular with Fresnel taken out: prefiltered radiance times the
+        // split sum's F0 scale plus F90 bias, which together are the GGX directional albedo (the engine's
+        // LUT, to within 0.06%; see chunk_sh_exp_split_sum)
+        let NoV = saturate(dot(normal, view_direction));
+        let dfg = textureSampleLevel(tSplitSum, sLinear, vec2<f32>(NoV, roughness), 0.0).rg;
+
+        value = get_ibl_radiance(view_direction, normal, roughness) * (dfg.x + dfg.y);
+    }
+
+    var color: vec3<f32>;
+
+    if (row < 3u) {
+        values[row * slots + pixel] = vec4<f32>(value, 1.0);
+        color = tonemap(value);
+    } else {
+        // red: SH exponential brighter than the reference, blue: darker; on the tonemapped scale
+        let difference = (luminance(tonemap(sh_exp)) - luminance(tonemap(reference))) * view.error_gain;
+        color = vec3<f32>(max(difference, 0.0), 0.0, max(-difference, 0.0));
+    }
+
+    textureStore(output, id.xy, vec4<f32>(srgb_encode(saturate(color)), 1.0));
+}
+`, [
+            chunk_playground_sphere,
+            chunk_sh_exp_p4q2_base_reflectance,
+            chunk_get_ibl_radiance,
+        ]),
+});

package/src/shade/playground/ssr_reprojection/README.md

@@ -1,103 +1,111 @@
-# SSR reflection lab
-
-Run `npm run dev` from `packages/meep-engine`, then open
-<http://localhost:5173/src/shade/playground/ssr_reprojection/>.
-The page uses the actual WebGPU renderer and production SSR shaders. Geometry and
-environment lighting are procedural; only the engine's bundled lookup/noise textures
-are loaded. The browser must meet the renderer's WebGPU feature requirements.
-
-## Five-minute check
-
-1. Start with **Lateral camera**, **Parallax**, roughness **0.03**, and final TAA off.
-   Watch the reflected coloured blocks move relative to the floor grid. Solid crosses
-   mark ideal planar-mirror image centres. Dashed crosses are fixed floor positions,
-   aligned at the start of the path. Their separation illustrates surface sticking.
-2. Select **Surface only**, then **No temporal history**. Switching mode restarts
-   the path and resets histories. Compare edge lag and noise at the same part of the
-   repeatable path. Surface only uses the new validation/blending, not the old shader.
-3. Try **Forward camera** and **Orbit camera**, then raise roughness through 0.2.
-   The virtual candidate is deliberately restricted to smooth, coherent reflections.
-4. Use **Moving object** and **Occluder** to expose residual trails and disocclusion.
-   Moving reflected geometry is an acknowledged limitation. Missing off-screen or
-   hidden source geometry is also an SSR limitation, not necessarily a reprojection bug.
-5. Press **Camera cut**, **Reset reflection history**, and change resolution.
-   Old reflections should not persist. **SSR off** is a useful control proving that
-   the visible reflection comes from SSR rather than the flat environment.
-
-The guides reflect physical object centres across y=0 independently of the temporal
-ray-extension formula. They are geometry guides, not colour references: visible
-front faces, occlusion and roughness do not necessarily centre on the marker. The
-floor is planar and its top is exactly y=0. Grid strips slightly above it are visible
-surface landmarks. Guides do not perform occlusion testing.
-
-The page fixes exposure and disables bloom, sharpening, ambient occlusion and motion
-blur. Final-image TAA defaults off to expose SSR's own temporal behaviour. Pause
-motion leaves temporal sampling running; **Still camera / noise** does the same at
-the initial view. **Step frame** advances the motion by 1/60 second. For exact manual
-frame counts, append `?manual` to the URL: no animation loop is scheduled, and the
-step button submits one frame at a time. From the browser console,
-`ssr_lab.step(60)` advances 60 deterministic frames at 1/60 second.
-
-**Validate GPU shaders** compiles trace, both resolves, both spatial variants, and
-temporal reprojection on the live GPU. This checks native WGSL compilation, while
-running the playground also exercises IBL pipeline creation and frame-graph wiring.
-The page reports and stops on uncaptured GPU errors. LPV composition is checked but
-the procedural scene uses IBL, so this does not test LPV atlas content or lighting.
-
-Production integration is small: `renderer.ssr.reprojection_mode` selects
-`SSRReprojectionMode.Parallax`, `.Surface`, or `.CurrentFrame`. Changing it invalidates
-SSR history. Default rendering continues to use Parallax.
-
-Do not use frame rate on this page as an SSR-only GPU timing measurement. It includes
-the entire renderer, the browser, and the overlay. Profile the actual passes before
-making performance claims. HMR is disabled by the playground Vite config; reload
-the browser explicitly after source edits.
-
-## Validation performed
-
-The page was exercised on the native NVIDIA adapter: IBL rendering, all four
-comparison modes, a moving target and occluder, camera cut, resolution change,
-and final TAA toggle. The SSR-off control visibly removes the reflections.
-All six SSR shader modules compile on that device, and the 14 SSR regression
-tests pass. Declaration emission and consumer API pins pass; the existing
-repository type-error budget is still exceeded (899 errors versus 897).
-
-## Spatial denoising
-
-The **Spatial denoising** checkbox defaults on. It toggles one spatial pass before
-reprojection and two afterward; the chosen reprojection mode stays unchanged.
-Changing this setting resets SSR history so filtered and unfiltered inputs are not
-mixed across the transition. The runtime setting is
-`renderer.ssr.spatial_denoising_enabled`. With the box unchecked and **No temporal
-history** selected, the output comes directly from resolve. Resolve still borrows
-neighbouring ray hits and uses roughness-dependent radiance filtering; this switch
-does not turn the resolve stage into a raw one-ray-per-pixel view.
-
-## Measuring actual filter effectiveness
-
-**Measure spatial filter** records the first spatial pass's input and output in
-one GPU frame. It reports the fraction of upward-facing mirror pixels whose maximum
-RGB-channel difference exceeds 0.001, mean/max difference in linear HDR radiance,
-and the fraction whose input variance is effectively zero. It is an effect check,
-not an image-quality score or an SSR performance benchmark. Readback runs only on
-request; its temporary texture is released afterward. Ordinary playback has no
-probe passes. SSR must be enabled. With spatial filtering off, the bypass is compared
-with itself and the measured difference is zero.
-
-This probe exposed a filter failure on 2026-09-08: roughly 98% of this scene's mirror
-pixels had resolve variance ≤1e-6. The old first pass changed radiance by just 0.00137
-on average; the sparse noisy samples were being rejected as colour edges. Resolve's
-within-pixel ray variance is not sufficient evidence of low spatial noise when only
-one hit supplies radiance or the hit confidence switches between SSR and fallback.
-
-The first pass now bootstraps uncertainty from a Gaussian-weighted 3×3 luminance
-neighbourhood, using the existing geometry weights, and carries that uncertainty
-through the subsequent spatial passes. It does not bootstrap again at larger radii.
-A representative corrected GPU measurement gave mean change 0.00552 with filtering
-on, and 0 with it off. These are separate frames, not a matched-noise quality metric.
-The native images visibly differ, and an emulator regression verifies reduced
-checker noise with zero input variance, unchanged constant colour (within float
-precision), and rejection across opposite normals. The full SSR suite has 16 tests.
-
-Spatial filtering trades sharpness for noise reduction, including at reflected
-colour edges; these guides and tests do not establish an optimal filter bandwidth.
+# SSR reflection lab
+
+Run `npm run dev` from `packages/meep-engine`, then open
+<http://localhost:5173/src/shade/playground/ssr_reprojection/>.
+The page uses the actual WebGPU renderer and production SSR shaders. Geometry and
+environment lighting are procedural; only the engine's bundled lookup/noise textures
+are loaded. The browser must meet the renderer's WebGPU feature requirements.
+
+## Five-minute check
+
+1. Start with **Lateral camera**, **Parallax**, roughness **0.03**, and final TAA off.
+   Watch the reflected coloured blocks move relative to the floor grid. Solid crosses
+   mark ideal planar-mirror image centres. Dashed crosses are fixed floor positions,
+   aligned at the start of the path. Their separation illustrates surface sticking.
+2. Select **Surface only**, then **No temporal history**. Switching mode restarts
+   the path and resets histories. Compare edge lag and noise at the same part of the
+   repeatable path. Surface only uses the new validation/blending, not the old shader.
+3. Try **Forward camera** and **Orbit camera**, then raise roughness through 0.2.
+   The virtual candidate is deliberately restricted to smooth, coherent reflections.
+4. Use **Moving object** and **Occluder** to expose residual trails and disocclusion.
+   Moving reflected geometry is an acknowledged limitation. Missing off-screen or
+   hidden source geometry is also an SSR limitation, not necessarily a reprojection bug.
+5. Press **Camera cut**, **Reset reflection history**, and change resolution.
+   Old reflections should not persist. **SSR off** is a useful control proving that
+   the visible reflection comes from SSR rather than the flat environment.
+
+The guides reflect physical object centres across y=0 independently of the temporal
+ray-extension formula. They are geometry guides, not colour references: visible
+front faces, occlusion and roughness do not necessarily centre on the marker. The
+floor is planar and its top is exactly y=0. Grid strips slightly above it are visible
+surface landmarks. Guides do not perform occlusion testing.
+
+The page fixes exposure and disables bloom, sharpening, ambient occlusion and motion
+blur. Final-image TAA defaults off to expose SSR's own temporal behaviour. Pause
+motion leaves temporal sampling running; **Still camera / noise** does the same at
+the initial view. **Step frame** advances the motion by 1/60 second. For exact manual
+frame counts, append `?manual` to the URL: no animation loop is scheduled, and the
+step button submits one frame at a time. From the browser console,
+`ssr_lab.step(60)` advances 60 deterministic frames at 1/60 second.
+
+**Validate GPU shaders** compiles trace, both resolves, both spatial variants, and
+temporal reprojection on the live GPU. This checks native WGSL compilation, while
+running the playground also exercises IBL pipeline creation and frame-graph wiring.
+The page reports and stops on uncaptured GPU errors. LPV composition is checked but
+the procedural scene uses IBL, so this does not test LPV atlas content or lighting.
+
+Production integration is small: `renderer.ssr.reprojection_mode` selects
+`SSRReprojectionMode.Parallax`, `.Surface`, or `.CurrentFrame`. Changing it invalidates
+SSR history. Default rendering continues to use Parallax.
+
+Do not use frame rate on this page as an SSR-only GPU timing measurement. It includes
+the entire renderer, the browser, and the overlay. Profile the actual passes before
+making performance claims. HMR is disabled by the playground Vite config; reload
+the browser explicitly after source edits.
+
+## Validation performed
+
+The page was exercised on the native NVIDIA adapter: IBL rendering, all four
+comparison modes, a moving target and occluder, camera cut, resolution change,
+and final TAA toggle. The SSR-off control visibly removes the reflections.
+All six SSR shader modules compile on that device, and the 14 SSR regression
+tests pass. Declaration emission and consumer API pins pass; the existing
+repository type-error budget is still exceeded (899 errors versus 897).
+
+## Spatial denoising
+
+The **Spatial denoising** checkbox defaults on. It toggles one spatial pass before
+reprojection and two afterward; the chosen reprojection mode stays unchanged.
+Changing this setting resets SSR history so filtered and unfiltered inputs are not
+mixed across the transition. The runtime setting is
+`renderer.ssr.spatial_denoising_enabled`. With the box unchecked and **No temporal
+history** selected, the output comes directly from resolve. Resolve still borrows
+neighbouring ray hits and uses roughness-dependent radiance filtering; this switch
+does not turn the resolve stage into a raw one-ray-per-pixel view.
+
+**Coverage tile denoising** is opt-in through `renderer.ssr.tile_denoising_enabled`.
+It classifies 8×8 internal-pixel tiles and protects the full spatial/temporal filter
+reach with a two-tile halo. Only stationary, constant radiance with no SSR support,
+uncertainty, or changing history can skip spatial work. Temporal geometry validation
+and history age still run; only proven constant neighborhood statistics are bypassed.
+Changing the setting resets history. Classification adds overhead, so profile
+the intended scene and device before enabling it, especially at low resolutions.
+
+## Measuring actual filter effectiveness
+
+**Measure spatial filter** records the first spatial pass's input and output in
+one GPU frame. It reports the fraction of upward-facing mirror pixels whose maximum
+RGB-channel difference exceeds 0.001, mean/max difference in linear HDR radiance,
+and the fraction whose input variance is effectively zero. It is an effect check,
+not an image-quality score or an SSR performance benchmark. Readback runs only on
+request; its temporary texture is released afterward. Ordinary playback has no
+probe passes. SSR must be enabled. With spatial filtering off, the bypass is compared
+with itself and the measured difference is zero.
+
+This probe exposed a filter failure on 2026-09-08: roughly 98% of this scene's mirror
+pixels had resolve variance ≤1e-6. The old first pass changed radiance by just 0.00137
+on average; the sparse noisy samples were being rejected as colour edges. Resolve's
+within-pixel ray variance is not sufficient evidence of low spatial noise when only
+one hit supplies radiance or the hit confidence switches between SSR and fallback.
+
+The first pass now bootstraps uncertainty from a Gaussian-weighted 3×3 luminance
+neighbourhood, using the existing geometry weights, and carries that uncertainty
+through the subsequent spatial passes. It does not bootstrap again at larger radii.
+A representative corrected GPU measurement gave mean change 0.00552 with filtering
+on, and 0 with it off. These are separate frames, not a matched-noise quality metric.
+The native images visibly differ, and an emulator regression verifies reduced
+checker noise with zero input variance, unchanged constant colour (within float
+precision), and rejection across opposite normals. The full SSR suite has 16 tests.
+
+Spatial filtering trades sharpness for noise reduction, including at reflected
+colour edges; these guides and tests do not establish an optimal filter bandwidth.

package/src/shade/playground/ssr_reprojection/SpatialFilterProbe.js

@@ -1,68 +1,68 @@
-import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
-import { ImageShader } from "../../renderer/shader/ImageShader.js";
-import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
-import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { graph_image_pass } from "../../renderer/shader/graph/graph_image_pass.js";
-import { graph_import_texture } from "../../renderer/shader/graph/graph_import_texture.js";
-import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../renderer/shader/ShaderDescriptor.js";
-import { GPUTextureContext } from "../../renderer/texture/GPUTextureContext.js";
-import { download_texture_data } from "../../renderer/texture/download_texture_data.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup().addTexture('tBefore').addTexture('tAfter').addTexture('tNormal', 'uint');
-const shader = new ImageShader({
-    descriptor: ShaderDescriptor.from({label:'SSR lab / spatial effect',resources,
-        body:CodeChunk.from(/* language=WGSL */ `
-@fragment fn main(@builtin(position) coord:vec4f) -> @location(0) vec4f {
-    let p = vec2i(coord.xy);
-    if (decode_g_buffer_normal(textureLoad(tNormal,p,0).xy).y < 0.99) { return vec4f(-1.0); }
-    let a = textureLoad(tBefore,p,0);
-    let b = textureLoad(tAfter,p,0);
-    let difference = abs(a.rgb-b.rgb);
-    return vec4f(max(difference.r,max(difference.g,difference.b)),a.w,b.w,1.0);
-}`, [chunk_decode_g_buffer_normal])}),
-    targets:[{format:'rgba32float'}],
-});
-
-/** Same-frame GPU input/output comparison. Opt-in; no cost during ordinary playback. */
-export class SpatialFilterProbe extends RenderExtension {
-    name = 'SSR lab / measure spatial filter';
-    enabled = false;
-    texture;
-    device;
-    constructor(device) { super(); this.device=device; }
-    record(frame) {
-        if (!this.enabled) { return; }
-        // This diagnostic intentionally inspects the playground's production graph.
-        const pass=frame.graph.__pass_nodes.find(p=>p.name==='SSR / spatial denoise with metadata');
-        const resolve=frame.graph.__pass_nodes.find(p=>p.name==='SSR resolve / IBL');
-        if (!resolve) { throw new Error('Enable SSR to measure its spatial filter.'); }
-        const before=pass ? pass.data.tInput : resolve.data['@output'][0];
-        const after=pass ? pass.data['@output'][0] : before;
-        const [width,height]=frame.resolution;
-        if (!this.texture || this.texture.width!==width || this.texture.height!==height) {
-            this.texture?.destroy();
-            this.texture=GPUTextureContext.fromTexture(this.device.createTexture({
-                size:[width,height,1],format:'rgba32float',
-                usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC,
-            }),this.device);
-        }
-        graph_image_pass({graph:frame.graph,shader,
-            inputs:{tBefore:before,tAfter:after,tNormal:resolve.data.tNormal},
-            output:[graph_import_texture(frame.graph,this.texture,'SSR spatial measurement')],
-        });
-    }
-    async read() {
-        const data=await download_texture_data({device:this.device,source:this.texture.gpu_texture});
-        let pixels=0,changed=0,zero_variance=0,mean=0,max=0;
-        for(let i=0;i<data.length;i+=4) {
-            if(data[i]<0) { continue; }
-            if(!Number.isFinite(data[i])) { throw new Error('Non-finite denoising output.'); }
-            pixels++; changed+=data[i]>0.001 ? 1 : 0; zero_variance+=data[i+1]<=1e-6 ? 1 : 0;
-            mean+=data[i]; max=Math.max(max,data[i]);
-        }
-        if(pixels===0) { throw new Error('No upward-facing mirror pixels in this view.'); }
-        return {pixels,changed_percent:100*changed/pixels,zero_variance_percent:100*zero_variance/pixels,mean:mean/pixels,max};
-    }
-}
+import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
+import { ImageShader } from "../../renderer/shader/ImageShader.js";
+import { CodeChunk } from "../../renderer/shader/compiler/CodeChunk.js";
+import { chunk_decode_g_buffer_normal } from "../../renderer/shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { graph_image_pass } from "../../renderer/shader/graph/graph_image_pass.js";
+import { graph_import_texture } from "../../renderer/shader/graph/graph_import_texture.js";
+import { ShaderResourceSetDescriptor } from "../../renderer/shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../renderer/shader/ShaderDescriptor.js";
+import { GPUTextureContext } from "../../renderer/texture/GPUTextureContext.js";
+import { download_texture_data } from "../../renderer/texture/download_texture_data.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup().addTexture('tBefore').addTexture('tAfter').addTexture('tNormal', 'uint');
+const shader = new ImageShader({
+    descriptor: ShaderDescriptor.from({label:'SSR lab / spatial effect',resources,
+        body:CodeChunk.from(/* language=WGSL */ `
+@fragment fn main(@builtin(position) coord:vec4f) -> @location(0) vec4f {
+    let p = vec2i(coord.xy);
+    if (decode_g_buffer_normal(textureLoad(tNormal,p,0).xy).y < 0.99) { return vec4f(-1.0); }
+    let a = textureLoad(tBefore,p,0);
+    let b = textureLoad(tAfter,p,0);
+    let difference = abs(a.rgb-b.rgb);
+    return vec4f(max(difference.r,max(difference.g,difference.b)),a.w,b.w,1.0);
+}`, [chunk_decode_g_buffer_normal])}),
+    targets:[{format:'rgba32float'}],
+});
+
+/** Same-frame GPU input/output comparison. Opt-in; no cost during ordinary playback. */
+export class SpatialFilterProbe extends RenderExtension {
+    name = 'SSR lab / measure spatial filter';
+    enabled = false;
+    texture;
+    device;
+    constructor(device) { super(); this.device=device; }
+    record(frame) {
+        if (!this.enabled) { return; }
+        // This diagnostic intentionally inspects the playground's production graph.
+        const pass=frame.graph.__pass_nodes.find(p=>p.name.startsWith('SSR / spatial denoise with metadata'));
+        const resolve=frame.graph.__pass_nodes.find(p=>p.name==='SSR resolve / IBL');
+        if (!resolve) { throw new Error('Enable SSR to measure its spatial filter.'); }
+        const before=pass ? pass.data.tInput : resolve.data['@output'][0];
+        const after=pass ? pass.data['@output'][0] : before;
+        const [width,height]=frame.resolution;
+        if (!this.texture || this.texture.width!==width || this.texture.height!==height) {
+            this.texture?.destroy();
+            this.texture=GPUTextureContext.fromTexture(this.device.createTexture({
+                size:[width,height,1],format:'rgba32float',
+                usage:GPUTextureUsage.RENDER_ATTACHMENT|GPUTextureUsage.COPY_SRC,
+            }),this.device);
+        }
+        graph_image_pass({graph:frame.graph,shader,
+            inputs:{tBefore:before,tAfter:after,tNormal:resolve.data.tNormal},
+            output:[graph_import_texture(frame.graph,this.texture,'SSR spatial measurement')],
+        });
+    }
+    async read() {
+        const data=await download_texture_data({device:this.device,source:this.texture.gpu_texture});
+        let pixels=0,changed=0,zero_variance=0,mean=0,max=0;
+        for(let i=0;i<data.length;i+=4) {
+            if(data[i]<0) { continue; }
+            if(!Number.isFinite(data[i])) { throw new Error('Non-finite denoising output.'); }
+            pixels++; changed+=data[i]>0.001 ? 1 : 0; zero_variance+=data[i+1]<=1e-6 ? 1 : 0;
+            mean+=data[i]; max=Math.max(max,data[i]);
+        }
+        if(pixels===0) { throw new Error('No upward-facing mirror pixels in this view.'); }
+        return {pixels,changed_percent:100*changed/pixels,zero_variance_percent:100*zero_variance/pixels,mean:mean/pixels,max};
+    }
+}