@woosh/meep-engine 2.168.1 → 2.169.1

package/src/engine/Engine.js

@@ -11,6 +11,7 @@ import ObservedBoolean from "../core/model/ObservedBoolean.js";
 import ConcurrentExecutor from '../core/process/executor/ConcurrentExecutor.js';
 import EmptyView from "../view/elements/EmptyView.js";
 import { ViewStack } from "../view/elements/navigation/ViewStack.js";
+import { WebGLContextFailureView } from "../view/graphics/WebGLContextFailureView.js";
 
 import { AssetManager } from './asset/AssetManager.js';
 import { AssetPreloader } from "./asset/preloader/AssetPreloader.js";
@@ -44,9 +45,48 @@ const METRIC_ID_FRAME = 'frame_delay';
 const METRIC_ID_RENDER = 'render_time';
 const METRIC_ID_SIMULATION = 'simulation_time';
 
+/**
+ * How long a context loss is tolerated before the simulation is paused as well, in seconds. Most losses
+ * are resolved in well under a second, and stopping the world for those would be more disruptive than
+ * letting it run; a longer outage is worth pausing for, as the player cannot see what is happening.
+ * @type {number}
+ */
+const CONTEXT_LOSS_SIMULATION_PAUSE_DELAY = 2;
+
 class Engine {
     #last_frame_timestamp = 0;
 
+    /**
+     * Handle of the pending render-loop frame, `-1` when the loop is not running
+     * @type {number}
+     */
+    #animation_frame_handle = -1;
+
+    /**
+     * Handle of the pending "pause the simulation, this outage is taking a while" timer, `-1` when none
+     * @type {number}
+     */
+    #context_loss_pause_timer = -1;
+
+    /**
+     * Whether the simulation was paused because of a context loss, and therefore should be resumed once
+     * the context comes back
+     * @type {boolean}
+     */
+    #paused_by_context_loss = false;
+
+    /**
+     * Absent when the engine is constructed with `enableGraphics: false`.
+     * @type {GraphicsEngine|null}
+     */
+    graphics = null;
+
+    /**
+     * Absent when the engine is constructed with `enableAudio: false`.
+     * @type {SoundEngine|null}
+     */
+    sound = null;
+
     viewStack = new ViewStack();
 
     /**
@@ -257,6 +297,10 @@ class Engine {
                 logger.error(`Failed to start GraphicEngine: ${e}`);
             }
 
+            graphicsEngine.on.contextLost.add(this.#handle_context_lost, this);
+            graphicsEngine.on.contextRestored.add(this.#handle_context_restored, this);
+            graphicsEngine.on.contextFailed.add(this.#handle_context_failed, this);
+
         } else {
             logger.info('enableGraphics option is not set, no graphics engine will be created');
         }
@@ -316,9 +360,84 @@ class Engine {
         this.plugins.initialize(this);
     }
 
+    #clear_context_loss_pause_timer() {
+        if (this.#context_loss_pause_timer !== -1) {
+            clearTimeout(this.#context_loss_pause_timer);
+            this.#context_loss_pause_timer = -1;
+        }
+    }
+
+    /**
+     * Pauses the simulation, if it is running. {@link Ticker#pause} freezes the clock, so no simulation
+     * time accrues while we wait and the first step after resuming is a normal-sized one.
+     *
+     * A ticker that is already paused is left alone - somebody else owns that pause and it is not ours to
+     * undo when the context comes back.
+     */
+    #pause_simulation_for_context_loss() {
+        this.#context_loss_pause_timer = -1;
+
+        if (this.#paused_by_context_loss) {
+            return;
+        }
+
+        const ticker = this.ticker;
+
+        if (!ticker.is_active || ticker.is_paused) {
+            return;
+        }
+
+        this.#paused_by_context_loss = true;
+
+        logger.warn('Graphics context outage is taking a while, pausing simulation');
+
+        ticker.pause();
+    }
+
+    #handle_context_lost() {
+        logger.warn('Graphics context lost, waiting for recovery');
+
+        this.#clear_context_loss_pause_timer();
+
+        this.#context_loss_pause_timer = setTimeout(
+            () => this.#pause_simulation_for_context_loss(),
+            CONTEXT_LOSS_SIMULATION_PAUSE_DELAY * 1000
+        );
+    }
+
+    #handle_context_restored() {
+        this.#clear_context_loss_pause_timer();
+
+        if (this.#paused_by_context_loss) {
+            this.#paused_by_context_loss = false;
+
+            if (this.ticker.is_active) {
+                this.ticker.resume();
+            }
+        }
+
+        logger.info('Graphics context restored, rendering resumed');
+    }
+
+    /**
+     *
+     * @param {WebGLContextFailureReason} reason
+     */
+    #handle_context_failed(reason) {
+        logger.error(`Graphics context recovery abandoned (${reason}), no further rendering is possible`);
+
+        this.#clear_context_loss_pause_timer();
+
+        // nothing can be drawn any more, so let the simulation stop rather than burn cycles invisibly.
+        // Application state is left intact, which keeps a save-on-failure handler viable.
+        this.#pause_simulation_for_context_loss();
+
+        this.viewStack.addChild(new WebGLContextFailureView());
+    }
+
     #initialize_audio() {
         const sound = this.sound;
-        if (sound === undefined || sound === null) {
+        if (sound === null) {
             // no sound engine
             return;
         }
@@ -348,7 +467,7 @@ class Engine {
 
         this.viewStack.push(gameView, 'game-view');
 
-        if (this.graphics !== undefined) {
+        if (this.graphics !== null) {
 
             const viewport = this.graphics.viewport;
 
@@ -440,12 +559,17 @@ class Engine {
 
         const graphics = this.graphics;
 
+        if (graphics === null) {
+            // headless
+            return;
+        }
+
         if (graphics.autoDraw) {
             // request redraw
             graphics.needDraw = true;
         }
 
-        if (graphics && this.renderingEnabled && graphics.needDraw) {
+        if (this.renderingEnabled && graphics.needDraw) {
 
             const metrics = this.performance;
 
@@ -465,7 +589,7 @@ class Engine {
      * Startup
      * @returns {Promise}
      */
-    start() {
+    async start() {
         this.assetManager.startup();
 
         this.#initialize_audio();
@@ -479,9 +603,14 @@ class Engine {
 
         this.__performacne_monitor.start();
 
+        const sound = this.sound;
+
+        const soundStarted = sound === null
+            ? Promise.resolve()
+            : sound.start();
+
         return Promise.all([
-            this.sound.start()
-                .then(promiseEntityManager),
+            soundStarted.then(promiseEntityManager),
             this.staticKnowledge.load(this.assetManager, this.executor),
             this.gui.startup(this),
             this.plugins.startup()
@@ -492,7 +621,7 @@ class Engine {
             /**
              * Starting the engine
              */
-            requestAnimationFrame(this.#animation_frame);
+            this.#animation_frame_handle = requestAnimationFrame(this.#animation_frame);
 
             //start simulation
             this.ticker.start({ maxTimeout: 200 });
@@ -504,6 +633,10 @@ class Engine {
             logger.info('engine started');
         }, function (e) {
             logger.error(`Engine Failed to start: ${e}`);
+
+            // the caller awaits start() to know whether the engine came up;
+            // swallowing this reported success after a failed startup
+            throw e;
         });
 
 
@@ -516,7 +649,7 @@ class Engine {
 
         const t0 = this.#last_frame_timestamp;
         const t1 = performance.now();
-        requestAnimationFrame(this.#animation_frame);
+        this.#animation_frame_handle = requestAnimationFrame(this.#animation_frame);
         this.render();
 
         const frame_delay = (t1 - t0) / 1000;
@@ -534,8 +667,14 @@ class Engine {
     async stop() {
         this.__performacne_monitor.stop();
 
-        // stop the ticker
-        this.ticker.pause();
+        // stop the ticker. pause() throws when the loop is not currently
+        // running, which would abort the whole teardown below
+        this.ticker.stop();
+
+        // and the render loop, which re-requests itself every frame and would
+        // otherwise keep calling render() on a torn-down engine forever
+        cancelAnimationFrame(this.#animation_frame_handle);
+        this.#animation_frame_handle = -1;
 
         // shutdown entity manager
         if (!this.__using_external_entity_manager) {

package/src/engine/animation/Animations.d.ts

@@ -9,19 +9,19 @@ export default _default;
  * @param {EntityComponentDataset} ecd
  * @param {Vector3} parameter destination in local offset from current position
  * @param {number} time duration
- * @param {function(x:number):number} transitionFunction
+ * @param {(x: number) => number} transitionFunction
  * @returns {Tween}
  */
-declare function translate(entity: number, ecd: EntityComponentDataset, parameter: Vector3, time: number, transitionFunction: any): Tween;
+declare function translate(entity: number, ecd: EntityComponentDataset, parameter: Vector3, time: number, transitionFunction: (x: number) => number): Tween;
 /**
  *
  * @param {number} entity
  * @param {EntityComponentDataset} ecd
  * @param {Vector3} parameter final opacity, 1 - fully opaque, 0 - fully transparent
  * @param {number} time duration
- * @param {function(x:number):number} transitionFunction
+ * @param {(x: number) => number} transitionFunction
  * @returns {Tween}
  */
-declare function fade(entity: number, ecd: EntityComponentDataset, parameter: Vector3, time: number, transitionFunction: any): Tween;
+declare function fade(entity: number, ecd: EntityComponentDataset, parameter: Vector3, time: number, transitionFunction: (x: number) => number): Tween;
 import Tween from "./Tween.js";
 //# sourceMappingURL=Animations.d.ts.map

package/src/engine/animation/Animations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Animations.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/Animations.js"],"names":[],"mappings":";;;;;AAkBA;;;;;;;;GAQG;AACH,mCAPW,MAAM,yDAGN,MAAM,4BAEJ,KAAK,CAcjB;AAED;;;;;;;;GAQG;AACH,8BAPW,MAAM,yDAGN,MAAM,4BAEJ,KAAK,CA2EjB;kBAxHiB,YAAY"}
+{"version":3,"file":"Animations.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/Animations.js"],"names":[],"mappings":";;;;;AAkBA;;;;;;;;GAQG;AACH,mCAPW,MAAM,yDAGN,MAAM,0BACF,MAAM,KAAK,MAAM,GACnB,KAAK,CAcjB;AAED;;;;;;;;GAQG;AACH,8BAPW,MAAM,yDAGN,MAAM,0BACF,MAAM,KAAK,MAAM,GACnB,KAAK,CA2EjB;kBAxHiB,YAAY"}

package/src/engine/animation/Animations.js

@@ -22,7 +22,7 @@ function doMaterial(m, what) {
  * @param {EntityComponentDataset} ecd
  * @param {Vector3} parameter destination in local offset from current position
  * @param {number} time duration
- * @param {function(x:number):number} transitionFunction
+ * @param {(x: number) => number} transitionFunction
  * @returns {Tween}
  */
 function translate(entity, ecd, parameter, time, transitionFunction) {
@@ -45,7 +45,7 @@ function translate(entity, ecd, parameter, time, transitionFunction) {
  * @param {EntityComponentDataset} ecd
  * @param {Vector3} parameter final opacity, 1 - fully opaque, 0 - fully transparent
  * @param {number} time duration
- * @param {function(x:number):number} transitionFunction
+ * @param {(x: number) => number} transitionFunction
  * @returns {Tween}
  */
 function fade(entity, ecd, parameter, time, transitionFunction) {

package/src/engine/animation/EntityAnimation.d.ts

@@ -21,10 +21,10 @@ declare class EntityAnimation {
     fade(parameter: any, duration: any, timingFunction: any): this;
     /**
      *
-     * @param {function(animation:EntityAnimation):void} callback
+     * @param {(animation: EntityAnimation) => void} callback
      * @returns {EntityAnimation}
      */
-    onEnded(callback: any): EntityAnimation;
+    onEnded(callback: (animation: EntityAnimation) => void): EntityAnimation;
     start(em: any): void;
 }
 /**
@@ -36,15 +36,15 @@ declare class AnimationSpec {
      * @param {AnimationSpec.Type} type
      * @param {number} parameter
      * @param {number} duration in seconds
-     * @param {function(x:number):number} transitionFunction
+     * @param {(x: number) => number} transitionFunction
      */
     constructor(type: {
         TRANSLATE: number;
         FADE: number;
-    }, parameter: number, duration: number, transitionFunction: any);
+    }, parameter: number, duration: number, transitionFunction: (x: number) => number);
     parameter: number;
     duration: number;
-    transitionFunction: any;
+    transitionFunction: (x: number) => number;
     type: {
         TRANSLATE: number;
         FADE: number;

package/src/engine/animation/EntityAnimation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityAnimation.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/EntityAnimation.js"],"names":[],"mappings":";AAiCA;IAQI;;;OAGG;IACH,oBAFW,MAAM,EAIhB;IAbD;;OAEG;IACH,gBAFU,MAAO,aAAa,CAAC,CAEX;IAEpB,qBAAiC;IAO7B,eAAoB;IAGxB;;;OAGG;IACH,cAFa,QAAQ,GAAG,CAAC,CAUxB;IAED,kFAGC;IAED,oEAEC;IAED,+DAEC;IAED;;;;OAIG;IACH,wBAFa,eAAe,CAW3B;IAED,qBA4CC;CACJ;AAtID;;GAEG;AACH;IACI;;;;;;OAMG;IACH;;;kBAJW,MAAM,YACN,MAAM,2BAchB;IAVG,kBAA0B;IAC1B,iBAAwB;IACxB,wBAA4C;IAC5C;;;MAAgB;IAEhB;;;OAGG;IACH,OAFU,QAAM,IAAI,CAEH;CAExB;;;;;;;0BA1ByB,mCAAmC"}
+{"version":3,"file":"EntityAnimation.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/EntityAnimation.js"],"names":[],"mappings":";AAiCA;IAQI;;;OAGG;IACH,oBAFW,MAAM,EAIhB;IAbD;;OAEG;IACH,gBAFU,MAAO,aAAa,CAAC,CAEX;IAEpB,qBAAiC;IAO7B,eAAoB;IAGxB;;;OAGG;IACH,cAFa,QAAQ,GAAG,CAAC,CAUxB;IAED,kFAGC;IAED,oEAEC;IAED,+DAEC;IAED;;;;OAIG;IACH,8BAHuB,eAAe,KAAK,IAAI,GAClC,eAAe,CAW3B;IAED,qBA4CC;CACJ;AAtID;;GAEG;AACH;IACI;;;;;;OAMG;IACH;;;kBAJW,MAAM,YACN,MAAM,0BACF,MAAM,KAAK,MAAM,EAa/B;IAVG,kBAA0B;IAC1B,iBAAwB;IACxB,wBALW,MAAM,KAAK,MAAM,CAKgB;IAC5C;;;MAAgB;IAEhB;;;OAGG;IACH,OAFU,QAAM,IAAI,CAEH;CAExB;;;;;;;0BA1ByB,mCAAmC"}

package/src/engine/animation/EntityAnimation.js

@@ -10,7 +10,7 @@ class AnimationSpec {
      * @param {AnimationSpec.Type} type
      * @param {number} parameter
      * @param {number} duration in seconds
-     * @param {function(x:number):number} transitionFunction
+     * @param {(x: number) => number} transitionFunction
      */
     constructor(type, parameter, duration, transitionFunction) {
         this.parameter = parameter;
@@ -76,7 +76,7 @@ class EntityAnimation {
 
     /**
      *
-     * @param {function(animation:EntityAnimation):void} callback
+     * @param {(animation: EntityAnimation) => void} callback
      * @returns {EntityAnimation}
      */
     onEnded(callback) {

package/src/engine/animation/TransitionFunctions.d.ts

@@ -1,8 +1,5 @@
 export default TransitionFunctions;
-/**
- * ):number}
- */
-type TransitionFunctions = (arg0: x) => number;
+type TransitionFunctions = (x: number) => number;
 declare namespace TransitionFunctions {
     export { linear as Linear };
     export { sine as Sine };

package/src/engine/animation/TransitionFunctions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransitionFunctions.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/TransitionFunctions.js"],"names":[],"mappings":";;;;wCAIqB,MAAM;;;;;;;;;AAY3B;;;GAGG;AACH,2BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,yBAHW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;GAIG;AACH,+BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,kCAHW,MAAM,GACJ,MAAM,CAIlB"}
+{"version":3,"file":"TransitionFunctions.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/TransitionFunctions.js"],"names":[],"mappings":";+BAIc,MAAM,KAAK,MAAM;;;;;;;;;AAY/B;;;GAGG;AACH,2BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;GAGG;AACH,yBAHW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;GAIG;AACH,+BAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,gCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,kCAHW,MAAM,GACJ,MAAM,CAIlB"}

package/src/engine/animation/TransitionFunctions.js

@@ -2,7 +2,7 @@ import { makeCubicCurve } from "../../core/math/spline/makeCubicCurve.js";
 
 /**
  *
- * @enum {function(x:number):number}
+ * @enum {(x: number) => number}
  */
 const TransitionFunctions = {
     Linear: linear,

package/src/engine/animation/Tween.d.ts

@@ -2,20 +2,20 @@ export default Tween;
 declare class Tween {
     /**
      *
-     * @param {function(value:number, timeDelta:number)} callback
+     * @param {(value: number, timeDelta: number) => void} callback
      * @param {number} valueStart
      * @param {number} valueEnd
      * @param {number} duration time in seconds
-     * @param {function(fraction:number):number} [formula=TransitionFunctions.Linear]
+     * @param {(fraction: number) => number} [formula=TransitionFunctions.Linear]
      * @param {boolean} [oscillate=false]
      */
-    constructor(callback: any, valueStart: number, valueEnd: number, duration: number, formula?: (x: number) => number, oscillate?: boolean);
+    constructor(callback: (value: number, timeDelta: number) => void, valueStart: number, valueEnd: number, duration: number, formula?: (fraction: number) => number, oscillate?: boolean);
     timeElapsed: number;
     on: {
         ended: Signal;
     };
     oscillate: boolean;
-    formula: (x: number) => number;
+    formula: (fraction: number) => number;
     script: Script;
     destroy(): void;
     build(em: any): any;

package/src/engine/animation/Tween.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Tween.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/Tween.js"],"names":[],"mappings":";AAIA;IAOI;;;;;;;;OAQG;IACH,uCANW,MAAM,YACN,MAAM,YACN,MAAM,+CAEN,OAAO,EAsCjB;IAnDD,oBAAgB;IAEhB;;MAEE;IAoBE,mBAA0B;IAC1B,+BAAsB;IAGtB,eAsBE;IAGN,gBAEC;IAED,oBAKC;IAJG,mBAAuB;IACvB,YAA+B;CAItC;mBApEkB,oCAAoC;mBACpC,6BAA6B"}
+{"version":3,"file":"Tween.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/Tween.js"],"names":[],"mappings":";AAIA;IAOI;;;;;;;;OAQG;IACH,8BAPmB,MAAM,aAAa,MAAM,KAAK,IAAI,cAC1C,MAAM,YACN,MAAM,YACN,MAAM,uBACK,MAAM,KAAK,MAAM,cAC5B,OAAO,EAsCjB;IAnDD,oBAAgB;IAEhB;;MAEE;IAoBE,mBAA0B;IAC1B,oBAbkB,MAAM,KAAK,MAAM,CAab;IAGtB,eAsBE;IAGN,gBAEC;IAED,oBAKC;IAJG,mBAAuB;IACvB,YAA+B;CAItC;mBApEkB,oCAAoC;mBACpC,6BAA6B"}

package/src/engine/animation/Tween.js

@@ -11,11 +11,11 @@ class Tween {
 
     /**
      *
-     * @param {function(value:number, timeDelta:number)} callback
+     * @param {(value: number, timeDelta: number) => void} callback
      * @param {number} valueStart
      * @param {number} valueEnd
      * @param {number} duration time in seconds
-     * @param {function(fraction:number):number} [formula=TransitionFunctions.Linear]
+     * @param {(fraction: number) => number} [formula=TransitionFunctions.Linear]
      * @param {boolean} [oscillate=false]
      */
     constructor(

package/src/engine/asset/AssetManager.d.ts

@@ -79,7 +79,7 @@ export class AssetManager<CTX> {
      * @param {String} type
      * @param {AssetRequestScope} [scope]
      * @param {boolean} [skip_queue] if true will skip the queue and dispatch request immediately
-     * @param {function(loaded:number, total:number)} [progress]
+     * @param {(loaded: number, total: number) => void} [progress]
      * @returns {Promise<Asset>}
      */
     promise(path: string, type: string, { scope, skip_queue, progress }?: AssetRequestScope): Promise<Asset>;
@@ -87,9 +87,9 @@ export class AssetManager<CTX> {
      * @template T
      * @param {String} path
      * @param {String} type
-     * @param {function(asset:Asset<T>)} [callback] success callback
-     * @param {function(reason:*)} [failure]
-     * @param {function(loaded:number, total:number)} [progress]
+     * @param {(asset: Asset<T>) => void} [callback] success callback
+     * @param {(reason: *) => void} [failure]
+     * @param {(loaded: number, total: number) => void} [progress]
      * @param {boolean} [skip_queue]
      * @param {AssetRequestScope} [scope]
      */
@@ -131,7 +131,7 @@ export class AssetManager<CTX> {
      * @template T
      * @param {string} path
      * @param {string} type
-     * @param {function(progress?:function(current:number, total:number)):Promise<Asset<T>>} loader
+     * @param {(progress?: (current: number, total: number) => void) => Promise<Asset<T>>} loader
      * @returns {Promise<Asset<T>>} loaded asset
      * @see insert
      * @example
@@ -141,7 +141,7 @@ export class AssetManager<CTX> {
      *   });
      *
      */
-    insertAsync<T_1>(path: string, type: string, loader: any): Promise<Asset<T_1>>;
+    insertAsync<T_1>(path: string, type: string, loader: (progress?: (current: number, total: number) => void) => Promise<Asset<T_1>>): Promise<Asset<T_1>>;
     /**
      * Manually add a fully resolved resource.
      * If a load for the same description is in flight, it is squashed: the inserted asset wins,

package/src/engine/asset/AssetManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetManager.js"],"names":[],"mappings":"AAkDA;;;;GAIG;AACH;IA4MI;;;;;OAKG;IACH,oCAJW,GAAG,EAYb;IAzND;;;;OAIG;IACH,eAEG;IAEH;;;OAGG;IACH,aAFU,YAAY,gBAAgB,EAAE,YAAY,CAAC,CAER;IAuB7C;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEY;IA4B5B;;;;;;OAMG;IACH,iBAAc;IAEd;;;OAGG;IACH,mBAFU,iBAAiB,CAEiB;IAsI5C,gBAWC;IAED;;;;;;OAMG;IACH,qBALW,OAAO,GAGN,QAAQ,IAAI,CAAC,CAgBxB;IA4ED;;;;;;;OAOG;IACH,yBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAOnB;IAED;;OAEG;IACH,cAEC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,sEALW,iBAAiB,GAGf,cAAc,CAc1B;IAED;;;;;;;;;OASG;IACH,qFA4DC;IAED;;;;;;;OAOG;IACH,gBAJW,MAAM,QACN,MAAM,GACL,OAAO,CAKlB;IAGD;;;;;;;OAOG;IACH,eALW,MAAM,QACN,MAAM,GACJ,OAAO,CAOnB;IAED;;;;;;;OAOG;IACH,eAJW,MAAM,QACN,MAAM,GACL,OAAO,CAMlB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uBAZW,MAAM,QACN,MAAM,gBAEJ,mBAAiB,CAuE7B;IAED;;;;;;;;;;;OAWG;IACH,kBAJW,MAAM,QACN,MAAM,2BAoChB;IAgbD;;;;;;OAMG;IACH,sBAkCC;IAGD;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,wBAAY,SAAS,CAMjC;IAaD;;;;;;;;;;OAUG;IACH,+BALW,MAAM,uCAEJ,IAAI,CAqBhB;IAED;;;;;;OAMG;IACH,iCALW,MAAM,uCAEJ,OAAO,CAyBnB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,kCAEJ,QAAQ,OAAO,CAAC,CAU5B;IAED;;;;;OAKG;IACH,0BAJW,MAAM,iEAwChB;IAED;;;OAGG;IACH,uBAFW,MAAM,iBAkBhB;IAED;;;;;;;OAOG;IACH,yCAFa,aAAS,IAAI,CAYzB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,mBAAiB,CAa5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,gBAAgB,GAAC,SAAS,CAQrC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,QACN,MAAM,QAUhB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BAv3C2B,0CAA0C;iCAOrC,uBAAuB;6BAM3B,mBAAmB;kCAFd,6BAA6B;kCAD7B,wBAAwB;4BAE9B,0BAA0B"}
+{"version":3,"file":"AssetManager.d.ts","sourceRoot":"","sources":["../../../../src/engine/asset/AssetManager.js"],"names":[],"mappings":"AAkDA;;;;GAIG;AACH;IA4MI;;;;;OAKG;IACH,oCAJW,GAAG,EAYb;IAzND;;;;OAIG;IACH,eAEG;IAEH;;;OAGG;IACH,aAFU,YAAY,gBAAgB,EAAE,YAAY,CAAC,CAER;IAuB7C;;;;;;;OAOG;IACH,kBAFU,MAAM,CAEY;IA4B5B;;;;;;OAMG;IACH,iBAAc;IAEd;;;OAGG;IACH,mBAFU,iBAAiB,CAEiB;IAsI5C,gBAWC;IAED;;;;;;OAMG;IACH,qBALW,OAAO,GAGN,QAAQ,IAAI,CAAC,CAgBxB;IA4ED;;;;;;;OAOG;IACH,yBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAOnB;IAED;;OAEG;IACH,cAEC;IAED,8BAEC;IAED;;;;;;;OAOG;IACH,sEALW,iBAAiB,GAGf,cAAc,CAc1B;IAED;;;;;;;;;OASG;IACH,qFA4DC;IAED;;;;;;;OAOG;IACH,gBAJW,MAAM,QACN,MAAM,GACL,OAAO,CAKlB;IAGD;;;;;;;OAOG;IACH,eALW,MAAM,QACN,MAAM,GACJ,OAAO,CAOnB;IAED;;;;;;;OAOG;IACH,eAJW,MAAM,QACN,MAAM,GACL,OAAO,CAMlB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,uBAZW,MAAM,QACN,MAAM,gCACgB,MAAM,SAAS,MAAM,KAAK,IAAI,KAAK,mBAAiB,GACxE,mBAAiB,CAuE7B;IAED;;;;;;;;;;;OAWG;IACH,kBAJW,MAAM,QACN,MAAM,2BAoChB;IAgbD;;;;;;OAMG;IACH,sBAkCC;IAGD;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,CAIlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,wBAAY,SAAS,CAMjC;IAaD;;;;;;;;;;OAUG;IACH,+BALW,MAAM,uCAEJ,IAAI,CAqBhB;IAED;;;;;;OAMG;IACH,iCALW,MAAM,uCAEJ,OAAO,CAyBnB;IAED;;;;;;OAMG;IACH,6BAJW,MAAM,kCAEJ,QAAQ,OAAO,CAAC,CAU5B;IAED;;;;;OAKG;IACH,0BAJW,MAAM,iEAwChB;IAED;;;OAGG;IACH,uBAFW,MAAM,iBAkBhB;IAED;;;;;;;OAOG;IACH,yCAFa,aAAS,IAAI,CAYzB;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACL,mBAAiB,CAa5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,gBAAgB,GAAC,SAAS,CAQrC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,MAAM,QACN,MAAM,QAUhB;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BAv3C2B,0CAA0C;iCAOrC,uBAAuB;6BAM3B,mBAAmB;kCAFd,6BAA6B;kCAD7B,wBAAwB;4BAE9B,0BAA0B"}