npm - @woosh/meep-engine - Versions diffs - 3.2.0 → 3.4.0 - Mend

@woosh/meep-engine 3.2.0 → 3.4.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 (893) hide show

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

@@ -0,0 +1,164 @@
+<!doctype html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>meep — Sponza / path tracer</title>
+    <style>
+        :root {
+            color-scheme: dark;
+            --panel: rgba(20, 22, 26, 0.88);
+            --line: #2b3038;
+            --text: #d6dae0;
+            --muted: #8b939f;
+            --pass: #55c46a;
+            --fail: #ff6b6b;
+            --warn: #e5b54a;
+        }
+        * { box-sizing: border-box; }
+        html, body { margin: 0; height: 100%; overflow: hidden; background: #0d0f12; }
+        /* body carries tabindex so the camera controller's keyboard device has something focusable
+           to listen on; the focus ring around the whole viewport is not wanted */
+        body:focus { outline: none; }
+        #view { display: block; width: 100vw; height: 100vh; }
+        #panel {
+            position: fixed;
+            top: 12px;
+            left: 12px;
+            width: 310px;
+            padding: 12px 14px;
+            background: var(--panel);
+            border: 1px solid var(--line);
+            border-radius: 8px;
+            backdrop-filter: blur(6px);
+            color: var(--text);
+            font: 13px/1.5 system-ui, -apple-system, Segoe UI, sans-serif;
+        }
+        #panel h1 { font-size: 13px; font-weight: 600; margin: 0 0 8px; }
+        label { display: flex; align-items: center; gap: 8px; padding: 3px 0; cursor: pointer; }
+        label input { margin: 0; }
+        label .hint { color: var(--muted); font-size: 11.5px; }
+        hr { border: 0; border-top: 1px solid var(--line); margin: 10px 0; }
+        button {
+            font: inherit;
+            padding: 5px 11px;
+            margin-right: 6px;
+            border-radius: 6px;
+            border: 1px solid var(--line);
+            background: #1c1f25;
+            color: var(--text);
+            cursor: pointer;
+        }
+        button:hover { border-color: #3d4552; }
+        .row { display: flex; gap: 6px; align-items: center; }
+        .row button { margin-right: 0; flex: 0 0 auto; }
+        #stress_count {
+            flex: 1 1 auto;
+            min-width: 0;
+            font: 12px ui-monospace, SFMono-Regular, Consolas, monospace;
+            padding: 4px 6px;
+            border-radius: 5px;
+            border: 1px solid var(--line);
+            background: #14161a;
+            color: var(--text);
+        }
+        #scene_url {
+            flex: 1 1 auto;
+            min-width: 0;
+            font: 11px/1.4 ui-monospace, SFMono-Regular, Consolas, monospace;
+            padding: 4px 6px;
+            border-radius: 5px;
+            border: 1px solid var(--line);
+            background: #14161a;
+            color: var(--muted);
+        }
+        #status { font-size: 12px; color: var(--muted); word-break: break-word; }
+        #status.pass { color: var(--pass); }
+        #status.fail { color: var(--fail); }
+        #status.warn { color: var(--warn); }
+        #stats {
+            margin-top: 6px;
+            font: 12px ui-monospace, SFMono-Regular, Consolas, monospace;
+            color: var(--text);
+        }
+        p.note { margin: 8px 0 0; font-size: 11.5px; color: var(--muted); }
+    </style>
+</head>
+<body tabindex="0">
+<canvas id="view"></canvas>
+<div id="panel">
+    <h1>Sponza — path tracer</h1>
+    <label>
+        <input type="checkbox" id="path_tracing">
+        <span>Path tracer <span class="hint">— traverses the TLAS</span></span>
+    </label>
+    <label>
+        <input type="checkbox" id="taa" checked>
+        <span>TAA <span class="hint">— off while tracing</span></span>
+    </label>
+    <hr>
+    <button id="pause">Pause</button>
+    <button id="reset_accumulation">Reset accumulation</button>
+    <hr>
+    <div class="row">
+        <input type="number" id="stress_count" value="20000" min="1" step="1000">
+        <button id="stress">Add boxes</button>
+    </div>
+    <p class="note">
+        Scatters simple boxes so the TLAS, rather than the per-mesh BLAS, is what traversal spends
+        its time in — which is the only condition under which TLAS quality is measurable at all.
+    </p>
+    <hr>
+    <div class="row">
+        <input id="scene_url" spellcheck="false">
+        <button id="load">Load</button>
+    </div>
+    <div id="status"></div>
+    <div id="stats"></div>
+    <p class="note">
+        Drag to orbit, wheel to zoom. The tracer accumulates one tile per frame and resets when
+        the camera moves, so let it settle before judging an image.
+    </p>
+</div>
+<script type="module">
+    import { start } from './main.js';
+    start().catch(error => {
+        const status = document.getElementById('status');
+        status.className = 'fail';
+        status.textContent = String(error?.message ?? error);
+        console.error(error);
+    });
+</script>
+</body>
+</html>

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

@@ -0,0 +1,8 @@
+/**
+ * Stand the prototype up. Called by the page rather than run on import, so that nothing here
+ * touches the DOM until there is one.
+ *
+ * @returns {Promise<void>}
+ */
+export function start(): Promise<void>;
+//# sourceMappingURL=main.d.ts.map

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

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/sponza_path_trace/main.js"],"names":[],"mappings":"AA+IA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAuNzB"}

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

@@ -0,0 +1,363 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+import { DEG_TO_RAD } from "../../../core/math/DEG_TO_RAD.js";
+import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { camera_frame_sphere } from "../../renderer/camera/camera_frame_sphere.js";
+import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
+import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
+import { create_frame_loop } from "../../renderer/create_frame_loop.js";
+import { BoxGeometry } from "../../renderer/geometry/BoxGeometry.js";
+import { make_sunlight } from "../../renderer/light/make_sunlight.js";
+import { StandardShadeMaterial } from "../../renderer/material/StandardShadeMaterial.js";
+import { load_gltf } from "../../renderer/loader/gltf/load_gltf.js";
+import { Renderer } from "../../renderer/Renderer.js";
+import { Scene } from "../../renderer/scene/Scene.js";
+import { load_scene_from_url } from "../../renderer/scene/serialization/deserialize_scene.js";
+import { add_random_meshes } from "../add_random_meshes.js";
+import { load_default_environment } from "../load_default_environment.js";
+import { make_playground_asset_manager } from "../make_playground_asset_manager.js";
+/**
+ * Sponza under the path tracer, as a prototype.
+ *
+ * The point is the one thing no device-free tier and no readback harness can answer: what the tree
+ * looks like when something traverses it. `AccumulatingPathTracer` binds `scene_ctx.tlas.buffer`
+ * directly and is the traversal-heaviest consumer in the tree, so it is where a wrong child index
+ * or a loose parent box shows up as something you can see — geometry that vanishes at a grazing
+ * angle, or light that leaks through a wall.
+ *
+ * It was written to A/B the GPU TLAS build against the legacy CPU one; that comparison has been run
+ * (`GPU_BVH_BUILD_PLAN.md` §4.6) and the legacy path is gone. What it is now is the place to notice
+ * a regression in the tree, and — through the box-scatter control — the place to build a workload
+ * where the TLAS is what traversal costs.
+ *
+ * Runs under the dev server (`npm run dev`), which is what resolves the one bare specifier the
+ * renderer reaches for (`robust-predicates`) and what serves `test_assets/`. The panel is
+ * hand-rolled rather than lil-gui: four checkboxes are not worth a dependency the library does not
+ * otherwise have.
+ */
+/**
+ * Served by the dev server out of `test_assets/`, which is gitignored and unpublished. See
+ * `test_assets/README.md` for how to put the assets there.
+ *
+ * glTF rather than one of the `.shade` scenes sitting next to it: `deserialize_scene` accepts
+ * format version 2 only — deliberately, with no backward compatibility — and every exported Sponza
+ * in the sibling repo is version 1. Re-exporting one is the fix if a `.shade` scene is wanted; the
+ * loader below still takes one, chosen by extension.
+ *
+ * @type {string}
+ */
+const DEFAULT_SCENE_URL = '/test_assets/Sponza/glTF/Sponza.gltf';
+/**
+ * How the boxes the stress control scatters are sized, as a fraction of the scene's shortest
+ * bounding-box span.
+ *
+ * Relative rather than absolute because the page loads whatever `?scene=` names and no two exports
+ * agree on what a unit is. The two-order-of-magnitude spread between them is the point: a Morton
+ * code sees a centroid and nothing about extent, so a mix of sizes is the case it orders worst.
+ *
+ * @type {NumericInterval}
+ */
+const STRESS_SIZE_FRACTION = new NumericInterval(0.005, 0.4);
+/**
+ * A frame-time readout, kept as a rolling mean so the number is readable rather than jittering.
+ */
+class FrameTimer {
+    #samples = new Float64Array(60);
+    #count = 0;
+    #cursor = 0;
+    /**
+     * @param {number} seconds
+     */
+    add(seconds) {
+        this.#samples[this.#cursor] = seconds * 1000;
+        this.#cursor = (this.#cursor + 1) % this.#samples.length;
+        this.#count = Math.min(this.#count + 1, this.#samples.length);
+    }
+    reset() {
+        this.#count = 0;
+        this.#cursor = 0;
+    }
+    /**
+     * @returns {number} mean frame time in milliseconds, or 0 before there is anything to average
+     */
+    get mean_ms() {
+        if (this.#count === 0) {
+            return 0;
+        }
+        let total = 0;
+        for (let i = 0; i < this.#count; i++) {
+            total += this.#samples[i];
+        }
+        return total / this.#count;
+    }
+}
+/**
+ * Populate a scene from a URL, picking the loader by extension: a glTF document comes in through
+ * `load_gltf` and needs a light placed for it, a `.shade` scene carries its own. Either way the
+ * camera ends up framing what arrived.
+ *
+ * @param {string} url
+ * @param {Scene} scene
+ * @param {OrbitalCameraController} controller
+ * @returns {Promise<void>}
+ */
+async function load_scene(url, scene, controller) {
+    if (/\.gltf$|\.glb$/i.test(url)) {
+        // glTF reads every byte through the asset framework, so it needs a manager with loaders
+        // registered for the two types it asks for
+        const bundle = await load_gltf(url, { assetManager: await make_playground_asset_manager() });
+        scene.add(bundle.scenes);
+        if (!scene.lights.elements.some(light => light.isDirectionalLight)) {
+            // a glTF document need not carry any light at all, and Sponza does not
+            scene.lights.add(make_sunlight({ intensity: 7.2 }));
+        }
+    } else {
+        await load_scene_from_url(url, scene);
+    }
+    const bounds = scene.instances.bounding_box;
+    const radius = Math.hypot(bounds.width, bounds.height, bounds.depth) * 0.5;
+    camera_frame_sphere(
+        controller,
+        radius,
+        new Vector3(bounds.centerX, bounds.centerY, bounds.centerZ)
+    );
+    controller.movement_speed_scale = Math.max(bounds.width, bounds.height, bounds.depth) * 0.1;
+}
+/**
+ * Stand the prototype up. Called by the page rather than run on import, so that nothing here
+ * touches the DOM until there is one.
+ *
+ * @returns {Promise<void>}
+ */
+export async function start() {
+    const element = id => document.getElementById(id);
+    const status_element = element('status');
+    const stats_element = element('stats');
+    /**
+     * @param {string} text
+     * @param {string} [kind]
+     */
+    function set_status(text, kind = '') {
+        status_element.textContent = text;
+        status_element.className = kind;
+    }
+    const canvas = element('view');
+    const context = canvas.getContext('webgpu');
+    if (context === null) {
+        set_status('no WebGPU context — this browser has none, or the page is not a secure context', 'fail');
+        return;
+    }
+    const renderer = new Renderer();
+    set_status('acquiring a device…');
+    await renderer.initialize({ context });
+    if (!renderer.graphics.device.features.has('subgroups')) {
+        // Not fatal for rasterization, but the GPU TLAS build takes subgroup builtins in the sort's
+        // scatter and in the extraction pass, so the A/B has only one usable side here.
+        set_status('device has no `subgroups` — the GPU TLAS path will fail; use the CPU side of the A/B', 'warn');
+    }
+    const camera = new PerspectiveCamera();
+    camera.transform.position.set(0, 2, -5);
+    camera.transform.lookAt(Vector3.zero);
+    camera.near = 0.1;
+    camera.far = 200;
+    camera.fov = 72 * DEG_TO_RAD;
+    camera.aspect = renderer.aspect_ratio;
+    const scene = new Scene();
+    // document.body rather than the canvas: the controller starts a keyboard device, and only a
+    // focusable element can receive key events — body carries tabindex for exactly that.
+    const controller = new OrbitalCameraController(camera, document.body);
+    // handy from the console
+    globalThis.renderer = renderer;
+    globalThis.scene = scene;
+    globalThis.camera = camera;
+    // ---- controls -------------------------------------------------------------------------
+    const frame_timer = new FrameTimer();
+    let paused = false;
+    element('path_tracing').addEventListener('change', event => {
+        renderer.feature_path_tracing_enabled = event.target.checked;
+        // Two temporal filters over one image is nonsense; the tracer accumulates on its own.
+        if (event.target.checked) {
+            element('taa').checked = false;
+            renderer.feature_taa_enabled = false;
+        }
+        renderer.indicate_view_change();
+        frame_timer.reset();
+    });
+    element('taa').addEventListener('change', event => {
+        renderer.feature_taa_enabled = event.target.checked;
+        renderer.indicate_view_change();
+    });
+    element('pause').addEventListener('click', () => {
+        paused = !paused;
+        element('pause').textContent = paused ? 'Resume' : 'Pause';
+    });
+    element('reset_accumulation').addEventListener('click', () => {
+        renderer.path_tracer.clear_history = true;
+        renderer.indicate_view_change();
+        frame_timer.reset();
+    });
+    // Built once and shared across clicks: a geometry per click would be a BLAS per click, which
+    // is the opposite of what this control is for. One generator likewise, so a second click
+    // scatters new boxes rather than laying the same ones down again.
+    const stress_geometry = new BoxGeometry(1, 1, 1);
+    const stress_material = new StandardShadeMaterial();
+    const stress_random = seededRandom(12345);
+    element('stress').addEventListener('click', () => {
+        const count = Math.max(1, Number.parseInt(element('stress_count').value, 10) || 0);
+        const bounds = scene.instances.bounding_box;
+        const shortest_span = Math.min(bounds.width, bounds.height, bounds.depth);
+        add_random_meshes({
+            batch: scene.instances,
+            geometries: [stress_geometry],
+            materials: [stress_material],
+            count,
+            region: bounds,
+            geometry_scale_range: new NumericInterval(
+                shortest_span * STRESS_SIZE_FRACTION.min,
+                shortest_span * STRESS_SIZE_FRACTION.max
+            ),
+            random: stress_random
+        });
+        renderer.path_tracer.clear_history = true;
+        renderer.indicate_view_change();
+        frame_timer.reset();
+        set_status(`added ${count} boxes — ${scene.instances.instances.length} instances`, 'pass');
+    });
+    // ---- the scene ------------------------------------------------------------------------
+    const url = new URLSearchParams(location.search).get('scene') ?? DEFAULT_SCENE_URL;
+    const url_input = element('scene_url');
+    url_input.value = url;
+    // A Scene has no teardown, so changing scenes reloads the page rather than trying to empty one
+    // in place.
+    function load_url(next) {
+        const parameters = new URLSearchParams(location.search);
+        parameters.set('scene', next);
+        location.search = parameters.toString();
+    }
+    element('load').addEventListener('click', () => load_url(url_input.value.trim()));
+    url_input.addEventListener('keydown', event => {
+        if (event.key === 'Enter') {
+            load_url(url_input.value.trim());
+        }
+    });
+    set_status(`loading ${url} …`);
+    try {
+        await load_scene(url, scene, controller);
+    } catch (error) {
+        set_status(
+            `could not load the scene (${error.message}). Put the assets under test_assets/ — `
+            + `see test_assets/README.md — or type a reachable URL above and press Load.`,
+            'fail'
+        );
+        console.error(error);
+        return;
+    }
+    // Image-based lighting if a sky is there, and nothing said about it if not: the scene renders
+    // either way, and a missing optional asset is not a reason to show a failure. The helper warns
+    // and resolves false rather than rejecting.
+    load_default_environment(scene).then(applied => {
+        if (applied) {
+            renderer.indicate_view_change();
+        }
+    });
+    // the controller's keyboard device listens on body, and only a focused element gets key events
+    document.body.focus();
+    set_status(`loaded — ${scene.instances.instances.length} instances`, 'pass');
+    renderer.indicate_view_change();
+    // ---- frame loop -----------------------------------------------------------------------
+    const FRAME_RATE_LIMIT = 60;
+    create_frame_loop(time_delta_s => {
+        const width = window.innerWidth;
+        const height = window.innerHeight;
+        renderer.resize(width, height);
+        renderer.pixel_ratio = window.devicePixelRatio;
+        camera.aspect = width / height;
+        controller.update();
+        if (paused) {
+            return;
+        }
+        renderer.render(camera, scene, time_delta_s);
+        frame_timer.add(time_delta_s);
+        const instances = scene.instances.instances.length;
+        const mean = frame_timer.mean_ms;
+        stats_element.textContent =
+            `${mean.toFixed(1)} ms  ·  ${mean > 0 ? (1000 / mean).toFixed(0) : '0'} fps  ·  `
+            + `${instances} instances`
+            + `${renderer.feature_path_tracing_enabled ? '  ·  path traced' : ''}`;
+    }, FRAME_RATE_LIMIT);
+}

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

@@ -93,6 +93,22 @@ export class Renderer {
      * @type {boolean}
      */
     feature_velocity_debug_view: boolean;
+    /**
+     * When true, {@link path_tracer} replaces the rasterized+shaded color for the frame. The
+     * traced result still goes through TAA and tone mapping like any other color.
+     *
+     * The path tracer accumulates across frames itself, one tile per call, and resets whenever the
+     * camera moves. TAA on top of that is two temporal filters fighting over the same image — turn
+     * `feature_taa_enabled` off while this is on.
+     *
+     * This is the traversal-heaviest consumer of the TLAS — it binds `scene_ctx.tlas.buffer`
+     * directly — which is what made it the check that the GPU TLAS build traces correctly, and what
+     * makes it the first place a regression in that tree would show. Default false: it is a
+     * prototype-grade path, not a shipping render mode.
+     *
+     * @type {boolean}
+     */
+    feature_path_tracing_enabled: boolean;
     /**
      * Screen-space ray-marched depth of field — the Tiny Glade model
      * (Stachowiak, GPC 2024; see {@link DepthOfField}): aperture sub-rays

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

	@@ -1 +1 @@
1	- {"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;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,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAE1C;;;;;;;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;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAE/B;;;OAGG;IACH,kBAA4B;IAiB5B;;;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;IA4BD;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAGD,sCAIC;IAeD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;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,~~CAu0BnB~~;;CACJ;~~6BAn0E4B~~,yBAAyB;0CACZ,gCAAgC;2BAL/C,yCAAyC;6BACvC,4CAA4C;8BAC3C,2CAA2C;4BAc7C,uBAAuB;gCA1BnB,sBAAsB;mBAjDnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BAvCvC,2BAA2B;iCAoCrB,0CAA0C;4CAvB/B,+DAA+D;yBA7BlF,yBAAyB;kCAgDhB,wBAAwB;oBAVtC,0BAA0B;uCAJP,sDAAsD"}
1	+ {"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA4FA;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,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAC1C,+BAA6B;IAC7B,4CAA0C;IAE1C;;;;;;;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;;;;;;;;;;;;OAYG;IACH,gBAFU,OAAO,CAEK;IAEtB;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B,wBAA+B;IAE/B;;;OAGG;IACH,kBAA4B;IAiB5B;;;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;IA4BD;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,2DAEC;IAED;;;;;OAKG;IACH,8CAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAGD,sCAIC;IAeD;;;;OAIG;IACH,iCAFY,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAYC;IAED;;;;OAIG;IACH,wCAFa,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,+BAuBC;IAmMD;;;;OAIG;IACH,0BAEC;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAiFD;;;;;OAKG;IACH,+EA0NC;IAED;;OAEG;IACH,gBAGC;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,CAy0BnB;;CACJ;6BAt1E4B,yBAAyB;0CACZ,gCAAgC;2BAL/C,yCAAyC;6BACvC,4CAA4C;8BAC3C,2CAA2C;4BAc7C,uBAAuB;gCA1BnB,sBAAsB;mBAjDnC,oCAAoC;oBACnC,4BAA4B;kCAuEd,gCAAgC;2BAvCvC,2BAA2B;iCAoCrB,0CAA0C;4CAvB/B,+DAA+D;yBA7BlF,yBAAyB;kCAgDhB,wBAAwB;oBAVtC,0BAA0B;uCAJP,sDAAsD"}

package/src/shade/renderer/Renderer.js CHANGED Viewed

@@ -258,6 +258,23 @@ export class Renderer {
      */
     feature_velocity_debug_view = false;
+    /**
+     * When true, {@link path_tracer} replaces the rasterized+shaded color for the frame. The
+     * traced result still goes through TAA and tone mapping like any other color.
+     *
+     * The path tracer accumulates across frames itself, one tile per call, and resets whenever the
+     * camera moves. TAA on top of that is two temporal filters fighting over the same image — turn
+     * `feature_taa_enabled` off while this is on.
+     *
+     * This is the traversal-heaviest consumer of the TLAS — it binds `scene_ctx.tlas.buffer`
+     * directly — which is what made it the check that the GPU TLAS build traces correctly, and what
+     * makes it the first place a regression in that tree would show. Default false: it is a
+     * prototype-grade path, not a shipping render mode.
+     *
+     * @type {boolean}
+     */
+    feature_path_tracing_enabled = false;
     /**
      * Screen-space ray-marched depth of field — the Tiny Glade model
      * (Stachowiak, GPC 2024; see {@link DepthOfField}): aperture sub-rays
@@ -2223,10 +2240,12 @@ export class Renderer {
         // current_color_out = gr_texture_material_albedo_ao;
-        // current_color_out = this.path_tracer.render({
-        //     graph,
-        //     view: view_ctx
-        // });
+        if (this.feature_path_tracing_enabled) {
+            current_color_out = this.path_tracer.render({
+                graph,
+                view: view_ctx
+            });
+        }
         // Debug override: replace the post-shading color with a
         // visualization of the velocity buffer via shader_debug_velocity.

package/src/shade/renderer/animation/GPUAnimationManager.d.ts CHANGED Viewed

@@ -340,7 +340,11 @@ export class GPUAnimationManager {
      *
      * Mesh→skin bindings register immediately via
      * {@link GPUMeshSkinningContext#bind}; the skinning context
-     * already tolerates pre-scene-build registration.
+     * already tolerates pre-scene-build registration. Each mesh also
+     * gets its {@link SkinnedMesh#skin} reference and a fresh set of
+     * bounds off it, synchronously — that part does not wait for
+     * `id_mapping`, because it reads the joints' `transform_global`
+     * rather than any GPU row.
      *
      * @param {Skin} skin
      * @returns {number} skin id (index into the `animation_skins` table)

package/src/shade/renderer/animation/GPUAnimationManager.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA6HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAyMI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED~~;;;;;;;;;;;;;;;;;;;;;;OAsBG~~;IACH,2BAFa,MAAM,~~CAuDlB~~;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IA0FD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA+FD,gBAYC;;CACJ;~~4BA7rD2B~~,gCAAgC"}
1	+ {"version":3,"file":"GPUAnimationManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/GPUAnimationManager.js"],"names":[],"mappings":"AA6HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAyMI;;;;OAIG;IACH,sCAHW,MAAM,kCAgBhB;IAED;;OAEG;IACH,4BAEC;IAED;;;;;;;;;;;;OAYG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAED;;;;;;;;;;OAUG;IACH,mCAEC;IAED;;;;;;;;;;;;OAYG;IACH,4CAFW,MAAM,QA6BhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAC,CAK3D;IAED;;;;;;;;;;;;OAYG;IACH,gCAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;;;;;;OAWG;IACH,kCAFa,MAAM,CA+BlB;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAJW;QAAE,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAEhD,MAAM,CA2BlB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;eAPc,MAAM;qBACA,MAAM;mBACR,MAAM;kBACP,MAAM;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAE,CAAC;QAEhE,MAAM,CAkElB;IAgCD;;;;;;;;;;;;;;;;;OAiBG;IACH,kBAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,2BAHW,MAAM,QACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,6BAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,mBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,SACN,MAAM,QAShB;IAED;;;;;;;;;;;OAWG;IACH,eAFW,MAAM,QAShB;IAED;;;;;;;;;OASG;IACH,cAFW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH;gBAJe,MAAM;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE,CAAA;SAAE,CAAC;QAEhE,MAAM,CAoElB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,2BAFa,MAAM,CA4ElB;IA8ED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,yCAFa,MAAM,CAyDlB;IAwDD;;;;;;;;;;;;;;;OAeG;IACH,yBAFW,MAAM,QAkChB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAFW,MAAM,QA2ChB;IA0FD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,8CAIC;IAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,iEA2CC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,kDAFW,MAAM,QAgChB;IA+FD,gBAYC;;CACJ;4BAttD2B,gCAAgC"}