@woosh/meep-engine 2.34.34 → 2.34.35

package/core/bvh2/BinaryNode.js

@@ -541,11 +541,12 @@ BinaryNode.prototype.bubbleRefit = function () {
         n = n.parentNode;
 
         if (n === null) {
+            // hit the root
             return;
         }
 
-        //check if this node violates bounds of the parent
 
+        //check if this node violates bounds of the parent
         let flag = false;
 
         if (_x0 < n.x0) {

package/core/bvh2/Node.d.ts

@@ -3,4 +3,7 @@ import {BinaryNode} from "./BinaryNode";
 
 export class Node<T> extends AABB3 {
     public parentNode: BinaryNode<T>
+
+
+    readonly leafNodeCount: number
 }

package/core/bvh2/transform/RotationOptimizer.js

@@ -1,8 +1,7 @@
-import { boxSurfaceArea2 as computeArea, scoreBoxesSAH as computeAreaFor2 } from "../aabb3/AABB3Math.js";
 import { BinaryNode } from "../BinaryNode.js";
 import { isLeaf } from "../LeafNode.js";
-import { surfaceAreaHeuristic as sah } from "../sah/surfaceAreaHeuristic.js";
 import { StacklessTraverser } from "../StacklessTraverser.js";
+import { tryRotateSingleNode } from "./tryRotateSingleNode.js";
 
 
 /**
@@ -73,266 +72,12 @@ function getLeafCount(node, leafCounts) {
     return result;
 }
 
-/**
- *
- * @param {Node} node
- * @param {BinaryNode} parent
- */
-function setParent(node, parent) {
-    node.parentNode = parent;
-}
-
-/**
- * Based on paper "Fast, Effective BVH Updates for Animated Scenes" Kopta et. al. (url: http://www.cs.utah.edu/~thiago/papers/rotations.pdf)
- * @param {BinaryNode} node
- * @param {Map.<NodeDescription,int>} leafCounts
- * @returns {int} value from 0 to 6, 0 means no rotation has taken place
- */
-function tryRotateSingleNode(node, leafCounts) {
-
-
-    const left = node.left;
-    const right = node.right;
-
-    if (left === null || right === null) {
-        return 0;
-    }
-
-    let bestRotation = 0;
-
-
-    const nodeArea = computeArea(node);
-    const leftArea = computeArea(left);
-    const rightArea = computeArea(right);
-
-    const leftLeaves = left.leafNodeCount;
-    const rightLeaves = right.leafNodeCount;
-
-
-    let bestCost = sah(
-        nodeArea,
-        leftArea,
-        rightArea,
-        leftLeaves,
-        rightLeaves
-    );
-
-    let candidateCost;
-
-    let leftLeftArea,
-        leftRightArea,
-        rightLeftArea,
-        rightRightArea;
-
-    let leftLeft,
-        leftRight,
-        rightLeft,
-        rightRight;
-
-    let leftLeftLeaves,
-        leftRightLeaves,
-        rightLeftLeaves,
-        rightRightLeaves;
-
-    let considerLeft = !isLeaf(left);
-
-    if (considerLeft) {
-        leftLeft = left.left;
-        leftRight = left.right;
-
-        considerLeft = (leftLeft !== null && leftRight !== null);
-        if (considerLeft) {
-
-            leftLeftArea = computeArea(leftLeft);
-            leftRightArea = computeArea(leftRight);
-
-            leftLeftLeaves = leftLeft.leafNodeCount;
-            leftRightLeaves = leftRight.leafNodeCount;
-
-            // (1)    N                     N      //
-            //       / \                   / \     //
-            //      L   R     ----->      L   LL   //
-            //     / \                   / \       //
-            //   LL   LR                R   LR     //
-            candidateCost = sah(nodeArea, computeAreaFor2(right, leftRight), leftLeftArea, rightLeaves + leftRightLeaves, leftLeftLeaves);
-
-            if (candidateCost < bestCost) {
-                bestRotation = 1;
-                bestCost = candidateCost;
-            }
-
-            // (2)    N                     N      //
-            //       / \                   / \     //
-            //      L   R     ----->      L   LR   //
-            //     / \                   / \       //
-            //   LL   LR               LL   R      //
-            candidateCost = sah(nodeArea, computeAreaFor2(leftLeft, right), leftRightArea, leftLeftLeaves + rightLeaves, leftRightLeaves);
-
-
-            if (candidateCost < bestCost) {
-                bestRotation = 2;
-                bestCost = candidateCost;
-            }
-        }
-    }
-    if (!isLeaf(right)) {
-        rightLeft = right.left;
-        rightRight = right.right;
-        if (rightLeft !== null && rightRight !== null) {
-
-            rightLeftArea = computeArea(rightLeft);
-            rightRightArea = computeArea(rightRight);
-
-            rightLeftLeaves = rightLeft.leafNodeCount;
-            rightRightLeaves = rightRight.leafNodeCount;
-
-            // (3)    N                     N        //
-            //       / \                   / \       //
-            //      L   R     ----->     RL   R      //
-            //         / \                   / \     //
-            //       RL   RR                L   RR   //
-            candidateCost = sah(nodeArea, rightLeftArea, computeAreaFor2(left, rightRight), rightLeftLeaves, leftLeaves + rightRightLeaves);
-
-            if (candidateCost < bestCost) {
-                bestRotation = 3;
-                bestCost = candidateCost;
-            }
-
-            // (4)    N                     N       //
-            //       / \                   / \      //
-            //      L   R     ----->     RR   R     //
-            //         / \                   / \    //
-            //       RL   RR               RL   L   //
-            candidateCost = sah(nodeArea, rightRightArea, computeAreaFor2(rightLeft, left), rightRightLeaves, rightLeftLeaves + leftLeaves);
-
-
-            if (candidateCost < bestCost) {
-                bestRotation = 4;
-                bestCost = candidateCost;
-            }
-
-            if (considerLeft) {
-                //both child nodes are not leaf
-
-                // (5)       N                      N        //
-                //         /   \                  /   \      //
-                //        L     R     ----->     L     R     //
-                //       / \   / \              / \   / \    //
-                //      LL LR RL RR            LL RL LR RR   //
-                candidateCost = sah(
-                    nodeArea,
-                    computeAreaFor2(leftLeft, rightLeft),
-                    computeAreaFor2(leftRight, rightRight),
-                    leftLeftLeaves + rightLeftLeaves,
-                    leftRightLeaves + rightRightLeaves
-                );
-
-
-                if (candidateCost < bestCost) {
-                    bestRotation = 5;
-                    bestCost = candidateCost;
-                }
-
-                // (6)       N                      N        //
-                //         /   \                  /   \      //
-                //        L     R     ----->     L     R     //
-                //       / \   / \              / \   / \    //
-                //      LL LR RL RR            LL RR RL LR   //
-                candidateCost = sah(
-                    nodeArea,
-                    computeAreaFor2(leftLeft, rightRight),
-                    computeAreaFor2(rightLeft, leftRight),
-                    leftLeftLeaves + rightRightLeaves,
-                    rightLeftLeaves + leftRightLeaves
-                );
-
-                if (candidateCost < bestCost) {
-                    bestRotation = 6;
-                }
-            }
-        }
-    }
-
-    switch (bestRotation) {
-        case 0:
-            //no rotation
-            break;
-        case 1:
-            node.right = leftLeft;
-            setParent(leftLeft, node);
-            left.left = right;
-            setParent(right, left);
-
-            left.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            break;
-        case 2:
-            node.right = leftRight;
-            setParent(leftRight, node);
-            left.right = right;
-            setParent(right, left);
-
-            left.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            break;
-        case 3:
-            node.left = rightLeft;
-            setParent(rightLeft, node);
-            right.left = left;
-            setParent(left, right);
-
-            right.refit();
-            //update leaf count
-            node.right.updateLeafNodeCount();
-            break;
-        case 4:
-            node.left = rightRight;
-            setParent(rightRight, node);
-            right.right = left;
-            setParent(left, right);
-
-            right.refit();
-            //update leaf count
-            node.right.updateLeafNodeCount();
-            break;
-        case 5:
-            left.right = rightLeft;
-            setParent(rightLeft, left);
-            right.left = leftRight;
-            setParent(leftRight, right);
-
-            left.refit();
-            right.refit();
-
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            node.right.updateLeafNodeCount();
-            break;
-        case 6:
-            left.right = rightRight;
-            setParent(rightRight, left);
-            right.right = leftRight;
-            setParent(leftRight, right);
-
-            left.refit();
-            right.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            node.right.updateLeafNodeCount();
-            break;
-    }
-
-    return bestRotation;
-}
-
 /**
  *
  * @param {BinaryNode} root
  * @param {int} maxIterations
  */
-function optimize(root, maxIterations = 1000) {
+export function optimize(root, maxIterations = 1000) {
     const traverser = new StacklessTraverser();
 
     traverser.init(root);
@@ -376,8 +121,3 @@ function optimize(root, maxIterations = 1000) {
 
     return changeCounter;
 }
-
-export {
-    optimize,
-    tryRotateSingleNode
-};

package/core/bvh2/transform/tryRotateSingleNode.js

@@ -0,0 +1,259 @@
+import { boxSurfaceArea2 as computeArea, scoreBoxesSAH as computeAreaFor2 } from "../aabb3/AABB3Math.js";
+import { surfaceAreaHeuristic as sah } from "../sah/surfaceAreaHeuristic.js";
+import { isLeaf } from "../LeafNode.js";
+
+/**
+ *
+ * @param {Node} node
+ * @param {BinaryNode} parent
+ */
+function setParent(node, parent) {
+    node.parentNode = parent;
+}
+
+/**
+ * Based on paper "Fast, Effective BVH Updates for Animated Scenes" Kopta et. al. (url: http://www.cs.utah.edu/~thiago/papers/rotations.pdf)
+ * @param {BinaryNode} node
+ * @returns {int} value from 0 to 6, 0 means no rotation has taken place
+ */
+export function tryRotateSingleNode(node) {
+
+    const left = node.left;
+    const right = node.right;
+
+    if (left === null || right === null) {
+        return 0;
+    }
+
+    /*
+     First we compute best rotation to apply, enumerated by 0-6
+     */
+
+    let bestRotation = 0;
+
+
+    const nodeArea = computeArea(node);
+    const leftArea = computeArea(left);
+    const rightArea = computeArea(right);
+
+    const leftLeaves = left.leafNodeCount;
+    const rightLeaves = right.leafNodeCount;
+
+
+    let bestCost = sah(
+        nodeArea,
+        leftArea,
+        rightArea,
+        leftLeaves,
+        rightLeaves
+    );
+
+    let candidateCost;
+
+    let leftLeftArea,
+        leftRightArea,
+        rightLeftArea,
+        rightRightArea;
+
+    let leftLeft,
+        leftRight,
+        rightLeft,
+        rightRight;
+
+    let leftLeftLeaves,
+        leftRightLeaves,
+        rightLeftLeaves,
+        rightRightLeaves;
+
+    let considerLeft = !isLeaf(left);
+
+    if (considerLeft) {
+        leftLeft = left.left;
+        leftRight = left.right;
+
+        considerLeft = (leftLeft !== null && leftRight !== null);
+        if (considerLeft) {
+
+            leftLeftArea = computeArea(leftLeft);
+            leftRightArea = computeArea(leftRight);
+
+            leftLeftLeaves = leftLeft.leafNodeCount;
+            leftRightLeaves = leftRight.leafNodeCount;
+
+            // (1)    N                     N      //
+            //       / \                   / \     //
+            //      L   R     ----->      L   LL   //
+            //     / \                   / \       //
+            //   LL   LR                R   LR     //
+            candidateCost = sah(nodeArea, computeAreaFor2(right, leftRight), leftLeftArea, rightLeaves + leftRightLeaves, leftLeftLeaves);
+
+            if (candidateCost < bestCost) {
+                bestRotation = 1;
+                bestCost = candidateCost;
+            }
+
+            // (2)    N                     N      //
+            //       / \                   / \     //
+            //      L   R     ----->      L   LR   //
+            //     / \                   / \       //
+            //   LL   LR               LL   R      //
+            candidateCost = sah(nodeArea, computeAreaFor2(leftLeft, right), leftRightArea, leftLeftLeaves + rightLeaves, leftRightLeaves);
+
+
+            if (candidateCost < bestCost) {
+                bestRotation = 2;
+                bestCost = candidateCost;
+            }
+        }
+    }
+    if (!isLeaf(right)) {
+        rightLeft = right.left;
+        rightRight = right.right;
+        if (rightLeft !== null && rightRight !== null) {
+
+            rightLeftArea = computeArea(rightLeft);
+            rightRightArea = computeArea(rightRight);
+
+            rightLeftLeaves = rightLeft.leafNodeCount;
+            rightRightLeaves = rightRight.leafNodeCount;
+
+            // (3)    N                     N        //
+            //       / \                   / \       //
+            //      L   R     ----->     RL   R      //
+            //         / \                   / \     //
+            //       RL   RR                L   RR   //
+            candidateCost = sah(nodeArea, rightLeftArea, computeAreaFor2(left, rightRight), rightLeftLeaves, leftLeaves + rightRightLeaves);
+
+            if (candidateCost < bestCost) {
+                bestRotation = 3;
+                bestCost = candidateCost;
+            }
+
+            // (4)    N                     N       //
+            //       / \                   / \      //
+            //      L   R     ----->     RR   R     //
+            //         / \                   / \    //
+            //       RL   RR               RL   L   //
+            candidateCost = sah(nodeArea, rightRightArea, computeAreaFor2(rightLeft, left), rightRightLeaves, rightLeftLeaves + leftLeaves);
+
+
+            if (candidateCost < bestCost) {
+                bestRotation = 4;
+                bestCost = candidateCost;
+            }
+
+            if (considerLeft) {
+                //both child nodes are not leaf
+
+                // (5)       N                      N        //
+                //         /   \                  /   \      //
+                //        L     R     ----->     L     R     //
+                //       / \   / \              / \   / \    //
+                //      LL LR RL RR            LL RL LR RR   //
+                candidateCost = sah(
+                    nodeArea,
+                    computeAreaFor2(leftLeft, rightLeft),
+                    computeAreaFor2(leftRight, rightRight),
+                    leftLeftLeaves + rightLeftLeaves,
+                    leftRightLeaves + rightRightLeaves
+                );
+
+
+                if (candidateCost < bestCost) {
+                    bestRotation = 5;
+                    bestCost = candidateCost;
+                }
+
+                // (6)       N                      N        //
+                //         /   \                  /   \      //
+                //        L     R     ----->     L     R     //
+                //       / \   / \              / \   / \    //
+                //      LL LR RL RR            LL RR RL LR   //
+                candidateCost = sah(
+                    nodeArea,
+                    computeAreaFor2(leftLeft, rightRight),
+                    computeAreaFor2(rightLeft, leftRight),
+                    leftLeftLeaves + rightRightLeaves,
+                    rightLeftLeaves + leftRightLeaves
+                );
+
+                if (candidateCost < bestCost) {
+                    bestRotation = 6;
+                }
+            }
+        }
+    }
+
+    switch (bestRotation) {
+        case 0:
+            //no rotation
+            break;
+        case 1:
+            node.right = leftLeft;
+            setParent(leftLeft, node);
+            left.left = right;
+            setParent(right, left);
+
+            left.refit();
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            break;
+        case 2:
+            node.right = leftRight;
+            setParent(leftRight, node);
+            left.right = right;
+            setParent(right, left);
+
+            left.refit();
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            break;
+        case 3:
+            node.left = rightLeft;
+            setParent(rightLeft, node);
+            right.left = left;
+            setParent(left, right);
+
+            right.refit();
+            //update leaf count
+            node.right.updateLeafNodeCount();
+            break;
+        case 4:
+            node.left = rightRight;
+            setParent(rightRight, node);
+            right.right = left;
+            setParent(left, right);
+
+            right.refit();
+            //update leaf count
+            node.right.updateLeafNodeCount();
+            break;
+        case 5:
+            left.right = rightLeft;
+            setParent(rightLeft, left);
+            right.left = leftRight;
+            setParent(leftRight, right);
+
+            left.refit();
+            right.refit();
+
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            node.right.updateLeafNodeCount();
+            break;
+        case 6:
+            left.right = rightRight;
+            setParent(rightRight, left);
+            right.right = leftRight;
+            setParent(leftRight, right);
+
+            left.refit();
+            right.refit();
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            node.right.updateLeafNodeCount();
+            break;
+    }
+
+    return bestRotation;
+}

package/core/events/signal/Signal.js

@@ -162,7 +162,7 @@ export class Signal {
      * @param {*} [context]
      */
     add(h, context) {
-        assert.typeOf(h, "function", "handler");
+        assert.isFunction(h, "handler");
 
         // if (!ENV_PRODUCTION) {
         //     if (this.handlers.length + 1 === 100) {

package/engine/asset/loaders/ArrayBufferLoader.js

@@ -1,5 +1,6 @@
 import { Asset } from "../Asset.js";
 import { AssetLoader } from "./AssetLoader.js";
+import { CrossOriginKind } from "../CORS/CrossOriginKind.js";
 
 export class ArrayBufferLoader extends AssetLoader {
     load(path, success, failure, progress) {
@@ -8,6 +9,12 @@ export class ArrayBufferLoader extends AssetLoader {
         xhr.open('GET', path, true);
         xhr.responseType = "arraybuffer";
 
+        const coc = this.assetManager.crossOriginConfig;
+
+        if (coc.kind === CrossOriginKind.UseCredentials) {
+            xhr.withCredentials = true;
+        }
+
         xhr.addEventListener('load', function () {
             if (xhr.readyState === xhr.DONE && xhr.status === 200) {
                 const arrayBuffer = xhr.response;

package/engine/asset/loaders/image/ImageRGBADataLoader.js

@@ -4,11 +4,11 @@ import { GameAssetType } from "../../GameAssetType.js";
 import { convertTexture2Sampler2D } from "../../../graphics/texture/sampler/convertTexture2Sampler2D.js";
 import { ImageRGBADataAsset } from "./ImageRGBADataAsset.js";
 import { ArrayBufferLoader } from "../ArrayBufferLoader.js";
-import { noop } from "../../../../core/function/Functions.js";
 import { CodecWithFallback } from "./codec/CodecWithFallback.js";
 import { ThreadedImageDecoder } from "./codec/ThreadedImageDecoder.js";
 import { NativeImageDecoder } from "./codec/NativeImageDecoder.js";
 
+const ASSET_TYPE_ARRAY_BUFFER = "arraybuffer";
 
 export class ImageRGBADataLoader extends AssetLoader {
     constructor() {
@@ -20,6 +20,15 @@ export class ImageRGBADataLoader extends AssetLoader {
         );
     }
 
+    async link(assetManager, engine) {
+
+        if (assetManager.getLoaderByType(ASSET_TYPE_ARRAY_BUFFER) === undefined) {
+            assetManager.registerLoader(ASSET_TYPE_ARRAY_BUFFER, new ArrayBufferLoader());
+        }
+
+        super.link(assetManager, engine);
+    }
+
     /**
      *
      * @param {string} path
@@ -27,11 +36,7 @@ export class ImageRGBADataLoader extends AssetLoader {
      * @private
      */
     async __decode_via_worker(path) {
-        const loader = new ArrayBufferLoader();
-
-        const asset = await new Promise((resolve, reject) => {
-            loader.load(path, resolve, reject, noop);
-        });
+        const asset = await this.assetManager.promise(path, ASSET_TYPE_ARRAY_BUFFER);
 
         /**
          * @type {ArrayBuffer}

package/engine/ecs/EntityBuilder.js

@@ -132,7 +132,7 @@ class EntityBuilder {
             throw new Error("Can not add " + componentInstance + " to EntityBuilder");
         }
 
-        assert.notOk(this.getComponent(componentInstance.__proto__.constructor) !== null, `Component of this type already exists`);
+        assert.notOk(this.getComponent(componentInstance.__proto__.constructor) !== null, 'Component of this type already exists');
 
         this.element.push(componentInstance);
 
@@ -150,12 +150,16 @@ class EntityBuilder {
      * @returns {T|null} component of specified class
      */
     getComponent(klass) {
-        for (let i = 0; i < this.element.length; i++) {
-            const component = this.element[i];
+        const elements = this.element;
+        const element_count = elements.length;
+
+        for (let i = 0; i < element_count; i++) {
+            const component = elements[i];
             if (component instanceof klass) {
                 return component;
             }
         }
+
         return null;
     }
 
@@ -314,7 +318,10 @@ class EntityBuilder {
         assert.defined(dataset, "dataset");
         assert.notNull(dataset, "dataset");
 
-        if (this.getFlag(EntityBuilderFlags.Built) && checkExistingComponents(this.entity, this.element, dataset)) {
+        if (
+            this.getFlag(EntityBuilderFlags.Built)
+            && checkExistingComponents(this.entity, this.element, dataset)
+        ) {
             //already built
             return this.entity;
         }
@@ -322,7 +329,7 @@ class EntityBuilder {
         const entity = this.entity = dataset.createEntity();
         this.dataset = dataset;
 
-        let i, l;
+        let i;
 
         const listeners = this.deferredListeners;
         const listeners_count = listeners.length;

package/engine/ecs/EntityComponentDataset.js

@@ -122,6 +122,13 @@ export class EntityComponentDataset {
          */
         this.componentTypeMap = [];
 
+        /**
+         * Fast index lookup from a component class
+         * @type {Map<Class, number>}
+         * @private
+         */
+        this.__type_to_index_map = new Map();
+
         /**
          * How many component types exist for this collection. This is the same as componentMap.length
          * @private
@@ -605,6 +612,13 @@ export class EntityComponentDataset {
         updateObservers(indexRemapping);
 
         this.componentTypeMap = map;
+
+        // rebuild class->index lookup
+        this.__type_to_index_map.clear();
+        for (let i = 0; i < newComponentTypeCount; i++) {
+            this.__type_to_index_map.set(map[i], i);
+        }
+
         this.componentTypeCount = newComponentTypeCount;
     }
 
@@ -876,7 +890,13 @@ export class EntityComponentDataset {
      * @returns {number}
      */
     computeComponentTypeIndex(klass) {
-        return this.componentTypeMap.indexOf(klass);
+        const idx = this.__type_to_index_map.get(klass);
+
+        if (idx === undefined) {
+            return -1;
+        }
+
+        return idx;
     }
 
     /**
@@ -926,16 +946,16 @@ export class EntityComponentDataset {
     addComponentToEntity(entityIndex, componentInstance) {
 
         if (!ENV_PRODUCTION) {
-            assert.notEqual(componentInstance, null, "componentInstance is null");
+            assert.notNull(componentInstance, "componentInstance");
 
-            assert.notEqual(componentInstance, undefined, "componentInstance is undefined");
+            assert.defined(componentInstance, "componentInstance");
         }
 
         const klass = componentInstance.constructor;
 
-        const componentTypeIndex = this.componentTypeMap.indexOf(klass);
+        const componentTypeIndex = this.__type_to_index_map.get(klass);
 
-        if (componentTypeIndex === -1) {
+        if (typeof componentTypeIndex !== "number") {
 
 
             throw new Error(`Component class not found in this dataset for componentInstance ${stringifyComponent(componentInstance)}`);
@@ -1509,7 +1529,7 @@ export class EntityComponentDataset {
     sendEvent(entity, name, event) {
         // console.log("sendEvent", entity, name, event);
 
-        assert.typeOf(name, "string", "name");
+        assert.isString(name, "name");
 
         dispatchEntityEventListeners(this.__entityEventListeners, entity, name, event);
 

package/engine/ecs/attachment/AttachmentSystem.js

@@ -175,7 +175,7 @@ export class AttachmentSystem extends System {
 
                 const boneName = attachmentSocket.boneName;
 
-                assert.typeOf(boneName, 'string', 'boneName');
+                assert.isString(boneName, 'boneName');
 
                 //try to get the bone
                 const mesh = ecd.getComponent(parent, Mesh);

package/engine/ecs/sockets/AttachmentSockets.js

@@ -18,7 +18,17 @@ export class AttachmentSockets {
      * @returns {AttachmentSocket|undefined}
      */
     get(id) {
-        return this.elements.find(s => s.id === id);
+        const elements = this.elements;
+        const n = elements.length;
+
+        for (let i = 0; i < n; i++) {
+            const socket = elements.get(i);
+
+            if (socket.id === id) {
+                return socket;
+            }
+        }
+
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/sample/load_gltf.js

@@ -46,9 +46,15 @@ async function main(engine) {
 
     const three_object = asset.create();
 
+    console.time('composition conversion');
     const composition = three_object_to_entity_composition(three_object);
+    console.timeEnd('composition conversion');
 
+    console.time('composition build');
+    // console.profile('composition build');
     composition.build(ecd);
+    // console.profileEnd('composition build');
+    console.timeEnd('composition build');
 }
 
 init(eh);

package/engine/sound/ecs/emitter/SoundEmitterSystem.js

@@ -14,11 +14,11 @@ import { BinaryNode } from "../../../../core/bvh2/BinaryNode.js";
 import SoundListener from "../SoundListener.js";
 import { IncrementalDeltaSet } from "../../../graphics/render/visibility/IncrementalDeltaSet.js";
 import { queryBinaryNode_SphereIntersections_Data } from "../../../../core/bvh2/traversal/queryBinaryNode_SphereIntersections.js";
-import { tryRotateSingleNode } from "../../../../core/bvh2/transform/RotationOptimizer.js";
 import { SoundEmitterComponentContext } from "./SoundEmitterComponentContext.js";
 import { SoundEmitterFlags } from "./SoundEmitterFlags.js";
 import { SoundEmitterChannel } from "./SoundEmitterChannel.js";
 import { invokeObjectCompare } from "../../../../core/model/object/invokeObjectCompare.js";
+import { tryRotateSingleNode } from "../../../../core/bvh2/transform/tryRotateSingleNode.js";
 
 /**
  * @readonly

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.34",
+  "version": "2.34.35",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",