@woosh/meep-engine 2.34.49 → 2.35.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

@@ -25,6 +25,8 @@ function array_set_plane_normalized(
 
 /**
  * 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[]} m4
  */

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

@@ -18,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;
         }
     }

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);

package/engine/ecs/parent/EntityNode.js

@@ -4,7 +4,7 @@ import { array_remove_first } from "../../../core/collection/array/array_remove_
 import { assert } from "../../../core/assert.js";
 import { array_push_if_unique } from "../../../core/collection/array/array_push_if_unique.js";
 import { Transform } from "../transform/Transform.js";
-import { TransformAttachment } from "../transform-attachment/TransformAttachment.js";
+import { TransformAttachment, TransformAttachmentFlags } from "../transform-attachment/TransformAttachment.js";
 
 export class EntityNode {
     /**
@@ -18,12 +18,14 @@ export class EntityNode {
          * @private
          */
         this.__parent = null;
+
         /**
          *
          * @type {EntityBuilder}
          * @private
          */
         this.__entity = entity;
+
         /**
          *
          * @type {EntityNode[]}
@@ -32,7 +34,7 @@ export class EntityNode {
         this.__children = [];
 
         /**
-         *
+         * Local transform
          * @type {Transform}
          * @private
          */
@@ -45,13 +47,18 @@ export class EntityNode {
      */
     __transform_sync_down() {
 
+        const transform = this.__transform;
+
         if (this.__parent === null) {
-            const t = this.__entity.getComponent(Transform);
-            if (t !== null) {
-                t.copy(this.__transform);
+            // not attached to anything, world and local transforms match
+            const cTransform = this.__entity.getComponent(Transform);
+
+            if (cTransform !== null) {
+                cTransform.copy(transform);
             }
+
         } else {
-            this.__safe_get_attachment().transform.copy(this.__transform);
+            this.__safe_get_attachment().transform.copy(transform);
         }
 
     }
@@ -85,7 +92,7 @@ export class EntityNode {
 
         if (attachment === null) {
             attachment = new TransformAttachment();
-            attachment.immediate = true;
+            attachment.setFlag(TransformAttachmentFlags.Immediate);
 
             entity.add(attachment);
         }
@@ -115,13 +122,15 @@ export class EntityNode {
     set parent(node) {
         this.__parent = node;
 
+        const this_entity = this.__entity;
+
         // check if entity is built
-        if (!this.__entity.isBuilt) {
+        if (!this_entity.isBuilt) {
             return;
         }
 
-        let parent_entity = this.__entity.removeComponent(ParentEntity);
-        let attachment = this.__entity.removeComponent(TransformAttachment);
+        let parent_entity = this_entity.removeComponent(ParentEntity);
+        let attachment = this_entity.removeComponent(TransformAttachment);
 
         if (node !== null) {
 
@@ -141,7 +150,7 @@ export class EntityNode {
             parent_entity.entity = parent_entity_id;
 
             // add component back
-            this.__entity.add(parent_entity);
+            this_entity.add(parent_entity);
 
 
             // handle component Attachment
@@ -230,6 +239,8 @@ export class EntityNode {
         }
 
         this.__transform_sync_down();
+
+        // attach listeners
         this.__transform.position.onChanged.add(this.__transform_sync_down, this);
         this.__transform.scale.onChanged.add(this.__transform_sync_down, this);
         this.__transform.rotation.onChanged.add(this.__transform_sync_down, this);
@@ -247,6 +258,7 @@ export class EntityNode {
     }
 
     destroy() {
+        // remove listeners
         this.__transform.position.onChanged.remove(this.__transform_sync_down, this);
         this.__transform.scale.onChanged.remove(this.__transform_sync_down, this);
         this.__transform.rotation.onChanged.remove(this.__transform_sync_down, this);

package/engine/ecs/transform/Transform.js

@@ -4,14 +4,16 @@
 
 import Vector3 from "../../../core/geom/Vector3.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
-import { Matrix4 } from "../../../core/geom/Matrix4.js";
 import { compose_matrix4_array } from "../../graphics/util/composeMatrix4.js";
 import { decompose_matrix_4_array } from "../../graphics/util/decompose_matrix_4_array.js";
+import { mat4 } from "gl-matrix";
 
 const delta = new Vector3();
 
-const m4_0 = new Matrix4();
-const m4_1 = new Matrix4();
+const scratch_buffer = new ArrayBuffer(32 * 4);
+
+const m4_0 = new Float32Array(scratch_buffer, 0, 16);
+const m4_1 = new Float32Array(scratch_buffer, 64, 16)
 
 export class Transform {
     /**
@@ -152,12 +154,12 @@ export class Transform {
      * @param {Transform} b
      */
     multiplyTransforms(a, b) {
-        m4_0.compose(a.position, a.rotation, a.scale);
-        m4_1.compose(b.position, b.rotation, b.scale);
+        compose_matrix4_array(m4_0, a.position, a.rotation, a.scale);
+        compose_matrix4_array(m4_1, b.position, b.rotation, b.scale);
 
-        m4_0.multiplyMatrices(m4_0, m4_1);
+        mat4.multiply(m4_0, m4_0, m4_1);
 
-        m4_0.decompose(this.position, this.rotation, this.scale);
+        this.fromMatrix4(m4_0);
     }
 
     /**
@@ -170,18 +172,18 @@ export class Transform {
 
     /**
      *
-     * @param {mat4|number[]|Float32Array} m
+     * @param {Matrix4} matrix
      */
-    fromMatrix4(m) {
-        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
+    toThreeMatrix(matrix) {
+        this.toMatrix4(matrix.elements);
     }
 
     /**
      *
-     * @param {Matrix4} matrix
+     * @param {mat4|number[]|Float32Array} m
      */
-    toThreeMatrix(matrix) {
-        this.toMatrix4(matrix.elements);
+    fromMatrix4(m) {
+        decompose_matrix_4_array(m, this.position, this.rotation, this.scale);
     }
 
     /**