@woosh/meep-engine 2.34.48 → 2.35.1

package/core/binary/BitSet.js

@@ -59,7 +59,6 @@ const SHRINK_FACTOR = 0.5;
  */
 const RESIZE_COUNT_THRESHOLD = 128;
 
-
 /**
  * Dynamically sized bit field
  * @constructor
@@ -389,6 +388,7 @@ BitSet.prototype.set = function (bitIndex, value) {
         const bitIndexInc = bitIndex + 1;
 
         if (bitIndexInc > this.__length) {
+            // ensure capacity
             this.__setLength(bitIndexInc);
         }
 
@@ -401,6 +401,7 @@ BitSet.prototype.set = function (bitIndex, value) {
         this.__data_uint32[word_offset] &= ~word_mask;
 
         if (bitIndex === this.__length - 1) {
+            // trim down set size potentially
             const newLastSetBit = this.previousSetBit(bitIndex);
 
             this.__setLength(newLastSetBit + 1);
@@ -538,9 +539,13 @@ BitSet.prototype.reset = function () {
     if (current_length <= 0) {
         // no action required
         return;
+    } else if (current_length <= 32) {
+        // one word, set first word to 0 manually
+        this.__data_uint32[0] = 0;
+    } else {
+        this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
     }
 
-    this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
     this.__length = 0;
 };
 

package/core/bvh2/BinaryNode.js

@@ -15,7 +15,7 @@ import { BVHVisitor } from "./traversal/BVHVisitor.js";
 import { traverseBinaryNodeUsingVisitor } from "./traversal/traverseBinaryNodeUsingVisitor.js";
 import { aabb3_intersect_aabb3 } from "./aabb3/aabb3_intersect_aabb3.js";
 import { aabb3_box_surface_area_2 } from "./aabb3/aabb3_box_surface_area_2.js";
-import { aabb3_compute_half_surface_area } from "./aabb3/aabb3_compute_half_surface_area.js";
+import { aabb3_combined_surface_area } from "./aabb3_combined_surface_area.js";
 
 
 /**
@@ -206,6 +206,7 @@ export class BinaryNode extends Node {
     /**
      * For incremental insertion, a sibling needs to be found, newly inserted node will be parented together with this sibling
      * @see https://github.com/erincatto/box2d/blob/9dc24a6fd4f32442c4bcf80791de47a0a7d25afb/src/collision/b2_dynamic_tree.cpp#L197
+     * @private
      * @param {AABB3} box
      * @returns {BinaryNode|LeafNode}
      */
@@ -215,13 +216,13 @@ export class BinaryNode extends Node {
         let cost_left = 0;
         let cost_right = 0;
 
-        while (node.isBinaryNode) {
+        while (node.isBinaryNode === true) {
             const left = node.left;
             const right = node.right;
 
             const area = aabb3_box_surface_area_2(node);
 
-            const combined_area = combined_surface_area(node, box);
+            const combined_area = aabb3_combined_surface_area(node, box);
 
             //cost of creating a new parent for this node and the new leaf
             const cost = combined_area;
@@ -231,10 +232,11 @@ export class BinaryNode extends Node {
 
             // cost of descending left
             if (left !== null) {
+                const combined_left = aabb3_combined_surface_area(left, box);
                 if (left.isLeafNode) {
-                    cost_left = combined_surface_area(left, box) + inheritance_cost;
+                    cost_left = combined_left + inheritance_cost;
                 } else {
-                    cost_left = combined_surface_area(left, box) - aabb3_box_surface_area_2(left) + inheritance_cost;
+                    cost_left = combined_left - aabb3_box_surface_area_2(left) + inheritance_cost;
                 }
             } else {
                 cost_left = Infinity;
@@ -243,10 +245,11 @@ export class BinaryNode extends Node {
             // cost of descending right
             if (right !== null) {
 
+                const combined_right = aabb3_combined_surface_area(right, box);
                 if (right.isLeafNode) {
-                    cost_right = combined_surface_area(right, box) + inheritance_cost;
+                    cost_right = combined_right + inheritance_cost;
                 } else {
-                    cost_right = combined_surface_area(right, box) - aabb3_box_surface_area_2(right) + inheritance_cost;
+                    cost_right = combined_right - aabb3_box_surface_area_2(right) + inheritance_cost;
                 }
             } else {
                 cost_right = Infinity;
@@ -1045,10 +1048,9 @@ export class BinaryNode extends Node {
 
         const sibling = this.__insertion_findSiblingFor(child);
 
-        const sibling_parent = sibling.parentNode;
-        let parent = sibling_parent;
+        let parent = sibling.parentNode;
 
-        if (sibling_parent === null) {
+        if (parent === null) {
             // "sibling" is the root node
 
             parent = sibling;
@@ -1069,15 +1071,15 @@ export class BinaryNode extends Node {
 
             // non-root
 
-            if (sibling_parent.left === sibling && sibling_parent.right === null) {
+            if (parent.left === sibling && parent.right === null) {
 
                 // right node is free, take it
-                sibling_parent.setChildRight(child);
+                parent.setChildRight(child);
 
-            } else if (sibling_parent.right === sibling && sibling_parent.left === null) {
+            } else if (parent.right === sibling && parent.left === null) {
 
                 // left node is free, take it
-                sibling_parent.setChildLeft(child);
+                parent.setChildLeft(child);
 
             } else {
 
@@ -1088,7 +1090,7 @@ export class BinaryNode extends Node {
         }
 
         // walk back up the tree fixing heights and bounds
-        while (parent !== null) {
+        do {
             // parent = this.balance();
 
             const left = parent.left;
@@ -1098,7 +1100,7 @@ export class BinaryNode extends Node {
             parent.refit();
 
             parent = parent.parentNode;
-        }
+        } while (parent !== null);
     }
 
     /**
@@ -1152,25 +1154,7 @@ BinaryNode.prototype.isBinaryNode = true;
  * @returns {number}
  */
 function inclusion_surface_area_heuristic(node, addition) {
-    return combined_surface_area(node, addition) - aabb3_box_surface_area_2(node);
-}
-
-/**
- *
- * @param {AABB3} node
- * @param {AABB3} addition
- * @returns {number}
- */
-function combined_surface_area(node, addition) {
-    const x0 = min2(node.x0, addition.x0);
-    const y0 = min2(node.y0, addition.y0);
-    const z0 = min2(node.z0, addition.z0);
-
-    const x1 = max2(node.x1, addition.x1);
-    const y1 = max2(node.y1, addition.y1);
-    const z1 = max2(node.z1, addition.z1);
-
-    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
+    return aabb3_combined_surface_area(node, addition) - aabb3_box_surface_area_2(node);
 }
 
 /**

package/core/bvh2/aabb3/aabb3_intersects_frustum_array.js

@@ -32,13 +32,13 @@ export function aabb3_intersects_frustum_array(aabb, frustum) {
 export function aabb3_intersects_frustum(x0, y0, z0, x1, y1, z1, frustum) {
     for (let i = 0; i < 24; i += 4) {
 
-        const plane_n_x = frustum[i];
-        const plane_n_y = frustum[i + 1];
-        const plane_n_z = frustum[i + 2];
-        const plane_constant = frustum[i + 3];
+        const plane_x = frustum[i];
+        const plane_y = frustum[i + 1];
+        const plane_z = frustum[i + 2];
+        const plane_w = frustum[i + 3];
 
         const plane_distance = aabb3_computeDistanceAbovePlane(
-            plane_n_x, plane_n_y, plane_n_z, plane_constant,
+            plane_x, plane_y, plane_z, plane_w,
             x0, y0, z0,
             x1, y1, z1
         );

package/core/bvh2/aabb3_combined_surface_area.js

@@ -0,0 +1,21 @@
+import { min2 } from "../math/min2.js";
+import { max2 } from "../math/max2.js";
+import { aabb3_compute_half_surface_area } from "./aabb3/aabb3_compute_half_surface_area.js";
+
+/**
+ *
+ * @param {AABB3} a
+ * @param {AABB3} b
+ * @returns {number}
+ */
+export function aabb3_combined_surface_area(a, b) {
+    const x0 = min2(a.x0, b.x0);
+    const y0 = min2(a.y0, b.y0);
+    const z0 = min2(a.z0, b.z0);
+
+    const x1 = max2(a.x1, b.x1);
+    const y1 = max2(a.y1, b.y1);
+    const z1 = max2(a.z1, b.z1);
+
+    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
+}

package/core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js

@@ -8,45 +8,57 @@ const stack = [];
 /**
  * @template T
  * @param {T[]} destination
- * @param {number} destinationOffset
+ * @param {number} destination_offset
  * @param {BinaryNode<T>} root
  * @param {ArrayLike<number>|number[]|Float32Array} frustum
  * @returns {number} Number of results
  */
-export function queryBinaryNode_FrustumIntersections_Data(destination, destinationOffset, root, frustum) {
+export function queryBinaryNode_FrustumIntersections_Data(destination, destination_offset, root, frustum) {
+
+    /**
+     * @type {BinaryNode<T>|LeafNode<T>}
+     */
     let n;
-    let i = 0;
+    let offset = destination_offset;
     let stackPointer = 1;
 
     stack[0] = root;
 
     while (stackPointer > 0) {
+
         stackPointer--;
 
         n = stack[stackPointer];
 
-        if (!n.intersectFrustum_array(frustum)) {
+        const node_intersects_frustum = n.intersectFrustum_array(frustum);
+
+        if (!node_intersects_frustum) {
             continue;
         }
 
-        if (n.isBinaryNode) {
+        if (n.isBinaryNode === true) {
 
-            if (n.right !== null) {
-                stack[stackPointer++] = n.right;
+            const right = n.right;
+
+            if (right !== null) {
+                stack[stackPointer++] = right;
             }
 
-            if (n.left !== null) {
-                stack[stackPointer++] = n.left;
+            const left = n.left;
+
+            if (left !== null) {
+                stack[stackPointer++] = left;
             }
 
         } else {
+            // leaf node
 
-            destination[destinationOffset + i] = n.object;
+            destination[offset] = n.object;
 
-            i++;
+            offset++;
         }
 
     }
 
-    return i;
+    return offset - destination_offset;
 }

package/core/cache/Cache.d.ts

@@ -28,4 +28,6 @@ export class Cache<K, V> {
     clear(): void
 
     drop(): void
+
+    getOrCompute(key: K, compute: (key: K) => V, compute_context?: any): V
 }

package/core/cache/Cache.js

@@ -1,7 +1,7 @@
 import { assert } from "../assert.js";
 import { HashMap } from "../collection/HashMap.js";
 import Signal from "../events/signal/Signal.js";
-import { noop, returnOne, returnZero, strictEquals } from "../function/Functions.js";
+import { returnOne, returnZero, strictEquals } from "../function/Functions.js";
 import { CacheElement } from "./CacheElement.js";
 
 /**
@@ -14,33 +14,25 @@ export class Cache {
      * @param {number} [maxWeight=Number.POSITIVE_INFINITY]
      * @param {function(key:Key):number} [keyWeigher= key=>0]
      * @param {function(value:Value):number} [valueWeigher= value=>1]
-     * @param {function(key:Key, value:Value)} [removeListener] will be notified when element is either explicitly removed or evicted
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
      * @param {number} capacity initial capacity for the cache, helps prevent early resizing
      * @constructor
-     * @template Key, Value
      */
     constructor({
                     maxWeight = Number.POSITIVE_INFINITY,
                     keyWeigher = returnZero,
                     valueWeigher = returnOne,
-                    removeListener = noop,
                     keyHashFunction = returnZero,
                     keyEqualityFunction = strictEquals,
                     capacity
                 } = {}) {
 
         assert.isNumber(maxWeight, 'maxWeight');
-        assert.typeOf(keyWeigher, 'function', 'keyWeigher');
-        assert.typeOf(valueWeigher, 'function', 'valueWeigher');
-        assert.typeOf(removeListener, 'function', 'removeListener');
-        assert.typeOf(keyHashFunction, 'function', 'keyHashFunction');
-        assert.typeOf(keyEqualityFunction, 'function', 'keyEqualityFunction');
-
-        if (removeListener !== noop) {
-            console.warn('removalListener is deprecated, use onRemoved signal instead');
-        }
+        assert.isFunction(keyWeigher, 'keyWeigher');
+        assert.isFunction(valueWeigher, 'valueWeigher');
+        assert.isFunction(keyHashFunction, 'keyHashFunction');
+        assert.isFunction(keyEqualityFunction, 'keyEqualityFunction');
 
         /**
          *
@@ -70,13 +62,6 @@ export class Cache {
          */
         this.valueWeigher = valueWeigher;
 
-        /**
-         *
-         * @type {function(Key, Value)}
-         * @private
-         */
-        this.removeListener = removeListener;
-
         /**
          *
          * @type {CacheElement<Key,Value>|null}
@@ -93,7 +78,7 @@ export class Cache {
 
         /**
          *
-         * @type {HashMap<Key, CacheElement<Key,Value>t>}
+         * @type {HashMap<Key, CacheElement<Key,Value>>}
          * @private
          */
         this.data = new HashMap({
@@ -398,13 +383,32 @@ export class Cache {
         this.__removeElement(element);
 
         //notify
-        this.removeListener(key, element.value);
-
         this.onRemoved.send2(key, element.value);
 
         return true;
     }
 
+    /**
+     *
+     * @param {Key} key
+     * @param {function(Key):Value} compute
+     * @param {*} [compute_context]
+     * @return {Value}
+     */
+    getOrCompute(key, compute, compute_context) {
+        const existing = this.get(key);
+
+        if (existing !== null) {
+            return existing;
+        }
+
+        const value = compute.call(compute_context, key);
+
+        this.set(key, value);
+
+        return value;
+    }
+
     /**
      * Remove all elements from the cache
      */

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

@@ -7,53 +7,58 @@
  * @param {number} z
  * @param {number} w
  */
-function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+function array_set_plane_normalized(
+    destination, destination_offset,
+    x, y, z, w
+) {
     // compute vector length
     const length = Math.hypot(x, y, z);
 
-    const inverseNormalLength = 1.0 / length;
+    const inverse_length = 1.0 / length;
 
     // apply normalization
-    destination[destination_offset] = x * inverseNormalLength;
-    destination[destination_offset + 1] = y * inverseNormalLength;
-    destination[destination_offset + 2] = z * inverseNormalLength;
-    destination[destination_offset + 3] = w * inverseNormalLength;
+    destination[destination_offset] = x * inverse_length;
+    destination[destination_offset + 1] = y * inverse_length;
+    destination[destination_offset + 2] = z * inverse_length;
+    destination[destination_offset + 3] = w * inverse_length;
 }
 
 /**
  * Set frustum from projection matrix
+ * NOTE: uses Gribb/Hartmann method
+ * @see "Fast Extraction of Viewing Frustum Planes from the WorldView-Projection Matrix", 2001 by Gribb & Hartmann
  * @param {number[]|Float32Array} frustum_planes
- * @param {number[]} me
+ * @param {number[]} m4
  */
-export function frustum_from_projection_matrix_array(frustum_planes, me) {
+export function frustum_from_projection_matrix_array(frustum_planes, m4) {
 
-    const me0 = me[0];
-    const me3 = me[3];
+    const me0 = m4[0];
+    const me3 = m4[3];
 
-    const me4 = me[4];
-    const me7 = me[7];
+    const me4 = m4[4];
+    const me7 = m4[7];
 
-    const me8 = me[8];
-    const me11 = me[11];
+    const me8 = m4[8];
+    const me11 = m4[11];
 
-    const me12 = me[12];
-    const me15 = me[15];
+    const me12 = m4[12];
+    const me15 = m4[15];
 
     array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
     array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
 
-    const me1 = me[1];
-    const me5 = me[5];
-    const me9 = me[9];
-    const me13 = me[13];
+    const me1 = m4[1];
+    const me5 = m4[5];
+    const me9 = m4[9];
+    const me13 = m4[13];
 
     array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
     array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
 
-    const me2 = me[2];
-    const me6 = me[6];
-    const me10 = me[10];
-    const me14 = me[14];
+    const me2 = m4[2];
+    const me6 = m4[6];
+    const me10 = m4[10];
+    const me14 = m4[14];
 
     array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
     array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);

package/core/math/max2.js

@@ -6,9 +6,5 @@
  * @returns {number}
  */
 export function max2(a, b) {
-    if (a < b) {
-        return b;
-    } else {
-        return a;
-    }
-}
+    return a < b ? b : a;
+}

package/core/math/min2.js

@@ -5,9 +5,5 @@
  * @returns {number}
  */
 export function min2(a, b) {
-    if (a < b) {
-        return a;
-    } else {
-        return b;
-    }
-}
+    return a < b ? a : b;
+}

package/engine/asset/loaders/geometry/geometry/computeGeometryEquality.js

@@ -1,4 +1,5 @@
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
+import { is_typed_array_equals } from "../../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 
 /**
@@ -17,7 +18,7 @@ export function computeGeometryEquality(a, b) {
             return false;
         }
 
-        if (!isArrayEqualStrict(a_index.array, b_index.array)) {
+        if (!is_typed_array_equals(a_index.array, b_index.array)) {
             return false;
         }
     }
@@ -46,7 +47,7 @@ export function computeGeometryEquality(a, b) {
         const a_attribute = a.attributes[key];
         const b_attribute = b.attributes[key];
 
-        if (!isArrayEqualStrict(a_attribute.array, b_attribute.array)) {
+        if (!is_typed_array_equals(a_attribute.array, b_attribute.array)) {
             return false;
         }
     }

package/engine/asset/loaders/geometry/geometry/computeGeometryHash.js

@@ -1,4 +1,5 @@
 import { computeBufferAttributeHash } from "./computeBufferAttributeHash.js";
+import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
 
 /**
  *
@@ -6,7 +7,14 @@ import { computeBufferAttributeHash } from "./computeBufferAttributeHash.js";
  * @returns {number}
  */
 export function computeGeometryHash(geometry) {
-    let hash = computeBufferAttributeHash(geometry.getIndex());
+    let hash = 0;
+    const attributes = geometry.attributes;
+
+    for (const attributesKey in attributes) {
+        hash = hash * 31 + computeStringHash(attributesKey);
+    }
+
+    hash ^= computeBufferAttributeHash(geometry.getIndex());
 
     const position_attribute = geometry.getAttribute('position');
 

package/engine/ecs/EntityComponentDataset.js

@@ -1319,11 +1319,16 @@ export class EntityComponentDataset {
 
         const numObservers = observersStore.length;
 
-        let i;
+        if (numObservers === 0) {
+            // no observers
+            return;
+        }
+
+        let i = 0;
 
         const args = [];
 
-        for (i = 0; i < numObservers; i++) {
+        for (; i < numObservers; i++) {
             const observer = observersStore[i];
 
             const match = matchComponentMask(this.componentOccupancy, entityIndex, this.componentTypeCount, observer.componentMask);

package/engine/ecs/foliage/ViewState.js

@@ -2,6 +2,8 @@ import { BitSet } from "../../../core/binary/BitSet.js";
 import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
 import { queryBinaryNode_FrustumIntersections_Data } from "../../../core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
+import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
+import Vector3 from "../../../core/geom/Vector3.js";
 
 /**
  *
@@ -153,13 +155,21 @@ export class ViewState {
 
             tempQuaternion.decodeFromUint32(encodedRotation);
 
+            scratch_v3_0.set(positionX, positionY, positionZ);
+            scratch_v3_1.set(scaleX, scaleY, scaleZ);
+
+            // compose transform
+            compose_matrix4_array(scratch_transform, scratch_v3_0, tempQuaternion, scratch_v3_1);
+
             //apply instance transforms
-            instances.setPositionAt(i, positionX, positionY, positionZ);
-            instances.setRotationAt(i, tempQuaternion.x, tempQuaternion.y, tempQuaternion.z, tempQuaternion.w);
-            instances.setScaleAt(i, scaleX, scaleY, scaleZ);
+            instances.setTransformAt(i, scratch_transform);
+            instances.requestAttributeUpdate();
         }
     }
 }
 
 const tempQuaternion = new Quaternion();
+const scratch_v3_0 = new Vector3();
+const scratch_v3_1 = new Vector3();
 const rowData = [];
+const scratch_transform = new Float32Array(16);