@woosh/meep-engine 3.17.1 → 3.18.0

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

@@ -0,0 +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};
+    }
+}

package/src/shade/playground/ssr_reprojection/index.html

@@ -0,0 +1,79 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>Meep — SSR reflection lab</title>
+    <style>
+        :root { color-scheme: dark; font: 14px/1.5 system-ui, sans-serif; background: #11151c; color: #e4eaf2; }
+        * { box-sizing: border-box; }
+        body { margin: 0; padding: 24px; }
+        header { display: flex; align-items: baseline; gap: 16px; margin-bottom: 18px; }
+        h1 { font-size: 24px; margin: 0; font-weight: 600; }
+        header span, .hint, small { color: #a2afc1; }
+        main { display: grid; grid-template-columns: minmax(0, 1fr) 290px; gap: 20px; align-items: start; }
+        .stage { position: relative; background: #090c11; border: 1px solid #344153; border-radius: 8px; overflow: hidden; }
+        /* Renderer writes inline presentation dimensions; both layers must scale together. */
+        canvas { display: block; width: 100% !important; height: auto !important; }
+        #overlay { position: absolute; inset: 0; pointer-events: none; }
+        aside { background: #1a212c; border: 1px solid #344153; border-radius: 8px; padding: 18px; }
+        label { display: block; margin-bottom: 13px; }
+        label > span { display: block; font-size: 12px; color: #a2afc1; margin-bottom: 4px; }
+        select, button { width: 100%; background: #252f3e; border: 1px solid #45556a; color: inherit; border-radius: 5px; padding: 8px; font: inherit; }
+        button { cursor: pointer; }
+        button:hover { background: #344359; }
+        button:disabled { opacity: .4; cursor: default; }
+        .buttons { display: flex; gap: 8px; margin-bottom: 10px; }
+        .check { display: flex; gap: 8px; align-items: center; }
+        input[type=range] { width: 100%; accent-color: #74c8ff; }
+        hr { border: 0; border-top: 1px solid #344153; margin: 18px 0; }
+        #status { font: 12px/1.5 ui-monospace, Consolas, monospace; white-space: pre-wrap; color: #95d6b4; }
+        #status.error { color: #ff9a9a; }
+        #hint { min-height: 3em; margin: 14px 0 0; }
+        .legend { display: flex; gap: 24px; flex-wrap: wrap; margin-top: 12px; color: #a2afc1; font-size: 12px; }
+        .legend b { color: #dce9ff; }
+        details { margin-top: 18px; max-width: 85ch; color: #a2afc1; }
+        summary { color: #dce9ff; cursor: pointer; }
+        @media (max-width: 850px) { main { grid-template-columns: 1fr; } aside { width: 100%; } header { display: block; } }
+    </style>
+</head>
+<body tabindex="0">
+<header><h1>SSR reflection lab</h1><span>Camera parallax · temporal stability · rejection</span></header>
+<main>
+    <section>
+        <div class="stage"><canvas id="view" width="960" height="600" tabindex="0" aria-label="Interactive WebGPU reflection scene"></canvas><canvas id="overlay" width="960" height="600" aria-hidden="true"></canvas></div>
+        <div class="legend"><span><b>Solid cross</b> — ideal reflected centre</span><span><b>Dashed cross</b> — point fixed to the floor</span></div>
+        <p id="hint" class="hint"></p>
+        <details open><summary>A quick visual check</summary>
+            <ol>
+                <li>Run <b>Lateral camera</b> with <b>Parallax</b>. Reflections should follow the solid crosses as the floor moves underneath.</li>
+                <li>Restart the same motion with <b>Surface only</b>, then <b>No temporal history</b>. Look for trails, delayed edges, and changes in noise.</li>
+                <li>Try <b>Moving object</b> and <b>Occluder</b>. Inspect the magenta object’s trail and newly revealed floor. Use <b>Camera cut</b> to check reset.</li>
+            </ol>
+            <p><b>Spatial denoising</b> smooths neighbouring reflection pixels in three passes. It is on by default and independent of reprojection. Turn it off and select <b>No temporal history</b> to inspect the resolve output; resolve still reuses neighbouring ray hits and filters radiance for roughness.</p>
+            <p>The crosses are geometric guides for object centres, not a pixel-perfect lighting reference. SSR loses information when reflected objects are hidden or off-screen. Surface only retains the new validation and blending fixes; it is not the old shader.</p>
+        </details>
+    </section>
+    <aside>
+        <label><span>Reprojection</span><select id="mode"><option value="0">Parallax</option><option value="1">Surface only</option><option value="2">No temporal history</option><option value="off">SSR off</option></select></label>
+        <label><span>Experiment</span><select id="experiment"><option value="lateral">Lateral camera</option><option value="forward">Forward camera</option><option value="orbit">Orbit camera</option><option value="object">Moving object</option><option value="occluder">Occluder</option><option value="still">Still camera / noise</option><option value="free">Free camera</option></select></label>
+        <label><span>Motion speed <output id="speed-value">1.0×</output></span><input id="speed" aria-label="Motion speed" type="range" min="0.2" max="2" value="1" step="0.1"></label>
+        <label><span>Mirror roughness <output id="roughness-value">0.03</output></span><input id="roughness" aria-label="Mirror roughness" type="range" min="0.01" max="0.7" value="0.03" step="0.01"></label>
+        <label><span>Render resolution</span><select id="resolution"><option value="640">640 × 400</option><option value="960" selected>960 × 600</option><option value="1280">1280 × 800</option></select></label>
+        <label class="check"><input id="guides" type="checkbox" checked>Show geometric guides</label>
+        <label class="check"><input id="denoising" type="checkbox" checked>Spatial denoising</label>
+        <label class="check"><input id="taa" type="checkbox">Final-image TAA</label>
+        <hr>
+        <div class="buttons"><button id="play">Pause motion</button><button id="step">Step frame</button></div>
+        <div class="buttons"><button id="restart">Restart path</button><button id="cut">Camera cut</button></div>
+        <button id="reset">Reset reflection history</button>
+        <hr>
+        <button id="measure">Measure spatial filter</button>
+        <button id="compile">Validate GPU shaders</button>
+        <p id="status" role="status">Starting WebGPU…</p>
+        <small>Fixed exposure. Bloom, sharpening, and motion blur are off. Free camera: drag to orbit, right-drag to pan, wheel to zoom.</small>
+    </aside>
+</main>
+<script type="module" src="./main.js"></script>
+</body>
+</html>

package/src/shade/playground/ssr_reprojection/main.d.ts

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

package/src/shade/playground/ssr_reprojection/main.d.ts.map

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

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

@@ -0,0 +1,245 @@
+import { SpatialFilterProbe } from "./SpatialFilterProbe.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { ShadeIndirectLightingMode } from "../../renderer/ShadeIndirectLightingMode.js";
+import { ssr_trace_shader } from "../../renderer/postprocess/ssr/ssr_trace_shader.js";
+import { ssr_resolve_shader_IBL } from "../../renderer/postprocess/ssr/resolve/ssr_resolve_shader_IBL.js";
+import { ssr_resolve_shader_LPV } from "../../renderer/postprocess/ssr/resolve/ssr_resolve_shader_LPV.js";
+import { ssr_reproject_shader } from "../../renderer/postprocess/ssr/ssr_reproject_shader.js";
+import { ssr_spatial_denoise_shader, ssr_spatial_denoise_metadata_shader } from "../../renderer/postprocess/ssr/ssr_spatial_denoise_shader.js";
+import { create_scene } from "./scene.js";
+
+const element = id => document.getElementById(id);
+const hints = {
+    lateral: 'The camera translates sideways without turning. The solid reflection guides should move differently from the dashed points attached to the floor.',
+    forward: 'The camera moves towards and away from the mirror. Watch reflection size and trailing edges against the solid guides.',
+    orbit: 'The camera rotates around the scene. Inspect reflection edges at oblique angles and near the edge of the mirror.',
+    object: 'The camera and mirror stay still while C moves. This deliberately challenges the current algorithm: mirror geometry alone cannot identify reflected-object motion.',
+    occluder: 'A dark pillar crosses the view. Look for stale reflections on newly revealed floor; screen-space tracing also loses hidden source geometry.',
+    still: 'The camera stays still while sampling continues. Compare temporal modes for noise; pausing motion still renders new samples.',
+    free: 'Drag on the scene to orbit, right-drag to pan, or scroll to zoom. Restart path returns to the original camera.',
+};
+
+function report(text, error = false) {
+    element('status').textContent = text;
+    element('status').classList.toggle('error', error);
+}
+
+async function start() {
+    if (!navigator.gpu) { throw new Error('WebGPU is unavailable in this browser. Open this localhost page in a current WebGPU-enabled browser.'); }
+    const canvas = element('view'), overlay = element('overlay');
+    const context = canvas.getContext('webgpu');
+    if (!context) { throw new Error('Could not create a WebGPU canvas context.'); }
+    const renderer = new Renderer();
+    report("Acquiring GPU and loading engine textures…");
+    await renderer.initialize({ context, pixelRatio: 1 });
+    renderer.feature_ssr_enabled = true;
+    renderer.indirect_lighting_mode = ShadeIndirectLightingMode.IBL;
+    renderer.feature_taa_enabled = false;
+    renderer.feature_ssao_enabled = false;
+    renderer.feature_bloom_enabled = false;
+    renderer.feature_sharpening_enabled = false;
+    renderer.feature_motion_blur_enabled = false;
+    renderer.feature_automatic_exposure_enabled = false;
+    renderer.exposure_compensation = 1;
+    renderer.internal_resolution_scale = 1;
+    report("Building procedural scene…");
+    const world = await create_scene();
+    const camera = new PerspectiveCamera();
+    camera.near = 0.1;
+    camera.far = 80;
+    camera.fov = 50 * Math.PI / 180;
+    const controller = new OrbitalCameraController(camera, canvas);
+    controller.movement_speed_scale = 0.5;
+    let phase = 0, frame_count = 0, paused = false, cut_side = 0, stopped = false;
+    let stop_loop;
+    let check_busy = false;
+    let last_status = 0;
+    let anchors = [];
+
+    function pose(position, target) {
+        camera.transform.setTranslation(...position);
+        camera.transform.lookAt(new Vector3(...target));
+        camera.transform.updateMatrix();
+    }
+    function update_scene() {
+        const experiment = element('experiment').value;
+        const t = Math.sin(phase);
+        const offset = cut_side * 2;
+        if (experiment === 'free') { controller.update(); }
+        else if (experiment === 'lateral') { pose([2 * t + offset, 3.4, 8], [2 * t + offset, 0.3, -1.5]); }
+        else if (experiment === 'forward') { pose([offset, 3.4, 8 + 1.6 * t], [offset, 0.3, -1.5 + 1.6 * t]); }
+        else if (experiment === 'orbit') { pose([4 * t + offset, 3.4, 8 - 0.7 * t * t], [0, 0.3, -1.5]); }
+        else { pose([offset, 3.4, 8], [0, 0.3, -1.5]); }
+        const moving = world.targets[2];
+        const x = moving.position[0] + (experiment === 'object' ? 1.3 * t : 0);
+        moving.mesh.transform_local.setTranslation(x, moving.position[1], moving.position[2]);
+        moving.mesh.updateMatrices();
+        world.occluder.transform_local.setTranslation(experiment === 'occluder' ? 3 * t : 20, 1, 1);
+        world.occluder.updateMatrices();
+    }
+    function reset_anchors() {
+        const c = camera.transform.translation;
+        // Independent oracle: mirror physical centres across y=0, then intersect C->V
+        // with the plane once. These anchors stay on the floor as the camera moves.
+        anchors = world.targets.map(({ mesh }) => {
+            const p = mesh.transform_local.translation;
+            const v = [p[0], -p[1], p[2]];
+            const t = -c[1] / (v[1] - c[1]);
+            return [c[0] + (v[0] - c[0]) * t, 0, c[2] + (v[2] - c[2]) * t];
+        });
+    }
+    function restart() {
+        phase = 0; cut_side = 0;
+        pose([0, 3.4, 8], [0, 0.3, -1.5]);
+        controller.look(new Vector3(0, 3.4, 8), new Vector3(0, 0.3, -1.5));
+        update_scene(); reset_anchors();
+        renderer.indicate_view_change();
+        element('hint').textContent = hints[element('experiment').value];
+    }
+    function resize() {
+        const width = Number(element('resolution').value), height = width * 5 / 8;
+        canvas.width = overlay.width = width;
+        canvas.height = overlay.height = height;
+        camera.aspect = width / height;
+        renderer.resize(width, height);
+    }
+    function apply_mode() {
+        const mode = element('mode').value;
+        renderer.feature_ssr_enabled = mode !== 'off';
+        renderer.ssr.reprojection_mode = mode === 'off' ? 0 : Number(mode);
+        restart();
+    }
+    function draw_guides() {
+        const ctx = overlay.getContext('2d');
+        ctx.clearRect(0, 0, overlay.width, overlay.height);
+        if (!element('guides').checked) { return; }
+        const m = camera.view_projection_matrix;
+        const project = p => {
+            const w = m[3]*p[0] + m[7]*p[1] + m[11]*p[2] + m[15];
+            if (w <= 0) { return null; }
+            return [(0.5 + 0.5*(m[0]*p[0]+m[4]*p[1]+m[8]*p[2]+m[12])/w)*overlay.width,
+                (0.5 - 0.5*(m[1]*p[0]+m[5]*p[1]+m[9]*p[2]+m[13])/w)*overlay.height];
+        };
+        const cross = (p, dashed, color, label) => {
+            const xy = project(p);
+            if (!xy) { return; }
+            const [x,y] = xy;
+            ctx.strokeStyle = color; ctx.fillStyle = color; ctx.lineWidth = 1.5;
+            ctx.setLineDash(dashed ? [3,3] : []);
+            ctx.beginPath(); ctx.moveTo(x-8,y); ctx.lineTo(x+8,y); ctx.moveTo(x,y-8); ctx.lineTo(x,y+8); ctx.stroke();
+            if (label) { ctx.font = '12px system-ui'; ctx.fillText(label,x+11,y-5); }
+        };
+        world.targets.forEach(({mesh,color,label},i) => {
+            const p = mesh.transform_local.translation;
+            cross([p[0],-p[1],p[2]],false,color,label);
+            cross(anchors[i],true,'#c2ccd9','');
+        });
+    }
+    function frame(dt, advance = true) {
+        if (stopped || check_busy) { return; }
+        try {
+            if (advance) { phase += dt * Number(element('speed').value) * 0.7; }
+            update_scene();
+            renderer.render(camera, world.scene, dt);
+            draw_guides(); frame_count++;
+            if (performance.now() - last_status > 500) {
+                report(`${canvas.width} × ${canvas.height} · frame ${frame_count}\n${paused ? 'Motion paused · sampling continues' : 'Running'} · ${element('mode').selectedOptions[0].textContent}`);
+                last_status = performance.now();
+            }
+        } catch (error) { fail(error); }
+    }
+    function fail(error) {
+        stopped = true; stop_loop?.();
+        report(error.message ?? String(error), true);
+        console.error(error);
+    }
+    const device = renderer.graphics.device;
+    const spatial_probe = new SpatialFilterProbe(device);
+    renderer.add_extension(spatial_probe);
+    element('measure').addEventListener('click', async () => {
+        if (check_busy || stopped) { return; }
+        if (!renderer.feature_ssr_enabled) { report('Enable SSR before measuring.'); return; }
+        check_busy = true;
+        const denoising_enabled = renderer.ssr.spatial_denoising_enabled;
+        element('measure').disabled = true;
+        try {
+            spatial_probe.enabled = true;
+            renderer.render(camera, world.scene, 0);
+            spatial_probe.enabled = false;
+            const r = await spatial_probe.read();
+            report(`Spatial pass 1 · same-frame GPU comparison
+Denoising ${denoising_enabled ? 'ON' : 'OFF'}
+Mirror pixels changed >0.001: ${r.changed_percent.toFixed(2)}%
+Mean / max RGB change: ${r.mean.toFixed(6)} / ${r.max.toFixed(4)}
+Input variance ≤1e-6: ${r.zero_variance_percent.toFixed(2)}%`);
+            last_status = performance.now()+30000;
+        } catch (error) { report(error.message,true); }
+        finally {
+            spatial_probe.enabled=false;
+            spatial_probe.texture?.destroy();
+            spatial_probe.texture=undefined;
+            check_busy=false;
+            element('measure').disabled=false;
+        }
+    });
+    device.addEventListener('uncapturederror', event => fail(event.error));
+    device.lost.then(info => fail(new Error(`GPU device lost: ${info.message}`)));
+    element('mode').addEventListener('change', apply_mode);
+    element('experiment').addEventListener('change', restart);
+    element('resolution').addEventListener('change', resize);
+    element('speed').addEventListener('input', () => { element('speed-value').textContent = `${Number(element('speed').value).toFixed(1)}×`; });
+    element('roughness').addEventListener('input', () => {
+        world.mirror_material.roughness_factor = Number(element('roughness').value);
+        element('roughness-value').textContent = world.mirror_material.roughness_factor.toFixed(2);
+        renderer.indicate_view_change();
+    });
+    element('denoising').addEventListener('change', () => {
+        renderer.ssr.spatial_denoising_enabled = element('denoising').checked;
+        last_status = 0;
+    });
+    element('taa').addEventListener('change', () => { renderer.feature_taa_enabled = element('taa').checked; });
+    element('play').addEventListener('click', () => {
+        paused = !paused; element('play').textContent = paused ? 'Play motion' : 'Pause motion';
+    });
+    element('step').addEventListener('click', () => { paused = true; element('play').textContent = 'Play motion'; frame(1/60); });
+    element('restart').addEventListener('click', restart);
+    element('cut').addEventListener('click', () => {
+        cut_side = cut_side === 1 ? -1 : 1;
+        if (element('experiment').value === 'free') { element('experiment').value = 'still'; }
+        renderer.indicate_view_change();
+    });
+    element('reset').addEventListener('click', () => { renderer.ssr.reset_history = true; });
+    element('compile').addEventListener('click', async () => {
+        if (check_busy) { return; }
+        check_busy = true; element('compile').disabled = true;
+        try {
+            const messages = [];
+            for (const shader of [ssr_trace_shader, ssr_resolve_shader_IBL, ssr_resolve_shader_LPV,
+                ssr_reproject_shader, ssr_spatial_denoise_shader, ssr_spatial_denoise_metadata_shader]) {
+                device.pushErrorScope('validation');
+                const module = device.createShaderModule({label:shader.descriptor.label,code:shader.descriptor.source});
+                const info = await module.getCompilationInfo();
+                const error = await device.popErrorScope();
+                const errors = info.messages.filter(m => m.type === 'error');
+                messages.push(`${shader.descriptor.label}: ${error || errors.length ? 'FAIL' : 'OK'}`);
+                if (error) { messages.push(error.message); }
+                messages.push(...errors.map(m => `${m.lineNum}:${m.linePos} ${m.message}`));
+            }
+            report(messages.join('\n'), messages.some(m => m.includes('FAIL')));
+            last_status = performance.now() + 12000;
+        } catch (error) { report(error.message, true); }
+        finally { check_busy = false; element('compile').disabled = false; }
+    });
+    resize(); restart();
+    // Explicit stepping is useful for reproducible runs in a background tab.
+    globalThis.ssr_lab = { renderer, camera, world, step: (n = 1) => { for (let i=0;i<n;i++) { frame(1/60); } return frame_count; } };
+    const manual = new URLSearchParams(location.search).has('manual');
+    if (!manual) { stop_loop = create_frame_loop(dt => frame(Math.min(dt, 0.05), !paused), 30); }
+    frame(0, false);
+}
+
+start().catch(error => { report(error.message, true); console.error(error); });

package/src/shade/playground/ssr_reprojection/scene.d.ts

@@ -0,0 +1,18 @@
+/** Small, entirely procedural scene. The top of the mirror is exactly y=0. */
+export function create_scene(): Promise<{
+    scene: Scene;
+    mirror_material: StandardShadeMaterial;
+    targets: {
+        mesh: Mesh;
+        label: string;
+        position: number[];
+        size: number[];
+        color: string;
+        rgb: number[];
+    }[];
+    occluder: Mesh;
+}>;
+import { Scene } from "../../renderer/scene/Scene.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { Mesh } from "../../renderer/scene/Mesh.js";
+//# sourceMappingURL=scene.d.ts.map

package/src/shade/playground/ssr_reprojection/scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ssr_reprojection/scene.js"],"names":[],"mappings":"AAUA,8EAA8E;AAC9E;;;;;;;;;;;;GAuCC;sBA3CqB,+BAA+B;sCAHf,kDAAkD;qBAEnE,8BAA8B"}

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

@@ -0,0 +1,51 @@
+import { Color } from "../../../core/color/Color.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { BoxGeometry } from "../../renderer/geometry/BoxGeometry.js";
+import { MeshoptClusterizer } from "../../renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { make_sunlight } from "../../renderer/light/make_sunlight.js";
+import { Mesh } from "../../renderer/scene/Mesh.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { make_flat_environment } from "../skinned_blas_refit/flat_environment.js";
+
+/** Small, entirely procedural scene. The top of the mirror is exactly y=0. */
+export async function create_scene() {
+    await MeshoptClusterizer.ready;
+    const scene = new Scene();
+    const cube = new BoxGeometry();
+    const material = (rgb, roughness = 0.65, metallic = 0, glow = 0) => {
+        const result = new StandardShadeMaterial();
+        result.diffuse_color.copy(new Color(...rgb));
+        result.emissive_factor.copy(new Color(...rgb.map(v => v * glow)));
+        result.roughness_factor = roughness;
+        result.metallic_factor = metallic;
+        return result;
+    };
+    const box = (name, position, scale, mat) => {
+        const mesh = Mesh.from(cube, mat);
+        mesh.name = name;
+        mesh.transform_local.setTranslation(...position);
+        mesh.transform_local.setScale(...scale);
+        mesh.updateMatrices();
+        scene.add(mesh);
+        return mesh;
+    };
+    const mirror_material = material([0.85, 0.88, 0.92], 0.03, 1);
+    box('Planar mirror', [0, -0.1, -1], [14, 0.2, 13], mirror_material);
+    // Sparse fixed lines make the different motion of floor and reflection visible.
+    const grid = material([0.11, 0.14, 0.18], 0.3, 0.7);
+    for (let i = -6; i <= 6; i += 2) {
+        box('Floor grid X', [i, 0.002, -1], [0.016, 0.004, 13], grid);
+        box('Floor grid Z', [0, 0.002, i - 1], [14, 0.004, 0.016], grid);
+    }
+    const targets = [
+        { label: 'A', position: [-2.4, 1.3, -1.8], size: [0.85, 2.1, 0.8], color: '#ff966b', rgb: [1, 0.23, 0.08] },
+        { label: 'B', position: [0, 1.7, -3.4], size: [0.9, 2.7, 0.8], color: '#82cfff', rgb: [0.08, 0.5, 1] },
+        { label: 'C', position: [2.3, 1.1, -0.8], size: [0.85, 1.7, 0.8], color: '#e9a4ff', rgb: [0.75, 0.1, 1] },
+    ].map(spec => ({ ...spec, mesh: box(spec.label, spec.position, spec.size, material(spec.rgb, 0.5, 0, 0.35)) }));
+    // Keep its resource identity stable while moving it into/out of the view.
+    const occluder = box('Moving occluder', [20, 1, 1], [0.7, 2, 0.35], material([0.04, 0.05, 0.06]));
+    scene.lights.environment = make_flat_environment([0.045, 0.055, 0.075]);
+    scene.lights.add(make_sunlight({ intensity: 1.5, direction: new Vector3(-0.4, -1, -0.3), temperature: 6500 }));
+    return { scene, mirror_material, targets, occluder };
+}

package/src/shade/renderer/Renderer.d.ts

@@ -53,15 +53,6 @@ export class Renderer {
      * @type {boolean}
      */
     feature_particles_enabled: boolean;
-    /**
-     * Most particles alive at once in a scene — the pool every emitter of that scene draws its
-     * records from. Read once, when the scene's {@link GPUParticleSystem} is created on the first
-     * frame {@link feature_particles_enabled} is on for it; the pool does not grow afterwards, so
-     * set this before that frame. Left undefined, the system's own default applies.
-     *
-     * @type {number|undefined}
-     */
-    particle_capacity: number | undefined;
     feature_ssr_enabled: boolean;
     feature_ssao_enabled: boolean;
     /**
@@ -190,20 +181,6 @@ export class Renderer {
      * @returns {DepthOfFieldU}
      */
     get dof_unreal(): DepthOfFieldU;
-    /**
-     * When true and {@link indirect_lighting_mode} is Brick4, run a single fused
-     * pass that produces the resolved indirect lighting directly (combining the
-     * brick4 diffuse, brick4 specular and indirect resolve passes). Trades a
-     * bit of cache pressure inside the pass for substantially less memory
-     * bandwidth: no intermediate rgba16float diffuse/specular targets, the
-     * g-buffer is read once, and a single brick4 probe pair is shared between
-     * the diffuse and specular evaluations.
-     *
-     * SSR is mutually exclusive with the fused path (it needs the standalone
-     * specular target as input), so when SSR is enabled the split path is used.
-     * @type {boolean}
-     */
-    fused_indirect: boolean;
     /**
      * RCAS
      * @type {boolean}
@@ -346,6 +323,8 @@ export class Renderer {
      * @param {Scene} scene
      */
     update_lpv(scene: Scene): void;
+    /** SSR settings, available after initialize(). @returns {import("./postprocess/ssr/SSR.js").SSR} */
+    get ssr(): import("./postprocess/ssr/SSR.js").SSR;
     /**
      * ReSTIR DI subsystem — exposed for runtime tuning (e.g. GUI toggles like
      * `use_screen_space_shadow`, `m_initial`).

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AAmGA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,0CAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;OAQG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAkB1C,uCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;OAKG;IACH,sCAOC;IAjBD,mCAEC;IAiBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAgB/B;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAwCD;;;OAGG;IACH,6BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,oBAAkB,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IA8OD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAeD;;;;;;OAMG;IACH,uCAFa,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EAkOC;IAED;;OAEG;IACH,gBAQC;IAQD,4BAwBC;IAqID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;OAUG;IACH,qEAHW,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8EAJW,MAAM,UACN,iBAAiB,GACf,OAAO,CA62BnB;;CACJ;6BAhgF4B,yBAAyB;0CACZ,gCAAgC;sCACpC,4BAA4B;+BACnC,6CAA6C;2BA3BjD,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAwC7C,uBAAuB;gCA7CnB,sBAAsB;mBArCnC,oCAAoC;oBACnC,4BAA4B;kCA8Ed,gCAAgC;2BA3DvC,2BAA2B;iCAyDrB,0CAA0C;4CA3C/B,+DAA+D;yBAgClF,yBAAyB;kCAChB,kCAAkC;kCASlC,wBAAwB;oBA9BtC,0BAA0B;uCAPP,sDAAsD"}