npm - @woosh/meep-engine - Versions diffs - 3.18.0 → 3.20.0 - Mend

@woosh/meep-engine 3.18.0 → 3.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (228) hide show

package/src/shade/playground/ssr_motion/index.html ADDED Viewed

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>SSR cross · camera motion</title><style>
+body{margin:24px;background:#14161a;color:#e7e9ee;font:14px/1.5 system-ui}h1{font-size:24px;margin-bottom:8px}p{color:#acb5c5;max-width:900px}main{display:grid;grid-template-columns:minmax(0,800px) 260px;gap:24px}canvas{display:block;width:100%;height:auto;background:#08090a;touch-action:none;outline:none}canvas:focus{outline:1px solid #749ac4}label{display:block;margin:0 0 14px}input[type=range],select{width:100%}button,select{font:inherit;padding:8px;background:#29313e;color:inherit;border:1px solid #4b586d;border-radius:4px}button{margin:0 4px 8px 0}output{float:right;font-variant-numeric:tabular-nums}a{color:#9ac9ff}#status{white-space:pre-wrap}.error{color:#ff9a9a}@media(max-width:900px){main{grid-template-columns:1fr}}
+</style></head><body tabindex="0">
+<h1>SSR cross · camera motion</h1>
+<p>The same glowing cross and colored markers as the variance lab. Fixed exposure; final-image TAA defaults off. Drag to orbit, right-drag to pan, scroll to zoom, or focus the scene and use WASD.</p>
+<main><section><canvas id="view" width="800" height="500" tabindex="0" aria-label="Interactive reflection scene"></canvas><p id="status" role="status">Initializing…</p><p><a href="../ssr_variance/">Exact variance and convergence measurements</a></p></section><aside>
+<label>Floor roughness <output id="roughness-value">0.30</output><input id="roughness" aria-label="Floor roughness" type="range" min="0.01" max="1" step="0.01" value="0.3"></label>
+<label>Camera <select id="motion"><option value="free">Free camera</option><option value="lateral">Lateral movement</option><option value="forward">Forward movement</option><option value="orbit">Orbit movement</option><option value="still">Still camera</option></select></label>
+<label>Motion speed <output id="speed-value">1.0×</output><input id="speed" aria-label="Motion speed" type="range" min="0.1" max="3" step="0.1" value="1"></label>
+<label>SSR history <select id="temporal"><option value="0">Parallax</option><option value="1">Surface only</option><option value="2">No temporal history</option></select></label>
+<label><input id="spatial" type="checkbox" checked> Spatial denoising</label>
+<label><input id="taa" type="checkbox"> Final-image TAA</label>
+<label><input id="jitter" type="checkbox"> Raster jitter</label>
+<button id="motion-pause">Pause motion</button><button id="render-pause">Pause rendering</button><button id="step">Step frame</button><button id="restart">Reset camera</button><button id="reset">Reset SSR history</button>
+<p>Pausing motion keeps sampling. Pausing rendering freezes the displayed frame. Ordinary camera movement preserves history; resets and material changes clear it.</p>
+</aside></main><script type="module" src="./main.js"></script></body></html>

package/src/shade/playground/ssr_motion/main.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=main.d.ts.map

package/src/shade/playground/ssr_motion/main.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_motion/main.js"],"names":[],"mappings":""}

package/src/shade/playground/ssr_motion/main.js ADDED Viewed

@@ -0,0 +1,149 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";
+import { FixedProjection } from "../ssr_variance/capture.js";
+import { create_scene } from "../ssr_variance/scene.js";
+const element = id => document.getElementById(id);
+const params = new URLSearchParams(location.search);
+const number = (name, fallback, min, max) => {
+    const value = Number(params.get(name) ?? fallback);
+    return Number.isFinite(value) ? Math.min(max, Math.max(min, value)) : fallback;
+};
+element('roughness').value = number('roughness', 0.3, 0.01, 1);
+element('speed').value = number('speed', 1, 0.1, 3);
+if (['free', 'lateral', 'forward', 'orbit', 'still'].includes(params.get('motion'))) { element('motion').value = params.get('motion'); }
+if (['0', '1', '2'].includes(params.get('temporal'))) { element('temporal').value = params.get('temporal'); }
+element('spatial').checked = params.get('spatial') !== 'off';
+for (const name of ['taa', 'jitter']) { element(name).checked = params.get(name) === 'on'; }
+async function start() {
+    const canvas = element('view'), renderer = new Renderer();
+    await renderer.initialize({ context: canvas.getContext('webgpu'), pixelRatio: 1 });
+    renderer.feature_ssr_enabled = true;
+    renderer.indirect_lighting_mode = ShadeIndirectLightingMode.IBL;
+    for (const name of ['ssao', 'bloom', 'sharpening', 'motion_blur', 'automatic_exposure']) { renderer[`feature_${name}_enabled`] = false; }
+    renderer.exposure_compensation = 1;
+    renderer.internal_resolution_scale = 1;
+    renderer.feature_taa_enabled = element('taa').checked;
+    renderer.ssr.spatial_denoising_enabled = element('spatial').checked;
+    renderer.ssr.reprojection_mode = Number(element('temporal').value);
+    const world = await create_scene();
+    world.ground_material.roughness_factor = Number(element('roughness').value);
+    const floor_materials = new Map([[world.ground_material.roughness_factor, world.ground_material]]);
+    const camera = new PerspectiveCamera();
+    camera.near = 0.1; camera.far = 50; camera.fov = 50 * Math.PI / 180;
+    camera.aspect = canvas.width / canvas.height;
+    const controller = new OrbitalCameraController(camera, canvas);
+    controller.movement_speed_scale = 2;
+    renderer.resize(canvas.width, canvas.height);
+    class ProjectionControl extends FixedProjection {
+        record(frame) { if (!element('jitter').checked) { super.record(frame); } }
+    }
+    renderer.add_extension(new ProjectionControl());
+    let phase = 0, frame_count = 0, motion_paused = false;
+    let rendering_paused = params.has('manual'), stopped = false, request, last_time, last_status = 0;
+    const pose = (position, target) => {
+        camera.transform.setTranslation(...position);
+        camera.transform.lookAt(new Vector3(...target));
+        camera.transform.updateMatrix();
+        controller.look(new Vector3(...position), new Vector3(...target));
+    };
+    function status() {
+        element('status').textContent = `Frame ${frame_count} · roughness ${world.ground_material.roughness_factor.toFixed(2)}\n${rendering_paused ? 'Rendering paused' : motion_paused ? 'Motion paused · sampling continues' : 'Running'} · final TAA ${renderer.feature_taa_enabled ? 'on' : 'off'}`;
+        element('render-pause').textContent = rendering_paused ? 'Resume rendering' : 'Pause rendering';
+    }
+    function fail(error) {
+        stopped = true; cancelAnimationFrame(request);
+        element('status').textContent = error.message ?? String(error);
+        element('status').classList.add('error'); console.error(error);
+    }
+    function reset_camera() {
+        phase = 0; pose([0, 3.2, 7], [0, 0.2, -2]);
+        renderer.indicate_view_change(); status();
+    }
+    function set_roughness() {
+        const roughness = Number(element('roughness').value);
+        // GPU material contexts are immutable after upload. Reuse at most one
+        // material per slider value, and refresh the scene's material membership.
+        let material = floor_materials.get(roughness);
+        if (!material) {
+            material = world.ground_material.clone();
+            material.roughness_factor = roughness;
+            floor_materials.set(roughness, material);
+        }
+        if (material !== world.ground_material) {
+            world.scene.remove(world.ground);
+            world.ground.material = world.ground_material = material;
+            world.ground.updateMatrices();
+            renderer.graphics.materials.obtain(material);
+            world.scene.add(world.ground);
+        }
+        element('roughness-value').textContent = world.ground_material.roughness_factor.toFixed(2);
+        renderer.indicate_view_change(); status();
+    }
+    function frame(dt = 1 / 60, advance = true) {
+        if (stopped) { throw new Error('Renderer stopped after an error'); }
+        const mode = element('motion').value;
+        if (advance && !motion_paused) {
+            phase += dt * Number(element('speed').value) * 0.7;
+            const t = Math.sin(phase);
+            if (mode === 'free') { controller.update(dt); }
+            else if (mode === 'lateral') { pose([2 * t, 3.2, 7], [2 * t, 0.2, -2]); }
+            else if (mode === 'forward') { pose([0, 3.2, 7 + 1.6 * t], [0, 0.2, -2 + 1.6 * t]); }
+            else if (mode === 'orbit') { pose([4 * t, 3.2, 7 - 0.7 * t * t], [0, 0.2, -2]); }
+        }
+        if (renderer.render(camera, world.scene, dt) === false) { throw new Error('Renderer did not submit the frame'); }
+        frame_count++;
+        if (performance.now() - last_status > 250 || rendering_paused) { status(); last_status = performance.now(); }
+        return frame_count;
+    }
+    function tick(time) {
+        if (stopped) { return; }
+        const dt = last_time === undefined ? 1 / 60 : Math.min((time - last_time) / 1000, 0.05);
+        last_time = time;
+        try { if (!rendering_paused) { frame(dt); } }
+        catch (error) { fail(error); return; }
+        request = requestAnimationFrame(tick);
+    }
+    element('roughness').oninput = set_roughness;
+    element('speed').oninput = () => { element('speed-value').textContent = `${Number(element('speed').value).toFixed(1)}×`; };
+    element('speed').oninput();
+    element('motion').onchange = () => {
+        if (element('motion').value !== 'free') { reset_camera(); }
+    };
+    canvas.addEventListener('pointerdown', () => { canvas.focus(); element('motion').value = 'free'; motion_paused = false; element('motion-pause').textContent = 'Pause motion'; });
+    canvas.addEventListener('contextmenu', event => event.preventDefault());
+    element('temporal').onchange = () => { renderer.ssr.reprojection_mode = Number(element('temporal').value); };
+    element('spatial').onchange = () => { renderer.ssr.spatial_denoising_enabled = element('spatial').checked; };
+    element('taa').onchange = () => { renderer.feature_taa_enabled = element('taa').checked; renderer.indicate_view_change(); status(); };
+    element('jitter').onchange = () => renderer.indicate_view_change();
+    element('motion-pause').onclick = () => { motion_paused = !motion_paused; element('motion-pause').textContent = motion_paused ? 'Resume motion' : 'Pause motion'; status(); };
+    element('render-pause').onclick = () => { rendering_paused = !rendering_paused; status(); };
+    element('step').onclick = () => { rendering_paused = true; try { frame(); } catch (error) { fail(error); } };
+    element('restart').onclick = reset_camera;
+    element('reset').onclick = () => { renderer.ssr.reset_history = true; };
+    const device = renderer.graphics.device;
+    device.addEventListener('uncapturederror', event => fail(event.error));
+    device.lost.then(info => { if (!stopped) { fail(new Error(`GPU device lost: ${info.message}`)); } });
+    addEventListener('pagehide', () => { stopped = true; cancelAnimationFrame(request); controller.pointer.stop(); controller.keyboard.stop(); renderer.destroy(); device.destroy(); });
+    addEventListener('pageshow', event => { if (event.persisted) { location.reload(); } });
+    reset_camera(); set_roughness();
+    const lab = globalThis.ssr_motion_lab = {
+        renderer, camera, world, frame, pose,
+        step(n = 1, advance = true) {
+            if (!rendering_paused) { throw new Error('Pause rendering before exact stepping'); }
+            if (!Number.isSafeInteger(n) || n < 1) { throw new Error('Step count must be a positive integer'); }
+            for (let i = 0; i < n; i++) { frame(1 / 60, advance); }
+            return frame_count;
+        },
+        get frame_count() { return frame_count; },
+    };
+    request = requestAnimationFrame(tick);
+    return lab;
+}
+globalThis.ssr_motion_ready = start().catch(error => {
+    element('status').textContent = error.message ?? String(error); console.error(error); throw error;
+});

package/src/shade/playground/ssr_variance/README.md ADDED Viewed

@@ -0,0 +1,105 @@
+# SSR variance playground
+Run `npm run dev` from the workspace, then open
+<http://localhost:5173/src/shade/playground/ssr_variance/>.
+The scene contains exactly two quads: a metallic ground plane at y=0 with roughness
+0.30, and a vertical card facing the camera. The card carries an emissive cross
+texture with two coloured details. The pattern does not add geometry or normal
+edges. A constant dim environment supplies the SSR fallback.
+The camera, scene, exposure (compensation 1), and 800×500 resolution are fixed.
+Automatic exposure, SSAO, bloom, sharpening, and motion blur are disabled.
+Main TAA defaults off and can be enabled independently.
+Raster jitter defaults off separately: the production renderer still applies its
+jitter sequence with TAA off, so a playground-only `FrameStart` extension freezes
+the view's projection and jitter uniforms before rasterization. The jitter control
+can restore production behaviour. SSR's stochastic frame index still advances.
+## Exact capture
+The page starts at frame **0** without submitting a frame or scheduling an animation
+loop. **Capture frames 100–115** submits exactly 115 frames, each with dt=1/60, and
+records frame 100 and every subsequent frame through 115. GPU completion and readback
+are awaited between captures. Readback does not render extra frames. The renderer's
+own count is checked against the experiment count; its zero-based SSR indices are
+99–114 for these captures.
+From the console:
+```js
+const lab = await ssr_variance_ready;
+const measurements = await lab.run(); // requires frame zero; finishes at frame 115
+lab.frame_count;                      // 115, stays there indefinitely
+lab.frames;                           // 16 PNG byte arrays and linear float32 stage arrays
+lab.files;                            // Map<filename, Uint8Array | Float32Array>
+```
+For manual control on a fresh page:
+```js
+await ssr_variance_ready;
+await ssr_variance_lab.step(99);
+await ssr_variance_lab.step(1, true);  // submit frame 100 and capture it
+await ssr_variance_lab.step(15, true); // capture every frame from 101 through 115
+```
+`step(n, true)` records each of its n frames. The standard `run()` additionally
+calculates statistics and fills the page's results. Operations are serialized;
+overlapping calls are rejected. Restarting or changing a control reloads the page,
+giving every comparison a fresh renderer and the same frame-index sequence.
+Appending `?run` runs the standard capture automatically. `spatial=off`,
+`temporal=off`, `jitter=on`, and `taa=on` select controls in the query string.
+Use `?run&jitter=on&taa=on` to measure the full production jitter/TAA path.
+## Convergence
+**Measure convergence**, `?convergence`, or `await lab.convergence()` on a fresh page
+records frames 4, 8, 16, 32, 64, 100, 128, 256, and 512. It then averages the
+pre-temporal input from frames 513–1536 into a separate float32 GPU texture. This
+reference is never fed into the renderer. The table compares each checkpoint's
+temporal and post-spatial output with that 1,024-sample mean, using linear luminance
+RMSE and signed bias over the same reflection rectangle.
+This catches a darkened or frozen output that scores well on temporal variance.
+The reference estimates the prefilter's expected output; it is not ray-traced
+ground truth and does not validate SSR visibility, ray reuse, or the prefilter's
+own bias. Finite reference noise also sets an error floor. This pixel-aligned
+comparison requires raster jitter off; the playground rejects it otherwise before
+submitting any frames. Production history is bounded at 128 frames to
+retain responsiveness, so convergence approaches a noise floor rather than an
+unbounded average. `convergence.json`, `reference.f32`, checkpoint PNGs, and stage
+arrays are available in `lab.files` after the run stops at frame 1536.
+## Outputs and measurement
+The playground copies resolve, spatial step 1, temporal reprojection, spatial step 2,
+spatial step 4, pre-TAA scene colour, and final linear scene colour after TAA using
+integer `textureLoad` calls before presentation.
+Copies run only on recorded frames. Disabling spatial filtering makes those stage
+captures refer to their bypass inputs. Resolve still performs its own ray reuse
+and roughness-dependent source mip sampling.
+Each displayed image is the actual canvas output copied immediately after render,
+before the browser can discard it. Select a thumbnail to download its PNG. The JSON
+download includes frame indices, controls, camera settings, and statistics. Full raw
+captures and per-pixel mean/variance maps are available as typed arrays in `lab.files`.
+An external driver can write each array directly, for example as a `fetch` request
+body. Captures stay in CPU memory without duplicating HDR arrays into Blob storage.
+RGBA captures are little-endian float32, row-major, top-left origin. SSR radiance
+alpha carries the shader's internal variance estimate; scene alpha is opacity.
+The mask uses 1 for upward-facing ground pixels and 0 elsewhere.
+Temporal variance is computed **per pixel** over all 16 linear Rec.709 luminance
+samples (0.2126 R + 0.7152 G + 0.0722 B), then averaged spatially. Population variance
+divides by 16; sample variance divides by 15. RMS temporal sigma is the square root
+of mean population variance. This is distinct from image contrast or the shader's
+alpha-channel estimate. Non-finite readback values fail the measurement.
+The JSON reports full-image, whole-ground, and reflection-region statistics. The
+reflection region is the fixed rectangle x=200…599, y=250…459 intersected with the
+frame-100 ground mask. It covers the main visible reflection, not its full rough
+tail. The heatmap uses a fixed 0…0.10 linear-luminance sigma scale. With raster jitter
+enabled, silhouette coverage can vary; the fixed-projection default avoids that
+confound. A lower variance alone does not prove better image quality: blurring can
+reduce variance while destroying reflected detail.

package/src/shade/playground/ssr_variance/capture.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+/** TAA-off currently leaves raster jitter active. Freeze only this lab's view before rasterization. */
+export class FixedProjection extends RenderExtension {
+    record(frame: any): void;
+}
+/** Exact textureLoad copies of production SSR stages, only on requested frames. */
+export class CaptureSSR extends RenderExtension {
+    constructor(device: any);
+    enabled: boolean;
+    textures: Map<any, any>;
+    device: any;
+    record(frame: any): void;
+    jitter: any[];
+    read(): Promise<{}>;
+}
+import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
+//# sourceMappingURL=capture.d.ts.map

package/src/shade/playground/ssr_variance/capture.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"capture.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_variance/capture.js"],"names":[],"mappings":"AA6BA,uGAAuG;AACvG;IAGI,yBAKC;CACJ;AAED,mFAAmF;AACnF;IAKI,yBAAsD;IAFtD,iBAAgB;IAChB,wBAAqB;IACU,YAAoB;IACnD,yBAuCC;IArCG,cAA2C;IAsC/C,oBAMC;CACJ;gCA/F+B,6CAA6C"}

package/src/shade/playground/ssr_variance/capture.js ADDED Viewed

@@ -0,0 +1,96 @@
+import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
+import { FramePhase } from "../../renderer/extension/FramePhase.js";
+import { SceneColor } from "../../renderer/extension/SceneColor.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('tSource', 'unfilterable-float').addTexture('tNormal', 'uint');
+const shader = new ImageShader({
+    descriptor: ShaderDescriptor.from({ label: 'SSR variance / capture', resources,
+        body: CodeChunk.from(/* language=WGSL */ `
+struct Capture { @location(0) radiance: vec4f, @location(1) mask: vec4f }
+@fragment fn main(@builtin(position) coord: vec4f) -> Capture {
+    let p = vec2i(coord.xy);
+    var output: Capture;
+    output.radiance = textureLoad(tSource, p, 0);
+    output.mask = vec4f(select(0.0, 1.0, decode_g_buffer_normal(textureLoad(tNormal, p, 0).xy).y > 0.99));
+    return output;
+}`, [chunk_decode_g_buffer_normal]) }),
+    targets: [{ format: 'rgba32float' }, { format: 'rgba32float' }],
+});
+/** TAA-off currently leaves raster jitter active. Freeze only this lab's view before rasterization. */
+export class FixedProjection extends RenderExtension {
+    name = 'SSR variance / fixed projection';
+    phase = FramePhase.FrameStart;
+    record(frame) {
+        frame.view.setJitter(0, 0);
+        frame.view.camera.setViewportOffset(0, 0);
+        frame.view.camera.update();
+        frame.view.update_uniforms();
+    }
+}
+/** Exact textureLoad copies of production SSR stages, only on requested frames. */
+export class CaptureSSR extends RenderExtension {
+    name = 'SSR variance / capture';
+    phase = FramePhase.BeforePresent;
+    enabled = false;
+    textures = new Map();
+    constructor(device) { super(); this.device = device; }
+    record(frame) {
+        if (!this.enabled) { return; }
+        this.jitter = Array.from(frame.view.jitter);
+        const passes = frame.graph.__pass_nodes;
+        const resolve = passes.find(p => p.name === 'SSR resolve / IBL');
+        const spatial1 = passes.find(p => p.name === 'SSR / spatial denoise with metadata');
+        const temporal = passes.find(p => p.name === 'SSR Reproject');
+        const spatial = passes.filter(p => p.name === 'SSR / spatial denoise');
+        const taa = passes.find(p => p.name === 'TAA');
+        if (!resolve || !temporal) { throw new Error('SSR stages missing from the frame graph'); }
+        const resolved = resolve.data['@output'][0];
+        const reprojected = temporal.data['@output'][0];
+        const stages = {
+            resolve: resolved,
+            spatial1: spatial1?.data['@output'][0] ?? resolved,
+            temporal: reprojected,
+            spatial2: spatial[0]?.data['@output'][0] ?? reprojected,
+            spatial4: spatial[1]?.data['@output'][0] ?? reprojected,
+            'pre-taa': taa?.data.ColourTexture ?? frame.get(SceneColor).color,
+            scene: frame.get(SceneColor).color,
+        };
+        const [width, height] = frame.resolution;
+        const texture = name => {
+            let t = this.textures.get(name);
+            if (!t || t.width !== width || t.height !== height) {
+                t?.destroy();
+                t = GPUTextureContext.fromTexture(this.device.createTexture({
+                    label: `SSR variance / ${name}`, size: [width, height, 1], format: 'rgba32float',
+                    usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC,
+                }), this.device);
+                this.textures.set(name, t);
+            }
+            return graph_import_texture(frame.graph, t, `SSR variance / ${name}`);
+        };
+        let mask = texture('mask');
+        for (const [name, handle] of Object.entries(stages)) {
+            [, mask] = graph_image_pass({ graph: frame.graph, shader,
+                inputs: { tSource: handle, tNormal: resolve.data.tNormal }, output: [texture(name), mask] });
+        }
+    }
+    async read() {
+        const result = {};
+        for (const [name, texture] of this.textures) {
+            result[name] = await download_texture_data({ device: this.device, source: texture.gpu_texture });
+        }
+        return result;
+    }
+}

package/src/shade/playground/ssr_variance/index.html ADDED Viewed

@@ -0,0 +1,23 @@
+<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>SSR variance lab</title><style>
+body{margin:24px;background:#14161a;color:#e7e9ee;font:14px system-ui}h1{font-size:24px;margin-bottom:8px}p{color:#acb5c5;max-width:900px}button,select,a{font:inherit}button,select{padding:8px;background:#29313e;color:inherit;border:1px solid #4b586d;border-radius:4px}button:disabled{opacity:.45}a{color:#9ac9ff}#view{display:block;width:800px;max-width:100%;height:auto;background:#08090a;margin:18px 0}#status{white-space:pre-wrap}table{border-collapse:collapse;font-variant-numeric:tabular-nums}td,th{padding:8px 14px;border-bottom:1px solid #394150;text-align:right}td:first-child,th:first-child{text-align:left}.frames{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px;max-width:1200px}.frames img{width:100%}figure{margin:0}figcaption{padding:5px}#heatmap{width:800px;max-width:100%}.error{color:#ff9a9a}
+</style></head><body>
+<h1>SSR variance lab</h1>
+<p>One ground plane · roughness 0.30 · metallic 1 · textured emissive card · fixed camera and exposure. Starts at frame zero. Rendering advances only when requested.</p>
+<p><a href="../ssr_motion/">Move the camera and adjust floor roughness</a></p>
+<label>Spatial <select id="spatial"><option value="on">On</option><option value="off">Off</option></select></label>
+<label>Temporal <select id="temporal"><option value="on">On</option><option value="off">Off</option></select></label>
+<label>Raster jitter <select id="jitter"><option value="off">Off</option><option value="on">On</option></select></label>
+<label>Main TAA <select id="taa"><option value="off">Off</option><option value="on">On</option></select></label>
+<button id="step" disabled>Step one frame</button> <button id="run" disabled>Capture frames 100–115</button>
+<button id="restart">Restart at frame zero</button>
+<button id="converge" disabled>Measure convergence</button>
+<canvas id="view" width="800" height="500"></canvas><div id="status">Initializing…</div>
+<div id="results" hidden>
+<p>Per-pixel temporal luminance variance, measured in linear HDR across 16 samples. Table: fixed reflection rectangle intersected with upward-facing ground pixels. Population variance uses ÷16; the JSON also includes sample variance (÷15), whole-ground and full-image measurements.</p>
+<table><thead><tr><th>Stage</th><th>Mean variance</th><th>RMS σ</th><th>95th percentile σ</th><th>Mean peak-to-peak</th></tr></thead><tbody id="metrics"></tbody></table>
+<p><a id="download">Download measurements JSON</a></p>
+<p>Final scene temporal standard deviation. Fixed scale: black = 0, yellow = 0.10 linear luminance. Red outline = measurement rectangle.</p><canvas id="heatmap" width="800" height="500"></canvas>
+<p>Recorded canvas output. Select a frame to download its full-resolution PNG.</p><div id="frames" class="frames"></div>
+</div><div id="convergence-results" hidden><p>SSR error against a separate float32 average of 1,024 later pre-temporal samples (frames 513–1536). The reference is never fed into the rendered image. This measures convergence to the prefilter's mean, not physical ground truth.</p><table><thead><tr><th>Frame</th><th>Input RMSE</th><th>Temporal RMSE</th><th>After spatial RMSE</th><th>Temporal bias</th></tr></thead><tbody id="convergence-metrics"></tbody></table><p><a id="convergence-download">Download convergence JSON</a></p></div><script type="module" src="./main.js"></script></body></html>

package/src/shade/playground/ssr_variance/main.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export {};
2	+ //# sourceMappingURL=main.d.ts.map

package/src/shade/playground/ssr_variance/main.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_variance/main.js"],"names":[],"mappings":""}