@woosh/meep-engine 3.32.0 → 3.34.0

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

@@ -5,8 +5,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 { meshlet_geometry_from_bytes } from "../../renderer/geometry/meshlet_geometry_transfer.js";
 import {
     vgeo_byte_source_over_url
@@ -173,6 +171,25 @@ const ROWS_LAST_KNOWN_GOOD = 2_200_000;
  */
 const HEAD_PREFIX_BYTES = 8 * 1024;
 
+/**
+ * How far the camera's far plane may reach, in multiples of the distance to the orbit's target.
+ *
+ * The far plane clips nothing — the projection is infinite reverse-Z — but the renderer spreads what
+ * it slices by depth over it: the sun's three shadow cascades (`DirectionalLightShadowmap` takes
+ * `camera.far` as its shadow distance), the light clusters, OIT's depth curve and the volumetric
+ * froxels. It was `distance × 2000` and **no shadow reached the screen**: framed on the first
+ * district that is 1,580 km, so the nearest cascade spanned 0–214 km.
+ *
+ * The far side of the world's bounding sphere is the other bound, and here it is not the one that
+ * binds: the world box is 26 by 28 km because `map_vista` is, a backdrop around an island whose
+ * ground is three kilometres across, so the sphere reaches twenty kilometres from anywhere on it.
+ * The same figure `vgeo_scene` settled on for the same shape of scene — at twenty, the nearest
+ * cascade reaches about two and a half times the distance to the target.
+ *
+ * @type {number}
+ */
+const FAR_PER_DISTANCE = 20;
+
 /**
  * @type {Record<string, ShadeDrawSide>}
  */
@@ -183,54 +200,6 @@ const DRAW_SIDES = Object.freeze({
 });
 
 
-/**
- * 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 = "caldera/vgeo frame start";
-
-    phase = FramePhase.FrameStart;
-
-    /**
-     * @param {CalderaPlayground} page
-     */
-    constructor(page) {
-        super();
-
-        this.page = page;
-    }
-
-    record(frame) {
-        this.page.runtime.begin_frame({ graph: frame.graph });
-    }
-}
-
-
-/**
- * Schedules the readback and closes the frame, after everything that could have cut has cut.
- */
-class VGeoFrameEnd extends RenderExtension {
-    name = "caldera/vgeo frame end";
-
-    phase = FramePhase.BeforePresent;
-
-    /**
-     * @param {CalderaPlayground} page
-     */
-    constructor(page) {
-        super();
-
-        this.page = page;
-    }
-
-    record(frame) {
-        this.page.feedback.read(frame.graph);
-        this.page.runtime.end_frame();
-    }
-}
-
-
 class CalderaPlayground {
 
     /** @type {Renderer} */
@@ -366,9 +335,15 @@ class CalderaPlayground {
     /** @type {GPUVirtualGeometryFeedback|undefined} */
     feedback;
 
-    /** @type {number} half the diagonal of the whole map, which sets the far plane */
+    /** @type {number} half the diagonal of the whole map, which bounds the far plane */
     world_radius = 1000;
 
+    /**
+     * The centre of the whole map's box.
+     * @type {Vector3}
+     */
+    world_center = new Vector3();
+
     /**
      * What the virtual-geometry tables were sized to, kept so a session can read back the numbers
      * the page chose rather than infer them.
@@ -397,8 +372,8 @@ class CalderaPlayground {
      *
      * The near and far planes are the part that matters here: Caldera is three kilometres across and
      * a viewer stands centimetres from a wall inside it, so a fixed pair of planes either z-fights
-     * everything close or clips everything far. Deriving them from the distance is what lets one
-     * page do both.
+     * everything close or spreads the sun's shadow over kilometres. Deriving them from the distance
+     * is what lets one page do both: the near plane here, the far plane in {@link fit_far}.
      *
      * @param {ArrayLike<number>} eye
      * @param {ArrayLike<number>} target
@@ -410,7 +385,6 @@ class CalderaPlayground {
         const distance = Math.max(Vector3.distance(from, to), 1e-3);
 
         this.camera.near = distance * 0.002;
-        this.camera.far = Math.max(distance * 2000, this.world_radius * 4);
 
         this.controller.distanceLimits.min = distance * 0.01;
         this.controller.distanceLimits.max = Math.max(distance * 2000, this.world_radius * 4);
@@ -418,11 +392,32 @@ class CalderaPlayground {
 
         this.controller.look(from, to);
 
+        this.fit_far();
+
         // the pixels the camera is about to cover have no correspondence in a TAA history written
         // from where it was standing
         this.renderer.indicate_view_change();
     }
 
+    /**
+     * Set the far plane from where the camera stands now: the far side of the world's bounding
+     * sphere, and no further than {@link FAR_PER_DISTANCE} times the distance to the target.
+     *
+     * Every frame rather than in {@link look}, because the orbit moves the eye between them.
+     */
+    fit_far() {
+        const eye = this.camera.transform;
+        const center = this.world_center;
+
+        const beyond_world = Math.hypot(
+            eye.translation_x - center.x,
+            eye.translation_y - center.y,
+            eye.translation_z - center.z
+        ) + this.world_radius;
+
+        this.camera.far = Math.min(beyond_world, this.controller.distance * FAR_PER_DISTANCE);
+    }
+
     /**
      * @param {string} text
      * @param {boolean} [error]
@@ -962,7 +957,9 @@ class CalderaPlayground {
                 instances_dropped: stats[VGEO_CUT_STAT.INSTANCES_DROPPED],
                 queue_dropped: stats[VGEO_CUT_STAT.QUEUE_DROPPED],
                 queue_remaining: stats[VGEO_CUT_STAT.QUEUE_REMAINING],
-                max_iterations: this.runtime.max_iterations,
+                // the main view's own bound: every view raises its own from its own readings
+                max_iterations: this.runtime.frame_view?.iterations_under(this.runtime)
+                    ?? this.runtime.max_iterations,
             },
             vram: pool === undefined ? undefined : {
                 pages: pool.resident_page_count,
@@ -1156,6 +1153,7 @@ async function start() {
     const box = manifest.world_bounds;
 
     page.world_radius = 0.5 * Math.hypot(box[3] - box[0], box[4] - box[1], box[5] - box[2]);
+    page.world_center.set(0.5 * (box[0] + box[3]), 0.5 * (box[1] + box[4]), 0.5 * (box[2] + box[5]));
 
     const renderer = new Renderer();
 
@@ -1223,6 +1221,25 @@ async function start() {
 
     page.scene_context = scene_context;
 
+    /*
+     The renderer's teardown reaches the scene context, which releases the virtual geometry it
+     built, 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.
+    */
+    let stopped = false;
+
+    globalThis.addEventListener('pagehide', () => {
+        stopped = true;
+
+        renderer.destroy();
+        renderer.graphics.device.destroy();
+    });
+    globalThis.addEventListener('pageshow', event => {
+        if (event.persisted) {
+            location.reload();
+        }
+    });
+
     if (has_virtual) {
         enable_virtual_geometry(page, manifest, parameters);
     }
@@ -1289,7 +1306,6 @@ async function start() {
     globalThis.__state = () => page.state();
     globalThis.__look = (eye, target) => page.look(eye, target);
 
-    let stopped = false;
     let last_time;
 
     const tick = time => {
@@ -1309,6 +1325,7 @@ async function start() {
 
         try {
             page.controller.update(dt);
+            page.fit_far();
 
             renderer.render(camera, scene, dt);
         } catch (error) {
@@ -1449,10 +1466,6 @@ function enable_virtual_geometry(page, manifest, parameters) {
     page.residency = page.scene_context.virtual_geometry_residency;
     page.feedback = page.scene_context.virtual_geometry_feedback;
 
-    globalThis.addEventListener('pagehide', () => page.feedback.destroy());
-
-    page.renderer.add_extension(new VGeoFrameStart(page));
-    page.renderer.add_extension(new VGeoFrameEnd(page));
 
     const tau = element('tau');
 

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;