@woosh/meep-engine 2.84.6 → 2.84.9

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) {

package/src/engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js

@@ -1,12 +1,12 @@
-import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
 import { assert } from "../../../../../../core/assert.js";
+import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
+import { isArrayEqualStrict } from "../../../../../../core/collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../../../../../../core/math/hash/computeHashFloatArray.js";
+import { inverseLerp } from "../../../../../../core/math/inverseLerp.js";
 import { max2 } from "../../../../../../core/math/max2.js";
 import { min2 } from "../../../../../../core/math/min2.js";
-import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 import { ParameterLookupTableSerializationAdapter } from "../emitter/serde/ParameterLookupTableSerializationAdapter.js";
-import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
-import { computeHashFloatArray } from "../../../../../../core/math/hash/computeHashFloatArray.js";
-import { isArrayEqualStrict } from "../../../../../../core/collection/array/isArrayEqualStrict.js";
+import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
 
 
 export class ParameterLookupTable {
@@ -174,7 +174,7 @@ export class ParameterLookupTable {
             const lowValue = data[low_offset + i];
             const highValue = data[high_offset + i];
 
-            // inlined for speed: mix(low, high, fraction)
+            // inlined for speed: lerp(low, high, fraction)
             const value = lowValue * (1 - fraction) + highValue * fraction;
 
             result[i] = value;

package/src/engine/intelligence/behavior/ecs/SendEventBehavior.js

@@ -0,0 +1,43 @@
+import { assert } from "../../../../core/assert.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+import { EntityBehavior } from "./EntityBehavior.js";
+
+export class SendEventBehavior extends EntityBehavior {
+    constructor() {
+        super();
+
+        this.event = "";
+        this.data = {};
+        this.target = -1;
+    }
+
+    fromJSON({ event, data = {}, target = -1 }) {
+        assert.typeOf(event, 'string', 'event');
+
+        this.event = event;
+        this.data = data;
+        this.target = target;
+    }
+
+    static fromJSON(j) {
+        const r = new SendEventBehavior();
+
+        r.fromJSON(j);
+
+        return r;
+    }
+
+    toString() {
+        return `SendEventBehavior{ event: ${this.event}, data:${this.data}, target:${this.target} }`;
+    }
+
+    tick(timeDelta) {
+        // console.log(`-> ${this}`);
+
+        const target = this.target !== -1 ? this.target : this.entity;
+
+        this.ecd.sendEvent(target, this.event, this.data);
+
+        return BehaviorStatus.Succeeded;
+    }
+}

package/src/view/View.js

@@ -3,15 +3,18 @@
  * @copyright Alex Goldring 2018
  */
 
-import Vector2 from "../core/geom/Vector2.js";
-
-import AABB2 from "../core/geom/2d/aabb/AABB2.js";
+import { assert } from "../core/assert.js";
 import Signal from "../core/events/signal/Signal.js";
 import { SignalBinding } from "../core/events/signal/SignalBinding.js";
-import { assert } from "../core/assert.js";
-import Vector1 from "../core/geom/Vector1.js";
+
+import AABB2 from "../core/geom/2d/aabb/AABB2.js";
 
 import { m3_cm_compose_transform } from "../core/geom/mat3/m3_cm_compose_transform.js";
+import Vector1 from "../core/geom/Vector1.js";
+import Vector2 from "../core/geom/Vector2.js";
+import { epsilonEquals } from "../core/math/epsilonEquals.js";
+import { FLT_EPSILON_32 } from "../core/math/FLT_EPSILON_32.js";
+import { writeCssTransformMatrix } from "./writeCssTransformMatrix.js";
 
 
 const scratch_m3_0 = new Float32Array(9);
@@ -29,26 +32,7 @@ function setElementTransform(domElement, position, scale, rotation) {
 
     m3_cm_compose_transform(m3, position.x, position.y, scale.x, scale.y, 0, 0, rotation);
 
-
-    /*
-     * CSS matrix is:
-     *      a c e
-     *      b d f
-     *      0 0 1
-     */
-
-    const a = m3[0];
-    const b = m3[3];
-    const c = m3[1];
-    const d = m3[4];
-    const e = m3[2];
-    const f = m3[5];
-
-    const transform = "matrix(" + a + ',' + b + ',' + c + ',' + d + ',' + e + ',' + f + ")";
-
-    const style = domElement.style;
-
-    style.transform = transform;
+    writeCssTransformMatrix(m3, domElement);
 }
 
 /**
@@ -88,6 +72,9 @@ const INITIAL_FLAGS = ViewFlags.Visible;
  * @class
  */
 class View {
+    #transform_written = new Float32Array(9);
+    #transform_current = new Float32Array(9);
+
     /**
      * @constructor
      */
@@ -112,31 +99,32 @@ class View {
         this.flags = INITIAL_FLAGS;
 
         /**
-         *
+         * @readonly
          * @type {Vector2}
          */
         const position = this.position = new Vector2(0, 0);
 
         /**
-         *
+         * @readonly
          * @type {Vector1}
          */
         const rotation = this.rotation = new Vector1(0);
 
         /**
-         *
+         * @readonly
          * @type {Vector2}
          */
         const scale = this.scale = new Vector2(1, 1);
 
         /**
-         *
+         * @readonly
          * @type {Vector2}
          */
         const size = this.size = new Vector2(0, 0);
 
         /**
          * Origin from which rotation and scaling is applied
+         * @readonly
          * @type {Vector2}
          */
         this.transformOrigin = new Vector2(0.5, 0.5);
@@ -274,7 +262,41 @@ class View {
      * @private
      */
     __updateTransform() {
-        setElementTransform(this.el, this.position, this.scale, this.rotation.getValue());
+        const position = this.position;
+        const scale = this.scale;
+        const rotation = this.rotation.getValue();
+
+        m3_cm_compose_transform(this.#transform_current, position.x, position.y, scale.x, scale.y, 0, 0, rotation);
+
+        this.#tryWriteTransform();
+    }
+
+    #tryWriteTransform() {
+
+        const current = this.#transform_current;
+        const written = this.#transform_written;
+
+        for (let i = 0; i < 9; i++) {
+            const a = current[i];
+            const b = written[i];
+
+            if (epsilonEquals(a, b, FLT_EPSILON_32)) {
+                // common path
+                continue;
+            }
+
+            this.#writeTransform();
+            return true;
+
+        }
+
+        return false;
+    }
+
+    #writeTransform() {
+        writeCssTransformMatrix(this.#transform_current, this.el);
+
+        this.#transform_written.set(this.#transform_current);
     }
 
     /**

package/src/view/writeCssTransformMatrix.js

@@ -0,0 +1,26 @@
+/**
+ *
+ * @param {Float32Array} m3
+ * @param {HTMLElement} domElement
+ */
+export function writeCssTransformMatrix(m3, domElement) {
+    /*
+     * CSS matrix is:
+     *      a c e
+     *      b d f
+     *      0 0 1
+     */
+
+    const a = m3[0];
+    const b = m3[3];
+    const c = m3[1];
+    const d = m3[4];
+    const e = m3[2];
+    const f = m3[5];
+
+    const transform = "matrix(" + a + ',' + b + ',' + c + ',' + d + ',' + e + ',' + f + ")";
+
+    const style = domElement.style;
+
+    style.transform = transform;
+}