@woosh/meep-engine 2.84.5 → 2.84.8

package/src/core/primitives/strings/string_strip_trailing.spec.js

@@ -0,0 +1,27 @@
+import { string_strip_trailing } from "./string_strip_trailing.js";
+
+test("strip empty from empty", () => {
+    expect(
+        string_strip_trailing("", "")
+    ).toBe("");
+});
+
+test("strip repeating 2 character sequence", () => {
+
+    expect(
+        string_strip_trailing("Cabab", "ab")
+    ).toBe("C");
+
+});
+
+test("mistakes", () => {
+
+    expect(
+        string_strip_trailing("food", "o")
+    ).toBe("food");
+
+    expect(
+        string_strip_trailing("food", "f")
+    ).toBe("food");
+
+});

package/src/core/process/worker/WorkerBuilder.js

@@ -3,7 +3,7 @@
  */
 
 
-import {convertPathToURL} from "../../../engine/network/convertPathToURL.js";
+import { convertPathToURL } from "../../../engine/network/convertPathToURL.js";
 import LineBuilder from "../../codegen/LineBuilder.js";
 import WorkerProxy from "./WorkerProxy.js";
 
@@ -16,6 +16,10 @@ class WorkerBuilder {
     functions = [];
     preamble = new LineBuilder();
 
+    /**
+     *
+     * @param {string} code
+     */
     addCode(code) {
         this.preamble.add(code);
     }

package/src/core/process/worker/WorkerProxy.js

@@ -66,10 +66,11 @@ class WorkerProxy {
     }
 
     /**
+     * Invoke a given method on the worker, as defined by the `WorkerBuilder`
      * @template T
-     * @param {number} name
+     * @param {number} name Method's name
      * @param {Array} args
-     * @return {Promise<T>}
+     * @return {Promise<T>} eventual result of the invoked method
      */
     $submitRequest(name, args) {
         const pending = this.__pending[name];

package/src/engine/ecs/Entity.spec.js

@@ -153,3 +153,36 @@ test("promiseEvent", async () => {
 
     await promise;
 });
+
+test("generation correctly set for build", () => {
+
+    const entity = new Entity();
+
+    const ecd = sampleDataset();
+
+    entity.build(ecd);
+
+    expect(entity.generation).toEqual(ecd.getEntityGeneration(entity.id));
+
+    // rebuild
+    entity.destroy();
+
+    entity.build(ecd);
+
+    expect(entity.generation).toEqual(ecd.getEntityGeneration(entity.id));
+});
+
+test("generation correctly set when binding live entity", () => {
+
+
+    const ecd = sampleDataset();
+
+
+    const entity_a = ecd.createEntity();
+    const entity_b = ecd.createEntity();
+    const entity_c = ecd.createEntity();
+
+    const entity = Entity.readFromDataset(entity_b, ecd);
+
+    expect(entity.generation).toEqual(ecd.getEntityGeneration(entity_b));
+});

package/src/engine/ecs/EntityComponentDataset.js

@@ -836,10 +836,10 @@ export class EntityComponentDataset {
 
     /**
      *
-     * @param {number} entityIndex
+     * @param {number} entity_id
      */
-    removeEntity(entityIndex) {
-        if (!this.entityExists(entityIndex)) {
+    removeEntity(entity_id) {
+        if (!this.entityExists(entity_id)) {
             // entity doesn't exist
             return;
         }
@@ -847,26 +847,31 @@ export class EntityComponentDataset {
         const componentOccupancy = this.componentOccupancy;
         const typeCount = this.componentTypeCount;
 
-        const occupancyStart = entityIndex * typeCount;
+        const occupancyStart = entity_id * typeCount;
         const occupancyEnd = occupancyStart + typeCount;
 
-        for (let i = componentOccupancy.nextSetBit(occupancyStart); i < occupancyEnd && i !== -1; i = componentOccupancy.nextSetBit(i + 1)) {
+        // remove all components from the entity
+        for (
+            let i = componentOccupancy.nextSetBit(occupancyStart);
+            i < occupancyEnd && i !== -1;
+            i = componentOccupancy.nextSetBit(i + 1)
+        ) {
             const componentIndex = i % typeCount;
-            this.removeComponentFromEntityByIndex_Unchecked(entityIndex, componentIndex, i);
+            this.removeComponentFromEntityByIndex_Unchecked(entity_id, componentIndex, i);
         }
 
         //dispatch event
-        this.sendEvent(entityIndex, EventType.EntityRemoved, entityIndex);
+        this.sendEvent(entity_id, EventType.EntityRemoved, entity_id);
 
         //purge all event listeners
-        delete this.__entityEventListeners[entityIndex];
-        delete this.__entityAnyEventListeners[entityIndex];
+        delete this.__entityEventListeners[entity_id];
+        delete this.__entityAnyEventListeners[entity_id];
 
-        this.entityOccupancy.set(entityIndex, false);
+        this.entityOccupancy.set(entity_id, false);
 
         this.entityCount--;
 
-        this.onEntityRemoved.send1(entityIndex);
+        this.onEntityRemoved.send1(entity_id);
     }
 
     /**
@@ -919,6 +924,7 @@ export class EntityComponentDataset {
     }
 
     /**
+     * This method doesn't perform any checks, make sure you understand what you are doing when using it
      * @private
      * @param {number} entityIndex
      * @param {number} componentIndex

package/src/engine/ecs/storage/BinaryBufferDeSerializer.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { number_pretty_print } from "../../../core/primitives/numbers/number_pretty_print.js";
 import Task from "../../../core/process/task/Task.js";
 import { TaskSignal } from "../../../core/process/task/TaskSignal.js";
 import { emptyTask } from "../../../core/process/task/util/emptyTask.js";
@@ -24,6 +25,7 @@ class BinaryBufferDeSerializer {
         assert.notEqual(engine, undefined, 'engine is undefined');
         assert.notEqual(dataset, undefined, 'dataset is undefined');
 
+        const entity_count_before = dataset.entityCount;
 
         const version = buffer.readUint16();
         const numSerializedTypes = buffer.readUint16();
@@ -37,7 +39,12 @@ class BinaryBufferDeSerializer {
         }
 
         task.on.completed.add(function () {
-            console.log(`Binary Buffer De-Serialization took ${task.getExecutedCpuTime()}ms`);
+            const entity_count_after = dataset.entityCount;
+
+            const execution_time = task.getExecutedCpuTime();
+            const entity_count = entity_count_after - entity_count_before;
+
+            console.log(`Binary Buffer De-Serialization took ${number_pretty_print(execution_time)}ms. ${entity_count} Entities`);
         });
 
         return task;

package/src/engine/graphics/camera/CameraShake.js

@@ -1,132 +1,6 @@
-import Vector3 from "../../../core/geom/Vector3.js";
-
 import SimplexNoise from 'simplex-noise';
+import Vector3 from "../../../core/geom/Vector3.js";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
-import { Behavior } from "../../intelligence/behavior/Behavior.js";
-import { BehaviorStatus } from "../../intelligence/behavior/BehaviorStatus.js";
-import Quaternion from "../../../core/geom/Quaternion.js";
-import { clamp01 } from "../../../core/math/clamp01.js";
-import { makeCubicCurve } from "../../../core/math/spline/makeCubicCurve.js";
-
-export class CameraShakeTraumaBehavior extends Behavior {
-
-    /**
-     *
-     * @param {CameraShakeBehavior} shakeBehavior
-     * @param {number} decay amount by which trauma decays per second
-     */
-    constructor({
-                    shakeBehavior,
-                    decay = 1,
-                }) {
-        super();
-
-
-        this.decay = decay;
-        this.trauma = 0;
-
-        this.shakeBehavior = shakeBehavior;
-
-        this.formula = makeCubicCurve(0, 0.1, 0.1, 1);
-    }
-
-    tick(timeDelta) {
-        const shake = this.formula(clamp01(this.trauma));
-
-        this.trauma = clamp01(this.trauma - timeDelta * this.decay);
-
-
-        this.shakeBehavior.strength = shake;
-
-        return BehaviorStatus.Running;
-    }
-}
-
-export class CameraShakeBehavior extends Behavior {
-    /**
-     *
-     * @param {number} maxPitch
-     * @param {number} maxYaw
-     * @param {number} maxRoll
-     * @param {number} maxOffsetX
-     * @param {number} maxOffsetY
-     * @param {number} maxOffsetZ
-     * @param {number} strength
-     * @param {TopDownCameraController} controller
-     */
-    constructor(
-        {
-            maxPitch = 0,
-            maxYaw = 0,
-            maxRoll = 0,
-            maxOffsetX = 0,
-            maxOffsetY = 0,
-            maxOffsetZ = 0,
-            strength = 0,
-
-            controller
-        }
-    ) {
-        super();
-
-        /**
-         *
-         * @type {TopDownCameraController}
-         */
-        this.controller = controller;
-
-        this.time = 0;
-
-        this.timeScale = 1;
-
-        this.strength = strength;
-
-        this.shake = new CameraShake();
-
-        this.shake.limitsRotation.set(maxPitch, maxYaw, maxRoll);
-        this.shake.limitsOffset.set(maxOffsetX, maxOffsetY, maxOffsetZ);
-
-        this.__target = new Vector3();
-        this.__rotation = new Vector3();
-    }
-
-    initialize() {
-        super.initialize();
-
-        //remember controller transform
-        this.__rotation.set(this.controller.pitch, this.controller.yaw, this.controller.roll);
-        this.__target.copy(this.controller.target);
-    }
-
-    tick(timeDelta) {
-        this.time += timeDelta * this.timeScale;
-
-        const offset = new Vector3();
-        const rotation = new Vector3();
-
-        //read out shake values
-        this.shake.read(this.strength, this.time, offset, rotation);
-
-        const q = new Quaternion();
-
-        q.fromEulerAngles(this.__rotation.x, this.__rotation.y, this.__rotation.z);
-
-        offset.applyQuaternion(q);
-
-        //update controller
-        this.controller.target.set(
-            this.__target.x + offset.x,
-            this.__target.y + offset.y,
-            this.__target.z + offset.z,
-        );
-
-        this.controller.pitch = this.__rotation.x + rotation.x;
-        this.controller.yaw = this.__rotation.y + rotation.y;
-        this.controller.roll = this.__rotation.z + rotation.z;
-
-        return BehaviorStatus.Running;
-    }
-}
 
 /**
  * Based on a 2016 GDC talk by Squirrel Eiserloh "Math for Game Programmers: Juicing Your Cameras With Math"

package/src/engine/graphics/camera/CameraShakeBehavior.js

@@ -0,0 +1,91 @@
+import Quaternion from "../../../core/geom/Quaternion.js";
+import Vector3 from "../../../core/geom/Vector3.js";
+import { Behavior } from "../../intelligence/behavior/Behavior.js";
+import { BehaviorStatus } from "../../intelligence/behavior/BehaviorStatus.js";
+import { CameraShake } from "./CameraShake.js";
+
+export class CameraShakeBehavior extends Behavior {
+    /**
+     *
+     * @param {number} maxPitch
+     * @param {number} maxYaw
+     * @param {number} maxRoll
+     * @param {number} maxOffsetX
+     * @param {number} maxOffsetY
+     * @param {number} maxOffsetZ
+     * @param {number} strength
+     * @param {TopDownCameraController} controller
+     */
+    constructor(
+        {
+            maxPitch = 0,
+            maxYaw = 0,
+            maxRoll = 0,
+            maxOffsetX = 0,
+            maxOffsetY = 0,
+            maxOffsetZ = 0,
+            strength = 0,
+
+            controller
+        }
+    ) {
+        super();
+
+        /**
+         *
+         * @type {TopDownCameraController}
+         */
+        this.controller = controller;
+
+        this.time = 0;
+
+        this.timeScale = 1;
+
+        this.strength = strength;
+
+        this.shake = new CameraShake();
+
+        this.shake.limitsRotation.set(maxPitch, maxYaw, maxRoll);
+        this.shake.limitsOffset.set(maxOffsetX, maxOffsetY, maxOffsetZ);
+
+        this.__target = new Vector3();
+        this.__rotation = new Vector3();
+    }
+
+    initialize() {
+        super.initialize();
+
+        //remember controller transform
+        this.__rotation.set(this.controller.pitch, this.controller.yaw, this.controller.roll);
+        this.__target.copy(this.controller.target);
+    }
+
+    tick(timeDelta) {
+        this.time += timeDelta * this.timeScale;
+
+        const offset = new Vector3();
+        const rotation = new Vector3();
+
+        //read out shake values
+        this.shake.read(this.strength, this.time, offset, rotation);
+
+        const q = new Quaternion();
+
+        q.fromEulerAngles(this.__rotation.x, this.__rotation.y, this.__rotation.z);
+
+        offset.applyQuaternion(q);
+
+        //update controller
+        this.controller.target.set(
+            this.__target.x + offset.x,
+            this.__target.y + offset.y,
+            this.__target.z + offset.z,
+        );
+
+        this.controller.pitch = this.__rotation.x + rotation.x;
+        this.controller.yaw = this.__rotation.y + rotation.y;
+        this.controller.roll = this.__rotation.z + rotation.z;
+
+        return BehaviorStatus.Running;
+    }
+}

package/src/engine/graphics/camera/CameraShakeTraumaBehavior.js

@@ -0,0 +1,38 @@
+import { clamp01 } from "../../../core/math/clamp01.js";
+import { makeCubicCurve } from "../../../core/math/spline/makeCubicCurve.js";
+import { Behavior } from "../../intelligence/behavior/Behavior.js";
+import { BehaviorStatus } from "../../intelligence/behavior/BehaviorStatus.js";
+
+export class CameraShakeTraumaBehavior extends Behavior {
+
+    /**
+     *
+     * @param {CameraShakeBehavior} shakeBehavior
+     * @param {number} decay amount by which trauma decays per second
+     */
+    constructor({
+                    shakeBehavior,
+                    decay = 1,
+                }) {
+        super();
+
+
+        this.decay = decay;
+        this.trauma = 0;
+
+        this.shakeBehavior = shakeBehavior;
+
+        this.formula = makeCubicCurve(0, 0.1, 0.1, 1);
+    }
+
+    tick(timeDelta) {
+        const shake = this.formula(clamp01(this.trauma));
+
+        this.trauma = clamp01(this.trauma - timeDelta * this.decay);
+
+
+        this.shakeBehavior.strength = shake;
+
+        return BehaviorStatus.Running;
+    }
+}

package/src/engine/graphics/ecs/animation/animator/AnimationGraphSystem.js

@@ -1,31 +1,17 @@
+import { Matrix4 } from "three";
+import { assert } from "../../../../../core/assert.js";
+import Vector4 from "../../../../../core/geom/Vector4.js";
 import { max3 } from "../../../../../core/math/max3.js";
+import { ResourceAccessKind } from "../../../../../core/model/ResourceAccessKind.js";
+import { ResourceAccessSpecification } from "../../../../../core/model/ResourceAccessSpecification.js";
 import { System } from "../../../../ecs/System.js";
-import { AnimationGraph } from "./graph/AnimationGraph.js";
+import { projectSphere } from "../../../util/projectSphere.js";
+import { CameraSystem } from "../../camera/CameraSystem.js";
 import Mesh, { MeshFlags } from "../../mesh/Mesh.js";
+import { MeshEvents } from "../../mesh/MeshEvents.js";
 import { MeshSystem } from "../../mesh/MeshSystem.js";
-import { assert } from "../../../../../core/assert.js";
-import Vector4 from "../../../../../core/geom/Vector4.js";
-import { Matrix4 } from "three";
-import { CameraSystem } from "../../camera/CameraSystem.js";
+import { AnimationGraph } from "./graph/AnimationGraph.js";
 import { AnimationGraphFlag } from "./graph/AnimationGraphFlag.js";
-import { projectSphere } from "../../../util/projectSphere.js";
-import { MeshEvents } from "../../mesh/MeshEvents.js";
-import { ResourceAccessSpecification } from "../../../../../core/model/ResourceAccessSpecification.js";
-import { ResourceAccessKind } from "../../../../../core/model/ResourceAccessKind.js";
-
-/**
- *
- * @param {AnimationGraph} graph
- * @param {Mesh} mesh
- * @param {number} entity
- * @param {EntityComponentDataset} ecd
- */
-function attach(graph, mesh, entity, ecd) {
-    graph.attach(mesh);
-
-    graph.link(entity, ecd);
-
-}
 
 /**
  * @type {Vector4}

package/src/engine/graphics/ecs/animation/animator/blending/BlendStateMatrix.js

@@ -1,7 +1,14 @@
+import { assert } from "../../../../../../core/assert.js";
 import { lerp } from "../../../../../../core/math/lerp.js";
 
 export class BlendStateMatrix {
+    /**
+     *
+     * @param {number} size
+     */
     constructor(size) {
+        assert.isNonNegativeInteger(size, 'size');
+
         this.weights = new Float32Array(size);
         this.timeScales = new Float32Array(size);
     }
@@ -64,15 +71,13 @@ export class BlendStateMatrix {
      *
      * @param {number} v
      */
-    divideScalar(v) {
-        const tW = this.weights;
-        const tTS = this.timeScales;
+    weightsMultiplyScalar(v) {
+        const weights = this.weights;
 
-        const n = tW.length;
+        const n = weights.length;
 
         for (let i = 0; i < n; i++) {
-            tW[i] /= v;
-            tTS[i] /= v;
+            weights[i] *= v;
         }
     }
 

package/src/engine/graphics/ecs/animation/animator/graph/AnimationGraph.js

@@ -1,16 +1,16 @@
-import { AnimationState } from "./AnimationState.js";
-import { AnimationTransition } from "./AnimationTransition.js";
-import { AnimationStateType } from "./AnimationStateType.js";
 import { AnimationMixer } from "three";
+import { assert } from "../../../../../../core/assert.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../../../../../../core/primitives/numbers/computeHashFloat.js";
+import { threeUpdateTransform } from "../../../../util/threeUpdateTransform.js";
 import { AnimationGraphFlag } from "./AnimationGraphFlag.js";
-import { writeAnimationGraphDefinitionToJSON } from "./definition/serialization/writeAnimationGraphDefinitionToJSON.js";
+import { AnimationState } from "./AnimationState.js";
+import { AnimationStateType } from "./AnimationStateType.js";
+import { AnimationTransition } from "./AnimationTransition.js";
 import {
     readAnimationGraphDefinitionFromJSON
 } from "./definition/serialization/readAnimationGraphDefinitionFromJSON.js";
-import { assert } from "../../../../../../core/assert.js";
-import { threeUpdateTransform } from "../../../../util/threeUpdateTransform.js";
-import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloat } from "../../../../../../core/primitives/numbers/computeHashFloat.js";
+import { writeAnimationGraphDefinitionToJSON } from "./definition/serialization/writeAnimationGraphDefinitionToJSON.js";
 
 export class AnimationGraph {
     constructor() {
@@ -142,15 +142,22 @@ export class AnimationGraph {
         };
     }
 
+    /**
+     *
+     * @param {*} def Graph definition JSON
+     * @param {number} state
+     * @param {number} debtTime
+     * @param {number} flags
+     */
     fromJSON({ def, state, debtTime = 0, flags = 0 }) {
-        const graphDefinition = readAnimationGraphDefinitionFromJSON(def);
+        const graph_definition = readAnimationGraphDefinitionFromJSON(def);
 
         this.debtTime = debtTime;
         this.flags = flags;
-        this.initialize(graphDefinition);
+        this.initialize(graph_definition);
 
         if (state === undefined) {
-            state = graphDefinition.states.indexOf(graphDefinition.startingSate);
+            state = graph_definition.states.indexOf(graph_definition.startingSate);
         }
 
         this.state = this.states[state];
@@ -522,7 +529,7 @@ export class AnimationGraph {
                 }
 
                 // normalize
-                currentBlendState.divideScalar(nAT);
+                currentBlendState.weightsMultiplyScalar(1 / nAT);
             }
         } else {
             //no active transitions, copy current state's blend matrix
@@ -553,6 +560,7 @@ export class AnimationGraph {
 
             if (action === undefined) {
                 console.warn(`Action[${i}] is undefined`);
+                continue;
             }
 
             action.weight = weight;

package/src/engine/graphics/ecs/animation/animator/graph/AnimationState.js

@@ -1,5 +1,5 @@
-import { AnimationStateType } from "./AnimationStateType.js";
 import { BlendStateMatrix } from "../blending/BlendStateMatrix.js";
+import { AnimationStateType } from "./AnimationStateType.js";
 
 export class AnimationState {
     constructor() {
@@ -11,13 +11,13 @@ export class AnimationState {
         this.def = null;
 
         /**
-         *
+         * Incoming transitions
          * @type {AnimationTransition[]}
          */
         this.inEdges = [];
 
         /**
-         *
+         * Outgoing transitions
          * @type {AnimationTransition[]}
          */
         this.outEdges = [];

package/src/engine/graphics/ecs/path/tube/build/estimatePathViaIterativeIntegral.js

@@ -18,7 +18,7 @@ export function estimatePathViaIterativeIntegral(path, epsilon) {
         return 0;
     }
 
-    for (let p = epsilon; ; i += epsilon) {
+    for (let p = epsilon; ; p += epsilon) {
         const ended = path.sample(p1, p);
 
         if (ended) {