@woosh/meep-engine 3.16.0 → 3.17.1

package/src/engine/animation/AnimationUtils.js

@@ -1,246 +1,246 @@
-import { SerializationMetadata } from "../ecs/components/SerializationMetadata.js";
-import Entity from "../ecs/Entity.js";
-import Vector3 from "../../core/geom/Vector3.js";
-import { Transform64 } from "../ecs/transform/Transform64.js";
-import { t64_announce_change } from "../ecs/transform/t64_announce_change.js";
-import { t64_read_translation } from "../ecs/transform/t64_read_translation.js";
-import { whenAllEntitiesDestroyed, whenEntityDestroyed } from "../ecs/util/EntityBuilderUtils.js";
-import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
-import { createSound, createTimer } from "../EntityCreator.js";
-import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
-import Trail2D from "../graphics/ecs/trail2d/Trail2D.js";
-import { Trail2DFlags } from "../graphics/ecs/trail2d/Trail2DFlags.js";
-import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
-import { ParticleEmitterFlag } from "../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
-import { SequenceBehavior } from "../intelligence/behavior/composite/SequenceBehavior.js";
-import { BehaviorComponent } from "../intelligence/behavior/ecs/BehaviorComponent.js";
-import { DieBehavior } from "../intelligence/behavior/ecs/DieBehavior.js";
-import { ActionBehavior } from "../intelligence/behavior/primitive/ActionBehavior.js";
-import { DelayBehavior } from "../intelligence/behavior/util/DelayBehavior.js";
-import { stopEntityAndNotifyWhenStopped } from "./AnimatedActions.js";
-import AnimationTrack from "./keyed2/AnimationTrack.js";
-import AnimationTrackPlayback from "./keyed2/AnimationTrackPlayback.js";
-import { playAnimationTrack } from "./playAnimationTrack.js";
-import TransitionFunctions from "./TransitionFunctions.js";
-
-/**
- *
- * @param {number} entity
- * @param {EntityComponentDataset} ecd
- * @returns {Promise}
- */
-export function stopTrailAndNotifyOnceFinished(entity, ecd) {
-    return new Promise((resolve, reject) => {
-        if (!ecd.entityExists(entity)) {
-            resolve();
-            return;
-        }
-
-        const trail = ecd.getComponent(entity, Trail2D);
-
-        if (trail === undefined) {
-            resolve();
-            return;
-        }
-
-        trail.clearFlag(Trail2DFlags.Spawning);
-
-        new Entity()
-            .add(BehaviorComponent.from(SequenceBehavior.from([
-                DelayBehavior.fromJSON({ value: trail.maxAge }),
-                new ActionBehavior(resolve)
-            ])))
-            .build(ecd);
-    });
-}
-
-/**
- *
- * @param {number} entity
- * @param {EntityComponentDataset} ecd
- * @returns {Promise}
- */
-export function stopEmitterAndNotifyOnceFinished(entity, ecd) {
-    return new Promise(function (resolve, reject) {
-        if (!ecd.entityExists(entity)) {
-            console.warn(`Entity ${entity} doesn't exist`);
-
-            resolve();
-            return;
-        }
-
-        /**
-         *
-         * @type {ParticleEmitter}
-         */
-        const emitter = ecd.getComponent(entity, ParticleEmitter);
-
-        if (emitter === undefined) {
-            console.warn(`Entity ${entity} doesn't have ParticleEmitter component`);
-
-            resolve();
-            return;
-        }
-
-        //stop emission
-        emitter.clearFlag(ParticleEmitterFlag.Emitting);
-
-
-        //figure out how long the emitter should stay alive
-        const maxLife = emitter.computeMaxEmittingParticleLife();
-
-        //wait out the particles that are already in flight, then report and clean up
-        new Entity()
-            .add(SerializationMetadata.Transient)
-            .add(BehaviorComponent.from(SequenceBehavior.from([
-                DelayBehavior.from(maxLife),
-                new ActionBehavior(resolve),
-                DieBehavior.create()
-            ])))
-            .build(ecd);
-    });
-}
-
-
-/**
- *
- * @param {number} entity
- * @param {EntityComponentDataset} ecd
- * @returns {Promise}
- */
-export function shutdownParticleEmitter(entity, ecd) {
-    const promise = stopEmitterAndNotifyOnceFinished(entity, ecd);
-
-
-    const MAX_PARTICLE_LIFE = 10;
-
-    /**
-     *
-     * @type {ParticleEmitter}
-     */
-    const particleEmitter = ecd.getComponent(entity, ParticleEmitter);
-
-    if (particleEmitter !== undefined) {
-
-        //destroy any particles that have very long lifespan
-
-        particleEmitter.traverseLayers((layer) => {
-            const maxParticleLife = layer.particleLife.max;
-
-            if (layer.emissionRate <= 0 && layer.emissionImmediate <= 0) {
-                //skip layers with no emission
-                return;
-            }
-
-            if (maxParticleLife > MAX_PARTICLE_LIFE) {
-                particleEmitter.destroyParticlesFromLayer(layer);
-            }
-        });
-    }
-
-    return promise;
-}
-
-/**
- *
- * @param entity
- * @param {EntityComponentDataset} ecd
- * @param {ParticleEmitter} emitter
- * @param {String} soundEffect
- * @param {number} [timeout]
- * @returns {Promise}
- */
-export function removeEntityWithEffect({ entity, ecd, emitter, soundEffect, timeout }) {
-    /**
-     *
-     * @type {Transform64}
-     */
-    const transform = ecd.getComponent(entity, Transform64);
-
-    //prevent further interactions
-    removeComponentsExcept(ecd, entity, [SGMesh, ParticleEmitter, Trail2D, Transform64]);
-
-    //make entity volatile so it does not end up in game saves
-    ecd.addComponentToEntity(entity, SerializationMetadata.Transient);
-
-    return new Promise((resolve, reject) => {
-
-        const entityStopped = stopEntityAndNotifyWhenStopped(entity, ecd);
-
-
-        const animationTrack = new AnimationTrack(['scale']);
-        animationTrack.addKey(0, [1]);
-        animationTrack.addKey(0.05, [1]);
-        animationTrack.addKey(0.27, [0]);
-        animationTrack.addTransition(0, TransitionFunctions.EaseOut);
-        animationTrack.addTransition(1, TransitionFunctions.EaseOut);
-
-
-        const originalScale = new Vector3(
-            transform.scale_x, transform.scale_y, transform.scale_z
-        );
-
-        const trackPlayback = new AnimationTrackPlayback(animationTrack, function (s) {
-            transform.setScale(
-                originalScale.x * s, originalScale.y * s, originalScale.z * s
-            );
-
-            // a scale write leaves the matrix describing the previous size
-            transform.updateMatrix();
-
-            t64_announce_change(ecd, entity, transform);
-        }, null);
-
-        trackPlayback.on.ended.add(() => {
-            //remove mesh if it exists since scale is 0
-            ecd.removeComponentFromEntity(entity, SGMesh);
-        });
-
-        const eAnimation = playAnimationTrack(trackPlayback, ecd);
-
-        const entityRemoved = Promise.all([
-            whenEntityDestroyed(eAnimation),
-            entityStopped
-        ])
-            .then(() => {
-
-                //check that the entity exists
-                if (ecd.entityExists(entity)) {
-                    ecd.removeEntity(entity);
-                }
-
-            });
-
-        const t = new Transform64();
-        t.copy(transform);
-
-        const emitterBuilder = new Entity();
-        emitterBuilder.add(t).add(emitter);
-        emitterBuilder.build(ecd);
-
-        const timer = createTimer({
-            timeout: emitter.layers.reduce((s, l) => {
-                return Math.max(s, l.particleLife.max)
-            }, 0),
-            action() {
-                emitterBuilder.destroy()
-            }
-        });
-
-        const sound = createSound({
-            position: t64_read_translation(new Vector3(), transform),
-            url: soundEffect,
-            positioned: true
-        });
-
-        Promise.all([
-            entityRemoved,
-            whenAllEntitiesDestroyed([timer, sound])
-        ])
-            .then(resolve, reject);
-
-        timer.build(ecd);
-        sound.build(ecd);
-    });
-
-}
+import { SerializationMetadata } from "../ecs/components/SerializationMetadata.js";
+import Entity from "../ecs/Entity.js";
+import Vector3 from "../../core/geom/Vector3.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { t64_announce_change } from "../ecs/transform/t64_announce_change.js";
+import { t64_read_translation } from "../ecs/transform/t64_read_translation.js";
+import { whenAllEntitiesDestroyed, whenEntityDestroyed } from "../ecs/util/EntityBuilderUtils.js";
+import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
+import { createSound, createTimer } from "../EntityCreator.js";
+import { SGMesh } from "../graphics/ecs/mesh-v2/aggregate/SGMesh.js";
+import Trail2D from "../graphics/ecs/trail2d/Trail2D.js";
+import { Trail2DFlags } from "../graphics/ecs/trail2d/Trail2DFlags.js";
+import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
+import { ParticleEmitterFlag } from "../graphics/particles/particular/engine/emitter/ParticleEmitterFlag.js";
+import { SequenceBehavior } from "../intelligence/behavior/composite/SequenceBehavior.js";
+import { BehaviorComponent } from "../intelligence/behavior/ecs/BehaviorComponent.js";
+import { DieBehavior } from "../intelligence/behavior/ecs/DieBehavior.js";
+import { ActionBehavior } from "../intelligence/behavior/primitive/ActionBehavior.js";
+import { DelayBehavior } from "../intelligence/behavior/util/DelayBehavior.js";
+import { stopEntityAndNotifyWhenStopped } from "./AnimatedActions.js";
+import AnimationTrack from "./keyed2/AnimationTrack.js";
+import AnimationTrackPlayback from "./keyed2/AnimationTrackPlayback.js";
+import { playAnimationTrack } from "./playAnimationTrack.js";
+import TransitionFunctions from "./TransitionFunctions.js";
+
+/**
+ *
+ * @param {number} entity
+ * @param {EntityComponentDataset} ecd
+ * @returns {Promise}
+ */
+export function stopTrailAndNotifyOnceFinished(entity, ecd) {
+    return new Promise((resolve, reject) => {
+        if (!ecd.entityExists(entity)) {
+            resolve();
+            return;
+        }
+
+        const trail = ecd.getComponent(entity, Trail2D);
+
+        if (trail === undefined) {
+            resolve();
+            return;
+        }
+
+        trail.clearFlag(Trail2DFlags.Spawning);
+
+        new Entity()
+            .add(BehaviorComponent.from(SequenceBehavior.from([
+                DelayBehavior.fromJSON({ value: trail.maxAge }),
+                new ActionBehavior(resolve)
+            ])))
+            .build(ecd);
+    });
+}
+
+/**
+ *
+ * @param {number} entity
+ * @param {EntityComponentDataset} ecd
+ * @returns {Promise}
+ */
+export function stopEmitterAndNotifyOnceFinished(entity, ecd) {
+    return new Promise(function (resolve, reject) {
+        if (!ecd.entityExists(entity)) {
+            console.warn(`Entity ${entity} doesn't exist`);
+
+            resolve();
+            return;
+        }
+
+        /**
+         *
+         * @type {ParticleEmitter}
+         */
+        const emitter = ecd.getComponent(entity, ParticleEmitter);
+
+        if (emitter === undefined) {
+            console.warn(`Entity ${entity} doesn't have ParticleEmitter component`);
+
+            resolve();
+            return;
+        }
+
+        //stop emission
+        emitter.clearFlag(ParticleEmitterFlag.Emitting);
+
+
+        //figure out how long the emitter should stay alive
+        const maxLife = emitter.computeMaxEmittingParticleLife();
+
+        //wait out the particles that are already in flight, then report and clean up
+        new Entity()
+            .add(SerializationMetadata.Transient)
+            .add(BehaviorComponent.from(SequenceBehavior.from([
+                DelayBehavior.from(maxLife),
+                new ActionBehavior(resolve),
+                DieBehavior.create()
+            ])))
+            .build(ecd);
+    });
+}
+
+
+/**
+ *
+ * @param {number} entity
+ * @param {EntityComponentDataset} ecd
+ * @returns {Promise}
+ */
+export function shutdownParticleEmitter(entity, ecd) {
+    const promise = stopEmitterAndNotifyOnceFinished(entity, ecd);
+
+
+    const MAX_PARTICLE_LIFE = 10;
+
+    /**
+     *
+     * @type {ParticleEmitter}
+     */
+    const particleEmitter = ecd.getComponent(entity, ParticleEmitter);
+
+    if (particleEmitter !== undefined) {
+
+        //destroy any particles that have very long lifespan
+
+        particleEmitter.traverseLayers((layer) => {
+            const maxParticleLife = layer.particleLife.max;
+
+            if (layer.emissionRate <= 0 && layer.emissionImmediate <= 0) {
+                //skip layers with no emission
+                return;
+            }
+
+            if (maxParticleLife > MAX_PARTICLE_LIFE) {
+                particleEmitter.destroyParticlesFromLayer(layer);
+            }
+        });
+    }
+
+    return promise;
+}
+
+/**
+ *
+ * @param entity
+ * @param {EntityComponentDataset} ecd
+ * @param {ParticleEmitter} emitter
+ * @param {String} soundEffect
+ * @param {number} [timeout]
+ * @returns {Promise}
+ */
+export function removeEntityWithEffect({ entity, ecd, emitter, soundEffect, timeout }) {
+    /**
+     *
+     * @type {Transform64}
+     */
+    const transform = ecd.getComponent(entity, Transform64);
+
+    //prevent further interactions
+    removeComponentsExcept(ecd, entity, [SGMesh, ParticleEmitter, Trail2D, Transform64]);
+
+    //make entity volatile so it does not end up in game saves
+    ecd.addComponentToEntity(entity, SerializationMetadata.Transient);
+
+    return new Promise((resolve, reject) => {
+
+        const entityStopped = stopEntityAndNotifyWhenStopped(entity, ecd);
+
+
+        const animationTrack = new AnimationTrack(['scale']);
+        animationTrack.addKey(0, [1]);
+        animationTrack.addKey(0.05, [1]);
+        animationTrack.addKey(0.27, [0]);
+        animationTrack.addTransition(0, TransitionFunctions.EaseOut);
+        animationTrack.addTransition(1, TransitionFunctions.EaseOut);
+
+
+        const originalScale = new Vector3(
+            transform.scale_x, transform.scale_y, transform.scale_z
+        );
+
+        const trackPlayback = new AnimationTrackPlayback(animationTrack, function (s) {
+            transform.setScale(
+                originalScale.x * s, originalScale.y * s, originalScale.z * s
+            );
+
+            // a scale write leaves the matrix describing the previous size
+            transform.updateMatrix();
+
+            t64_announce_change(ecd, entity);
+        }, null);
+
+        trackPlayback.on.ended.add(() => {
+            //remove mesh if it exists since scale is 0
+            ecd.removeComponentFromEntity(entity, SGMesh);
+        });
+
+        const eAnimation = playAnimationTrack(trackPlayback, ecd);
+
+        const entityRemoved = Promise.all([
+            whenEntityDestroyed(eAnimation),
+            entityStopped
+        ])
+            .then(() => {
+
+                //check that the entity exists
+                if (ecd.entityExists(entity)) {
+                    ecd.removeEntity(entity);
+                }
+
+            });
+
+        const t = new Transform64();
+        t.copy(transform);
+
+        const emitterBuilder = new Entity();
+        emitterBuilder.add(t).add(emitter);
+        emitterBuilder.build(ecd);
+
+        const timer = createTimer({
+            timeout: emitter.layers.reduce((s, l) => {
+                return Math.max(s, l.particleLife.max)
+            }, 0),
+            action() {
+                emitterBuilder.destroy()
+            }
+        });
+
+        const sound = createSound({
+            position: t64_read_translation(new Vector3(), transform),
+            url: soundEffect,
+            positioned: true
+        });
+
+        Promise.all([
+            entityRemoved,
+            whenAllEntitiesDestroyed([timer, sound])
+        ])
+            .then(resolve, reject);
+
+        timer.build(ecd);
+        sound.build(ecd);
+    });
+
+}

package/src/engine/animation/Animations.js

@@ -1,74 +1,74 @@
-import GUIElement from "../ecs/gui/GUIElement.js";
-import Vector3 from "../../core/geom/Vector3.js";
-import { Transform64 } from "../ecs/transform/Transform64.js";
-import { t64_announce_change } from "../ecs/transform/t64_announce_change.js";
-import { t64_read_translation } from "../ecs/transform/t64_read_translation.js";
-import Tween from "./Tween.js";
-
-/**
- *
- * @param {number} entity
- * @param {EntityComponentDataset} ecd
- * @param {Vector3} parameter destination in local offset from current position
- * @param {number} time duration
- * @param {(x: number) => number} transitionFunction
- * @returns {Tween}
- */
-function translate(entity, ecd, parameter, time, transitionFunction) {
-    const transform = ecd.getComponent(entity, Transform64);
-
-    const origin = t64_read_translation(new Vector3(), transform);
-    const target = origin.clone().add(parameter);
-
-    const temp = origin.clone();
-
-    return new Tween(function (v) {
-        temp.copy(origin).lerp(target, v);
-
-        // the translation is the matrix's own column, so nothing is left to recompose - but the
-        // component still has to say it moved, or nothing following the entity will move with it
-        transform.setTranslation(temp.x, temp.y, temp.z);
-
-        t64_announce_change(ecd, entity, transform);
-    }, 0, 1, time, transitionFunction);
-}
-
-/**
- * **A model does not fade.** This used to clone the three material off the entity's mesh and animate
- * its opacity; the renderer 3.0 ships has a transparency mode but no per-instance opacity, and
- * `Mesh.opacity` did not come across the mesh cutover (D45), so what fades is what has an opacity to
- * fade — the entity's GUI element (D56).
- *
- * @param {number} entity
- * @param {EntityComponentDataset} ecd
- * @param {Vector3} parameter final opacity, 1 - fully opaque, 0 - fully transparent
- * @param {number} time duration
- * @param {(x: number) => number} transitionFunction
- * @returns {Tween}
- */
-function fade(entity, ecd, parameter, time, transitionFunction) {
-
-    const tweenUpdateCallbacks = [];
-
-    const original = 1;
-
-    const guiElement = ecd.getComponent(entity, GUIElement);
-
-    if (guiElement !== undefined) {
-        tweenUpdateCallbacks.push(function (v) {
-            guiElement.view.el.style.opacity = v;
-        });
-    }
-
-    return new Tween(function (v) {
-        for (let i = 0; i < tweenUpdateCallbacks.length; i++) {
-            tweenUpdateCallbacks[i](v);
-        }
-
-    }, original, parameter, time, transitionFunction);
-}
-
-export default {
-    translate: translate,
-    fade: fade
-};
+import GUIElement from "../ecs/gui/GUIElement.js";
+import Vector3 from "../../core/geom/Vector3.js";
+import { Transform64 } from "../ecs/transform/Transform64.js";
+import { t64_announce_change } from "../ecs/transform/t64_announce_change.js";
+import { t64_read_translation } from "../ecs/transform/t64_read_translation.js";
+import Tween from "./Tween.js";
+
+/**
+ *
+ * @param {number} entity
+ * @param {EntityComponentDataset} ecd
+ * @param {Vector3} parameter destination in local offset from current position
+ * @param {number} time duration
+ * @param {(x: number) => number} transitionFunction
+ * @returns {Tween}
+ */
+function translate(entity, ecd, parameter, time, transitionFunction) {
+    const transform = ecd.getComponent(entity, Transform64);
+
+    const origin = t64_read_translation(new Vector3(), transform);
+    const target = origin.clone().add(parameter);
+
+    const temp = origin.clone();
+
+    return new Tween(function (v) {
+        temp.copy(origin).lerp(target, v);
+
+        // the translation is the matrix's own column, so nothing is left to recompose - but the
+        // component still has to say it moved, or nothing following the entity will move with it
+        transform.setTranslation(temp.x, temp.y, temp.z);
+
+        t64_announce_change(ecd, entity);
+    }, 0, 1, time, transitionFunction);
+}
+
+/**
+ * **A model does not fade.** This used to clone the three material off the entity's mesh and animate
+ * its opacity; the renderer 3.0 ships has a transparency mode but no per-instance opacity, and
+ * `Mesh.opacity` did not come across the mesh cutover (D45), so what fades is what has an opacity to
+ * fade — the entity's GUI element (D56).
+ *
+ * @param {number} entity
+ * @param {EntityComponentDataset} ecd
+ * @param {Vector3} parameter final opacity, 1 - fully opaque, 0 - fully transparent
+ * @param {number} time duration
+ * @param {(x: number) => number} transitionFunction
+ * @returns {Tween}
+ */
+function fade(entity, ecd, parameter, time, transitionFunction) {
+
+    const tweenUpdateCallbacks = [];
+
+    const original = 1;
+
+    const guiElement = ecd.getComponent(entity, GUIElement);
+
+    if (guiElement !== undefined) {
+        tweenUpdateCallbacks.push(function (v) {
+            guiElement.view.el.style.opacity = v;
+        });
+    }
+
+    return new Tween(function (v) {
+        for (let i = 0; i < tweenUpdateCallbacks.length; i++) {
+            tweenUpdateCallbacks[i](v);
+        }
+
+    }, original, parameter, time, transitionFunction);
+}
+
+export default {
+    translate: translate,
+    fade: fade
+};