@woosh/meep-engine 2.33.20 → 2.33.24

package/core/bvh2/binary/IndexedBinaryBVH.js

@@ -6,8 +6,13 @@ import { min2 } from "../../math/min2.js";
 import { IndexedBinaryBVHVisitor } from "./IndexedBinaryBVHVisitor.js";
 import { NodeType } from "./NodeType.js";
 import { RayLeafIntersectionVisitor } from "./RayLeafIntersectionVisitor.js";
+import { array_copy } from "../../collection/array/copyArray.js";
 
 
+/**
+ *
+ * @type {Float32Array|number[]}
+ */
 const scratch_aabb_0 = new Float32Array(6);
 
 
@@ -30,16 +35,16 @@ export default class IndexedBinaryBVH {
         this.binaryNodeCount = 0;
 
         /**
-         *
+         * Total number of boxes contained in the tree, some might be unused
          * @type {number}
          */
         this.boxCount = 0;
 
         /**
          *
-         * @type {null|Float32Array}
+         * @type {Float32Array|number[]}
          */
-        this.data = null;
+        this.data = new Float32Array(16);
     }
 
     /**
@@ -59,7 +64,14 @@ export default class IndexedBinaryBVH {
 
         this.boxCount = this.leafNodeCount + this.binaryNodeCount;
 
-        this.data = new Float32Array(this.boxCount * 6);
+        // possibly resize the storage
+        const storage_size = this.boxCount * 6;
+
+        if (this.data.length < storage_size) {
+            this.data = new Float32Array(storage_size);
+        } else {
+            this.data.fill(0);
+        }
     }
 
     unsortedBuiltIntermediate() {
@@ -117,7 +129,7 @@ export default class IndexedBinaryBVH {
         }
 
         //set bounds of the bvh
-        copy_box_array(0, data, scratch_aabb_0, 0);
+        array_copy(data, 0, scratch_aabb_0, 0, 6);
 
         this.x0 = scratch_aabb_0[0];
         this.y0 = scratch_aabb_0[1];
@@ -238,7 +250,7 @@ export default class IndexedBinaryBVH {
     }
 
     /**
-     *
+     * @deprecated use a visitor object instead
      * @param {number} startX
      * @param {number} startY
      * @param {number} startZ
@@ -265,22 +277,6 @@ export default class IndexedBinaryBVH {
     }
 }
 
-/**
- *
- * @param {number} source_offset
- * @param {number[]|Float32Array} source
- * @param {number[]|Float32Array} destination
- * @param {number} destination_offset
- */
-function copy_box_array(source_offset, source, destination, destination_offset) {
-    destination[destination_offset] = source[source_offset];
-    destination[destination_offset + 1] = source[source_offset + 1];
-    destination[destination_offset + 2] = source[source_offset + 2];
-    destination[destination_offset + 3] = source[source_offset + 3];
-    destination[destination_offset + 4] = source[source_offset + 4];
-    destination[destination_offset + 5] = source[source_offset + 5];
-}
-
 /**
  *
  * @param {number[]|Float32Array} source
@@ -348,23 +344,23 @@ function writeBox(array, address, x0, y0, z0, x1, y1, z1) {
  * @param {Float32Array} array
  */
 function copyBox(from, to, array) {
-    copy_box_array(from, array, array, to);
+    array_copy(data, from, scratch_aabb_0, to, 6);
 }
 
 /**
  *
  * @param {number} from
  * @param {number} to
- * @param {Float32Array} array
+ * @param {Float32Array|number[]} array
  */
 function copyBoxZeroSize(from, to, array) {
-    copy_box_array(from, array, scratch_aabb_0, 0);
+    array_copy(array, from, scratch_aabb_0, 0, 3);
 
     scratch_aabb_0[3] = scratch_aabb_0[0];
     scratch_aabb_0[4] = scratch_aabb_0[1];
     scratch_aabb_0[5] = scratch_aabb_0[2];
 
-    copy_box_array(0, scratch_aabb_0, array, to);
+    array_copy(scratch_aabb_0, 0, array, to, 6);
 }
 
 /**

package/core/bvh2/traversal/__detailed_box_volume_intersection.js

@@ -4,9 +4,8 @@ import { computePointDistanceToPlane, plane3_computeLineSegmentIntersection } fr
 import { aabb3_corner_edge_mapping } from "../aabb3/aabb3_corner_edge_mapping.js";
 import { aabb3_edge_corner_mapping } from "../aabb3/aabb3_edge_corner_mapping.js";
 import { __process_point_if_within_planes } from "./__process_point_if_within_planes.js";
-import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane_computeConvex3PlaneIntersection.js";
+import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 import { EPSILON } from "../../math/MathUtils.js";
-import Vector3 from "../../geom/Vector3.js";
 
 /**
  *
@@ -26,7 +25,11 @@ const scratch_aabb_planes = new Float32Array(24);
  */
 const scratch_corner_out_bitfields = new Uint32Array(8);
 
-const scratch_v3 = new Vector3();
+/**
+ *
+ * @type {number[]}
+ */
+const scratch_v3_array = new Float32Array(3);
 
 /**
  *
@@ -183,7 +186,7 @@ export function __detailed_box_volume_intersection(
             const c = planes[plane_address + 3];
 
             const edge_intersects = plane3_computeLineSegmentIntersection(
-                scratch_v3,
+                scratch_v3_array, 0,
                 corner_0_x, corner_0_y, corner_0_z,
                 corner_1_x, corner_1_y, corner_1_z,
                 nx, ny, nz, c
@@ -192,7 +195,7 @@ export function __detailed_box_volume_intersection(
             if (edge_intersects) {
                 // a possible candidate, let's see if this point is within rest of the planes
                 __process_point_if_within_planes(
-                    scratch_v3.x, scratch_v3.y, scratch_v3.z,
+                    scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2],
                     (plane_mask ^ plane_bit_mask),
                     planes,
                     plane_count,
@@ -230,7 +233,7 @@ export function __detailed_box_volume_intersection(
             const cp_1 = next_orthogonal_plane_index * 4;
 
             const intersection_exists = plane_computeConvex3PlaneIntersection(
-                scratch_v3,
+                scratch_v3_array, 0,
                 aabb_plane_nx, aabb_plane_ny, aabb_plane_nz, aabb_plane_constant,
                 planes[cp_0], planes[cp_0 + 1], planes[cp_0 + 2], planes[cp_0 + 3],
                 planes[cp_1], planes[cp_1 + 1], planes[cp_1 + 2], planes[cp_1 + 3]
@@ -238,14 +241,14 @@ export function __detailed_box_volume_intersection(
 
             if (intersection_exists) {
 
-                const point_within_box = box.containsPointWithTolerance(scratch_v3.x, scratch_v3.y, scratch_v3.z, EPSILON);
+                const point_within_box = box.containsPointWithTolerance(scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2], EPSILON);
 
                 if (point_within_box) {
                     // point is within the AABB bounds
 
                     // ThreeClippingPlaneComputingBVHVisitor.DEBUG_POINTS_2.send3(scratch_v3.x, scratch_v3.y, scratch_v3.z);
 
-                    callback.call(thisArg, scratch_v3.x, scratch_v3.y, scratch_v3.z);
+                    callback.call(thisArg, scratch_v3_array[0], scratch_v3_array[1], scratch_v3_array[2]);
                 }
             }
         }

package/core/collection/ArrayUtils.js

@@ -6,9 +6,9 @@
  */
 import { assert } from "../assert.js";
 import { returnZero } from "../function/Functions.js";
-import { randomIntegerBetween } from "../math/MathUtils.js";
 import { min2 } from "../math/min2.js";
 import { HashMap } from "./HashMap.js";
+import { randomIntegerBetween } from "../math/random/randomIntegerBetween.js";
 
 
 /**

package/core/collection/HashMap.js

@@ -26,6 +26,18 @@ class MapEntry {
     }
 }
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_INITIAL_CAPACITY = 16;
+
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_LOAD_FACTOR = 0.75;
+
 /**
  * Implements part of {@link Map} interface
  * @template K,V
@@ -36,10 +48,14 @@ export class HashMap {
      * @template K, V
      * @param {function(K):number} [keyHashFunction]
      * @param {function(K,K):boolean} [keyEqualityFunction]
+     * @param {number} [capacity] initial number of buckets in the hash table
+     * @param {number} [loadFactor] a measure of how full the hash table is allowed to get before its capacity is automatically increased
      */
     constructor({
                     keyHashFunction = invokeObjectHash,
-                    keyEqualityFunction = invokeObjectEquals
+                    keyEqualityFunction = invokeObjectEquals,
+                    capacity = DEFAULT_INITIAL_CAPACITY,
+                    loadFactor = DEFAULT_LOAD_FACTOR
                 } = {}) {
         assert.typeOf(keyHashFunction, 'function', 'keyHashFunction');
         assert.typeOf(keyEqualityFunction, 'function', 'keyEqualityFunction');
@@ -69,14 +85,21 @@ export class HashMap {
          * @type {number}
          * @private
          */
-        this.__bucket_count = 16384;
+        this.__bucket_count = capacity;
+
+        /**
+         * How full the table can get before number of buckets is increased
+         * @type {number}
+         * @private
+         */
+        this.__load_factor = loadFactor;
     }
 
     /**
      * Proportion between actual number of records in the map and the bucket count (number of potential hashes)
      * @returns {number}
      */
-    getLoadFactor() {
+    getCurrentLoad() {
         return this.size / this.__bucket_count;
     }
 
@@ -133,7 +156,7 @@ export class HashMap {
         this.__bucket_count = count;
         if (this.size > 0) {
             // re-hash
-            this.updateHashes();
+            this.rebuild();
         }
     }
 
@@ -167,31 +190,49 @@ export class HashMap {
         let bucket = this.records[bucket_index];
 
         if (bucket === undefined) {
-            bucket = [new MapEntry(key, value)];
+
+            // bucket for this value doesn't exist
+
+            bucket = [];
+
             this.records[bucket_index] = bucket;
 
-            this.size++;
+        } else {
 
-            return;
-        }
+            // bucket exists
 
-        const bucketSize = bucket.length;
+            const bucketSize = bucket.length;
 
-        //check if key already exists
-        for (let i = 0; i < bucketSize; i++) {
-            const entry = bucket[i];
+            //check if key already exists
+            for (let i = 0; i < bucketSize; i++) {
+                const entry = bucket[i];
 
-            const entryKey = entry.key;
-            if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
+                const entryKey = entry.key;
 
-                entry.value = value;
-                return;
+                if (entryKey === key || this.keyEqualityFunction(entryKey, key)) {
+
+                    entry.value = value;
+                    return;
+
+                }
 
             }
+
         }
 
         bucket.push(new MapEntry(key, value));
-        this.size++;
+
+        const old_size = this.size;
+        const new_size = old_size + 1;
+        this.size = new_size;
+
+        // compute actual current load
+        const load = new_size / this.__bucket_count;
+
+        if (load > this.__load_factor) {
+            // increase table size
+            this.setBucketCount(this.__bucket_count * 2);
+        }
     }
 
     /**
@@ -308,20 +349,22 @@ export class HashMap {
     }
 
     /**
-     *
+     * Rebuild table, useful for when table is resized or hashes of stored keys change
      */
-    updateHashes() {
+    rebuild() {
 
         let h, i, l;
 
         const records = this.records;
 
         for (h in records) {
+            const stored_bucket_index = parseInt(h);
+
             if (!records.hasOwnProperty(h)) {
                 continue;
             }
 
-            const bucket = records[h];
+            const bucket = records[stored_bucket_index];
 
             for (i = 0, l = bucket.length; i < l; i++) {
                 /**
@@ -333,7 +376,6 @@ export class HashMap {
                 const raw_hash = this.keyHashFunction(entry.key);
                 const actual_bucket_index = this.__compute_bucket_index(raw_hash);
 
-                const stored_bucket_index = parseInt(h);
 
                 if (actual_bucket_index !== stored_bucket_index) {
                     //remove entry from the bucket
@@ -345,15 +387,17 @@ export class HashMap {
 
                     if (bucket.length === 0) {
                         //delete empty bucket
-                        delete records[h];
+                        delete records[stored_bucket_index];
                     }
 
                     const newBucket = records[actual_bucket_index];
+
                     if (newBucket === undefined) {
                         records[actual_bucket_index] = [entry];
                     } else {
                         newBucket.push(entry);
                     }
+
                 }
             }
         }

package/core/collection/array/arrayQuickSort.js

@@ -5,11 +5,14 @@ const stack = [];
 /**
  * @template T
  * @param {T[]} data
- * @param {function(T):number} keyExtractor
+ * @param {function(T):number} score_function
+ * @param {*} score_function_context
  * @param {number} start
  * @param {number} end
+ * @param {function(T[],number, number):*} [swap_operator]
+ * @param {*} [swap_context]
  */
-export function arrayQuickSort(data, keyExtractor, start, end) {
+export function arrayQuickSort(data, score_function, score_function_context, start, end, swap_operator = arraySwapElements, swap_context = undefined) {
     if (start >= end) {
         // section of 0 size, nothing to sort
         return;
@@ -32,15 +35,15 @@ export function arrayQuickSort(data, keyExtractor, start, end) {
 
         const pivotIndex = (left + right) >> 1;
 
-        const pivot = keyExtractor(data[pivotIndex]);
+        const pivot = score_function.call(score_function_context,data[pivotIndex]);
 
         /* partition */
         while (i <= j) {
-            while (keyExtractor(data[i]) < pivot) {
+            while (score_function.call(score_function_context,data[i]) < pivot) {
                 i++;
             }
 
-            while (keyExtractor(data[j]) > pivot) {
+            while (score_function.call(score_function_context,data[j]) > pivot) {
                 j--;
             }
 
@@ -48,7 +51,7 @@ export function arrayQuickSort(data, keyExtractor, start, end) {
 
                 if (i !== j) {
                     //do swap
-                    arraySwapElements(data, i, j);
+                    swap_operator.call(swap_context, data, i, j);
                 }
 
                 i++;

package/core/collection/array/array_swap.js

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} a
+ * @param {number} a_offset
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} b
+ * @param {number} b_offset
+ * @param {number} length How many elements should be moved
+ */
+export function array_swap(a, a_offset, b, b_offset, length) {
+
+    let i, j, k;
+
+    for (k = 0; k < length; k++) {
+        i = a_offset + k;
+        j = b_offset + k;
+
+        const t = b[j];
+
+        b[j] = a[i];
+        a[i] = t;
+    }
+}

package/core/collection/array/computeHashArray.js

@@ -0,0 +1,22 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {function(T):number} elementHashFunction
+ */
+export function computeHashArray(array, elementHashFunction) {
+
+    const numArguments = array.length;
+    let hash = numArguments;
+
+    for (let i = 0; i < numArguments; i++) {
+
+        const singleValue = array[i];
+
+        const elementHash = elementHashFunction(singleValue);
+
+        hash = ((hash << 5) - hash) + elementHash;
+        hash |= 0; // Convert to 32bit integer
+    }
+
+    return hash;
+}

package/core/collection/array/computeHashIntegerArray.js

@@ -0,0 +1,15 @@
+/**
+ * Computes hash on integer values
+ * @param {...number} value
+ * @returns {number}
+ */
+export function computeHashIntegerArray(value) {
+    let hash = 0;
+    const numArguments = arguments.length;
+    for (let i = 0; i < numArguments; i++) {
+        const singleValue = arguments[i];
+        hash = ((hash << 5) - hash) + singleValue;
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
+}

package/core/collection/table/DataType2TypedArrayConstructorMapping.js

@@ -16,4 +16,19 @@ export const DataType2TypedArrayConstructorMapping = {
     [DataType.Float16]: Uint16Array,
     [DataType.Float32]: Float32Array,
     [DataType.Float64]: Float64Array,
+};
+
+/**
+ *
+ * @param {DataType} dt
+ * @returns {constructor|function}
+ */
+export function compute_typed_array_constructor_from_data_type(dt) {
+    const r = DataType2TypedArrayConstructorMapping[dt];
+
+    if (r === undefined) {
+        throw new Error(`Unsupported data type '${dt}'`);
+    }
+
+    return r;
 }

package/core/color/Color.js

@@ -1,11 +1,12 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
-import { computeHashFloat, computeHashIntegerArray } from "../math/MathUtils.js";
 import { parseColor, rgb2hsv } from "./ColorUtils.js";
 import { clamp } from "../math/clamp.js";
 import { min2 } from "../math/min2.js";
 import { max2 } from "../math/max2.js";
 import { min3 } from "../math/min3.js";
+import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 class Color {
     /**

package/core/function/FunctionCompiler.js

@@ -1,11 +1,12 @@
 import { assert } from "../assert.js";
 import { Cache } from "../cache/Cache.js";
 import { isArrayEqualStrict } from "../collection/array/isArrayEqualStrict.js";
-import { computeHashArray, computeHashIntegerArray } from "../math/MathUtils.js";
 import { invokeObjectEquals } from "../model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../model/object/invokeObjectHash.js";
 import { computeStringHash } from "../primitives/strings/computeStringHash.js";
 import { computeUTF8StringByteSize } from "../primitives/strings/StringUtils.js";
+import { computeHashArray } from "../collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
 
 /**
  * Hash is an integer value, so this is an invalid value for a computed hash

package/core/geom/3d/CircleMath.js

@@ -1,4 +1,4 @@
-import { v3_angleBetween } from "../Vector3.js";
+import { v3_angle_between } from "../v3_angle_between.js";
 
 /**
  * NOTE: based on https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
@@ -12,9 +12,9 @@ import { v3_angleBetween } from "../Vector3.js";
  * @param {number} radius
  */
 export function computeCircleBoundingBox(result, centerX, centerY, centerZ, normalX, normalY, normalZ, radius) {
-    const ax = v3_angleBetween(normalX, normalY, normalZ, 1, 0, 0);
-    const ay = v3_angleBetween(normalX, normalY, normalZ, 0, 1, 0);
-    const az = v3_angleBetween(normalX, normalY, normalZ, 0, 0, 1);
+    const ax = v3_angle_between(normalX, normalY, normalZ, 1, 0, 0);
+    const ay = v3_angle_between(normalX, normalY, normalZ, 0, 1, 0);
+    const az = v3_angle_between(normalX, normalY, normalZ, 0, 0, 1);
 
     const rX = Math.sin(ax) * radius;
     const rY = Math.sin(ay) * radius;

package/core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js

@@ -1,5 +1,3 @@
-import { computePointDistanceToPlane } from "../../Plane.js";
-
 /**
  * @param {number} plane_normal_x
  * @param {number} plane_normal_y
@@ -14,38 +12,16 @@ import { computePointDistanceToPlane } from "../../Plane.js";
  * @returns {number}
  */
 export function aabb3_computeDistanceAbovePlane(
-    plane_normal_x,
-    plane_normal_y,
-    plane_normal_z,
-    plane_constant,
-    _x0,
-    _y0,
-    _z0,
-    _x1,
-    _y1,
-    _z1
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+    _x0, _y0, _z0,
+    _x1, _y1, _z1
 ) {
 
-    let px, py, pz;
-
-    // pick a corner point furthest along the normal
-    if (plane_normal_x > 0) {
-        px = _x1;
-    } else {
-        px = _x0;
-    }
-
-    if (plane_normal_y > 0) {
-        py = _y1;
-    } else {
-        py = _y0;
-    }
-
-    if (plane_normal_z > 0) {
-        pz = _z1;
-    } else {
-        pz = _z0;
-    }
+    // pick a corner point furthest along the plane normal
+    const px = plane_normal_x > 0 ? _x1 : _x0;
+    const py = plane_normal_y > 0 ? _y1 : _y0;
+    const pz = plane_normal_z > 0 ? _z1 : _z0;
 
-    return computePointDistanceToPlane(px, py, pz, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant);
+    // dot(v4,v4) inlined for speed
+    return (plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz) + plane_constant;
 }

package/core/geom/3d/cone/computeConeBoundingBox.js

@@ -1,6 +1,6 @@
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
-import { v3_angleBetween } from "../../Vector3.js";
+import { v3_angle_between } from "../../v3_angle_between.js";
 
 /**
  * NOTE: used stackoverflow answer as a basis for circle part: https://stackoverflow.com/questions/2592011/bounding-boxes-for-circle-and-arcs-in-3d
@@ -15,9 +15,9 @@ import { v3_angleBetween } from "../../Vector3.js";
  * @param {number} length
  */
 export function computeConeBoundingBox(result, originX, originY, originZ, directionX, directionY, directionZ, angle, length) {
-    const ax = v3_angleBetween(directionX, directionY, directionZ, 1, 0, 0);
-    const ay = v3_angleBetween(directionX, directionY, directionZ, 0, 1, 0);
-    const az = v3_angleBetween(directionX, directionY, directionZ, 0, 0, 1);
+    const ax = v3_angle_between(directionX, directionY, directionZ, 1, 0, 0);
+    const ay = v3_angle_between(directionX, directionY, directionZ, 0, 1, 0);
+    const az = v3_angle_between(directionX, directionY, directionZ, 0, 0, 1);
 
     //compute radius of the base of the cone
     const radius = length * Math.tan(angle);

package/core/geom/3d/{compute_bounding_cone_of_2_cones.js → cone/compute_bounding_cone_of_2_cones.js}

@@ -1,9 +1,9 @@
 //
 
 
-import Vector3 from "../Vector3.js";
-import Quaternion, { quat3_createFromAxisAngle } from "../Quaternion.js";
-import { max2 } from "../../math/max2.js";
+import Vector3 from "../../Vector3.js";
+import Quaternion, { quat3_createFromAxisAngle } from "../../Quaternion.js";
+import { max2 } from "../../../math/max2.js";
 
 const tangent = new Vector3();
 

package/core/geom/3d/{compute_bounding_cone_of_2_cones.spec.js → cone/compute_bounding_cone_of_2_cones.spec.js}

@@ -1,5 +1,5 @@
 import { compute_bounding_cone_of_2_cones } from "./compute_bounding_cone_of_2_cones.js";
-import { ConicRay } from "../ConicRay.js";
+import { ConicRay } from "../../ConicRay.js";
 
 /**
  *

package/core/geom/3d/frustum/array_setFromProjectionMatrix.js

@@ -1,4 +1,4 @@
-import { v3_length } from "../../Vector3.js";
+import { v3_length } from "../../v3_length.js";
 
 /**
  *