@woosh/meep-engine 3.46.0 → 3.47.0

package/src/engine/sound/sopra/runtime/EffectParamOverrides.d.ts

@@ -0,0 +1,123 @@
+/**
+ * @typedef {import("../definition/EventDescription.js").EventDescription} EventDescription
+ * @typedef {import("./EventInstance.js").EventInstance} EventInstance
+ */
+/**
+ * How an {@link EffectParamOverrides} tells its owner to move the instance it currently plays: to `value`,
+ * now when `timeConstant` is 0, as a glide (`approachEffectParam`) above 0. A removed override sends the
+ * event's own value.
+ * @callback EffectParamChange
+ * @param {number} effectIndex
+ * @param {string} name
+ * @param {number} value
+ * @param {number} timeConstant seconds
+ * @returns {void}
+ */
+/**
+ * Live overrides of an event's insert-effect parameters ({@link EventDescription.effects}) that outlive any
+ * one {@link EventInstance}. They belong to whatever plays the event over and over — an `AudioEmitter`,
+ * whose spatially managed instance is torn down on demotion and built afresh on promotion — and are put
+ * onto every instance it gets ({@link applyTo}), so a filter set on the emitter stays set however often
+ * the voice underneath is rebuilt.
+ *
+ * Runtime state, not a definition: never serialized, and no part of its owner's identity.
+ *
+ * An override is addressed the way an instance addresses the parameter itself: the effect's index in the
+ * event's `effects`, and one of that effect class's `parameters`. While {@link attach}ed to the event it
+ * addresses, every write is checked against the event's effects and one they do not have throws at the
+ * write, storing nothing; overrides written before that are checked when it attaches. Values are checked
+ * as an `AudioParam` would check them, in every build (not by `assert`). So an override that is held
+ * always fits, and no later rebuild of an instance can trip on one — as long as the event's effects are
+ * not edited in place while it is attached.
+ *
+ * One owner at a time: the attached one is told of every change ({@link EffectParamChange}) and moves the
+ * instance it currently plays, if any.
+ */
+export class EffectParamOverrides {
+    /**
+     * @returns {number} how many parameters are overridden
+     */
+    get size(): number;
+    /**
+     * @returns {boolean} whether an owner is attached
+     */
+    get attached(): boolean;
+    /**
+     * Throw unless {@link attach} would take `event`: when another owner is attached, or when an override
+     * already held is one the event's effects do not have (named). Changes nothing — so an owner can ask
+     * before it does anything else, and attach once nothing else can fail.
+     * @param {EventDescription} event
+     */
+    checkAttach(event: EventDescription): void;
+    /**
+     * Become the overrides of whatever plays `event`: from now on every write is checked against its
+     * effects, and `onChange` is told of it. Checked first as {@link checkAttach} checks; on a throw nothing
+     * changes.
+     * @param {EventDescription} event the event the owner's instances are built from
+     * @param {EffectParamChange} onChange
+     */
+    attach(event: EventDescription, onChange: EffectParamChange): void;
+    /**
+     * Stop telling `onChange` of changes — if it is the attached owner; a later owner is left attached. The
+     * overrides themselves are kept, for whatever attaches next.
+     * @param {EffectParamChange} onChange
+     * @returns {boolean} whether `onChange` was attached
+     */
+    detach(onChange: EffectParamChange): boolean;
+    /**
+     * Override a parameter; the current instance moves there now.
+     * @param {number} effectIndex position in the event's `effects`
+     * @param {string} name one of that effect class's `parameters`
+     * @param {number} value in the parameter's own units (Hz, dB, ...)
+     */
+    set(effectIndex: number, name: string, value: number): void;
+    /**
+     * Override a parameter; the current instance glides there (see {@link EventInstance#approachEffectParam}).
+     * The override itself is the target, so an instance built while the glide is in flight starts AT it.
+     * @param {number} effectIndex
+     * @param {string} name
+     * @param {number} value
+     * @param {number} timeConstant seconds, above 0
+     */
+    approach(effectIndex: number, name: string, value: number, timeConstant: number): void;
+    /**
+     * @param {number} effectIndex
+     * @param {string} name
+     * @returns {number|undefined} the override, or undefined if the parameter is not overridden
+     */
+    get(effectIndex: number, name: string): number | undefined;
+    /**
+     * @param {number} effectIndex
+     * @param {string} name
+     * @returns {boolean}
+     */
+    has(effectIndex: number, name: string): boolean;
+    /**
+     * Drop an override: the current instance returns to the event's own value now, and later ones are built
+     * at it. To glide back instead, {@link approach} the event's value first.
+     * @param {number} effectIndex
+     * @param {string} name
+     * @returns {boolean} false if the parameter was not overridden
+     */
+    remove(effectIndex: number, name: string): boolean;
+    /**
+     * Drop every override (see {@link remove}).
+     */
+    clear(): void;
+    /**
+     * Put every override onto a freshly built instance, at once: a new instance starts at the overrides, not
+     * gliding toward them from the definition.
+     * @param {EventInstance} instance
+     */
+    applyTo(instance: EventInstance): void;
+    #private;
+}
+export type EventDescription = import("../definition/EventDescription.js").EventDescription;
+export type EventInstance = import("./EventInstance.js").EventInstance;
+/**
+ * How an {@link EffectParamOverrides } tells its owner to move the instance it currently plays: to `value`,
+ * now when `timeConstant` is 0, as a glide (`approachEffectParam`) above 0. A removed override sends the
+ * event's own value.
+ */
+export type EffectParamChange = (effectIndex: number, name: string, value: number, timeConstant: number) => void;
+//# sourceMappingURL=EffectParamOverrides.d.ts.map

package/src/engine/sound/sopra/runtime/EffectParamOverrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EffectParamOverrides.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/EffectParamOverrides.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0BI;;OAEG;IACH,mBAEC;IAED;;OAEG;IACH,wBAEC;IAED;;;;;OAKG;IACH,mBAFW,gBAAgB,QAsB1B;IAED;;;;;;OAMG;IACH,cAHW,gBAAgB,YAChB,iBAAiB,QAS3B;IAED;;;;;OAKG;IACH,iBAHW,iBAAiB,GACf,OAAO,CAWnB;IA8CD;;;;;OAKG;IACH,iBAJW,MAAM,QACN,MAAM,SACN,MAAM,QAQhB;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,QACN,MAAM,SACN,MAAM,gBACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,iBAJW,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,SAAS,CAM5B;IAED;;;;OAIG;IACH,iBAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAMnB;IAED;;;;;;OAMG;IACH,oBAJW,MAAM,QACN,MAAM,GACJ,OAAO,CAmBnB;IAED;;OAEG;IACH,cAkBC;IAcD;;;;OAIG;IACH,kBAFW,aAAa,QAcvB;;CACJ;+BA3TY,OAAO,mCAAmC,EAAE,gBAAgB;4BAC5D,OAAO,oBAAoB,EAAE,aAAa;;;;;;8CAQ5C,MAAM,QACN,MAAM,SACN,MAAM,gBACN,MAAM,KACJ,IAAI"}

package/src/engine/sound/sopra/runtime/EffectParamOverrides.js

@@ -0,0 +1,320 @@
+import { assert } from "../../../../core/assert.js";
+import { effectParamIndex } from "./EffectChain.js";
+
+/**
+ * @typedef {import("../definition/EventDescription.js").EventDescription} EventDescription
+ * @typedef {import("./EventInstance.js").EventInstance} EventInstance
+ */
+
+/**
+ * How an {@link EffectParamOverrides} tells its owner to move the instance it currently plays: to `value`,
+ * now when `timeConstant` is 0, as a glide (`approachEffectParam`) above 0. A removed override sends the
+ * event's own value.
+ * @callback EffectParamChange
+ * @param {number} effectIndex
+ * @param {string} name
+ * @param {number} value
+ * @param {number} timeConstant seconds
+ * @returns {void}
+ */
+
+/**
+ * Live overrides of an event's insert-effect parameters ({@link EventDescription.effects}) that outlive any
+ * one {@link EventInstance}. They belong to whatever plays the event over and over — an `AudioEmitter`,
+ * whose spatially managed instance is torn down on demotion and built afresh on promotion — and are put
+ * onto every instance it gets ({@link applyTo}), so a filter set on the emitter stays set however often
+ * the voice underneath is rebuilt.
+ *
+ * Runtime state, not a definition: never serialized, and no part of its owner's identity.
+ *
+ * An override is addressed the way an instance addresses the parameter itself: the effect's index in the
+ * event's `effects`, and one of that effect class's `parameters`. While {@link attach}ed to the event it
+ * addresses, every write is checked against the event's effects and one they do not have throws at the
+ * write, storing nothing; overrides written before that are checked when it attaches. Values are checked
+ * as an `AudioParam` would check them, in every build (not by `assert`). So an override that is held
+ * always fits, and no later rebuild of an instance can trip on one — as long as the event's effects are
+ * not edited in place while it is attached.
+ *
+ * One owner at a time: the attached one is told of every change ({@link EffectParamChange}) and moves the
+ * instance it currently plays, if any.
+ */
+export class EffectParamOverrides {
+
+    /**
+     * effect index → that effect's overridden parameters (name → value). Null until the first override:
+     * most owners never hold one.
+     * @type {Map<number, Map<string, number>>|null}
+     */
+    #values = null;
+
+    /**
+     * @type {number}
+     */
+    #size = 0;
+
+    /**
+     * The event the attached owner plays; null while detached. Its `effects` are read at each check, so a
+     * check follows whatever list the owner's next instance will be built from.
+     * @type {EventDescription|null}
+     */
+    #event = null;
+
+    /**
+     * @type {EffectParamChange|null}
+     */
+    #onChange = null;
+
+    /**
+     * @returns {number} how many parameters are overridden
+     */
+    get size() {
+        return this.#size;
+    }
+
+    /**
+     * @returns {boolean} whether an owner is attached
+     */
+    get attached() {
+        return this.#onChange !== null;
+    }
+
+    /**
+     * Throw unless {@link attach} would take `event`: when another owner is attached, or when an override
+     * already held is one the event's effects do not have (named). Changes nothing — so an owner can ask
+     * before it does anything else, and attach once nothing else can fail.
+     * @param {EventDescription} event
+     */
+    checkAttach(event) {
+        assert.defined(event, 'event');
+
+        if (this.#onChange !== null) {
+            throw new Error('sopra: these effect overrides already have an owner - one playing thing at a time (one entity per AudioEmitter)');
+        }
+
+        const values = this.#values;
+
+        if (values === null) {
+            return;
+        }
+
+        const effects = event.effects;
+
+        for (const [effectIndex, params] of values) {
+            for (const name of params.keys()) {
+                effectParamIndex(effects, effectIndex, name);
+            }
+        }
+    }
+
+    /**
+     * Become the overrides of whatever plays `event`: from now on every write is checked against its
+     * effects, and `onChange` is told of it. Checked first as {@link checkAttach} checks; on a throw nothing
+     * changes.
+     * @param {EventDescription} event the event the owner's instances are built from
+     * @param {EffectParamChange} onChange
+     */
+    attach(event, onChange) {
+        assert.isFunction(onChange, 'onChange');
+
+        this.checkAttach(event);
+
+        this.#event = event;
+        this.#onChange = onChange;
+    }
+
+    /**
+     * Stop telling `onChange` of changes — if it is the attached owner; a later owner is left attached. The
+     * overrides themselves are kept, for whatever attaches next.
+     * @param {EffectParamChange} onChange
+     * @returns {boolean} whether `onChange` was attached
+     */
+    detach(onChange) {
+        if (this.#onChange !== onChange) {
+            return false;
+        }
+
+        this.#event = null;
+        this.#onChange = null;
+
+        return true;
+    }
+
+    /**
+     * @param {number} effectIndex
+     * @param {string} name
+     * @param {number} value
+     */
+    #store(effectIndex, name, value) {
+        // a fractional or negative index is no position, and would be held where no instance can take it
+        if (!Number.isInteger(effectIndex) || effectIndex < 0) {
+            throw new Error(`sopra: an effect index is a non-negative integer, got ${effectIndex}`);
+        }
+
+        assert.isString(name, 'name');
+
+        // An AudioParam throws on a non-finite value. Refused here in every build - an `assert` is stripped
+        // from a production one, and the value would be held until some promotion tripped over it.
+        if (!Number.isFinite(value)) {
+            throw new Error(`sopra: an effect parameter's value is a finite number, got ${value}`);
+        }
+
+        if (this.#event !== null) {
+            effectParamIndex(this.#event.effects, effectIndex, name);
+        }
+
+        let values = this.#values;
+
+        if (values === null) {
+            values = new Map();
+            this.#values = values;
+        }
+
+        let params = values.get(effectIndex);
+
+        if (params === undefined) {
+            params = new Map();
+            values.set(effectIndex, params);
+        }
+
+        if (!params.has(name)) {
+            this.#size++;
+        }
+
+        params.set(name, value);
+    }
+
+    /**
+     * Override a parameter; the current instance moves there now.
+     * @param {number} effectIndex position in the event's `effects`
+     * @param {string} name one of that effect class's `parameters`
+     * @param {number} value in the parameter's own units (Hz, dB, ...)
+     */
+    set(effectIndex, name, value) {
+        this.#store(effectIndex, name, value);
+
+        if (this.#onChange !== null) {
+            this.#onChange(effectIndex, name, value, 0);
+        }
+    }
+
+    /**
+     * Override a parameter; the current instance glides there (see {@link EventInstance#approachEffectParam}).
+     * The override itself is the target, so an instance built while the glide is in flight starts AT it.
+     * @param {number} effectIndex
+     * @param {string} name
+     * @param {number} value
+     * @param {number} timeConstant seconds, above 0
+     */
+    approach(effectIndex, name, value, timeConstant) {
+        assert.isFinite(timeConstant, 'timeConstant');
+        assert.greaterThan(timeConstant, 0, 'timeConstant');
+
+        this.#store(effectIndex, name, value);
+
+        if (this.#onChange !== null) {
+            this.#onChange(effectIndex, name, value, timeConstant);
+        }
+    }
+
+    /**
+     * @param {number} effectIndex
+     * @param {string} name
+     * @returns {number|undefined} the override, or undefined if the parameter is not overridden
+     */
+    get(effectIndex, name) {
+        const params = this.#values === null ? undefined : this.#values.get(effectIndex);
+
+        return params === undefined ? undefined : params.get(name);
+    }
+
+    /**
+     * @param {number} effectIndex
+     * @param {string} name
+     * @returns {boolean}
+     */
+    has(effectIndex, name) {
+        const params = this.#values === null ? undefined : this.#values.get(effectIndex);
+
+        return params !== undefined && params.has(name);
+    }
+
+    /**
+     * Drop an override: the current instance returns to the event's own value now, and later ones are built
+     * at it. To glide back instead, {@link approach} the event's value first.
+     * @param {number} effectIndex
+     * @param {string} name
+     * @returns {boolean} false if the parameter was not overridden
+     */
+    remove(effectIndex, name) {
+        const values = this.#values;
+        const params = values === null ? undefined : values.get(effectIndex);
+
+        if (params === undefined || !params.delete(name)) {
+            return false;
+        }
+
+        if (params.size === 0) {
+            values.delete(effectIndex);
+        }
+
+        this.#size--;
+
+        this.#released(effectIndex, name);
+
+        return true;
+    }
+
+    /**
+     * Drop every override (see {@link remove}).
+     */
+    clear() {
+        const values = this.#values;
+
+        if (values === null) {
+            return;
+        }
+
+        this.#values = null;
+        this.#size = 0;
+
+        for (const [effectIndex, params] of values) {
+            for (const name of params.keys()) {
+                // the owner may write while it is told; a parameter overridden again meanwhile keeps that
+                if (!this.has(effectIndex, name)) {
+                    this.#released(effectIndex, name);
+                }
+            }
+        }
+    }
+
+    /**
+     * Tell the owner a parameter is no longer overridden: its instance goes back to the event's own value,
+     * the definition field the parameter starts from.
+     * @param {number} effectIndex
+     * @param {string} name
+     */
+    #released(effectIndex, name) {
+        if (this.#onChange !== null) {
+            this.#onChange(effectIndex, name, this.#event.effects[effectIndex][name], 0);
+        }
+    }
+
+    /**
+     * Put every override onto a freshly built instance, at once: a new instance starts at the overrides, not
+     * gliding toward them from the definition.
+     * @param {EventInstance} instance
+     */
+    applyTo(instance) {
+        const values = this.#values;
+
+        if (values === null) {
+            return;
+        }
+
+        for (const [effectIndex, params] of values) {
+            for (const [name, value] of params) {
+                instance.setEffectParam(effectIndex, name, value);
+            }
+        }
+    }
+}

package/src/engine/sound/sopra/runtime/EventInstance.d.ts

@@ -74,10 +74,16 @@ export class EventInstance {
      */
     busId: string;
     /**
-     * World position for spatialization. Null = non-positional.
-     * @type {Vector3|null}
+     * World position for spatialization, read by index. Null = non-positional.
+     *
+     * Held by reference, not copied, and read when the instance starts, after {@link moved}, and
+     * whenever the listener moves ({@link SopraEngine#setListener}). So whoever writes it says so with
+     * {@link moved}; a source written without saying so keeps sounding where it last was. Give each
+     * instance an array of its own: every instance reads the one it holds, so instances sharing one
+     * are all wherever it was last written. (The acoustic simulation reads it afresh on each solve.)
+     * @type {ArrayLike<number>|null}
      */
-    position: Vector3 | null;
+    position: ArrayLike<number> | null;
     /**
      * World orientation of the source (shared {@link Transform} rotation ref, so it tracks the entity).
      * Read by the {@link AcousticSimulator} only to evaluate {@link directivity}; null when the source has
@@ -119,6 +125,38 @@ export class EventInstance {
      * @param {number} now
      */
     start(now: number): void;
+    /**
+     * Move a parameter of this instance's copy of one of the event's insert effects, now — one play of a
+     * cue made duller, brighter or louder than the others. Other instances of the event, and the
+     * {@link EventDescription} itself, are untouched.
+     *
+     * Valid from the moment the instance exists, including while its buffers are still loading. The effect
+     * is addressed by its position in {@link EventDescription.effects}, the parameter by one of its class's
+     * `parameters` (`'frequency'` on an `EqEffect`).
+     *
+     * @param {number} effectIndex
+     * @param {string} name
+     * @param {number} value in the parameter's own units (Hz, dB, seconds, ...)
+     */
+    setEffectParam(effectIndex: number, name: string, value: number): void;
+    /**
+     * Glide a parameter of this instance's copy of one of the event's insert effects toward `value` —
+     * tracking a game value while the sound plays. See {@link EffectChain#approachParam}; addressed as
+     * {@link setEffectParam}.
+     *
+     * @param {number} effectIndex
+     * @param {string} name
+     * @param {number} value
+     * @param {number} timeConstant seconds, above 0
+     */
+    approachEffectParam(effectIndex: number, name: string, value: number, timeConstant: number): void;
+    /**
+     * Where this instance's effect parameter was last sent (a glide's target), or its defined value.
+     * @param {number} effectIndex
+     * @param {string} name
+     * @returns {number}
+     */
+    getEffectParam(effectIndex: number, name: string): number;
     /**
      * Live instance gain in decibels (composes with 3D attenuation).
      * @returns {number}
@@ -174,10 +212,22 @@ export class EventInstance {
     /**
      * Advance the instance one frame: update spatialization, then evaluate the timeline against the
      * playhead (spawning / virtualizing voices).
+     *
+     * The listener is the engine's ({@link SopraEngine#listenerPosition}), read here together with the
+     * version that says whether it moved, so a listener set during a tick is never paired with another's
+     * version.
      * @param {number} now context time
-     * @param {Vector3|null} listenerPosition
      */
-    update(now: number, listenerPosition: Vector3 | null): void;
+    update(now: number): void;
+    /**
+     * Report that {@link position} was written, so the next {@link update} puts the source where it now
+     * is: its panner, its distance attenuation and whether it is audible at all. The instance reads the
+     * array only when something has moved, so a write nobody reports is not heard.
+     *
+     * Cheap and idempotent: it marks the instance, and the work happens once, in the next update,
+     * however many writes were reported before it. Harmless on a 2D instance, or on one that has stopped.
+     */
+    moved(): void;
     /**
      * Stop all voices, tear down the output chain, and finish the instance.
      */

package/src/engine/sound/sopra/runtime/EventInstance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EventInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/EventInstance.js"],"names":[],"mappings":";;;iCAqBU,MAAM;;;;;;AAoFhB;;;;;;;;;GASG;AACH;IAkLI;;;;OAIG;IACH,oBAJW,WAAW,eACX,gBAAgB,qIAChB;QAAC,KAAK,CAAC,EAAC,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAC,OAAO,CAAC;QAAC,OAAO,CAAC,EAAC,OAAO,CAAC;QAAC,WAAW,CAAC,EAAC,MAAM,CAAC;QAAC,eAAe,CAAC,EAAC,oBAAoB,CAAC;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAC,OAAO,CAAC;QAAC,OAAO,CAAC,EAAC,OAAO,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,WAAW,CAAC,EAAC,UAAU,CAAC;QAAC,WAAW,CAAC,EAAC,mBAAmB,CAAA;KAAC,EA0EnQ;IA7PD;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,OAFU,kBAAkB,GAAC,MAAM,CAEA;IAEnC;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAAuB;IAsKnB;;OAEG;IACH,QAFU,WAAW,CAED;IAEpB;;OAEG;IACH,aAFU,gBAAgB,CAEI;IAE9B;;OAEG;IACH,OAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,UAFU,OAAO,GAAC,IAAI,CAEE;IAExB;;;;;OAKG;IACH,aAFU,UAAU,GAAC,IAAI,CAEK;IAE9B;;;;;OAKG;IACH,aAFU,mBAAmB,GAAC,IAAI,CAEJ;IAE9B;;OAEG;IACH,SAFU,OAAO,CAEK;IAEtB;;OAEG;IACH,oBAFU,MAAM,CAEqB;IAErC;;OAEG;IACH,iBAFU,oBAAoB,CAEQ;IAW1C;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,WAFW,MAAM,QAyChB;IAwJD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,cAFW,MAAM,QAQhB;IAED;;;;;;;;;;;OAWG;IACH,sBAFW,gBAAgB,QAgE1B;IAED;;;;;OAKG;IACH,uBAJW,MAAM,YACN,MAAM,eACN,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,yBAHW,MAAM,eACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,cAFW,MAAM,QAehB;IAED;;OAEG;IACH,gBAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,oBACN,OAAO,GAAC,IAAI,QA8DtB;IAuGD;;OAEG;IACH,aAsCC;;CACJ;yBAv9BY,OAAO,qCAAqC,EAAE,UAAU;sBACxD,OAAO,kCAAkC,EAAE,OAAO;+BAClD,OAAO,2CAA2C,EAAE,gBAAgB;kCACpE,OAAO,oDAAoD,EAAE,mBAAmB;0BAChF,OAAO,mBAAmB,EAAE,WAAW;+BACvC,OAAO,mCAAmC,EAAE,gBAAgB;mCAC5D,OAAO,2BAA2B,EAAE,oBAAoB;oBACxD,OAAO,YAAY,EAAE,KAAK"}
+{"version":3,"file":"EventInstance.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/EventInstance.js"],"names":[],"mappings":";;;iCAsBU,MAAM;;;;;;AAoFhB;;;;;;;;;GASG;AACH;IAuNI;;;;OAIG;IACH,oBAJW,WAAW,eACX,gBAAgB,qIAChB;QAAC,KAAK,CAAC,EAAC,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAC,OAAO,CAAC;QAAC,OAAO,CAAC,EAAC,OAAO,CAAC;QAAC,WAAW,CAAC,EAAC,MAAM,CAAC;QAAC,eAAe,CAAC,EAAC,oBAAoB,CAAC;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAC,OAAO,CAAC;QAAC,OAAO,CAAC,EAAC,OAAO,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,WAAW,CAAC,EAAC,UAAU,CAAC;QAAC,WAAW,CAAC,EAAC,mBAAmB,CAAA;KAAC,EAoFnQ;IA5SD;;OAEG;IACH,WAFU,MAAM,CAEF;IAEd;;OAEG;IACH,OAFU,kBAAkB,GAAC,MAAM,CAEA;IAEnC;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,aAAuB;IA2MnB;;OAEG;IACH,QAFU,WAAW,CAED;IAEpB;;OAEG;IACH,aAFU,gBAAgB,CAEI;IAE9B;;OAEG;IACH,OAFU,MAAM,CAEE;IAElB;;;;;;;;;OASG;IACH,UAFU,UAAU,MAAM,CAAC,GAAC,IAAI,CAER;IAExB;;;;;OAKG;IACH,aAFU,UAAU,GAAC,IAAI,CAEK;IAE9B;;;;;OAKG;IACH,aAFU,mBAAmB,GAAC,IAAI,CAEJ;IAE9B;;OAEG;IACH,SAFU,OAAO,CAEK;IAEtB;;OAEG;IACH,oBAFU,MAAM,CAEqB;IAErC;;OAEG;IACH,iBAFU,oBAAoB,CAEQ;IAe1C;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,2CAeC;IAED;;;OAGG;IACH,WAFW,MAAM,QAyChB;IA+JD;;;;;;;;;;;;OAYG;IACH,4BAJW,MAAM,QACN,MAAM,SACN,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,iCALW,MAAM,QACN,MAAM,SACN,MAAM,gBACN,MAAM,QAIhB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAaD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;;OAGG;IACH,cAFW,MAAM,QAQhB;IAED;;;;;;;;;;;OAWG;IACH,sBAFW,gBAAgB,QAgE1B;IAED;;;;;OAKG;IACH,uBAJW,MAAM,YACN,MAAM,eACN,MAAM,QAqBhB;IAED;;;;;OAKG;IACH,yBAHW,MAAM,eACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,cAFW,MAAM,QAehB;IAED;;OAEG;IACH,gBAEC;IAED;;;;;;;;OAQG;IACH,YAFW,MAAM,QA+DhB;IAED;;;;;;;OAOG;IACH,cAEC;IAwJD;;OAEG;IACH,aAyCC;;CACJ;yBAroCY,OAAO,qCAAqC,EAAE,UAAU;sBACxD,OAAO,kCAAkC,EAAE,OAAO;+BAClD,OAAO,2CAA2C,EAAE,gBAAgB;kCACpE,OAAO,oDAAoD,EAAE,mBAAmB;0BAChF,OAAO,mBAAmB,EAAE,WAAW;+BACvC,OAAO,mCAAmC,EAAE,gBAAgB;mCAC5D,OAAO,2BAA2B,EAAE,oBAAoB;oBACxD,OAAO,YAAY,EAAE,KAAK"}