@woosh/meep-engine 2.34.33 → 2.34.37

package/core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js

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

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/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/core/geom/3d/aabb/aabb3_matrix4_project.js

@@ -1,8 +1,7 @@
-
 /**
  * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
- * @param {number[]} result
- * @param {number[]} aabb
+ * @param {ArrayLike<number>|number[]|Float32Array} result
+ * @param {ArrayLike<number>|number[]|Float32Array} aabb
  * @param {number[]} matrix 4x4 matrix
  */
 export function aabb3_matrix4_project(result, aabb, matrix) {
@@ -15,7 +14,7 @@ export function aabb3_matrix4_project(result, aabb, matrix) {
     for (let i = 0; i < 3; i++) {
         for (let j = 0; j < 3; j++) {
 
-            const m_a = i * 4 + j;
+            const m_a = i + j * 4;
             const m_v = matrix[m_a];
 
             const a = m_v * aabb[j];

package/core/geom/3d/aabb/aabb3_matrix4_project.spec.js

@@ -1,4 +1,7 @@
 import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+import { compose_matrix4_array } from "../../../../engine/graphics/util/composeMatrix4.js";
+import Vector3 from "../../Vector3.js";
+import Quaternion from "../../Quaternion.js";
 
 test('identity', () => {
     const r = [];
@@ -39,3 +42,13 @@ test('scale case', () => {
 
     expect(r).toEqual([-5, 4, -27, -1, 14, -9]);
 });
+
+test('translation + scale case', () => {
+    const m4 = [];
+    compose_matrix4_array(m4, new Vector3(-1, 2, -3), Quaternion.identity, new Vector3(7, -11, 13));
+
+    const r = [];
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], m4);
+
+    expect(r).toEqual([6, -75, 36, 34, -20, 114]);
+});

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -95,9 +95,8 @@ export function computeTriangleRayIntersection(
     // Line intersects triangle, check if ray does.
     const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
 
-    // t < 0, no intersection
     if (QdN < 0) {
-
+        // t < 0, no intersection
         return false;
 
     }

package/core/geom/Quaternion.d.ts

@@ -22,4 +22,6 @@ export default class Quaternion {
     threeSetRotationMatrix(result: Matrix4): void
 
     setFromRotationMatrix(m: Matrix4): void
+
+    decodeFromUint32(uint: number): void
 }

package/core/geom/Vector3.js

@@ -523,21 +523,25 @@ class Vector3 {
     /**
      *
      * @param {THREE.Matrix4} matrix4
-     * @returns {Vector3}
      */
     applyMatrix4_three(matrix4) {
+        this.applyMatrix4(matrix4.elements);
+    }
 
+    /**
+     *
+     * @param {ArrayList<number>|number[]|Float32Array} m4
+     */
+    applyMatrix4(m4) {
         const x = this.x;
         const y = this.y;
         const z = this.z;
 
-        const e = matrix4.elements;
-
-        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
-        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
-        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+        const _x = m4[0] * x + m4[4] * y + m4[8] * z + m4[12];
+        const _y = m4[1] * x + m4[5] * y + m4[9] * z + m4[13];
+        const _z = m4[2] * x + m4[6] * y + m4[10] * z + m4[14];
 
-        return this.set(_x, _y, _z);
+        this.set(_x, _y, _z);
     }
 
     /**
@@ -589,11 +593,18 @@ class Vector3 {
      * @param {THREE.Matrix4} matrix4
      */
     threejs_setFromMatrixPosition(matrix4) {
-        const e = matrix4.elements;
+        this.setFromMatrixPosition(matrix4.elements);
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} matrix4 4x4 transform matrix
+     */
+    setFromMatrixPosition(matrix4) {
 
-        const _x = e[12];
-        const _y = e[13];
-        const _z = e[14];
+        const _x = matrix4[12];
+        const _y = matrix4[13];
+        const _z = matrix4[14];
 
         this.set(_x, _y, _z);
     }

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/attachment/TransformAttachmentBinding.js

@@ -8,7 +8,6 @@ const scratch_m4_2 = new Float32Array(16);
 export class TransformAttachmentBinding extends AttachmentBinding {
     constructor() {
         super();
-
     }
 
     /**

package/engine/ecs/foliage/FoliageVisibilitySetBuilder.js

@@ -5,28 +5,13 @@ export class FoliageVisibilitySetBuilder extends BVHVisitor {
     constructor() {
         super();
 
-        /**
-         * Visibility filters
-         * @type {(function(LeafNode):boolean)[]}
-         */
-        this.filters = [];
-
         /**
          *
          * @type {BitSet}
          */
         this.visibleSet = new BitSet();
         //prevent re-allocation
-        this.visibleSet.__shrinkFactor = 0;
-    }
-
-    /**
-     *
-     * @param {(function(LeafNode):boolean)[]} filters
-     */
-    setFilters(filters) {
-        this.filters = filters;
-        this.filterCount = filters.length;
+        this.visibleSet.preventShrink();
     }
 
     initialize() {
@@ -34,21 +19,6 @@ export class FoliageVisibilitySetBuilder extends BVHVisitor {
     }
 
     visitLeaf(node) {
-
-        const n = this.filterCount;
-
-        const filters = this.filters;
-
-        for (let i = 0; i < n; i++) {
-            const visibilityFilter = filters[i];
-
-            if (!visibilityFilter(node)) {
-                //not visible
-                return;
-            }
-
-        }
-
         const index = node.object;
 
         //TODO check screen space size to decide if element should be seen or not