@woosh/meep-engine 2.33.23 → 2.33.27

package/engine/asset/loaders/material/computeTextureEquality.js

@@ -1,4 +1,5 @@
 import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 
 //
 
@@ -50,20 +51,10 @@ export function computeTextureEquality(a, b) {
         const aMipmaps = a.mipmaps;
         const bMipmaps = b.mipmaps;
 
-        const n = aMipmaps.length;
-
-        if (n !== bMipmaps.length) {
+        if (!textureMipChainEqual(aMipmaps, bMipmaps)) {
             return false;
         }
 
-        for (let i = 0; i < n; i++) {
-            const aMipmap = aMipmaps[i];
-            const bMipmap = bMipmaps[i];
-
-            if (!textureMipmapEqual(aMipmap, bMipmap)) {
-                return false;
-            }
-        }
     }
 
     //TODO implement support for other texture types
@@ -119,47 +110,52 @@ export function textureImagesEqual(a, b) {
             const bMipmaps = bi.mipmaps;
 
             //TODO should we ignore mipmaps if they are absent?
-            if (aMipmaps === undefined) {
-                if (bMipmaps === undefined) {
-                    continue;
-                } else {
-                    return false;
-                }
-            } else if (bMipmaps === undefined) {
+            if (!textureMipChainEqual(aMipmaps, bMipmaps)) {
                 return false;
             }
+        }
+
+    }
 
-            for (let j = 0; j < aMipmaps.length; j++) {
-                const aMipmap = aMipmaps[j];
-                const bMipmap = bMipmaps[j];
+    // assume equivalent
+    return true;
+}
+
+/**
+ *
+ * @param {[]} a
+ * @param {[]} b
+ * @returns {boolean}
+ */
+function textureMipChainEqual(a, b) {
+    if (a === undefined) {
+        if (b === undefined) {
+            return true;
+        } else {
+            return false;
+        }
+    } else if (b === undefined) {
+        return false;
+    }
 
-                /**
-                 * @type {Uint8Array}
-                 */
-                const aData = aMipmap.data;
+    const a_length = a.length;
 
-                /**
-                 * @type {Uint8Array}
-                 */
-                const bData = bMipmap.data;
+    if (a_length !== b.length) {
+        // different mip chain length
+        return false;
+    }
 
-                const dataLength = aData.length;
-                if (dataLength !== bData.length) {
-                    return false;
-                }
+    for (let j = a_length - 1; j >= 0; j--) { //traverse chain top to bottom, starting from smallest mip for faster rejection
 
+        const aMipmap = a[j];
+        const bMipmap = b[j];
 
-                for (let k = 0; k < dataLength; k++) {
-                    if (aData[k] !== bData[k]) {
-                        return false;
-                    }
-                }
-            }
+        if (!textureMipmapEqual(aMipmap, bMipmap)) {
+            return false;
         }
 
     }
 
-    // assume equivalent
     return true;
 }
 
@@ -182,16 +178,11 @@ function textureMipmapEqual(a, b) {
     const aData = a.data;
     const bData = b.data;
 
-    const n = aData.length;
-    if (bData.length !== n) {
-        return false;
-    }
 
-    for (let i = 0; i < n; i++) {
-        if (aData[i] !== bData[i]) {
-            return false;
-        }
+    if (aData === bData) {
+        // special case
+        return true;
     }
 
-    return true;
+    return isArrayEqualStrict(aData, bData);
 }

package/engine/asset/loaders/material/computeTextureHash.js

@@ -1,6 +1,7 @@
-import { computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { max2 } from "../../../../core/math/max2.js";
 import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/ecs/EntityBuilder.js

@@ -1,6 +1,7 @@
 import Signal from "../../core/events/signal/Signal.js";
 import { assert } from "../../core/assert.js";
 import { EventType } from "./EntityManager.js";
+import { isDefined } from "../../core/process/matcher/Matchers.js";
 
 /**
  *
@@ -63,7 +64,6 @@ class EntityBuilder {
         this.on = {
             built: new Signal()
         };
-
     }
 
     /**
@@ -238,10 +238,10 @@ class EntityBuilder {
             this.dataset.addEntityEventListener(this.entity, eventName, listener, context);
         } else {
             this.deferredListeners.push({
-                                            name: eventName,
-                                            listener: listener,
-                                            context
-                                        });
+                name: eventName,
+                listener: listener,
+                context
+            });
         }
         return this;
     }
@@ -356,6 +356,26 @@ class EntityBuilder {
         this.on.built.send2(entity, dataset);
         return entity;
     }
+
+    /**
+     *
+     * @param {number} entity
+     * @param {EntityComponentDataset} dataset
+     * @returns {EntityBuilder}
+     */
+    static readFromDataset(entity, dataset) {
+        const r = new EntityBuilder();
+
+        dataset.getAllComponents(entity)
+            .filter(isDefined)
+            .forEach(r.add, r);
+
+        r.setFlag(EntityBuilderFlags.Built);
+        r.entity = entity;
+        r.dataset = dataset;
+
+        return r;
+    }
 }
 
 /**

package/engine/ecs/EntityComponentDataset.js

@@ -1212,7 +1212,7 @@ export class EntityComponentDataset {
 
         if (!ENV_PRODUCTION) {
             assert.isNumber(componentTypeIndex, "componentTypeIndex");
-            assert.typeOf(visitor, "function", "visitor");
+            assert.isFunction(visitor, "visitor");
         }
 
 

package/engine/ecs/animation/Animation.js

@@ -8,7 +8,8 @@ import ObservedString from "../../../core/model/ObservedString.js";
 import ObservedInteger from "../../../core/model/ObservedInteger.js";
 import Vector1 from "../../../core/geom/Vector1.js";
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../core/math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

package/engine/ecs/animation/InverseKinematics.js

@@ -1,7 +1,8 @@
 import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
 import { NumericInterval } from "../../../core/math/interval/NumericInterval.js";
-import { computeHashFloat, computeHashIntegerArray } from "../../../core/math/MathUtils.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../core/math/hash/computeHashFloat.js";
 
 class IKConstraint {
     constructor() {

package/engine/ecs/attachment/AttachmentBinding.js

@@ -30,6 +30,14 @@ export class AttachmentBinding {
         this.attachment = null;
     }
 
+    link() {
+
+    }
+
+    unlink() {
+
+    }
+
     update() {
 
     }

package/engine/ecs/attachment/AttachmentSystem.js

@@ -265,6 +265,8 @@ export class AttachmentSystem extends System {
             //update iterator
             this.waiting.splice(i, 1);
 
+            binding.link();
+
             i--;
             numRecords--;
         }
@@ -305,6 +307,8 @@ export class AttachmentSystem extends System {
                         parentBindings.splice(i, 1);
                     }
 
+                    attachmentBinding.unlink();
+
                     break;
                 }
             }

package/engine/ecs/attachment/TransformAttachmentBinding.js

@@ -1,18 +1,9 @@
-import Vector3 from "../../../core/geom/Vector3.js";
-import { Matrix4, Quaternion as ThreeQuaternion } from "three";
 import { AttachmentBinding } from "./AttachmentBinding.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
+import { mat4 } from "gl-matrix";
 
-const socketM4 = new Matrix4();
-
-const threeQuaternion = new ThreeQuaternion();
-
-const pScale = new Vector3();
-const pPosition = new Vector3();
-
-const attachmentM4 = new Matrix4();
-
-const parentM4 = new Matrix4();
+const scratch_m4_0 = new Float32Array(16);
+const scratch_m4_1 = new Float32Array(16);
+const scratch_m4_2 = new Float32Array(16);
 
 export class TransformAttachmentBinding extends AttachmentBinding {
     constructor() {
@@ -24,40 +15,19 @@ export class TransformAttachmentBinding extends AttachmentBinding {
      * TODO make use of Transform.multiplyTransforms for better readability and performance
      */
     update() {
-        const socketTransform = this.socket.transform;
-
-        threeQuaternion.copy(socketTransform.rotation);
-
-        socketM4.compose(socketTransform.position, threeQuaternion, socketTransform.scale);
-
-        const parentTransform = this.parentTransform;
-
-        threeQuaternion.copy(parentTransform.rotation);
-
-        parentM4.compose(parentTransform.position, threeQuaternion, parentTransform.scale);
-
-        const attachment = this.attachment;
-        const aT = attachment.transform;
-
-        threeQuaternion.copy(aT.rotation);
-
-        attachmentM4.compose(aT.position, threeQuaternion, aT.scale);
-
-        socketM4.multiplyMatrices(parentM4, socketM4);
-        socketM4.multiply(attachmentM4);
-        socketM4.decompose(pPosition, threeQuaternion, pScale);
-
-        const t = this.attachedTransform;
 
-        if (Number.isNaN(threeQuaternion.x)) {
-            t.rotation.copy(Quaternion.identity);
-        } else {
-            t.rotation.copy(threeQuaternion);
-        }
+        this.socket.transform.toMatrix4(scratch_m4_0);
+        this.parentTransform.toMatrix4(scratch_m4_1);
+        this.attachment.transform.toMatrix4(scratch_m4_2);
 
-        t.scale.copy(pScale);
+        mat4.multiply(
+            scratch_m4_0, scratch_m4_1, scratch_m4_0
+        );
+        mat4.multiply(
+            scratch_m4_0, scratch_m4_0, scratch_m4_2
+        );
 
-        t.position.copy(pPosition);
+        this.attachedTransform.fromMatrix4(scratch_m4_0);
     }
 
     link() {

package/engine/ecs/components/Tag.js

@@ -81,6 +81,8 @@ export class Tag {
      * @returns {boolean}
      */
     add(value) {
+        assert.isString(value, 'value');
+
         if (this.contains(value)) {
             return false;
         }
@@ -117,6 +119,8 @@ export class Tag {
      * @returns {boolean}
      */
     contains(value) {
+        assert.isString(value, 'value');
+
         return this.values.indexOf(value) !== -1;
     }
 
@@ -125,16 +129,20 @@ export class Tag {
      * @param {string[]} values
      */
     containsAll(values) {
-        const valueCount = values.length;
+        assert.isArray(values, 'values');
+
+        const search_value_count = values.length;
+
+        const these_values = this.values;
+        const these_values_count = these_values.length;
 
-        const values1 = this.values;
-        const tagCount = values1.length;
+        let i = 0, j = 0;
 
-        main: for (let i = 0; i < valueCount; i++) {
+        main: for (; i < search_value_count; i++) {
             const v = values[i];
 
-            for (let j = 0; j < tagCount; j++) {
-                const tag = values1[j];
+            for (j = 0; j < these_values_count; j++) {
+                const tag = these_values[j];
 
                 if (tag === v) {
                     continue main;
@@ -287,6 +295,19 @@ export class Tag {
         return result;
     }
 
+    /**
+     *
+     * @param {string} tag
+     * @returns {Tag}
+     */
+    static fromOne(tag) {
+        const r = new Tag();
+
+        r.add(tag);
+
+        return r;
+    }
+
 
     /**
      *

package/engine/ecs/dynamic_actions/DynamicActorSystem.js

@@ -14,11 +14,12 @@ import { SerializationMetadata } from "../components/SerializationMetadata.js";
 import Tag from "../components/Tag.js";
 import { OverrideContextBehavior } from "../../../../model/game/util/behavior/OverrideContextBehavior.js";
 import { HashMap } from "../../../core/collection/HashMap.js";
-import { randomFloatBetween, randomFromArray } from "../../../core/math/MathUtils.js";
 import { assert } from "../../../core/assert.js";
 import { RuleExecution } from "./RuleExecution.js";
 import { computeContextualDynamicRuleDebugString } from "./rules/computeContextualDynamicRuleDebugString.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
 
 /**
  * In seconds

package/engine/ecs/dynamic_actions/DynamicRuleDescriptionTable.spec.js

@@ -3,15 +3,13 @@ import { DynamicRuleDescriptionTable } from "./rules/DynamicRuleDescriptionTable
 import { createRandomReactiveExpression } from "../../../core/model/reactive/model/util/createRandomReactiveExpression.js";
 import { ReactiveReference } from "../../../core/model/reactive/model/terminal/ReactiveReference.js";
 import { ReactiveLiteralNumber } from "../../../core/model/reactive/model/terminal/ReactiveLiteralNumber.js";
-import {
-    randomFloatBetween,
-    randomFromArray,
-    randomIntegerBetween
-} from "../../../core/math/MathUtils.js";
 import { ReactiveLiteralString } from "../../../core/model/reactive/model/terminal/ReactiveLiteralString.js";
 import { ReactiveLiteralBoolean } from "../../../core/model/reactive/model/terminal/ReactiveLiteralBoolean.js";
 import { DynamicRuleDescription } from "./rules/DynamicRuleDescription.js";
 import DataType from "../../../core/parser/simple/DataType.js";
+import { randomFromArray } from "../../../core/math/random/randomFromArray.js";
+import { randomFloatBetween } from "../../../core/math/random/randomFloatBetween.js";
+import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
 
 describe.skip('performance', () => {
 

package/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js

@@ -1,7 +1,7 @@
 import { AbstractActionDescription } from "./AbstractActionDescription.js";
 import { WeightedRandomBehavior } from "../../../../intelligence/behavior/selector/WeightedRandomBehavior.js";
 import { WeightedElement } from "../../../../intelligence/behavior/selector/WeightedElement.js";
-import { computeHashFloat } from "../../../../../core/math/MathUtils.js";
+import { computeHashFloat } from "../../../../../core/math/hash/computeHashFloat.js";
 
 export class WeightedRandomActionDescription extends AbstractActionDescription {
     constructor() {

package/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.js

@@ -1,6 +1,6 @@
 import { PointFitnessFunction } from "../PointFitnessFunction.js";
 import { assert } from "../../../../core/assert.js";
-import { gaussian } from "../../../../core/math/MathUtils.js";
+import { gaussian } from "../../../../core/math/gaussian.js";
 
 export class PointFitnessGaussianBlur extends PointFitnessFunction {
     constructor() {