@woosh/meep-engine 2.169.1 → 2.169.3

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -1,4 +1,5 @@
 import { m4_invert } from "../../../../core/geom/3d/mat4/m4_invert.js";
+import { assert } from "../../../../core/assert.js";
 import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
 import { AABB3 } from "../../../../core/geom/3d/aabb/AABB3.js";
 import { aabb3_from_three_geometry } from "../../../../core/geom/3d/aabb/aabb3_from_three_geometry.js";
@@ -42,6 +43,22 @@ const scratch_ray_0 = new Float32Array(6);
  * This is roughly equivalent to single draw call, note that his is not a hierarchical data structure, if you want that - you will need to combine multiple entities, each with a `ShadedGeometry` component
  */
 export class ShadedGeometry {
+    /**
+     * Set when a transform change has been observed but the bounding box and the BVH have
+     * not been brought up to date yet. Only ever set under
+     * {@link ShadedGeometryFlags.DeferredBoundsUpdate}, and doubles as the "already queued"
+     * bit for {@link #bounds_queue}.
+     * @type {boolean}
+     */
+    #bounds_dirty = false;
+
+    /**
+     * Transient, assigned in the system. Where this component parks itself when its bounds
+     * go stale under {@link ShadedGeometryFlags.DeferredBoundsUpdate}.
+     * @type {DeferredBoundsQueue|null}
+     */
+    #bounds_queue = null;
+
     constructor() {
         /**
          *
@@ -205,11 +222,58 @@ export class ShadedGeometry {
         return this.__c_transform.matrix;
     }
 
+    /**
+     * Attach this component to the queue that collects deferred bounds updates.
+     * Called by the system when the component enters the BVH.
+     * @param {DeferredBoundsQueue} queue
+     * @returns {void}
+     */
+    bindBoundsQueue(queue) {
+        assert.defined(queue, 'queue');
+
+        this.#bounds_queue = queue;
+    }
+
+    /**
+     * Called by the system when the component leaves the BVH. Any update parked in the
+     * queue is abandoned — the entry is left in place and becomes inert, so unlinking
+     * stays O(1).
+     * @returns {void}
+     */
+    unbindBoundsQueue() {
+        this.#bounds_dirty = false;
+        this.#bounds_queue = null;
+    }
+
+    /**
+     * Recompute the bounding box and push it into the BVH, if a deferred update is pending.
+     *
+     * This is the single point where a parked update lands; it is driven both by
+     * {@link DeferredBoundsQueue.flush} and by any read of the bounding box.
+     * @returns {boolean} whether an update was actually pending
+     */
+    applyDeferredBoundsUpdate() {
+        if (!this.#bounds_dirty) {
+            return false;
+        }
+
+        this.#bounds_dirty = false;
+
+        this.update_bounds();
+
+        this.__bvh_leaf.write_bounds();
+
+        return true;
+    }
+
     /**
      *
      * @param {AABB3} destination
      */
     getBoundingBox(destination) {
+        // settle a pending deferred update, so a read never observes a stale box
+        this.applyDeferredBoundsUpdate();
+
         const aabb = this.__bvh_leaf.bounds;
 
         destination.readFromArray(aabb);
@@ -247,7 +311,22 @@ export class ShadedGeometry {
         return r;
     }
 
+    /**
+     * Change handler subscribed to the entity's {@link Transform} while the component is
+     * linked; see {@link ShadedGeometrySystem.link}.
+     * @returns {void}
+     */
     updateTransform() {
+        if (this.getFlag(ShadedGeometryFlags.DeferredBoundsUpdate)) {
+            if (!this.#bounds_dirty) {
+                this.#bounds_dirty = true;
+
+                this.#bounds_queue.add(this);
+            }
+
+            return;
+        }
+
         this.update_bounds();
 
         this.__bvh_leaf.write_bounds();

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometryFlags.js

@@ -19,9 +19,27 @@ export const ShadedGeometryFlags = {
     Visible: 16,
 
     /**
-     * Bounds are updated whenever transforms change, we can defer this until next frame render request
-     * This lets us back updated and do less work overall
-     * TODO implement, currently it's ignored
+     * Bounds are updated whenever transforms change; with this set that work is deferred
+     * until the tree is next read (a render request, a query, or a read of the bounding
+     * box), and every change observed in between collapses into a single update.
+     *
+     * This is a trade, not a free win, and which way it goes depends entirely on how many
+     * times the transform is written between reads:
+     *
+     *   - Set it on anything whose transform is written more than once per frame. A
+     *     {@link Transform} signals `position`, `rotation` and `scale` separately, so a
+     *     mover that changes all three pays three bounds recomputations and three walks to
+     *     the BVH root, and everything driven through a transform hierarchy writes all
+     *     three every time (the hierarchy hands its children a matrix, and decomposing it
+     *     touches each). Measured on a 20k-mesh scene with 2k movers: 3x fewer updates,
+     *     ~20-25% off the frame.
+     *   - Leave it off for a mesh whose transform is written exactly once. There is
+     *     nothing to collapse, and the same work now spans two passes over the components
+     *     instead of one — measured ~10-20% worse on the same scene.
+     *   - Costs nothing on a mesh that does not move; an empty flush is one length test.
+     *
+     * @see ShadedGeometrySystem.flushBoundsUpdates
+     * @see ShadedGeometryDeferredBounds.bench.spec.js
      */
     DeferredBoundsUpdate: 32,
 };

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.d.ts

@@ -44,10 +44,22 @@ export class ShadedGeometrySystem extends System<any> {
     __optimization_task: Task;
     __maintenance_task: Task;
     /**
-     *
+     * NOTE: components carrying {@link ShadedGeometryFlags.DeferredBoundsUpdate} only reach
+     * the tree at a {@link flushBoundsUpdates}, so a caller reaching for the tree directly
+     * must flush first. Every query on this system already does.
      * @returns {BVH}
      */
     get bvh(): BVH;
+    /**
+     * Apply every bounds update parked by components carrying
+     * {@link ShadedGeometryFlags.DeferredBoundsUpdate}, bringing {@link bvh} in line with
+     * the current transforms.
+     *
+     * Cheap when nothing is pending, which is why every query calls it unconditionally.
+     * @returns {number} how many meshes had their bounds applied, i.e. how many BVH
+     * refits this flush cost
+     */
+    flushBoundsUpdates(): number;
     /**
      * NOTE: DO NOT MODIFY RESULTS
      * @returns {Map<number,number>}

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js"],"names":[],"mappings":"AA8DA;IASI;;;OAGG;IACH,4BAmEC;IAjEG,2DAA+C;IAE/C;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,uBAA0B;IAE1B;;;;OAIG;IACH,wBAAgC;IAEhC;;;;OAIG;IACH,4BAAoC;IAEpC;;;;OAIG;IACH,kCAA0C;IAE1C;;;;OAIG;IACH,qBAA6B;IAI7B,0BAYE;IAEF,yBAIC;IAIL;;;OAGG;IACH,eAEC;IAED;;;OAGG;IACH,4BAFa,IAAI,MAAM,EAAC,MAAM,CAAC,CAI9B;IAED;;;;OAIG;IACH,+BAHW,MAAM,+CAsBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACL,OAAO,CAmBlB;IAED;;;;OAIG;IACH,4BASC;IAED;;;;OAIG;IACH,8BAMC;IAED,2CAqCC;IAED,4CAmBC;IAED;;;;;OAKG;IACH,SAJW,cAAc,KACd,SAAS,UACT,MAAM,QA2ChB;IAED;;;;;OAKG;IACH,WAJW,cAAc,KACd,SAAS,UACT,MAAM,QA4BhB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GACxB,MAAM,CAQlB;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,6BACG,MAAM,QAAQ,cAAc,KAAK,OAAO,kCAE/C;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAC;QAAC,OAAO,EAAE,aAAa,CAAA;KAAC,EAAE,CA8D1E;IAGD;;;;;;;;;;;;OAYG;IACH,wBAXW,aAAa,YACb,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,6BACG,MAAM,QAAQ,cAAc,KAAK,OAAO,kCAE/C;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAA;KAAC,GAAC,SAAS,CAmF1D;;CACJ;uBAviBsB,wBAAwB;0BACrB,qCAAqC;+BAIhC,qBAAqB;iBATnC,uCAAuC;oBAZpC,mCAAmC;8BAUzB,2CAA2C"}
+{"version":3,"file":"ShadedGeometrySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js"],"names":[],"mappings":"AA8DA;IAiBI;;;OAGG;IACH,4BAmEC;IAjEG,2DAA+C;IAE/C;;;;OAIG;IACH,iBAAsB;IAEtB;;;;OAIG;IACH,uBAA0B;IAE1B;;;;OAIG;IACH,wBAAgC;IAEhC;;;;OAIG;IACH,4BAAoC;IAEpC;;;;OAIG;IACH,kCAA0C;IAE1C;;;;OAIG;IACH,qBAA6B;IAI7B,0BAYE;IAEF,yBAIC;IAIL;;;;;OAKG;IACH,eAEC;IAED;;;;;;;;OAQG;IACH,sBAHa,MAAM,CAKlB;IAED;;;OAGG;IACH,4BAFa,IAAI,MAAM,EAAC,MAAM,CAAC,CAI9B;IAED;;;;OAIG;IACH,+BAHW,MAAM,+CAsBhB;IAED;;;;OAIG;IACH,iCAHW,MAAM,GACL,OAAO,CAmBlB;IAED;;;;OAIG;IACH,4BASC;IAED;;;;OAIG;IACH,8BAMC;IAED,2CA0CC;IAED,4CAmBC;IAED;;;;;OAKG;IACH,SAJW,cAAc,KACd,SAAS,UACT,MAAM,QAuChB;IAED;;;;;OAKG;IACH,WAJW,cAAc,KACd,SAAS,UACT,MAAM,QAgChB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,EAAE,iBACR,MAAM,UACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GACxB,MAAM,CAUlB;IAED;;;;;;;;;;;OAWG;IACH,kBAVW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,6BACG,MAAM,QAAQ,cAAc,KAAK,OAAO,kCAE/C;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAC;QAAC,OAAO,EAAE,aAAa,CAAA;KAAC,EAAE,CAgE1E;IAGD;;;;;;;;;;;;OAYG;IACH,wBAXW,aAAa,YACb,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,6BACG,MAAM,QAAQ,cAAc,KAAK,OAAO,kCAE/C;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,IAAI,EAAC,cAAc,CAAA;KAAC,GAAC,SAAS,CAqF1D;;CACJ;uBA1kBsB,wBAAwB;0BACrB,qCAAqC;+BAKhC,qBAAqB;iBAVnC,uCAAuC;oBAXpC,mCAAmC;8BASzB,2CAA2C"}

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -1,6 +1,5 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
 import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
 import {
     bvh_query_user_data_intersects_frustum
@@ -17,7 +16,8 @@ import TaskState from "../../../../core/process/task/TaskState.js";
 import { iteratorTask } from "../../../../core/process/task/util/iteratorTask.js";
 import { System } from "../../../ecs/System.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
-import { isForwardPlusLightingSkipped } from "../../render/forward_plus/plugin/isForwardPlusLightingSkipped.js";
+import { make_bvh_depth_range_computer } from "../make_bvh_depth_range_computer.js";
+import { DeferredBoundsQueue } from "./DeferredBoundsQueue.js";
 import { RuntimeDrawMethodOptimizer } from "./render/optimization/RuntimeDrawMethodOptimizer.js";
 import { ShadedGeometryRendererContext } from "./render/ShadedGeometryRendererContext.js";
 import { ShadedGeometry } from "./ShadedGeometry.js";
@@ -69,6 +69,14 @@ export class ShadedGeometrySystem extends System {
      */
     #material_references = new Map();
 
+    /**
+     * Bounds updates parked by components carrying
+     * {@link ShadedGeometryFlags.DeferredBoundsUpdate}, drained by
+     * {@link flushBoundsUpdates} before anything reads {@link bvh}.
+     * @type {DeferredBoundsQueue}
+     */
+    #deferred_bounds = new DeferredBoundsQueue();
+
     /**
      *
      * @param {Engine} engine
@@ -144,13 +152,28 @@ export class ShadedGeometrySystem extends System {
 
 
     /**
-     *
+     * NOTE: components carrying {@link ShadedGeometryFlags.DeferredBoundsUpdate} only reach
+     * the tree at a {@link flushBoundsUpdates}, so a caller reaching for the tree directly
+     * must flush first. Every query on this system already does.
      * @returns {BVH}
      */
     get bvh() {
         return this.__bvh_binary;
     }
 
+    /**
+     * Apply every bounds update parked by components carrying
+     * {@link ShadedGeometryFlags.DeferredBoundsUpdate}, bringing {@link bvh} in line with
+     * the current transforms.
+     *
+     * Cheap when nothing is pending, which is why every query calls it unconditionally.
+     * @returns {number} how many meshes had their bounds applied, i.e. how many BVH
+     * refits this flush cost
+     */
+    flushBoundsUpdates() {
+        return this.#deferred_bounds.flush();
+    }
+
     /**
      * NOTE: DO NOT MODIFY RESULTS
      * @returns {Map<number,number>}
@@ -262,12 +285,17 @@ export class ShadedGeometrySystem extends System {
                 return 0;
             }
 
+            this.flushBoundsUpdates();
+
             return ctx.collect(destination, destination_offset, graphics.renderer, view, this.__bvh_binary, ecd);
         });
 
-        const bvh = this.__bvh_binary;
-        this.__render_layer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
-            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
+        const compute_depth_range = make_bvh_depth_range_computer(this.__bvh_binary);
+
+        this.__render_layer.compute_depth_range = (result, frustum, nx, ny, nz, plane_constant) => {
+            this.flushBoundsUpdates();
+
+            compute_depth_range(result, frustum, nx, ny, nz, plane_constant);
         };
 
         this.__optimization_task.state.set(TaskState.INITIAL);
@@ -321,16 +349,12 @@ export class ShadedGeometrySystem extends System {
         // exists we simply overwrite it rather than guarding a can't-happen case
         this.#material_references.set(entity, material_reference);
 
-        assert.ok(
-            !isForwardPlusLightingSkipped(material_manager, sg.material),
-            'lit material was not transformed for Forward+ clustered lighting,'
-            + ' ensure the Forward+ plugin is registered before entities are linked'
-        );
-
         sg.__c_transform = t;
 
         sg.update_bounds();
 
+        sg.bindBoundsQueue(this.#deferred_bounds);
+
         t.subscribe(sg.updateTransform, sg);
 
         // remember entity for lookups
@@ -356,6 +380,10 @@ export class ShadedGeometrySystem extends System {
     unlink(sg, t, entity) {
         t.unsubscribe(sg.updateTransform, sg);
 
+        // abandon any deferred update still parked in the queue, it would otherwise be
+        // applied to a leaf that no longer belongs to this tree
+        sg.unbindBoundsQueue();
+
         // disconnect BVH
         sg.__bvh_leaf.unlink();
 
@@ -393,6 +421,8 @@ export class ShadedGeometrySystem extends System {
         result_offset,
         planes
     ) {
+        this.flushBoundsUpdates();
+
         return bvh_query_user_data_intersects_frustum(result, result_offset, this.__bvh_binary, planes);
     }
 
@@ -417,6 +447,8 @@ export class ShadedGeometrySystem extends System {
 
         const hits = [];
 
+        this.flushBoundsUpdates();
+
         const bvh = this.__bvh_binary;
 
         const hit_count = bvh_query_leaves_generic(hits, 0, bvh, bvh.root, BVHQueryIntersectsRay.from([origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]));
@@ -497,6 +529,8 @@ export class ShadedGeometrySystem extends System {
 
         const hits = [];
 
+        this.flushBoundsUpdates();
+
         const bvh = this.__bvh_binary;
 
         const hit_count = bvh_query_leaves_generic(hits, 0, bvh, bvh.root, BVHQueryIntersectsRay.from([origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]));

package/src/engine/graphics/ecs/render_layers_compute_depth_range.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Accumulate the world-space depth range of every visible BVH-backed render
+ * layer's content that falls inside `frustum_planes`, measured along a camera's
+ * view direction.
+ *
+ * WHY THIS EXISTS
+ *
+ * `auto_set_camera_clipping_planes` and `extend_shadow_camera_near_for_casters`
+ * each restated two things verbatim:
+ *
+ *  - the three.js matrix-layout invariant that a camera's view direction is the
+ *    negated third column of `matrixWorld` (`-m[8], -m[9], -m[10]`) and its
+ *    position is the fourth (`m[12..14]`). That is vendor layout knowledge and
+ *    belongs in one place, not restated at every site that needs a depth plane.
+ *  - the layer sweep itself, including the `+Infinity / -Infinity` sentinel
+ *    initialisation and the two guards (`layer.state.visible`,
+ *    `layer.compute_depth_range === null`).
+ *
+ * Callers keep their own clamping policy — the auto-clip applies hysteresis and
+ * user outer bounds, the shadow fit only ever pulls `near` closer — which is
+ * the part that genuinely differs between them.
+ *
+ * Runs once per camera per frame. The cost is dominated by the BVH walks inside
+ * each layer's `compute_depth_range`, not by this wrapper.
+ *
+ * @param {{near: number, far: number}} out_range written with the accumulated range; `near` stays `+Infinity` and `far` stays `-Infinity` when no layer contributes
+ * @param {RenderLayerManager} layers
+ * @param {Float32Array} frustum_planes 6 planes in flat form (24 floats), in world space
+ * @param {number[]|Float32Array} matrix_world_elements the camera's `matrixWorld.elements`
+ */
+export function render_layers_compute_depth_range(out_range: {
+    near: number;
+    far: number;
+}, layers: RenderLayerManager, frustum_planes: Float32Array, matrix_world_elements: number[] | Float32Array): void;
+//# sourceMappingURL=render_layers_compute_depth_range.d.ts.map

package/src/engine/graphics/ecs/render_layers_compute_depth_range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render_layers_compute_depth_range.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/ecs/render_layers_compute_depth_range.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,6DALW;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,8CAE3B,YAAY,yBACZ,MAAM,EAAE,GAAC,YAAY,QAmC/B"}

package/src/engine/graphics/ecs/render_layers_compute_depth_range.js

@@ -0,0 +1,64 @@
+/**
+ * Accumulate the world-space depth range of every visible BVH-backed render
+ * layer's content that falls inside `frustum_planes`, measured along a camera's
+ * view direction.
+ *
+ * WHY THIS EXISTS
+ *
+ * `auto_set_camera_clipping_planes` and `extend_shadow_camera_near_for_casters`
+ * each restated two things verbatim:
+ *
+ *  - the three.js matrix-layout invariant that a camera's view direction is the
+ *    negated third column of `matrixWorld` (`-m[8], -m[9], -m[10]`) and its
+ *    position is the fourth (`m[12..14]`). That is vendor layout knowledge and
+ *    belongs in one place, not restated at every site that needs a depth plane.
+ *  - the layer sweep itself, including the `+Infinity / -Infinity` sentinel
+ *    initialisation and the two guards (`layer.state.visible`,
+ *    `layer.compute_depth_range === null`).
+ *
+ * Callers keep their own clamping policy — the auto-clip applies hysteresis and
+ * user outer bounds, the shadow fit only ever pulls `near` closer — which is
+ * the part that genuinely differs between them.
+ *
+ * Runs once per camera per frame. The cost is dominated by the BVH walks inside
+ * each layer's `compute_depth_range`, not by this wrapper.
+ *
+ * @param {{near: number, far: number}} out_range written with the accumulated range; `near` stays `+Infinity` and `far` stays `-Infinity` when no layer contributes
+ * @param {RenderLayerManager} layers
+ * @param {Float32Array} frustum_planes 6 planes in flat form (24 floats), in world space
+ * @param {number[]|Float32Array} matrix_world_elements the camera's `matrixWorld.elements`
+ */
+export function render_layers_compute_depth_range(
+    out_range,
+    layers,
+    frustum_planes,
+    matrix_world_elements
+) {
+    // Depth plane: passes through the camera position, normal pointing along the
+    // view direction (-Z in camera local). A world-space point's distance to
+    // this plane equals its signed depth in front of the camera.
+    const m = matrix_world_elements;
+
+    const nx = -m[8];
+    const ny = -m[9];
+    const nz = -m[10];
+
+    const plane_constant = -(nx * m[12] + ny * m[13] + nz * m[14]);
+
+    out_range.near = Number.POSITIVE_INFINITY;
+    out_range.far = Number.NEGATIVE_INFINITY;
+
+    layers.traverse((layer) => {
+        if (!layer.state.visible) {
+            return;
+        }
+
+        const compute = layer.compute_depth_range;
+
+        if (compute === null) {
+            return;
+        }
+
+        compute(out_range, frustum_planes, nx, ny, nz, plane_constant);
+    });
+}

package/src/engine/graphics/ecs/trail2d/Trail2DSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Trail2DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail2d/Trail2DSystem.js"],"names":[],"mappings":";AA0BA;IAmCI;;;OAGG;IACH,4BA4BC;IAlED,oDAAoC;IAEpC,iHAGE;IAEF;;;OAGG;IACH,WAFU,4BAA4B,CAES;IAE/C;;;;OAIG;IACH,wBAAiC;IAGjC;;;;OAIG;IACH,oBAAgB;IAEhB;;;OAGG;IACH,YAAgB;IAcZ;;;;OAIG;IACH,iBAAsB;IAEtB;;;OAGG;IACH,UAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,2CAmBC;IAED,4CAIC;IAED;;;;;OAKG;IACH,sBAsDC;IAED;;;;;OAKG;IACH,YAHW,OAAO,aADP,SAAS,YAET,MAAM,QAahB;IAED;;;;;OAKG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAShB;IAED;;;;OAIG;IACH,yBAHW,OAAO,aACP,SAAS,QAoCnB;IAED,6BAWC;CACJ;uBAvQsB,wBAAwB;0BACrB,qCAAqC;oBAY3C,cAAc;4CAdU,uDAAuD;6CAYtD,yDAAyD;+BARvE,yBAAyB"}
+{"version":3,"file":"Trail2DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail2d/Trail2DSystem.js"],"names":[],"mappings":";AA0BA;IAmCI;;;OAGG;IACH,4BA4BC;IAlED,oDAAoC;IAEpC,iHAGE;IAEF;;;OAGG;IACH,WAFU,4BAA4B,CAES;IAE/C;;;;OAIG;IACH,wBAAiC;IAGjC;;;;OAIG;IACH,oBAAgB;IAEhB;;;OAGG;IACH,YAAgB;IAcZ;;;;OAIG;IACH,iBAAsB;IAEtB;;;OAGG;IACH,UAFU,cAAc,CAEO;IAE/B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,2CAgBC;IAED,4CAIC;IAED;;;;;OAKG;IACH,sBAsDC;IAED;;;;;OAKG;IACH,YAHW,OAAO,aADP,SAAS,YAET,MAAM,QAahB;IAED;;;;;OAKG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAShB;IAED;;;;OAIG;IACH,yBAHW,OAAO,aACP,SAAS,QAoCnB;IAED,6BAWC;CACJ;uBApQsB,wBAAwB;0BACrB,qCAAqC;oBAY3C,cAAc;4CAdU,uDAAuD;6CAYtD,yDAAyD;+BARvE,yBAAyB"}

package/src/engine/graphics/ecs/trail2d/Trail2DSystem.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
+import { make_bvh_depth_range_computer } from "../make_bvh_depth_range_computer.js";
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { clamp } from "../../../../core/math/clamp.js";
 import { max2 } from "../../../../core/math/max2.js";
@@ -106,10 +106,7 @@ class Trail2DSystem extends System {
             }
         );
 
-        const bvh = this.bvh;
-        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
-            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
-        };
+        this.renderLayer.compute_depth_range = make_bvh_depth_range_computer(this.bvh);
 
         this.__ribbon_plugin = await this.__engine.plugins.acquire(RibbonXPlugin);
     }

package/src/engine/graphics/ecs/trail3d/Trail3DSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Trail3DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail3d/Trail3DSystem.js"],"names":[],"mappings":";AAmDA;IAkCI;;;OAGG;IACH,4BAkBC;IAvDD,oDAAoC;IAEpC,iHAGE;IAEF;;OAEG;IACH,WAFU,0BAA0B,CAES;IAiB7C;;;OAGG;IACH,YAAgB;IAeZ;;OAEG;IACH,UAFU,cAAc,CAEO;IAE/B;;OAEG;IACH,aAFU,cAAY,IAAI,CAEH;IAG3B,2CAmBC;IAED,4CAIC;IA4DD;;;;OAIG;IACH,YAJW,OAAO,aACP,SAAS,YACT,MAAM,QAgBhB;IAED;;;;OAIG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAQhB;IAED;;;OAGG;IACH,yBAHW,OAAO,aACP,SAAS,QAiCnB;IAED,6BAWC;;CACJ;uBA7QsB,wBAAwB;0BACrB,qCAAqC;oBAQ3C,cAAc;4CAVU,uDAAuD;2CAMxD,0DAA0D;+BAFtE,yBAAyB"}
+{"version":3,"file":"Trail3DSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/trail3d/Trail3DSystem.js"],"names":[],"mappings":";AAmDA;IAkCI;;;OAGG;IACH,4BAkBC;IAvDD,oDAAoC;IAEpC,iHAGE;IAEF;;OAEG;IACH,WAFU,0BAA0B,CAES;IAiB7C;;;OAGG;IACH,YAAgB;IAeZ;;OAEG;IACH,UAFU,cAAc,CAEO;IAE/B;;OAEG;IACH,aAFU,cAAY,IAAI,CAEH;IAG3B,2CAgBC;IAED,4CAIC;IA4DD;;;;OAIG;IACH,YAJW,OAAO,aACP,SAAS,YACT,MAAM,QAgBhB;IAED;;;;OAIG;IACH,kBAJW,OAAO,aACP,SAAS,UACT,MAAM,QAQhB;IAED;;;OAGG;IACH,yBAHW,OAAO,aACP,SAAS,QAiCnB;IAED,6BAWC;;CACJ;uBA1QsB,wBAAwB;0BACrB,qCAAqC;oBAQ3C,cAAc;4CAVU,uDAAuD;2CAMxD,0DAA0D;+BAFtE,yBAAyB"}

package/src/engine/graphics/ecs/trail3d/Trail3DSystem.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
+import { make_bvh_depth_range_computer } from "../make_bvh_depth_range_computer.js";
 import Vector3 from '../../../../core/geom/Vector3.js';
 import { clamp } from "../../../../core/math/clamp.js";
 import { max2 } from "../../../../core/math/max2.js";
@@ -120,10 +120,7 @@ class Trail3DSystem extends System {
             }
         );
 
-        const bvh = this.bvh;
-        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
-            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
-        };
+        this.renderLayer.compute_depth_range = make_bvh_depth_range_computer(this.bvh);
 
         this.#tube_plugin = await this.#engine.plugins.acquire(TubeXPlugin);
     }

package/src/engine/graphics/ecs/water/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAaA;IAyBI;;;;OAIG;IACH,sCAmBC;IAhDD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,wBAA2B;IAK/B,4CASC;IAED,2CAwEC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBArSsB,wBAAwB;kBAM7B,YAAY;oBARV,mCAAmC"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAaA;IAyBI;;;;OAIG;IACH,sCAmBC;IAhDD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAEvB;;;;OAIG;IACH,wBAA2B;IAK/B,4CASC;IAED,2CAqEC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBAlSsB,wBAAwB;kBAM7B,YAAY;oBARV,mCAAmC"}

package/src/engine/graphics/ecs/water/WaterSystem.js

@@ -1,7 +1,7 @@
 import { BackSide, PlaneBufferGeometry } from 'three';
 import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { bvh_query_depth_range_in_frustum } from "../../../../core/bvh2/bvh3/query/bvh_query_depth_range_in_frustum.js";
+import { make_bvh_depth_range_computer } from "../make_bvh_depth_range_computer.js";
 import { System } from '../../../ecs/System.js';
 import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
 import { make_bvh_visibility_builder } from "../../render/make_bvh_visibility_builder.js";
@@ -106,10 +106,7 @@ class WaterSystem extends System {
             }
         )
 
-        const bvh = this.bvh;
-        this.renderLayer.compute_depth_range = (result, frustum, nx, ny, nz, c) => {
-            bvh_query_depth_range_in_frustum(result, bvh, frustum, nx, ny, nz, c);
-        };
+        this.renderLayer.compute_depth_range = make_bvh_depth_range_computer(this.bvh);
 
 
         const self = this;

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh32_geometry_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;GAeG;AACH,8FAXW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,KACpC,MAAM,KACN,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,OAAO,CAoNnB"}
+{"version":3,"file":"bvh32_geometry_nearest.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;GAeG;AACH,8FAXW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,KACpC,MAAM,KACN,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,OAAO,CAiJnB"}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_nearest.js

@@ -1,22 +1,17 @@
-import { assert } from "../../../../../core/assert.js";
-import {
-    typed_array_value_denormalize
-} from "../../../../../core/collection/array/typed/typed_array_value_denormalize.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import {
     aabb3_unsigned_distance_sqr_to_point
 } from "../../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
-import { tri3_closest_point_barycentric } from "../../../../../core/geom/3d/triangle/tri3_closest_point_barycentric.js";
-import { tri3_compute_normal } from "../../../../../core/geom/3d/triangle/tri3_compute_normal.js";
-import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
+import { read_triangle_vertices } from "../read_triangle_vertices.js";
+import { nearest_point_on_triangle_record } from "./nearest_point_on_triangle_record.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
- *
- * @type {number[]}
+ * `ax, ay, az, bx, by, bz, cx, cy, cz` of the triangle currently being visited
+ * @type {Float64Array}
  */
-const v3_scratch_0 = [];
+const triangle_scratch = new Float64Array(9);
 
 /**
  * Get the nearest point on the geometry, relative to query point
@@ -149,97 +144,30 @@ export function bvh32_geometry_nearest(
             // leaf node
             // read triangle data
             const triangle_index = uint32[node_address + 6];
-            const index3 = triangle_index * 3;
-
-            let a, b, c;
-            if (indices !== undefined) {
-                assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
-
-                a = indices[index3];
-                b = indices[index3 + 1];
-                c = indices[index3 + 2];
-            } else {
-                // implicit indices
-                a = index3;
-                b = index3 + 1;
-                c = index3 + 2;
-            }
-
-            const a_address = a * vertex_stride + vertex_offset;
-            const b_address = b * vertex_stride + vertex_offset;
-            const c_address = c * vertex_stride + vertex_offset;
-
-            assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
-            assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
-            assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
-
-            let ax = vertices[a_address];
-            let ay = vertices[a_address + 1];
-            let az = vertices[a_address + 2];
 
-            let bx = vertices[b_address];
-            let by = vertices[b_address + 1];
-            let bz = vertices[b_address + 2];
-
-            let cx = vertices[c_address];
-            let cy = vertices[c_address + 1];
-            let cz = vertices[c_address + 2];
-
-            // denormalize if necessary
-            if (vertex_data_normalized) {
-                ax = typed_array_value_denormalize(ax, vertices);
-                ay = typed_array_value_denormalize(ay, vertices);
-                az = typed_array_value_denormalize(az, vertices);
-
-                bx = typed_array_value_denormalize(bx, vertices);
-                by = typed_array_value_denormalize(by, vertices);
-                bz = typed_array_value_denormalize(bz, vertices);
-
-                cx = typed_array_value_denormalize(cx, vertices);
-                cy = typed_array_value_denormalize(cy, vertices);
-                cz = typed_array_value_denormalize(cz, vertices);
-            }
+            read_triangle_vertices(
+                triangle_scratch, 0,
+                vertices, vertex_offset, vertex_stride,
+                vertex_data_normalized,
+                indices,
+                triangle_index
+            );
 
-            tri3_closest_point_barycentric(
-                v3_scratch_0, 0,
+            const distance_to_triangle_sqr = nearest_point_on_triangle_record(
+                result,
+                triangle_index,
+                nearest_distance_sqr,
                 x, y, z,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
+                triangle_scratch[0], triangle_scratch[1], triangle_scratch[2],
+                triangle_scratch[3], triangle_scratch[4], triangle_scratch[5],
+                triangle_scratch[6], triangle_scratch[7], triangle_scratch[8]
             );
 
-            const u = v3_scratch_0[0];
-            const v = v3_scratch_0[1];
-            const w = 1 - u - v;
-
-            // construct edge
-
-            const contact_x = ax * u + bx * v + cx * w;
-            const contact_y = ay * u + by * v + cy * w;
-            const contact_z = az * u + bz * v + cz * w;
+            if (distance_to_triangle_sqr < nearest_distance_sqr) {
+                nearest_distance_sqr = distance_to_triangle_sqr;
 
-            const distance_to_triangle_sqr = v3_distance_sqr(
-                contact_x, contact_y, contact_z,
-                x, y, z
-            );
-
-            if (distance_to_triangle_sqr >= nearest_distance_sqr) {
-                continue;
+                got_a_hit = true;
             }
-
-            nearest_distance_sqr = distance_to_triangle_sqr;
-
-            result.position.set(contact_x, contact_y, contact_z);
-
-            tri3_compute_normal(result.normal, 0,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
-            );
-
-            result.index = triangle_index;
-
-            got_a_hit = true;
         }
     } while (stack.pointer > stack_top);
 

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh32_geometry_overlap_clipping_volume.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;GAYG;AACH,uFAVW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,UACpC,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,GACJ,OAAO,CAuFnB"}
+{"version":3,"file":"bvh32_geometry_overlap_clipping_volume.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;GAYG;AACH,uFAVW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,UACpC,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,GACJ,OAAO,CA2CnB"}