@woosh/meep-engine 2.169.0 → 2.169.2

package/src/engine/animation/curve/animation_curve_binary_codec.js

@@ -0,0 +1,60 @@
+import { AnimationCurve } from "./AnimationCurve.js";
+import { Keyframe } from "./Keyframe.js";
+
+/**
+ * Binary wire codec for {@link AnimationCurve}: a `uintVar` keyframe count followed by
+ * `time / value / inTangent / outTangent` as float32 per key.
+ *
+ * WHY this exists: {@link AnimationCurve} has no registered binary class adapter of its own, so every binary
+ * adapter that owns a curve-valued FIELD has to spell the payload out inline. Two sopra adapters
+ * (`EventDescriptionSerializationAdapter` for the attenuation curve, `BlendContainerAudioClipSerializationAdapter`
+ * for the per-child blend curves) had written the same four float32s out and read them back — four hand-written
+ * copies of one wire format, where changing the payload (adding wrap modes, packing tangents) in three of the
+ * four places leaves the fourth silently mis-reading a stream it thinks it understands.
+ *
+ * This is deliberately a plain read/write PAIR rather than a registered `ObjectBasedClassSerializationAdapter`:
+ * routing curves through the object adapter would prefix each one with a class tag and change the bytes on the
+ * wire, breaking every already-serialized payload. The format here is byte-identical to what the sopra adapters
+ * previously emitted inline.
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AnimationCurve} curve
+ */
+export function serialize_animation_curve(buffer, curve) {
+    const keys = curve.keys;
+    const key_count = keys.length;
+
+    buffer.writeUintVar(key_count);
+
+    for (let i = 0; i < key_count; i++) {
+        const key = keys[i];
+
+        buffer.writeFloat32(key.time);
+        buffer.writeFloat32(key.value);
+        buffer.writeFloat32(key.inTangent);
+        buffer.writeFloat32(key.outTangent);
+    }
+}
+
+/**
+ * Read back a curve written by {@link serialize_animation_curve}.
+ *
+ * @param {BinaryBuffer} buffer
+ * @returns {AnimationCurve} a fresh curve
+ */
+export function deserialize_animation_curve(buffer) {
+    const curve = new AnimationCurve();
+
+    const key_count = buffer.readUintVar();
+
+    for (let i = 0; i < key_count; i++) {
+        const time = buffer.readFloat32();
+        const value = buffer.readFloat32();
+        const inTangent = buffer.readFloat32();
+        const outTangent = buffer.readFloat32();
+
+        curve.add(Keyframe.from(time, value, inTangent, outTangent));
+    }
+
+    return curve;
+}

package/src/engine/animation/curve/draw/canvas_point_to_curve.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Map a point in canvas space (pixels) back to curve space (time, value).
+ *
+ * Inverse of {@link curve_point_to_canvas}; see that function for why the mapping lives in exactly
+ * one place. Written as an out-parameter form so callers on a drag path do not allocate.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: curve time then curve value
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x canvas x
+ * @param {number} y canvas y
+ */
+export function canvas_point_to_curve(out: Float32Array | Float64Array | number[], out_offset: number, size: Vector2, frame: AABB2, margin: Vector2, x: number, y: number): void;
+//# sourceMappingURL=canvas_point_to_curve.d.ts.map

package/src/engine/animation/curve/draw/canvas_point_to_curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas_point_to_curve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/canvas_point_to_curve.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,2CARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,mDAIN,MAAM,KACN,MAAM,QAShB"}

package/src/engine/animation/curve/draw/canvas_point_to_curve.js

@@ -0,0 +1,22 @@
+/**
+ * Map a point in canvas space (pixels) back to curve space (time, value).
+ *
+ * Inverse of {@link curve_point_to_canvas}; see that function for why the mapping lives in exactly
+ * one place. Written as an out-parameter form so callers on a drag path do not allocate.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: curve time then curve value
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x canvas x
+ * @param {number} y canvas y
+ */
+export function canvas_point_to_curve(out, out_offset, size, frame, margin, x, y) {
+
+    const u = (x - margin.x) / (size.x - margin.x * 2);
+    const v = 1 - (y - margin.y) / (size.y - margin.y * 2);
+
+    out[out_offset] = u * frame.width + frame.x0;
+    out[out_offset + 1] = v * frame.height + frame.y0;
+}

package/src/engine/animation/curve/draw/curve_point_to_canvas.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Map a point in curve space (time, value) to canvas space (pixels).
+ *
+ * The frame is stretched to fill the canvas minus a symmetric pixel margin on each side, and the
+ * value axis is flipped so larger values are higher on screen.
+ *
+ * This is the ONE definition of the curve-editor's coordinate mapping. It exists because the editor
+ * used to draw the curve through an inline copy of this arithmetic
+ * ({@link canvas2dPlotCurvePoints}) while hit-testing, marker placement and panning went through
+ * {@link position_curve_to_canvas} / {@link position_canvas_to_curve} — the same formula written
+ * twice, so a change to the margin or anchoring convention in one desynced what the user clicks
+ * from what they see. Written as an out-parameter form because the plot calls it once per pixel
+ * column.
+ *
+ * Inverse of {@link canvas_point_to_curve}.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: canvas x then canvas y
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible; a zero-width or zero-height frame
+ * collapses that axis onto the low edge of the plot rather than producing a non-finite coordinate
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x curve time
+ * @param {number} y curve value
+ */
+export function curve_point_to_canvas(out: Float32Array | Float64Array | number[], out_offset: number, size: Vector2, frame: AABB2, margin: Vector2, x: number, y: number): void;
+//# sourceMappingURL=curve_point_to_canvas.d.ts.map

package/src/engine/animation/curve/draw/curve_point_to_canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve_point_to_canvas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/curve_point_to_canvas.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,2CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,mDAKN,MAAM,KACN,MAAM,QAchB"}

package/src/engine/animation/curve/draw/curve_point_to_canvas.js

@@ -0,0 +1,38 @@
+/**
+ * Map a point in curve space (time, value) to canvas space (pixels).
+ *
+ * The frame is stretched to fill the canvas minus a symmetric pixel margin on each side, and the
+ * value axis is flipped so larger values are higher on screen.
+ *
+ * This is the ONE definition of the curve-editor's coordinate mapping. It exists because the editor
+ * used to draw the curve through an inline copy of this arithmetic
+ * ({@link canvas2dPlotCurvePoints}) while hit-testing, marker placement and panning went through
+ * {@link position_curve_to_canvas} / {@link position_canvas_to_curve} — the same formula written
+ * twice, so a change to the margin or anchoring convention in one desynced what the user clicks
+ * from what they see. Written as an out-parameter form because the plot calls it once per pixel
+ * column.
+ *
+ * Inverse of {@link canvas_point_to_curve}.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives 2 floats: canvas x then canvas y
+ * @param {number} out_offset
+ * @param {Vector2} size canvas size in pixels
+ * @param {AABB2} frame region of curve space made visible; a zero-width or zero-height frame
+ * collapses that axis onto the low edge of the plot rather than producing a non-finite coordinate
+ * @param {Vector2} margin pixels reserved on each side of the plot
+ * @param {number} x curve time
+ * @param {number} y curve value
+ */
+export function curve_point_to_canvas(out, out_offset, size, frame, margin, x, y) {
+
+    const curve_width = frame.width;
+    const curve_width_multiplier = curve_width > 0 ? 1 / curve_width : 0;
+    const u = (x - frame.x0) * curve_width_multiplier;
+
+    const curve_height = frame.height;
+    const curve_height_multiplier = curve_height > 0 ? 1 / curve_height : 0;
+    const v = 1 - (y - frame.y0) * curve_height_multiplier;
+
+    out[out_offset] = margin.x + u * (size.x - margin.x * 2);
+    out[out_offset + 1] = margin.y + v * (size.y - margin.y * 2);
+}

package/src/engine/animation/curve/draw/position_canvas_to_curve.d.ts

@@ -1,4 +1,6 @@
 /**
+ * Allocating convenience wrapper around {@link canvas_point_to_curve}; use that directly on any
+ * path that runs per-pixel or per-frame.
  *
  * @param {Vector2} size
  * @param {AABB2} frame

package/src/engine/animation/curve/draw/position_canvas_to_curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"position_canvas_to_curve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_canvas_to_curve.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAclB;oBAvBmB,kCAAkC"}
+{"version":3,"file":"position_canvas_to_curve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_canvas_to_curve.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;oBArBmB,kCAAkC"}

package/src/engine/animation/curve/draw/position_canvas_to_curve.js

@@ -1,24 +1,22 @@
-import Vector2 from "../../../../core/geom/Vector2.js";
-
-/**
- *
- * @param {Vector2} size
- * @param {AABB2} frame
- * @param {Vector2} margin
- * @param {number} x
- * @param {number} y
- * @return {Vector2}
- */
-export function position_canvas_to_curve(size, frame, margin, x, y) {
-
-    const width = size.x;
-    const height = size.y;
-
-    const u = (x - margin.x) / (width - margin.x * 2);
-    const v = 1 - (y - margin.y) / (height - margin.y * 2);
-
-    return new Vector2(
-        u * frame.width + frame.x0,
-        v * frame.height + frame.y0
-    );
-}
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { canvas_point_to_curve } from "./canvas_point_to_curve.js";
+
+const scratch = new Float64Array(2);
+
+/**
+ * Allocating convenience wrapper around {@link canvas_point_to_curve}; use that directly on any
+ * path that runs per-pixel or per-frame.
+ *
+ * @param {Vector2} size
+ * @param {AABB2} frame
+ * @param {Vector2} margin
+ * @param {number} x
+ * @param {number} y
+ * @return {Vector2}
+ */
+export function position_canvas_to_curve(size, frame, margin, x, y) {
+
+    canvas_point_to_curve(scratch, 0, size, frame, margin, x, y);
+
+    return new Vector2(scratch[0], scratch[1]);
+}

package/src/engine/animation/curve/draw/position_curve_to_canvas.d.ts

@@ -1,4 +1,6 @@
 /**
+ * Allocating convenience wrapper around {@link curve_point_to_canvas}; use that directly on any
+ * path that runs per-pixel or per-frame.
  *
  * @param {Vector2} size
  * @param {AABB2} frame

package/src/engine/animation/curve/draw/position_curve_to_canvas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"position_curve_to_canvas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_curve_to_canvas.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAelB;oBAxBmB,kCAAkC"}
+{"version":3,"file":"position_curve_to_canvas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/draw/position_curve_to_canvas.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,+CAPW,OAAO,wBAEP,OAAO,KACP,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;oBArBmB,kCAAkC"}

package/src/engine/animation/curve/draw/position_curve_to_canvas.js

@@ -1,25 +1,22 @@
-import Vector2 from "../../../../core/geom/Vector2.js";
-
-/**
- *
- * @param {Vector2} size
- * @param {AABB2} frame
- * @param {Vector2} margin
- * @param {number} x
- * @param {number} y
- * @return {Vector2}
- */
-export function position_curve_to_canvas(size, frame, margin, x, y) {
-    const width = size.x;
-    const height = size.y;
-
-    const curve_width = frame.width;
-    const curve_width_multiplier = curve_width > 0 ? 1 / curve_width : 0;
-    const u = (x - frame.x0) * curve_width_multiplier;
-
-    const curve_height = frame.height;
-    const curve_height_multiplier = curve_height > 0 ? 1 / curve_height : 0;
-    const v = 1 - (y - frame.y0) * curve_height_multiplier;
-
-    return new Vector2(margin.x + (u * (width - margin.x * 2)), margin.y + v * (height - margin.y * 2));
-}
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { curve_point_to_canvas } from "./curve_point_to_canvas.js";
+
+const scratch = new Float64Array(2);
+
+/**
+ * Allocating convenience wrapper around {@link curve_point_to_canvas}; use that directly on any
+ * path that runs per-pixel or per-frame.
+ *
+ * @param {Vector2} size
+ * @param {AABB2} frame
+ * @param {Vector2} margin
+ * @param {number} x
+ * @param {number} y
+ * @return {Vector2}
+ */
+export function position_curve_to_canvas(size, frame, margin, x, y) {
+
+    curve_point_to_canvas(scratch, 0, size, frame, margin, x, y);
+
+    return new Vector2(scratch[0], scratch[1]);
+}

package/src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas2dDrawWorldAxisLabels.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,+IAVW,wBAAwB,QAwDlC"}
+{"version":3,"file":"canvas2dDrawWorldAxisLabels.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,+IAVW,wBAAwB,QAyDlC"}

package/src/engine/animation/curve/editor/canvas2dDrawWorldAxisLabels.js

@@ -40,8 +40,9 @@ export function canvas2dDrawWorldAxisLabels({
     const direction_x = delta_x / distance;
     const direction_y = delta_y / distance;
 
-    // number of marks
-    const mark_count = Math.ceil(distance / spacing);
+    // largest multiple of `spacing` that still lands on or before the axis end;
+    // using ceil would place a final tick past position_1 with an extrapolated value
+    const mark_count = Math.floor(distance / spacing);
 
     for (let i = 0; i <= mark_count; i++) {
         const offset = spacing * i;

package/src/engine/animation/curve/editor/canvas2dPlotCurvePoints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas2dPlotCurvePoints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dPlotCurvePoints.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,2FAPW,wBAAwB,QAgElC"}
+{"version":3,"file":"canvas2dPlotCurvePoints.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/animation/curve/editor/canvas2dPlotCurvePoints.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,2FAPW,wBAAwB,QA4DlC"}

package/src/engine/animation/curve/editor/canvas2dPlotCurvePoints.js

@@ -1,4 +1,8 @@
-import {Vector2} from "three";
+import AABB2 from "../../../../core/geom/2d/aabb/AABB2.js";
+import { curve_point_to_canvas } from "../draw/curve_point_to_canvas.js";
+
+const scratch_frame = new AABB2();
+const scratch_point = new Float64Array(2);
 
 /**
  *
@@ -28,18 +32,15 @@ export function canvas2dPlotCurvePoints({
     const firstKeyTime = keyframes[0].time;
     const lastKeyTime = keyframes[keyframes.length - 1].time;
 
-    const axisSize = new Vector2(
-        dimension.x - offset.x * 2,
-        dimension.y - offset.y * 2
-    );
+    // curve->canvas mapping is shared with the editor's hit-testing and marker placement,
+    // see `draw/curve_point_to_canvas.js`
+    scratch_frame.set(minX, minY, maxX, maxY);
 
-    const timeRange = maxX - minX
-    const valueRange = maxY - minY
+    const axisSizeX = dimension.x - offset.x * 2;
 
-    const inverseTimeRange = timeRange !== 0 ? 1 / timeRange : 0;
-    const inverseValueRange = valueRange !== 0 ? 1 / valueRange : 0;
+    const timeRange = maxX - minX
 
-    const pixelCountX = Math.max(axisSize.x - 1 , 1);
+    const pixelCountX = Math.max(axisSizeX - 1, 1);
     const timeStep = timeRange * (1 / pixelCountX)
 
     ctx.beginPath();
@@ -52,11 +53,10 @@ export function canvas2dPlotCurvePoints({
 
         const value = curve.evaluate(t);
 
-        const normY = (value - minY) * inverseValueRange
-        const normX = (t - minX) * inverseTimeRange
+        curve_point_to_canvas(scratch_point, 0, dimension, scratch_frame, offset, t, value);
 
-        const y = (1 - normY) * axisSize.y + offset.y
-        const x = normX * axisSize.x + offset.x
+        const x = scratch_point[0];
+        const y = scratch_point[1];
 
         if (x >= -offScreenMargin && !started) {
             ctx.moveTo(x, y);

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

@@ -1 +1 @@
-{"version":3,"file":"removeEntityWithMeshParticlesEffect.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/removeEntityWithMeshParticlesEffect.js"],"names":[],"mappings":"AA6IA;;;;;;;GAOG;AACH,+GAFa,QAAQ,GAAG,CAAC,CAuDxB"}
+{"version":3,"file":"removeEntityWithMeshParticlesEffect.d.ts","sourceRoot":"","sources":["../../../../src/engine/animation/removeEntityWithMeshParticlesEffect.js"],"names":[],"mappings":"AA8IA;;;;;;;GAOG;AACH,+GAFa,QAAQ,GAAG,CAAC,CA2DxB"}

package/src/engine/animation/removeEntityWithMeshParticlesEffect.js

@@ -2,6 +2,7 @@ import Mesh from "../graphics/ecs/mesh/Mesh.js";
 import {
     distributeParticlesOnObject3D
 } from "../graphics/particles/particular/engine/utils/distributeParticlesOnObject3D.js";
+import { SerializationMetadata } from "../ecs/components/SerializationMetadata.js";
 import { removeComponentsExcept } from "../ecs/util/removeComponentsExcept.js";
 import { ParticleEmitter } from "../graphics/particles/particular/engine/emitter/ParticleEmitter.js";
 import Trail2D from "../graphics/ecs/trail2d/Trail2D.js";
@@ -173,6 +174,10 @@ export function removeEntityWithMeshParticlesEffect(
     //prevent further interactions
     removeComponentsExcept(ecd, entity, [Mesh, ParticleEmitter, Trail2D, Transform]);
 
+    //make entity volatile so it does not end up in game saves. The entity is mid-death here;
+    //without this a save taken during the effect would restore a corpse that never finishes dying.
+    ecd.addComponentToEntity(entity, SerializationMetadata.Transient);
+
     /**
      *
      * @type {Transform}

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"}