@woosh/meep-engine 2.34.31 → 2.34.35

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/collection/list/List.js

@@ -719,40 +719,6 @@ List.prototype.copy = function (other) {
     }
 };
 
-/**
- *
- * @param {List} other
- * @param {function} elementComparator
- * @returns {number} -1, 0 or 1
- */
-List.prototype.compare = function (other, elementComparator) {
-    const thisLength = this.length;
-    const otherLength = other.length;
-
-    const deltaLength = thisLength - otherLength;
-
-    if (deltaLength !== 0) {
-        return deltaLength;
-    }
-
-    for (let i = 0; i < thisLength; i++) {
-        const thisElement = this.get(i);
-        const otherElement = other.get(i);
-
-        if (thisElement === otherElement) {
-            continue;
-        }
-
-        const elementDelta = elementComparator(thisElement, otherElement);
-
-        if (elementDelta !== 0) {
-            return elementDelta;
-        }
-    }
-
-    return 0;
-};
-
 /**
  * NOTE: do not modify resulting array
  * @returns {T[]}

package/core/collection/table/DataTypeByteSizes.js

@@ -19,3 +19,19 @@ export const DataTypeByteSizes = {
     [DataType.Float32]: 4,
     [DataType.Float64]: 8
 };
+
+
+/**
+ *
+ * @param {DataType} type
+ * @return {number}
+ */
+export function dataTypeByteSize(type) {
+    const size = DataTypeByteSizes[type];
+
+    if (size === undefined) {
+        throw new Error(`Unsupported type '${type}'`);
+    }
+
+    return size;
+}

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/Engine.js

@@ -131,6 +131,11 @@ class Engine {
             const v_fps = (1 / stats.mean).toFixed(2);
 
 
+            // clear stats
+            m_render.clear();
+            m_sim.clear();
+            m_frame.clear();
+
             return `FPS: ${v_fps}, RENDER: ${v_render}ms, SIMULATION: ${v_sim}ms`;
         });
 

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/development/performance/AbstractMetric.js

@@ -21,4 +21,8 @@ export class AbstractMetric {
     computeStats(result) {
         throw new Error('Not implemented');
     }
+
+    clear(){
+        throw new Error('Not implemented');
+    }
 }

package/engine/development/performance/RingBufferMetric.js

@@ -31,4 +31,8 @@ export class RingBufferMetric extends AbstractMetric {
         result.max = computeArrayMax(array, 0, data_count);
         result.min = computeArrayMin(array, 0, data_count);
     }
+
+    clear() {
+        this.__data.clear();
+    }
 }

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/ecs/transform/Transform.js

@@ -162,7 +162,7 @@ export class Transform {
 
     /**
      *
-     * @param {Matrix4} matrix
+     * @param {THREE.Matrix4} matrix
      */
     fromThreeMatrix4(matrix) {
         this.fromMatrix4(matrix.elements);

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -125,16 +125,29 @@ export class ShadedGeometry {
     }
 
     __build_object() {
+        /**
+         * @type {THREE.Object3D}
+         */
+        let object;
+
         const mode = this.mode;
+        const shader = this.material;
+        const geo = this.geometry;
+
         if (mode === DrawMode.Triangles) {
-            this.__cached_object = new Mesh(this.geometry, this.material);
+            object = new Mesh(geo, shader);
         } else if (mode === DrawMode.Lines) {
-            this.__cached_object = new Line(this.geometry, this.material);
+            object = new Line(geo, shader);
         } else if (mode === DrawMode.LineSegments) {
-            this.__cached_object = new LineSegments(this.geometry, this.material);
+            object = new LineSegments(geo, shader);
         } else {
             throw new Error(`Unsupported draw mode '${mode}'`);
         }
+
+        object.matrixAutoUpdate = false;
+        object.frustumCulled = false;
+
+        this.__cached_object = object;
     }
 
     get bvh() {

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -81,6 +81,9 @@ export class ShadedGeometrySystem extends System {
 
         const leaf_node = sg.bvh;
 
+        // record entity on the BVH leaf
+        leaf_node.entity = entity;
+
         // remember entity for lookups
         sg.__entity = entity;