@woosh/meep-engine 3.33.0 → 3.35.0

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

@@ -134,6 +134,5 @@ and `camera_state()` / `apply_camera(...)` copy a view between sessions.
 
 ## What this page does not cover
 
-Lighting is the unlit hook — `chunk_particle_lighting_unlit`, not the shading-chunk-backed one a
-lit-emitter variant would swap in. No emitter opts into simulation culling, so the frustum test in
+No emitter here opts into `EMITTER_FLAG.LIGHTING`; the bonfire in `../particle_ecs/` does. No emitter opts into simulation culling, so the frustum test in
 the tick pass is never taken here; the measured boxes are read by the occupancy pass all the same.

package/src/shade/playground/profile_hotkey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"profile_hotkey.d.ts","sourceRoot":"","sources":["../../../../src/shade/playground/profile_hotkey.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAZ8D,QAAQ,EAA3D,OAAO,yBAAyB,EAAE,QAAQ;IAE3B,IAAI,EAAnB,MAAM;IACoB,MAAM,GAAhC,WAAW,GAAC,IAAI;IAEc,QAAQ,SAA1B,MAAM,EAAE;IAEJ,KAAK,GAArB,MAAM;IACU,GAAG,GAAnB,MAAM;IACe,MAAM,GAA3B,WAAW;IACT,mBAAmB,CAwO/B;;wBA3PyB,OAAO;;;;kBACP,QAAQ,IAAI,CAAC;;;;mBACb,IAAI"}
+{"version":3,"file":"profile_hotkey.d.ts","sourceRoot":"","sources":["../../../../src/shade/playground/profile_hotkey.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAZ8D,QAAQ,EAA3D,OAAO,yBAAyB,EAAE,QAAQ;IAE3B,IAAI,EAAnB,MAAM;IACoB,MAAM,GAAhC,WAAW,GAAC,IAAI;IAEc,QAAQ,SAA1B,MAAM,EAAE;IAEJ,KAAK,GAArB,MAAM;IACU,GAAG,GAAnB,MAAM;IACe,MAAM,GAA3B,WAAW;IACT,mBAAmB,CAoM/B;;wBAvNyB,OAAO;;;;kBACP,QAAQ,IAAI,CAAC;;;;mBACb,IAAI"}

package/src/shade/playground/profile_hotkey.js

@@ -139,56 +139,20 @@ export function install_profile_hotkey({
         );
     }
 
-    /**
-     * Wait for frames already submitted to finish landing in the session.
-     *
-     * A frame is committed when its timestamp readback resolves — a `mapAsync` a frame or two behind
-     * submit, see `ShadeGPUCommandContext.profiling_absorbed` — and `record_frame` silently ignores
-     * anything arriving after `stop()`. Stopping the instant the key goes down therefore discards
-     * the last few frames, which are the ones you were most likely looking at.
-     *
-     * Drains the queue, then waits for the frame count to stop moving. Capped, because a recording
-     * taken while the page is paused never moves at all.
-     *
-     * @param {GPUProfileSession} recording
-     * @returns {Promise<void>}
-     */
-    async function drain(recording) {
-        const DEADLINE_MS = 1000;
-        const QUIET_MS = 60;
-
-        await renderer.device.queue.onSubmittedWorkDone();
-
-        const deadline = performance.now() + DEADLINE_MS;
-
-        let previous = recording.frames_recorded;
-
-        while (performance.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, QUIET_MS));
-
-            if (recording.frames_recorded === previous) {
-                return;
-            }
-
-            previous = recording.frames_recorded;
-        }
-    }
-
     async function stop() {
         const recording = session;
 
         session = null;
 
-        // Detached first, so nothing encoded during the drain below joins the recording. Frames
-        // already encoded are unaffected: Renderer captures the session into a local before it
+        // Detached first, so nothing encoded while the frames in flight land joins the recording.
+        // Those frames are unaffected: Renderer captures the session into a local before it
         // subscribes to the readback.
         renderer.profile_session = null;
 
         set_status("stopping — draining in-flight frames…");
 
-        await drain(recording);
-
-        const bytes = recording.stop();
+        // resolves once the frames already submitted have landed, the last ones you were looking at
+        const bytes = await recording.stop();
         const filename = `${name}-${file_timestamp()}.sgpt`;
 
         download_bytes(bytes, filename);

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/main.js"],"names":[],"mappings":"AAwQA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAukBzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/main.js"],"names":[],"mappings":"AAwQA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAoiBzB"}

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

@@ -702,55 +702,20 @@ export async function start() {
         );
     }
 
-    /**
-     * Wait for frames already submitted to finish landing in the session.
-     *
-     * A frame is committed when its timestamp readback resolves — a `mapAsync` a frame or two behind
-     * submit, see `ShadeGPUCommandContext.profiling_absorbed` — and `record_frame` silently ignores
-     * anything arriving after `stop()`. Stopping the instant the key goes down therefore discards
-     * the last few frames, which are the ones you were most likely looking at.
-     *
-     * Drains the queue, then waits for the frame count to stop moving. Capped, because a recording
-     * taken while the page is paused never moves at all.
-     *
-     * @param {GPUProfileSession} session
-     */
-    async function drain_profile(session) {
-        const DEADLINE_MS = 1000;
-        const QUIET_MS = 60;
-
-        await renderer.device.queue.onSubmittedWorkDone();
-
-        const deadline = performance.now() + DEADLINE_MS;
-
-        let previous = session.frames_recorded;
-
-        while (performance.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, QUIET_MS));
-
-            if (session.frames_recorded === previous) {
-                return;
-            }
-
-            previous = session.frames_recorded;
-        }
-    }
-
     async function stop_profile() {
         const session = profile_session;
 
         profile_session = null;
 
-        // Detach first, so nothing encoded during the drain below joins the recording. Frames
-        // already encoded are unaffected: Renderer captures the session into a local before it
+        // Detached first, so nothing encoded while the frames in flight land joins the recording.
+        // Those frames are unaffected: Renderer captures the session into a local before it
         // subscribes to the readback.
         renderer.profile_session = null;
 
         set_profile_status('stopping — draining in-flight frames…');
 
-        await drain_profile(session);
-
-        const bytes = session.stop();
+        // resolves once the frames already submitted have landed, the last ones you were looking at
+        const bytes = await session.stop();
 
         const filename = `skinned_blas_refit-${file_timestamp()}.sgpt`;
 

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

@@ -4,8 +4,6 @@ import { EntityComponentDataset } from "../../../engine/ecs/EntityComponentDatas
 import { Transform64 } from "../../../engine/ecs/transform/Transform64.js";
 import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
-import { FramePhase } from "../../renderer/extension/FramePhase.js";
-import { RenderExtension } from "../../renderer/extension/RenderExtension.js";
 import { VGEO_CUT_STAT } from "../../renderer/geometry/virtual/runtime/layout/VGEO_CUT_STAT.js";
 import { VirtualGeometry } from "../../renderer/geometry/virtual/runtime/VirtualGeometry.js";
 import {
@@ -98,51 +96,6 @@ const PAGE_SIZE = 64 * 1024;
  */
 const PAGE_CAPACITY = 4096;
 
-/**
- * Opens the VG frame before anything records a rasterization pass, because the seam inside those
- * passes writes into the feedback buffer this creates.
- */
-class VGeoFrameStart extends RenderExtension {
-    name = "vgeo/frame start";
-
-    phase = FramePhase.FrameStart;
-
-    /**
-     * @param {VGeoPlayground} page
-     */
-    constructor(page) {
-        super();
-
-        this.page = page;
-    }
-
-    record(frame) {
-        this.page.begin(frame);
-    }
-}
-
-/**
- * Schedules the readback and closes the frame, after everything that could have cut has cut.
- */
-class VGeoFrameEnd extends RenderExtension {
-    name = "vgeo/frame end";
-
-    phase = FramePhase.BeforePresent;
-
-    /**
-     * @param {VGeoPlayground} page
-     */
-    constructor(page) {
-        super();
-
-        this.page = page;
-    }
-
-    record(frame) {
-        this.page.finish(frame);
-    }
-}
-
 class VGeoPlayground {
     /**
      * @type {Renderer}
@@ -322,24 +275,6 @@ class VGeoPlayground {
         this.fov_y = this.camera.fov;
     }
 
-    /**
-     * @param {FrameContext} frame
-     */
-    begin(frame) {
-        this.runtime.begin_frame({ graph: frame.graph });
-    }
-
-    /**
-     * @param {FrameContext} frame
-     */
-    finish(frame) {
-        this.feedback.read(frame.graph);
-
-        this.runtime.end_frame();
-
-        this.frames++;
-    }
-
     /**
      * Open a container over a byte source and put it on screen in place of whatever is there.
      *
@@ -494,9 +429,10 @@ class VGeoPlayground {
      * Measured at 64 bytes a drop, which is a residual rather than a leak worth a playground
      * reaching into the geometry manager over.
      *
-     * `abort()` first, and that is not tidiness either. The wants in flight name page indices *of
-     * the container being retired*, and a fetch that lands after its reader is gone resolves a byte
-     * range out of a child table nothing owns any more.
+     * The residency lets go of it through `unregister`, which cancels its fetches — the ones on the
+     * wire and the ones still waiting for a slot — and that is not tidiness either. The wants in
+     * flight name page indices *of the container being retired*, and a fetch that lands after its
+     * reader is gone resolves a byte range out of a child table nothing owns any more.
      */
     retire() {
         if (this.entity !== -1) {
@@ -791,16 +727,27 @@ async function start() {
     page.material = material;
 
     /*
-     The loop's only teardown caller anywhere, and worth having for the same reason M12's clock was:
-     `abort()` existed and nothing pulled it, so the one thing the `AbortSignal` was added for was
-     never exercised outside a spec. Nothing in the engine constructs a feedback loop yet — a scene
-     context gives you a runtime and a pool, and the host wires the loop — so this page is the whole
-     population of hosts, and it is what a real one should do on the way out.
+     A host's part of the way out. The renderer releases its scene contexts, a scene context
+     releases the virtual geometry it built — the loop, the residency's fetches and their workers,
+     the runtime's feedback buffer, the pool (REVIEW_LEDGER U1) — and the device takes whatever the
+     renderer does not release. Declared here rather than beside the frame loop so the handler can
+     stop the loop from the moment it exists. A page restored from the back cache has no renderer
+     left to draw with, so it starts again.
      */
-    globalThis.addEventListener('pagehide', () => page.feedback.destroy());
+    let stopped = false;
+
+    globalThis.addEventListener('pagehide', () => {
+        stopped = true;
+
+        renderer.destroy();
+        renderer.graphics.device.destroy();
+    });
+    globalThis.addEventListener('pageshow', event => {
+        if (event.persisted) {
+            location.reload();
+        }
+    });
 
-    renderer.add_extension(new VGeoFrameStart(page));
-    renderer.add_extension(new VGeoFrameEnd(page));
 
     element('tau').addEventListener('input', event => {
         page.runtime.tau = Number(event.target.value);
@@ -869,7 +816,6 @@ async function start() {
         );
     }
 
-    let stopped = false;
     let last_time;
 
     function paint() {
@@ -949,6 +895,8 @@ async function start() {
             page.controller.update(dt);
 
             renderer.render(camera, scene, dt);
+
+            page.frames++;
         } catch (error) {
             stopped = true;