@woosh/meep-engine 2.33.24 → 2.33.28

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

@@ -40,7 +40,7 @@ function obtainSampler(bitmap, ctx) {
 }
 
 /**
- *
+ * Ref holding webgl context, being weak-ref, allows context to be removed when not in use
  * @type {WeakRef<WebGL2RenderingContext>|null}
  */
 let ctx_ref = null;
@@ -97,8 +97,13 @@ export function sampler_from_bitmap(bitmap) {
  * @returns {boolean}
  */
 export function computeImageBitmapEquality(a, b) {
+    if (a === b) {
+        // strict equality check, special case
+        return true;
+    }
 
     if (a.width !== b.width || a.height !== b.height) {
+        // check dimensions
         return false;
     }
 

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/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/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;
+    }
+
 
     /**
      *