@woosh/meep-engine 2.169.0 → 2.169.2

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

@@ -109,11 +109,11 @@ export class ShadedGeometrySystem extends System<any> {
      * @param {number} direction_x
      * @param {number} direction_y
      * @param {number} direction_z
-     * @param {function(entity:number, mesh:ShadedGeometry):boolean} [filter_function]
+     * @param {(entity: number, mesh: ShadedGeometry) => boolean} [filter_function]
      * @param {*} [filter_function_context]
      * @returns {{entity:number, mesh:ShadedGeometry, contact: SurfacePoint3}[]}
      */
-    raycast(origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, filter_function?: typeof returnTrue, filter_function_context?: any): {
+    raycast(origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, filter_function?: (entity: number, mesh: ShadedGeometry) => boolean, filter_function_context?: any): {
         entity: number;
         mesh: ShadedGeometry;
         contact: SurfacePoint3;
@@ -127,11 +127,11 @@ export class ShadedGeometrySystem extends System<any> {
      * @param {number} direction_x
      * @param {number} direction_y
      * @param {number} direction_z
-     * @param {function(entity:number, mesh:ShadedGeometry):boolean} [filter_function]
+     * @param {(entity: number, mesh: ShadedGeometry) => boolean} [filter_function]
      * @param {*} [filter_function_context]
      * @returns {{entity:number, mesh:ShadedGeometry}|undefined}
      */
-    raycastNearest(contact: SurfacePoint3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, filter_function?: typeof returnTrue, filter_function_context?: any): {
+    raycastNearest(contact: SurfacePoint3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, filter_function?: (entity: number, mesh: ShadedGeometry) => boolean, filter_function_context?: any): {
         entity: number;
         mesh: ShadedGeometry;
     } | undefined;
@@ -142,6 +142,5 @@ import { Transform } from "../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "./ShadedGeometry.js";
 import Task from "../../../../core/process/task/Task.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { returnTrue } from "../../../../core/function/returnTrue.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 //# sourceMappingURL=ShadedGeometrySystem.d.ts.map

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,uEAGJ;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,uEAGJ;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;2BAQ5B,yCAAyC;8BAEtC,2CAA2C"}
+{"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,2CAkCC;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;uBApiBsB,wBAAwB;0BACrB,qCAAqC;+BAIhC,qBAAqB;iBATnC,uCAAuC;oBAZpC,mCAAmC;8BAUzB,2CAA2C"}

package/src/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.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 { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
 import {
     bvh_query_user_data_intersects_frustum
@@ -265,10 +265,7 @@ export class ShadedGeometrySystem extends System {
             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);
-        };
+        this.__render_layer.compute_depth_range = make_bvh_depth_range_computer(this.__bvh_binary);
 
         this.__optimization_task.state.set(TaskState.INITIAL);
         engine.executor.run(this.__optimization_task);
@@ -404,7 +401,7 @@ export class ShadedGeometrySystem extends System {
      * @param {number} direction_x
      * @param {number} direction_y
      * @param {number} direction_z
-     * @param {function(entity:number, mesh:ShadedGeometry):boolean} [filter_function]
+     * @param {(entity: number, mesh: ShadedGeometry) => boolean} [filter_function]
      * @param {*} [filter_function_context]
      * @returns {{entity:number, mesh:ShadedGeometry, contact: SurfacePoint3}[]}
      */
@@ -480,7 +477,7 @@ export class ShadedGeometrySystem extends System {
      * @param {number} direction_x
      * @param {number} direction_y
      * @param {number} direction_z
-     * @param {function(entity:number, mesh:ShadedGeometry):boolean} [filter_function]
+     * @param {(entity: number, mesh: ShadedGeometry) => boolean} [filter_function]
      * @param {*} [filter_function_context]
      * @returns {{entity:number, mesh:ShadedGeometry}|undefined}
      */

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"}

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

@@ -2,13 +2,17 @@ import { assert } from "../../../../../core/assert.js";
 import {
     bvh32_query_user_data_overlaps_clipping_volume
 } from "../../../../../core/bvh2/binary/2/bvh32_query_user_data_overlaps_clipping_volume.js";
-import {
-    typed_array_value_denormalize
-} from "../../../../../core/collection/array/typed/typed_array_value_denormalize.js";
 import { tri3_intersects_clipping_volume } from "../../../../../core/geom/3d/triangle/tri3_intersects_clipping_volume.js";
+import { read_triangle_vertices } from "../read_triangle_vertices.js";
 
 const scratch_array = []
 
+/**
+ * `ax, ay, az, bx, by, bz, cx, cy, cz` of the triangle currently being tested
+ * @type {Float64Array}
+ */
+const triangle_scratch = new Float64Array(9);
+
 /**
  *
  * @param {BinaryUint32BVH} bvh
@@ -40,66 +44,22 @@ export function bvh32_geometry_overlap_clipping_volume(
         planes, planes_offset, plane_count
     );
 
-    let a, b, c;
-
     for (let i = 0; i < hit_count; i++) {
         const triangle_index = scratch_array[i];
 
-        const index3 = triangle_index * 3;
-
-        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
+        );
 
         if (tri3_intersects_clipping_volume(
             planes, planes_offset, plane_count,
-            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]
         )) {
             return true;
         }

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

@@ -1 +1 @@
-{"version":3,"file":"bvh32_geometry_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAhBW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,YACpC,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA2GnB;8BAjI6B,8CAA8C"}
+{"version":3,"file":"bvh32_geometry_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_raycast.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAhBW,aAAa,kCAEb,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,YACpC,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA+DnB;8BA5F6B,8CAA8C"}

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

@@ -1,14 +1,18 @@
 import { assert } from "../../../../../core/assert.js";
 import { bvh32_query_user_data_ray } from "../../../../../core/bvh2/binary/2/bvh32_query_user_data_ray.js";
-import {
-    typed_array_value_denormalize
-} from "../../../../../core/collection/array/typed/typed_array_value_denormalize.js";
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { tri3_ray_intersection } from "../../../../../core/geom/3d/triangle/tri3_ray_intersection.js";
+import { read_triangle_vertices } from "../read_triangle_vertices.js";
 
 const scratch_array = []
 const scratch_hit = new SurfacePoint3()
 
+/**
+ * `ax, ay, az, bx, by, bz, cx, cy, cz` of the triangle currently being tested
+ * @type {Float64Array}
+ */
+const triangle_scratch = new Float64Array(9);
+
 /**
  *
  * @param {SurfacePoint3} result
@@ -53,68 +57,24 @@ export function bvh32_geometry_raycast(
 
     let best_distance_sqr = max_distance * max_distance;
 
-    let a, b, c;
-
     for (let i = 0; i < hit_count; i++) {
         const triangle_index = scratch_array[i];
 
-        const index3 = triangle_index * 3;
-
-        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
+        );
 
         const triangle_hit_found = tri3_ray_intersection(
             scratch_hit,
             origin_x, origin_y, origin_z,
             direction_x, direction_y, direction_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]
         )
 
         if (!triangle_hit_found) {