@woosh/meep-engine 2.117.35 → 2.117.37

package/build/meep.module.js

@@ -66531,13 +66531,19 @@ function bvh32_geometry_overlap_clipping_volume(
     return false;
 }
 
+/**
+ * 4-tuples
+ * @type {number[]}
+ */
 const scratch_planes = [];
 
 class GeometrySpatialQueryAccelerator {
-    constructor(cache_size = 100 * 1024 * 1024) {
+    constructor(
+        cache_size = 100 * 1024 * 1024
+    ) {
 
         /**
-         *
+         * @private
          * @type {Cache<THREE.BufferGeometry, BinaryUint32BVH>}
          */
         this.cache = new Cache({
@@ -66583,8 +66589,7 @@ class GeometrySpatialQueryAccelerator {
      */
     queryContainmentViaClippingPlanes(geometry, planes) {
 
-
-        const bvh = this.__acquireBVH(geometry);
+        const bvh = this.acquire_bvh(geometry);
 
         read_three_planes_to_array(planes, scratch_planes);
 
@@ -66658,7 +66663,7 @@ class GeometrySpatialQueryAccelerator {
         let bvh;
 
         try {
-            bvh = this.__acquireBVH(geometry);
+            bvh = this.acquire_bvh(geometry);
         } catch (e) {
             return false;
         }
@@ -66723,11 +66728,22 @@ class GeometrySpatialQueryAccelerator {
     }
 
     /**
-     * @private
+     * Destroys cache for a given geometry, useful for when geometry changes and cache needs to be invalidated
+     * @param {THREE.BufferGeometry} geometry
+     * @returns {boolean}
+     */
+    cache_remove_geometry(geometry) {
+
+        return this.cache.remove(geometry);
+
+    }
+
+    /**
+     * NOTE: do not modify the BVH
      * @param {THREE.BufferGeometry} geometry
      * @returns {BinaryUint32BVH}
      */
-    __acquireBVH(geometry) {
+    acquire_bvh(geometry) {
 
         const existing = this.cache.get(geometry);
 
@@ -66735,7 +66751,7 @@ class GeometrySpatialQueryAccelerator {
             return existing;
         }
 
-        const bvh = this.__buildBVH(geometry);
+        const bvh = this.__build_bvh(geometry);
 
         this.cache.put(geometry, bvh);
 
@@ -66747,7 +66763,7 @@ class GeometrySpatialQueryAccelerator {
      * @param {THREE.BufferGeometry} geometry
      * @returns {BinaryUint32BVH}
      */
-    __buildBVH(geometry) {
+    __build_bvh(geometry) {
         const bvh = new BinaryUint32BVH();
 
         const position_attribute = geometry.getAttribute('position');

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.117.35",
+  "version": "2.117.37",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,kEAPW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,2BACN,MAAM,GACJ,MAAM,CAsElB"}
+{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,kEAPW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,2BACN,MAAM,GACJ,MAAM,CA+ElB"}

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.js

@@ -35,13 +35,22 @@ export function ebvh_build_hierarchy(
     while (unprocessed_node_count > 1) {
 
         for (let i = 0; i < sah_optimization_level; i++) {
+
             // sort intermediate nodes using small locality and SAH metric
-            const offset = (i<<1) & 3;
-            const swap_count = ebvh_nodes_sort_sah_local4(bvh, unprocessed_nodes, offset, unprocessed_node_count - offset);
 
-            if(swap_count === 0){
+            const offset = (i << 1) & 3;
+
+            const swap_count = ebvh_nodes_sort_sah_local4(
+                bvh,
+                unprocessed_nodes,
+                offset,
+                unprocessed_node_count - offset
+            );
+
+            if (swap_count === 0) {
                 break;
             }
+
         }
 
         let added_nodes = 0;

package/src/core/geom/3d/Ray3.js

@@ -2,9 +2,9 @@ import { assert } from "../../assert.js";
 import { array_copy } from "../../collection/array/array_copy.js";
 import { array_range_equal_strict } from "../../collection/array/array_range_equal_strict.js";
 import { computeHashFloatArray } from "../../math/hash/computeHashFloatArray.js";
+import { v3_array_matrix4_rotate } from "../vec3/v3_array_matrix4_rotate.js";
 import { v3_array_normalize } from "../vec3/v3_array_normalize.js";
 import { v3_matrix4_multiply } from "../vec3/v3_matrix4_multiply.js";
-import { v3_matrix4_rotate } from "../vec3/v3_matrix4_rotate.js";
 import { ray3_interval_array_apply_matrix4 } from "./ray/ray3_interval_array_apply_matrix4.js";
 
 /**
@@ -175,7 +175,7 @@ export class Ray3 extends Float32Array {
 
             // special case
             v3_matrix4_multiply(this, 0, this, 0, m4);
-            v3_matrix4_rotate(this, 3, this, 3, m4);
+            v3_array_matrix4_rotate(this, 3, this, 3, m4);
 
         }
     }

package/src/core/geom/3d/plane/plane3_matrix4_project.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {number[]|Float64Array|Float32Array} destination
+ * @param {number} destination_offset
+ * @param {number[]|Float32Array|Float64Array} matrix
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ */
+export function plane3_matrix4_project(destination: number[] | Float64Array | Float32Array, destination_offset: number, matrix: number[] | Float32Array | Float64Array, x: number, y: number, z: number, w: number): void;
+//# sourceMappingURL=plane3_matrix4_project.d.ts.map

package/src/core/geom/3d/plane/plane3_matrix4_project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plane3_matrix4_project.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/plane3_matrix4_project.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,oDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB"}

package/src/core/geom/3d/plane/plane3_matrix4_project.js

@@ -0,0 +1,33 @@
+import { v3_dot_array_array } from "../../vec3/v3_dot_array_array.js";
+import { v3_matrix4_multiply } from "../../vec3/v3_matrix4_multiply.js";
+import { v3_matrix4_rotate } from "../../vec3/v3_matrix4_rotate.js";
+import { v3_multiply_scalar } from "../../vec3/v3_multiply_scalar.js";
+
+const scratch_v3_0 = new Float32Array(3);
+
+/**
+ *
+ * @param {number[]|Float64Array|Float32Array} destination
+ * @param {number} destination_offset
+ * @param {number[]|Float32Array|Float64Array} matrix
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ */
+export function plane3_matrix4_project(
+    destination, destination_offset,
+    matrix,
+    x, y, z, w,
+) {
+
+    // build reference point in the new pane
+    v3_multiply_scalar(scratch_v3_0, 0, x, y, z, -w);
+    v3_matrix4_multiply(scratch_v3_0, 0, scratch_v3_0, 0, matrix);
+
+    // construct rotation matrix for the normal
+    v3_matrix4_rotate(destination, destination_offset, x, y, z, matrix);
+
+    // figure out new planar offset using new orientation and a reference point
+    destination[destination_offset + 3] = -v3_dot_array_array(scratch_v3_0, 0, destination, destination_offset);
+}

package/src/core/geom/vec3/v3_array_matrix4_rotate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ * NOTE: produces a normalized vector
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_array_matrix4_rotate(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number, m4: number[] | Float32Array): void;
+//# sourceMappingURL=v3_array_matrix4_rotate.d.ts.map

package/src/core/geom/vec3/v3_array_matrix4_rotate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_array_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_array_matrix4_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,gDANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAY/B"}

package/src/core/geom/vec3/v3_array_matrix4_rotate.js

@@ -0,0 +1,22 @@
+import { v3_matrix4_rotate } from "./v3_matrix4_rotate.js";
+
+/**
+ * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ * NOTE: produces a normalized vector
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} input
+ * @param {number} input_offset
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_array_matrix4_rotate(
+    output, output_offset,
+    input, input_offset,
+    m4
+) {
+    const x = input[input_offset];
+    const y = input[input_offset + 1];
+    const z = input[input_offset + 2];
+
+    v3_matrix4_rotate(output,output_offset,x,y,z,m4);
+}

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts

@@ -2,9 +2,10 @@
  * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
  * @param {number[]|Float32Array} output
  * @param {number} output_offset
- * @param {number[]|Float32Array} input
- * @param {number} input_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
  * @param {number[]|Float32Array} m4
  */
-export function v3_matrix4_rotate(output: number[] | Float32Array, output_offset: number, input: number[] | Float32Array, input_offset: number, m4: number[] | Float32Array): void;
+export function v3_matrix4_rotate(output: number[] | Float32Array, output_offset: number, x: number, y: number, z: number, m4: number[] | Float32Array): void;
 //# sourceMappingURL=v3_matrix4_rotate.d.ts.map

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,0CANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAoB/B"}
+{"version":3,"file":"v3_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAkB/B"}

package/src/core/geom/vec3/v3_matrix4_rotate.js

@@ -4,26 +4,25 @@ import { v3_length } from "./v3_length.js";
  * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
  * @param {number[]|Float32Array} output
  * @param {number} output_offset
- * @param {number[]|Float32Array} input
- * @param {number} input_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
  * @param {number[]|Float32Array} m4
  */
 export function v3_matrix4_rotate(
     output, output_offset,
-    input, input_offset,
+    x, y, z,
     m4
 ) {
-    const x = input[input_offset];
-    const y = input[input_offset + 1];
-    const z = input[input_offset + 2];
 
     const _x = m4[0] * x + m4[4] * y + m4[8] * z;
     const _y = m4[1] * x + m4[5] * y + m4[9] * z;
     const _z = m4[2] * x + m4[6] * y + m4[10] * z;
 
+    // perform normalization
     const norm = 1 / v3_length(_x, _y, _z);
 
     output[output_offset] = _x * norm;
     output[output_offset + 1] = _y * norm;
     output[output_offset + 2] = _z * norm;
-}
+}

package/src/core/geom/vec3/v3_multiply_scalar.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number[]|Float64Array|Float32Array} result
+ * @param {number} result_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} scalar
+ */
+export function v3_multiply_scalar(result: number[] | Float64Array | Float32Array, result_offset: number, x: number, y: number, z: number, scalar: number): void;
+//# sourceMappingURL=v3_multiply_scalar.d.ts.map

package/src/core/geom/vec3/v3_multiply_scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_multiply_scalar.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_multiply_scalar.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,2CAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,QAWhB"}

package/src/core/geom/vec3/v3_multiply_scalar.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {number[]|Float64Array|Float32Array} result
+ * @param {number} result_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} scalar
+ */
+export function v3_multiply_scalar(
+    result, result_offset,
+    x, y, z, scalar
+) {
+
+    result[result_offset] = x * scalar;
+    result[result_offset + 1] = y * scalar;
+    result[result_offset + 2] = z * scalar;
+
+}

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_unindexed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_compute_vertex_normals_unindexed.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_unindexed.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,qEAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,gBAC3B,MAAM,QAgChB"}
+{"version":3,"file":"geometry_compute_vertex_normals_unindexed.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_unindexed.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,qEAJW,MAAO,MAAM,CAAC,GAAC,YAAY,WAC3B,MAAO,MAAM,CAAC,GAAC,YAAY,gBAC3B,MAAM,QA8BhB"}

package/src/engine/graphics/geometry/buffered/geometry_compute_vertex_normals_unindexed.js

@@ -1,6 +1,5 @@
 import { array_copy } from "../../../../core/collection/array/array_copy.js";
 import { geometry_construct_triangle_normal } from "../geometry_construct_triangle_normal.js";
-import { v3_array_normalize_many } from "./v3_array_normalize_many.js";
 
 const scratch_v3 = new Float64Array(3);
 
@@ -36,7 +35,5 @@ export function geometry_compute_vertex_normals_unindexed(
 
     }
 
-    // ensure unit magnitude
-
-    v3_array_normalize_many(normals);
+    // no need to normalize, that's already handled during normal construction for each triangle
 }

package/src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.d.ts

@@ -1,25 +1,78 @@
-import {BufferGeometry, Plane} from "three";
-import {SurfacePoint3} from "../../../../../core/geom/3d/SurfacePoint3";
-import Vector3 from "../../../../../core/geom/Vector3";
-
-export class GeometrySpatialQueryAccelerator {
-    constructor(cache_size?: number)
-
-    queryContainmentViaClippingPlanes(geometry: BufferGeometry, planes: Plane[]): boolean
-
-    queryRaycastNearest(destination: SurfacePoint3, geometry: BufferGeometry, ray_origin: Vector3, ray_direction: Vector3): boolean
-
-    queryRaycastNearest_primitive(
-        destination: SurfacePoint3,
-        geometry: BufferGeometry,
-        origin_x: number, origin_y: number, origin_z: number,
-        direction_x: number, direction_y: number, direction_z: number
-    ): boolean
-
-    /**
-     * In bytes
-     */
-    cache_size: number
-
-    static INSTANCE: GeometrySpatialQueryAccelerator;
-}
+export class GeometrySpatialQueryAccelerator {
+    constructor(cache_size?: number);
+    /**
+     * @private
+     * @type {Cache<THREE.BufferGeometry, BinaryUint32BVH>}
+     */
+    private cache;
+    /**
+     *
+     * @param {number} value in bytes
+     */
+    set cache_size(arg: number);
+    /**
+     *
+     * @return {number} in bytes
+     */
+    get cache_size(): number;
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     * @param {Plane[]} planes
+     * @returns {boolean} true means some overlap exists, false otherwise
+     */
+    queryContainmentViaClippingPlanes(geometry: THREE.BufferGeometry, planes: Plane[]): boolean;
+    /**
+     *
+     * @param {SurfacePoint3} destination
+     * @param {THREE.BufferGeometry} geometry
+     * @param {number[]|ArrayLike<number>|Float32Array} ray 6 component vector, [origin_x, origin_y, origin_z, direction_x, direction_y, direction_z]
+     * @return {boolean}
+     */
+    queryRaycastNearest_array(destination: SurfacePoint3, geometry: THREE.BufferGeometry, ray: number[] | ArrayLike<number> | Float32Array): boolean;
+    /**
+     *
+     * @param {SurfacePoint3} destination
+     * @param {THREE.BufferGeometry} geometry
+     * @param {number} ray_origin_x
+     * @param {number} ray_origin_y
+     * @param {number} ray_origin_z
+     * @param {number} ray_direction_x
+     * @param {number} ray_direction_y
+     * @param {number} ray_direction_z
+     * @return {boolean}
+     */
+    queryRaycastNearest_primitive(destination: SurfacePoint3, geometry: THREE.BufferGeometry, ray_origin_x: number, ray_origin_y: number, ray_origin_z: number, ray_direction_x: number, ray_direction_y: number, ray_direction_z: number): boolean;
+    /**
+     * Get the nearest ray intersection
+     * @param {SurfacePoint3} destination
+     * @param {THREE.BufferGeometry} geometry
+     * @param {Vector3} ray_origin
+     * @param {Vector3} ray_direction
+     * @returns {boolean} true if hit detected, false otherwise
+     */
+    queryRaycastNearest(destination: SurfacePoint3, geometry: THREE.BufferGeometry, ray_origin: Vector3, ray_direction: Vector3): boolean;
+    /**
+     * Destroys cache for a given geometry, useful for when geometry changes and cache needs to be invalidated
+     * @param {THREE.BufferGeometry} geometry
+     * @returns {boolean}
+     */
+    cache_remove_geometry(geometry: THREE.BufferGeometry): boolean;
+    /**
+     * NOTE: do not modify the BVH
+     * @param {THREE.BufferGeometry} geometry
+     * @returns {BinaryUint32BVH}
+     */
+    acquire_bvh(geometry: THREE.BufferGeometry): BinaryUint32BVH;
+    /**
+     * @private
+     * @param {THREE.BufferGeometry} geometry
+     * @returns {BinaryUint32BVH}
+     */
+    private __build_bvh;
+}
+export namespace GeometrySpatialQueryAccelerator {
+    let INSTANCE: GeometrySpatialQueryAccelerator;
+}
+import { BinaryUint32BVH } from "../../../../../core/bvh2/binary/2/BinaryUint32BVH.js";
+//# sourceMappingURL=GeometrySpatialQueryAccelerator.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"GeometrySpatialQueryAccelerator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js"],"names":[],"mappings":"AAYA;IACI,iCAuBC;IArBG;;;OAGG;IACH,OAFU,MAAM,MAAM,cAAc,EAAE,eAAe,CAAC,CAiBpD;IAIN;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,4CAJW,MAAM,cAAc,UACpB,OAAO,GACL,OAAO,CAwCnB;IAED;;;;;;OAMG;IACH,gEAJW,MAAM,cAAc,OACpB,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACtC,OAAO,CASlB;IAED;;;;;;;;;;;OAWG;IACH,oEATW,MAAM,cAAc,gBACpB,MAAM,gBACN,MAAM,gBACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,GACL,OAAO,CAwDlB;IAED;;;;;;;OAOG;IACH,0DALW,MAAM,cAAc,gDAGlB,OAAO,CAcnB;IAED;;;;OAIG;IACH,qBAeC;IAED;;;;OAIG;IACH,mBAoBC;CAEJ;;kBAIS,+BAA+B;;sBAjQnB,oCAAoC;gCAD1B,sDAAsD"}
+{"version":3,"file":"GeometrySpatialQueryAccelerator.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/GeometrySpatialQueryAccelerator.js"],"names":[],"mappings":"AAgBA;IACI,iCAyBC;IArBG;;;OAGG;IACH,cAeE;IAIN;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;OAKG;IACH,4CAJW,MAAM,cAAc,UACpB,OAAO,GACL,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,gEAJW,MAAM,cAAc,OACpB,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GACtC,OAAO,CASlB;IAED;;;;;;;;;;;OAWG;IACH,oEATW,MAAM,cAAc,gBACpB,MAAM,gBACN,MAAM,gBACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,GACL,OAAO,CAwDlB;IAED;;;;;;;OAOG;IACH,0DALW,MAAM,cAAc,gDAGlB,OAAO,CAcnB;IAED;;;;OAIG;IACH,gCAHW,MAAM,cAAc,GAClB,OAAO,CAMnB;IAED;;;;OAIG;IACH,sBAHW,MAAM,cAAc,GAClB,eAAe,CAiB3B;IAED;;;;OAIG;IACH,oBAoBC;CAEJ;;kBAIS,+BAA+B;;gCAlRT,sDAAsD"}

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

@@ -8,13 +8,19 @@ import { deinterleaveBufferAttribute } from "../deinterleaveBufferAttribute.js";
 import { bvh32_geometry_overlap_clipping_volume } from "./bvh32_geometry_overlap_clipping_volume.js";
 import { bvh32_geometry_raycast } from "./bvh32_geometry_raycast.js";
 
+/**
+ * 4-tuples
+ * @type {number[]}
+ */
 const scratch_planes = []
 
 export class GeometrySpatialQueryAccelerator {
-    constructor(cache_size = 100 * 1024 * 1024) {
+    constructor(
+        cache_size = 100 * 1024 * 1024
+    ) {
 
         /**
-         *
+         * @private
          * @type {Cache<THREE.BufferGeometry, BinaryUint32BVH>}
          */
         this.cache = new Cache({
@@ -62,8 +68,7 @@ export class GeometrySpatialQueryAccelerator {
         assert.notNull(geometry, 'geometry');
         assert.defined(geometry, 'geometry');
 
-
-        const bvh = this.__acquireBVH(geometry);
+        const bvh = this.acquire_bvh(geometry);
 
         read_three_planes_to_array(planes, scratch_planes);
 
@@ -139,7 +144,7 @@ export class GeometrySpatialQueryAccelerator {
         let bvh;
 
         try {
-            bvh = this.__acquireBVH(geometry);
+            bvh = this.acquire_bvh(geometry);
         } catch (e) {
             console.error(e);
             return false;
@@ -205,11 +210,22 @@ export class GeometrySpatialQueryAccelerator {
     }
 
     /**
-     * @private
+     * Destroys cache for a given geometry, useful for when geometry changes and cache needs to be invalidated
+     * @param {THREE.BufferGeometry} geometry
+     * @returns {boolean}
+     */
+    cache_remove_geometry(geometry) {
+
+        return this.cache.remove(geometry);
+
+    }
+
+    /**
+     * NOTE: do not modify the BVH
      * @param {THREE.BufferGeometry} geometry
      * @returns {BinaryUint32BVH}
      */
-    __acquireBVH(geometry) {
+    acquire_bvh(geometry) {
         assert.notNull(geometry, 'geometry');
         assert.defined(geometry, 'geometry');
 
@@ -219,7 +235,7 @@ export class GeometrySpatialQueryAccelerator {
             return existing;
         }
 
-        const bvh = this.__buildBVH(geometry);
+        const bvh = this.__build_bvh(geometry);
 
         this.cache.put(geometry, bvh);
 
@@ -231,7 +247,7 @@ export class GeometrySpatialQueryAccelerator {
      * @param {THREE.BufferGeometry} geometry
      * @returns {BinaryUint32BVH}
      */
-    __buildBVH(geometry) {
+    __build_bvh(geometry) {
         const bvh = new BinaryUint32BVH();
 
         const position_attribute = geometry.getAttribute('position');

package/src/engine/graphics/sh3/path_tracer/ray_hit_apply_transform.js

@@ -1,4 +1,4 @@
-import { v3_matrix4_rotate } from "../../../../core/geom/vec3/v3_matrix4_rotate.js";
+import { v3_array_matrix4_rotate } from "../../../../core/geom/vec3/v3_array_matrix4_rotate.js";
 
 
 /**
@@ -26,6 +26,6 @@ export function ray_hit_apply_transform(output, hit, m) {
     output[2] = result_p_z;
 
     // transform normal
-    v3_matrix4_rotate(output, 3, hit, 3, m);
+    v3_array_matrix4_rotate(output, 3, hit, 3, m);
 
 }

package/src/engine/graphics/sh3/path_tracer/texture/sample_material.js

@@ -1,7 +1,7 @@
 import { vec3 } from "gl-matrix";
 import { dataTypeFromTypedArray } from "../../../../../core/binary/type/dataTypeFromTypedArray.js";
+import { v3_array_matrix4_rotate } from "../../../../../core/geom/vec3/v3_array_matrix4_rotate.js";
 import { v3_distance_sqr } from "../../../../../core/geom/vec3/v3_distance_sqr.js";
-import { v3_matrix4_rotate } from "../../../../../core/geom/vec3/v3_matrix4_rotate.js";
 import { decode_attribute_value } from "../../../geometry/decode_attribute_value.js";
 import { geometry_construct_triangle_normal } from "../../../geometry/geometry_construct_triangle_normal.js";
 import { sample_triangle_attribute } from "../geometry/sample_triangle_attribute.js";
@@ -86,7 +86,7 @@ export function sample_material(
     }
 
     // apply transform
-    v3_matrix4_rotate(out, 3, out, 3, mesh.transform);
+    v3_array_matrix4_rotate(out, 3, out, 3, mesh.transform);
 
     material.normal.sample(normal, texture_uv[0], texture_uv[1]);