@woosh/meep-engine 2.33.22 → 2.33.26

package/engine/EngineHarness.js

@@ -367,6 +367,7 @@ export class EngineHarness {
             sensitivity
         });
 
+        eb.add(Tag.fromJSON(['CameraController']));
         eb.add(SerializationMetadata.Transient);
 
         eb.build(ecd);

package/engine/animation/AnimationUtils.js

@@ -7,7 +7,7 @@ import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
 import { createSound, createTimer } from "../EntityCreator.js";
 import Mesh from "../graphics/ecs/mesh/Mesh.js";
 import Trail2D, { Trail2DFlags } from "../graphics/ecs/trail2d/Trail2D.js";
-import { ParticleEmitterSystem2 } from "../graphics/particles/ecs/ParticleEmitterSystem2.js";
+import { ParticleEmitterSystem } from "../graphics/particles/ecs/ParticleEmitterSystem.js";
 import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
 import { ParticleEmitterFlag } from "../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
 import { distributeParticlesOnObject3D } from "../graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js";
@@ -137,9 +137,9 @@ export function removeEntityWithMeshParticlesEffect(
 
     /**
      *
-     * @type {ParticleEmitterSystem2}
+     * @type {ParticleEmitterSystem}
      */
-    const sPE = entityManager.getSystem(ParticleEmitterSystem2);
+    const sPE = entityManager.getSystem(ParticleEmitterSystem);
 
     /**
      *
@@ -214,9 +214,9 @@ export function removeEntityGenericEffect(
 
     /**
      *
-     * @type {ParticleEmitterSystem2}
+     * @type {ParticleEmitterSystem}
      */
-    const sPE = engine.entityManager.getSystem(ParticleEmitterSystem2);
+    const sPE = engine.entityManager.getSystem(ParticleEmitterSystem);
 
     /**
      *

package/engine/animation/curve/AnimationCurve.js

@@ -0,0 +1,72 @@
+import { inverseLerp } from "../../../core/math/inverseLerp.js";
+
+/**
+ *
+ * @param {number} t
+ * @param {Keyframe} keyframe0
+ * @param {Keyframe} keyframe1
+ * @return {number}
+ */
+function evaluate(t, keyframe0, keyframe1) {
+
+    const dt = keyframe1.time - keyframe0.time;
+
+    const m0 = keyframe0.outTangent * dt;
+    const m1 = keyframe1.inTangent * dt;
+
+    const t2 = t * t;
+    const t3 = t2 * t;
+
+    const a = 2 * t3 - 3 * t2 + 1;
+    const b = t3 - 2 * t2 + t;
+    const c = t3 - t2;
+    const d = -2 * t3 + 3 * t2;
+
+    return a * keyframe0.value + b * m0 + c * m1 + d * keyframe1.value;
+}
+
+/**
+ * Modelled on unity's AnimationCurve
+ * @see https://github.com/nothke/ThreadableCurve/blob/master/ThreadableCurve.cs
+ */
+export class AnimationCurve {
+    constructor() {
+        /**
+         *
+         * @type {Keyframe[]}
+         */
+        this.keys = [];
+    }
+
+    evaluate(t) {
+        const keys = this.keys;
+        const key_count = keys.length;
+        if (key_count === 0) {
+            return 0;
+        }
+
+        if (key_count === 1) {
+            return keys[0].value;
+        }
+
+        if (t < keys[0].time) {
+            // before start
+            return keys[0].value;
+        }
+
+        for (let i = 1; i < key_count; i++) {
+            const f1 = keys[i];
+
+            if (t < f1.time) {
+                const f0 = keys[i - 1];
+                const kt = inverseLerp(f0.time, f1.time, t);
+
+                return evaluate(kt, f0, f1);
+            }
+        }
+
+        // past end
+        return keys[key_count - 1].value;
+    }
+
+}

package/engine/animation/curve/Keyframe.js

@@ -0,0 +1,27 @@
+export class Keyframe {
+    constructor() {
+        /**
+         *
+         * @type {number}
+         */
+        this.value = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.time = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.inTangent = 0;
+
+        /**
+         *
+         * @type {number}
+         */
+        this.outTangent = 0;
+    }
+}

package/engine/animation/keyed2/AnimationTrack.js

@@ -19,18 +19,43 @@ function AnimationTrack(properties) {
      */
     this.propertyCount = properties.length;
 
+    /**
+     *
+     * @type {number[]}
+     */
     this.keyValues = [];
+
+    /**
+     *
+     * @type {number[]}
+     */
     this.keyTimes = [];
 
     this.timeStart = Number.POSITIVE_INFINITY;
     this.timeEnd = Number.NEGATIVE_INFINITY;
 
+    /**
+     * Indices of keys from which transition takes place
+     * @type {number[]}
+     */
     this.transitionKeys = [];
+
+    /**
+     * Transition function associated with a key
+     * @type {function[]}
+     */
     this.transitionFunctions = [];
 }
 
-AnimationTrack.prototype.initialize = function () {
-    const keysTyped = new Float64Array(this.keyValues.length);
+AnimationTrack.prototype.optimize = function () {
+    const key_value_count = this.keyValues.length;
+    const key_count = this.keyTimes.length;
+
+    // use a common buffer to get better cache locality
+    const buffer = new ArrayBuffer(key_count * 4 + key_value_count * 8);
+
+    const keyTimesTyped = new Float32Array(buffer, 0, key_count);
+    const keysTyped = new Float64Array(buffer, key_count * 4, key_value_count);
 
     //transfer original keys into typed array
     keysTyped.set(this.keyValues, 0);
@@ -38,7 +63,6 @@ AnimationTrack.prototype.initialize = function () {
     //overwrite the original array
     this.keyValues = keysTyped;
 
-    const keyTimesTyped = new Float32Array(this.keyTimes.length);
     keyTimesTyped.set(this.keyTimes, 0);
 
     this.keyTimes = keyTimesTyped;

package/engine/asset/Asset.js

@@ -4,9 +4,9 @@
  * @param {string} type
  * @constructor
  */
-import { computeHashIntegerArray } from "../../core/math/MathUtils.js";
 import { assert } from "../../core/assert.js";
 import { computeStringHash } from "../../core/primitives/strings/computeStringHash.js";
+import { computeHashIntegerArray } from "../../core/collection/array/computeHashIntegerArray.js";
 
 export class AssetDescription {
     /**

package/engine/asset/loaders/GLTFAssetLoader.d.ts

@@ -2,5 +2,5 @@ import {AssetLoader} from "./AssetLoader";
 import {Object3D} from "three";
 
 export class GLTFAssetLoader extends AssetLoader<Object3D> {
-
+    setDracoDecoderPath(path: string): void
 }

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -127,6 +127,8 @@ export class GLTFAssetLoader extends AssetLoader {
 
         this.__dracoLoader = new DRACOLoader();
         this.__dracoLoader.setWorkerLimit(1);
+
+        // set default path
         this.__dracoLoader.setDecoderPath(buildDracoDecoderPath());
 
         const loader = new GLTFLoader();
@@ -156,6 +158,14 @@ export class GLTFAssetLoader extends AssetLoader {
         });
     }
 
+    /**
+     *
+     * @param {string} p
+     */
+    setDracoDecoderPath(p) {
+        this.__dracoLoader.setDecoderPath(p);
+    }
+
     /**
      *
      * @param {boolean} v

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

@@ -28,6 +28,12 @@ export class ImageRGBADataAsset extends Asset {
          */
         this.height = height;
 
+        /**
+         * Number of channels
+         * @type {number}
+         */
+        this.itemSize = 4;
+
         this.byteSize = data.length;
     }
 
@@ -35,7 +41,8 @@ export class ImageRGBADataAsset extends Asset {
         return {
             data: this.data,
             width: this.width,
-            height: this.height
+            height: this.height,
+            itemSize: this.itemSize
         };
     }
 }

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

@@ -79,6 +79,17 @@ function obtainCanvasCtx(width, height) {
     return gl;
 }
 
+/**
+ *
+ * @param {ImageBitmap} bitmap
+ * @return {Sampler2D}
+ */
+export function sampler_from_bitmap(bitmap) {
+    const ctx = obtainCanvasCtx(bitmap.width, bitmap.height);
+
+    return obtainSampler(bitmap, ctx);
+}
+
 /**
  *
  * @param {ImageBitmap} a

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

@@ -1,47 +1,41 @@
 import { min2 } from "../../../../core/math/min2.js";
-import { computeIntegerArrayHash } from "../../../../core/primitives/array/computeIntegerArrayHash.js";
+import { sampler_from_bitmap } from "./computeImageBitmapEquality.js";
 
-let canvas = null;
-let canvasContext = null;
 
 /**
  *
- * @returns {CanvasRenderingContext2D}
+ * @param {ImageBitmap} bitmap
+ * @returns {number}
  */
-function getCanvasContext() {
+export function computeImageBitmapHash(bitmap) {
 
-    if (canvasContext === null) {
-        canvas = document.createElement('canvas');
+    const w = min2(bitmap.width, 8);
+    const h = min2(bitmap.height, 8);
 
-        canvas.height = 8;
-        canvas.width = 8;
+    const sampler = sampler_from_bitmap(bitmap);
 
-        canvasContext = canvas.getContext('2d');
+    const sampler_data = sampler.data;
+    const item_size = sampler.itemSize;
 
-    }
+    let hash = 0;
 
-    return canvasContext;
+    for (let y = 0; y < h; y++) {
 
-}
+        const row_size = y * sampler.width;
 
-/**
- *
- * @param {ImageBitmap} bitmap
- * @returns {number}
- */
-export function computeImageBitmapHash(bitmap) {
-    const ctx = getCanvasContext();
+        for (let x = 0; x < w; x++) {
 
-    const w = min2(bitmap.width, 8);
-    const h = min2(bitmap.height, 8);
+            const texel_index = x + row_size;
+            const address = texel_index * item_size;
 
-    ctx.clearRect(0, 0, w, h);
+            for (let i = 0; i < item_size; i++) {
 
-    ctx.drawImage(bitmap, 0, 0, w, h, 0, 0, w, h);
+                const v = sampler_data[address];
 
-    const imageData = ctx.getImageData(0, 0, w, h);
-
-    const data = imageData.data;
+                hash = (hash << 5) - hash + v;
+            }
+        }
+    }
 
-    return computeIntegerArrayHash(data, 0, data.length);
+    return hash;
 }

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

@@ -1,7 +1,9 @@
-import { computeHashArray, computeHashFloat, computeHashIntegerArray } from "../../../../core/math/MathUtils.js";
 import { planeHash } from "./planeHash.js";
 import { computeTextureHash } from "./computeTextureHash.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { computeHashArray } from "../../../../core/collection/array/computeHashArray.js";
+import { computeHashIntegerArray } from "../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../core/math/hash/computeHashFloat.js";
 
 /**
  *

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/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', () => {