@woosh/meep-engine 2.48.1 → 2.48.5

package/src/engine/sound/ecs/emitter/SoundEmitterComponentContext.js

@@ -118,61 +118,21 @@ export class SoundEmitterComponentContext {
         //connect to target
         nodes.volume.connect(targetNode);
 
-        nodes.source.loop = soundTrack.getFlag(SoundTrackFlags.Loop);
         nodes.volume.gain.setValueAtTime(soundTrack.volume, 0);
 
         loadSoundTrackAsset(soundTrack, assetManager, function (asset) {
-            /**
-             *
-             * @type {AudioBuffer}
-             */
-            const buffer = asset.create();
 
-            // Make the sound source use the buffer and start playing it.
-            if (nodes.source.buffer !== buffer) {
-                nodes.source.buffer = buffer;
-            }
+            soundTrack.buffer = asset.create();
 
             if (soundTrack.getFlag(SoundTrackFlags.StartWhenReady)) {
-                //TODO: figure out a way to use AudioBuffer.playbackRate.value to control speed of playback
-
-                if (soundTrack.time < 0) {
-                    // playback will start in the future
-
-                    /**
-                     * @type {AudioContext}
-                     */
-                    const audioContext = targetNode.context;
-
-                    let when = -soundTrack.time;
-
-                    if (audioContext !== undefined) {
-                        when += audioContext.currentTime;
-                    }
-
-                    nodes.source.start(when, 0);
-                } else {
-                    // playback will start from within the track's duration (already playing)
 
-                    nodes.source.start(0, soundTrack.time);
-                }
-
-                soundTrack.setFlag(SoundTrackFlags.Playing);
+                soundTrack.start(context.currentTime);
             }
 
-        }, console.error);
-
 
-        nodes.source.onended = function () {
-            if (!nodes.source.loop) {
-                soundTrack.clearFlag(SoundTrackFlags.Playing);
-
-                soundTrack.on.ended.dispatch();
+        }, console.error);
 
-                //remove track
-                emitter.tracks.removeOneOf(soundTrack);
-            }
-        };
+        soundTrack.on.ended.add(emitter.tracks.removeOneOf, emitter.tracks);
     }
 
     /**
@@ -187,6 +147,30 @@ export class SoundEmitterComponentContext {
         const volume = track.nodes.volume;
 
         volume.disconnect();
+
+        const emitter = this.emitter;
+
+        track.on.ended.remove(emitter.tracks.removeOneOf, emitter.tracks);
+    }
+
+    /**
+     * @param {SoundTrack} t
+     */
+    suspendTrack(t) {
+        if (t.getFlag(SoundTrackFlags.Playing)) {
+            t.suspend();
+        }
+    }
+
+    /**
+     *
+     * @param {SoundTrack} t
+     */
+    resumeTrack(t) {
+
+        if (t.getFlag(SoundTrackFlags.Playing)) {
+            t.start();
+        }
     }
 
     connect() {
@@ -194,10 +178,14 @@ export class SoundEmitterComponentContext {
             return;
         }
 
-        const targetNode = this.emitter.getTargetNode();
+        const emitter = this.emitter;
+        const targetNode = emitter.getTargetNode();
 
         targetNode.connect(this.targetNode);
 
+        // update all track times
+        emitter.tracks.forEach(this.resumeTrack);
+
         this.__isConnected = true;
     }
 
@@ -206,12 +194,20 @@ export class SoundEmitterComponentContext {
             return;
         }
 
-        const targetNode = this.emitter.getTargetNode();
+        const emitter = this.emitter;
+        const targetNode = emitter.getTargetNode();
 
         if (targetNode !== null) {
             targetNode.disconnect();
         }
 
+        /*
+         The reason we suspend all tracks is to be able to track progression of a track after it is disconnected
+         From experiments it appears that at least on Chrome v111 disconnected sources do not advance time, which leads to dis-synchronization when we later reconnected
+         To circumvent this issue we introduced "Suspended" flag to keep track of timing on disconnected tracks
+         */
+        emitter.tracks.forEach(this.suspendTrack, this)
+
         this.__isConnected = false;
     }
 

package/src/engine/sound/ecs/emitter/SoundEmitterSystem.js

@@ -21,6 +21,7 @@ import { SoundEmitterFlags } from "./SoundEmitterFlags.js";
 import { SoundEmitterChannel } from "./SoundEmitterChannel.js";
 import { invokeObjectCompare } from "../../../../core/model/object/invokeObjectCompare.js";
 import { tryRotateSingleNode } from "../../../../core/bvh2/transform/tryRotateSingleNode.js";
+import { SoundTrackFlags } from "./SoundTrackFlags.js";
 
 /**
  * @readonly
@@ -88,7 +89,6 @@ export class SoundEmitterSystem extends System {
 
         assetManager.registerLoader(GameAssetType.Sound, new SoundAssetLoader(context));
 
-
         /**
          *
          * @type {SoundEmitterComponentContext[]}
@@ -352,7 +352,7 @@ export class SoundEmitterSystem extends System {
              */
             const tracks = emitter.tracks;
 
-            const trackCount = tracks.length;
+            let trackCount = tracks.length;
 
 
             //update play time
@@ -360,6 +360,19 @@ export class SoundEmitterSystem extends System {
                 const soundTrack = tracks.get(i);
 
                 soundTrack.time += timeDelta;
+
+                if (
+                    soundTrack.setFlag(SoundTrackFlags.Suspended | SoundTrackFlags.Playing)
+                    && !soundTrack.getFlag(SoundTrackFlags.Loop)
+                    && soundTrack.time > soundTrack.duration
+                ) {
+                    // track is suspended, but should have ended, trigger this state manually
+                    emitter.endTrack(soundTrack);
+
+                    // update cursors
+                    trackCount--;
+                    i--;
+                }
             }
 
         }

package/src/engine/sound/ecs/emitter/SoundTrack.js

@@ -10,51 +10,149 @@ import { compareNumbers } from "../../../../core/primitives/numbers/compareNumbe
 const DEFAULT_FLAGS = SoundTrackFlags.StartWhenReady;
 
 export class SoundTrack {
+
     /**
      *
-     * @constructor
+     * @type {AudioBuffer|null}
      */
-    constructor() {
-        /**
-         *
-         * @type {String|null}
-         */
-        this.url = null;
+    #buffer = null;
 
-        /**
-         *
-         * @type {number}
-         */
-        this.time = 0;
+    /**
+     *
+     * @type {String|null}
+     */
+    url = null;
 
-        /**
-         * @deprecated Not used
-         * @type {String|null}
-         */
-        this.channel = "";
+    /**
+     *
+     * @type {number}
+     */
+    time = 0;
 
-        /**
-         * @private
-         * @type {number}
-         */
-        this.__volume = 1;
+    /**
+     * @deprecated Not used
+     * @type {String|null}
+     */
+    channel = "";
+
+    /**
+     * @private
+     * @type {number}
+     */
+    __volume = 1;
 
+    /**
+     * In seconds
+     * Obtained once clip is loaded
+     * @type {number}
+     */
+    duration = -1;
 
-        /**
-         *
-         * @type {number|SoundTrackFlags}
-         */
-        this.flags = DEFAULT_FLAGS;
 
-        this.on = {
-            ended: new Signal()
-        };
+    /**
+     *
+     * @type {number|SoundTrackFlags}
+     */
+    flags = DEFAULT_FLAGS;
 
+    on = {
         /**
-         * @private
-         * @type {SoundTrackNodes}
+         * @type {Signal<this>}
          */
-        this.nodes = null;
+        ended: new Signal()
+    };
+
+    /**
+     * @private
+     * @type {SoundTrackNodes}
+     */
+    nodes = null;
+
+
+    /**
+     *
+     * @param {AudioBuffer} v
+     */
+    set buffer(v) {
+        this.#buffer = v;
+
+        this.duration = v.duration;
+
+        this.setFlag(SoundTrackFlags.Ready);
+    }
+
+    get buffer() {
+        return this.#buffer;
+    }
+
+    /**
+     *
+     * @returns {BaseAudioContext}
+     */
+    get #context() {
+        return this.nodes.volume.context;
+    }
+
+    start(startTime = 0) {
+        //TODO: figure out a way to use AudioBuffer.playbackRate.value to control speed of playback
+        const nodes = this.nodes;
+
+        if (nodes.source !== null) {
+
+            /*
+             source is already used up, need to create a new one
+             NOTE: AudioBufferSourceNode can only be used once, if we want to start playback again - we have to create a new one
+             see https://stackoverflow.com/questions/59815825/how-to-skip-ahead-n-seconds-while-playing-track-using-web-audio-api
+             */
+            this.suspend();
+
+        }
+
+        nodes.source = this.#context.createBufferSource();
+
+        //connect source to output
+        nodes.source.connect(nodes.volume);
+
+        const looping = this.getFlag(SoundTrackFlags.Loop);
+
+        nodes.source.loop = looping;
+
+        // Make the sound source use the buffer and start playing it.
+        nodes.source.buffer = this.#buffer;
+
+        nodes.source.onended = ()=> {
+            if(!looping){
+                this.clearFlag(SoundTrackFlags.Playing);
+                this.on.ended.send1(this);
+            }
+        }
+
+        let when = startTime;
+
+        if (this.time < 0) {
+            // playback will start in the future
+            when = -this.time;
+
+            nodes.source.start(when, 0);
+        } else {
+            // playback will start from within the track's duration (already playing)
+
+            nodes.source.start(when, this.time);
+        }
+
+        this.setFlag(SoundTrackFlags.Playing);
+        this.clearFlag(SoundTrackFlags.Suspended);
+    }
+
+    suspend() {
+        const nodes = this.nodes;
+
+        nodes.source.stop();
+        nodes.source.disconnect();
+
+        nodes.source = null;
+
+        this.setFlag(SoundTrackFlags.Suspended);
     }
 
     /**
@@ -310,7 +408,8 @@ export class SoundTrack {
             volume: this.volume,
             playing: this.getFlag(SoundTrackFlags.Playing),
             startWhenReady: this.getFlag(SoundTrackFlags.StartWhenReady),
-            usingAssetAlias: this.getFlag(SoundTrackFlags.UsingAliasURL)
+            usingAssetAlias: this.getFlag(SoundTrackFlags.UsingAliasURL),
+            synchronized: this.getFlag(SoundTrackFlags.Synchronized)
         };
     }
 
@@ -322,7 +421,8 @@ export class SoundTrack {
             volume = 1,
             playing = false,
             startWhenReady = true,
-            usingAssetAlias = false
+            usingAssetAlias = false,
+            synchronized = false
         }
     ) {
         assert.typeOf(url, 'string', 'url');
@@ -340,6 +440,8 @@ export class SoundTrack {
         this.writeFlag(SoundTrackFlags.Playing, playing);
 
         this.writeFlag(SoundTrackFlags.StartWhenReady, startWhenReady);
+
+        this.writeFlag(SoundTrackFlags.Synchronized, synchronized);
     }
 
     static fromJSON(json) {

package/src/engine/sound/ecs/emitter/SoundTrackFlags.js

@@ -9,5 +9,21 @@ export const SoundTrackFlags = {
     /**
      * URL field is not a path to actual resource, but instead an alias that needs to be resolved
      */
-    UsingAliasURL: 8
+    UsingAliasURL: 8,
+
+    /**
+     * If set, this flag will result in track being scheduled instead of starting immediately, this will result in pore precise time synchronization
+     * as a trade-off, there will be a delay until next system update tick
+     */
+    Synchronized: 16,
+
+    /**
+     * Track is not actually playing, only time is being advanced
+     */
+    Suspended: 32,
+
+    /**
+     * Track is loaded and ready to play
+     */
+    Ready: 64
 };

package/src/engine/sound/ecs/emitter/SoundTrackNodes.js

@@ -8,13 +8,11 @@ export class SoundTrackNodes {
          *
          * @type {AudioBufferSourceNode}
          */
-        this.source = context.createBufferSource();
+        this.source = null;
         /**
          *
          * @type {GainNode}
          */
         this.volume = context.createGain();
-        //connect volume to source
-        this.source.connect(this.volume);
     }
-}
+}

package/src/engine/sound/ecs/emitter/loadSoundTrackAsset.js

@@ -4,10 +4,9 @@ import { noop } from "../../../../core/function/Functions.js";
 import { assert } from "../../../../core/assert.js";
 
 /**
- *
  * @param {SoundTrack} track
  * @param {AssetManager} assetManager
- * @param {function} [resolve]
+ * @param {function(Asset<AudioBuffer>)} [resolve]
  * @param {function} [reject]
  */
 export function loadSoundTrackAsset(track, assetManager, resolve = noop, reject = noop) {

package/src/generation/theme/ThemeEngine.js

@@ -366,7 +366,7 @@ export class ThemeEngine {
      * @param {number} seed
      * @returns {Task|TaskGroup}
      */
-    applyNodes(grid, ecd, seed=0) {
+    applyNodes(grid, ecd, seed = 0) {
         /**
          *
          * @type {MarkerNode[]}
@@ -579,10 +579,27 @@ export class ThemeEngine {
         // build terrain tiles
         const tTerrainGeometry = futureTask(new Future((resolve, reject) => {
 
-            terrain.updateWorkerHeights();
+            const is_linked = terrain.getFlag(TerrainFlags.Linked);
+
+            if (!is_linked) {
+                terrain.startBuildService();
+            }
+
+            if (!terrain.getFlag(TerrainFlags.Built)) {
+                terrain.buildNonVisual();
+            }
+
             terrain.__tiles.rebuild();
 
-            terrain.promiseAllTiles().then(resolve, reject);
+            terrain.promiseAllTiles()
+                .then(resolve, reject)
+                .finally(() => {
+                    if (!is_linked && !terrain.getFlag(TerrainFlags.Linked)) {
+                        // cleanup after ourselves
+                        terrain.stopBuildService();
+                    }
+                });
+
         }), 'Wait for terrain tiles');
 
         const tInitializeThemes = this.initializeThemes(this.random(), ecd, grid);

package/src/view/{elements/image → common}/HTMLElementCacheKey.js

@@ -1,8 +1,8 @@
-import { KeyValuePair } from "../../../core/collection/KeyValuePair.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 { isArrayEqual } from "../../../core/collection/array/isArrayEqual.js";
+import { KeyValuePair } from "../../core/collection/KeyValuePair.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 { isArrayEqual } from "../../core/collection/array/isArrayEqual.js";
 
 /**
  *

package/src/view/elements/button/ButtonView.js

@@ -10,6 +10,7 @@ import domify from "../../DOM.js";
 class ButtonView extends View {
     /**
      *
+     * @param {string} [tag]
      * @param {function} action
      * @param {string|ObservedString} [name]
      * @param {string} [icon] URL
@@ -17,14 +18,21 @@ class ButtonView extends View {
      * @param {object} [css]
      * @constructor
      */
-    constructor({ action, name, icon = undefined, classList = [], css }) {
+    constructor({
+                    tag = 'div',
+                    action,
+                    name,
+                    icon = undefined,
+                    classList = [],
+                    css
+                }) {
         super();
 
         if (typeof action !== "function") {
             throw new Error("Action must be a function");
         }
 
-        const dRoot = domify();
+        const dRoot = domify(tag);
 
         this.el = dRoot.el;
         //add background and foreground elements for styling purposes

package/src/view/elements/image/ImageView.js

@@ -4,7 +4,7 @@
 
 import View from "../../View.js";
 import { noop } from "../../../core/function/Functions.js";
-import { HTMLElementCacheKey } from "./HTMLElementCacheKey.js";
+import { HTMLElementCacheKey } from "../../common/HTMLElementCacheKey.js";
 import { KeyValuePair } from "../../../core/collection/KeyValuePair.js";
 import { ObjectPoolFactory } from "../../../core/model/object/ObjectPoolFactory.js";
 import { ImmutableObjectPool } from "../../../core/model/object/ImmutableObjectPool.js";

package/src/view/elements/video/VideoView.js

@@ -1,4 +1,4 @@
-import { HTMLElementCacheKey } from "../image/HTMLElementCacheKey.js";
+import { HTMLElementCacheKey } from "../../common/HTMLElementCacheKey.js";
 import { KeyValuePair } from "../../../core/collection/KeyValuePair.js";
 import { Cache } from "../../../core/cache/Cache.js";
 import { noop } from "../../../core/function/Functions.js";