@woosh/meep-engine 2.154.0 → 2.156.0

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Plays exactly ONE child, chosen at trigger time by a discrete parameter (RTPC). The parameter value
+ * is read once when the timeline is planned (like a Random pick, but deterministic by parameter value
+ * rather than the RNG), then rounded + clamped to a child index — e.g. a "surface" parameter selecting
+ * grass / stone / wood footsteps. Supersedes the dormant `material/` surface-switch concept.
+ */
+export class SwitchContainerAudioClip extends ContainerAudioClip {
+    /**
+     * @param {AbstractAudioClip[]} [children]
+     * @param {{parameter?:string, defaultValue?:number}} [options]
+     * @returns {SwitchContainerAudioClip}
+     */
+    static from(children?: AbstractAudioClip[], { parameter, defaultValue }?: {
+        parameter?: string;
+        defaultValue?: number;
+    }): SwitchContainerAudioClip;
+    /**
+     * RTPC name whose (rounded) value selects the child index.
+     * @type {string}
+     */
+    parameter: string;
+    /**
+     * Parameter value used when the parameter is unset.
+     * @type {number}
+     */
+    defaultValue: number;
+    planTimeline(env: any, gainDb?: number, pitchCents?: number, offset?: number): {
+        plays: {
+            clip: SampleAudioClip;
+            offset: number;
+            gainDb: number;
+            pitchCents: number;
+        }[];
+        duration: number;
+    };
+    /**
+     * @param {SwitchContainerAudioClip} other
+     * @returns {boolean}
+     */
+    equals(other: SwitchContainerAudioClip): boolean;
+    clone(): SwitchContainerAudioClip;
+    toJSON(): {
+        gain: number;
+        pitch: number;
+        parameter: string;
+        defaultValue: number;
+        children: {
+            type: string;
+            data: any;
+        }[];
+    };
+    fromJSON({ gain, pitch, parameter, defaultValue, children }: {
+        gain?: number;
+        pitch?: number;
+        parameter?: string;
+        defaultValue?: number;
+        children?: any[];
+    }): void;
+    #private;
+}
+export namespace SwitchContainerAudioClip {
+    let typeName: string;
+}
+import { ContainerAudioClip } from "./ContainerAudioClip.js";
+//# sourceMappingURL=SwitchContainerAudioClip.d.ts.map

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwitchContainerAudioClip.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH;IAcI;;;;OAIG;IACH,uBAJW,mBAAmB,gCACnB;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,CAAA;KAAC,GACvC,wBAAwB,CAUpC;IAzBD;;;OAGG;IACH,WAFU,MAAM,CAED;IAEf;;;OAGG;IACH,cAFU,MAAM,CAEC;IAmCjB;;;;;;;;MAWC;IAED;;;OAGG;IACH,cAHW,wBAAwB,GACtB,OAAO,CAMnB;IAiBD,kCAYC;IAED;;;;;;;;;MAQC;IAED;;;;;;aAMC;;CACJ;;;;mCA7HkC,yBAAyB"}

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClip.js

@@ -0,0 +1,131 @@
+import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
+import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
+import { ContainerAudioClip } from "./ContainerAudioClip.js";
+import { deserializeAudioClipFromJSON, serializeAudioClipToJSON } from "../../serialization/sopraJSON.js";
+
+/**
+ * Plays exactly ONE child, chosen at trigger time by a discrete parameter (RTPC). The parameter value
+ * is read once when the timeline is planned (like a Random pick, but deterministic by parameter value
+ * rather than the RNG), then rounded + clamped to a child index — e.g. a "surface" parameter selecting
+ * grass / stone / wood footsteps. Supersedes the dormant `material/` surface-switch concept.
+ */
+export class SwitchContainerAudioClip extends ContainerAudioClip {
+
+    /**
+     * RTPC name whose (rounded) value selects the child index.
+     * @type {string}
+     */
+    parameter = "";
+
+    /**
+     * Parameter value used when the parameter is unset.
+     * @type {number}
+     */
+    defaultValue = 0;
+
+    /**
+     * @param {AbstractAudioClip[]} [children]
+     * @param {{parameter?:string, defaultValue?:number}} [options]
+     * @returns {SwitchContainerAudioClip}
+     */
+    static from(children = [], { parameter = "", defaultValue = 0 } = {}) {
+        const r = new SwitchContainerAudioClip();
+
+        r.addChildren(children);
+        r.parameter = parameter;
+        r.defaultValue = defaultValue;
+
+        return r;
+    }
+
+    /**
+     * Clamp a parameter value to a valid child index.
+     * @param {number} value
+     * @returns {number}
+     */
+    #indexFor(value) {
+        const n = this.children.length;
+        const i = Math.round(value);
+
+        if (i < 0) {
+            return 0;
+        }
+        if (i >= n) {
+            return n - 1;
+        }
+        return i;
+    }
+
+    planTimeline(env, gainDb = 0, pitchCents = 0, offset = 0) {
+        const children = this.children;
+
+        if (children.length === 0) {
+            return { plays: [], duration: 0 };
+        }
+
+        const value = env.getParameter(this.parameter) ?? this.defaultValue;
+        const index = this.#indexFor(value);
+
+        return children[index].planTimeline(env, gainDb + this.gain, pitchCents + this.pitch, offset);
+    }
+
+    /**
+     * @param {SwitchContainerAudioClip} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return super.equals(other) // gain/pitch + children
+            && this.parameter === other.parameter
+            && this.defaultValue === other.defaultValue;
+    }
+
+    hash() {
+        let h = combine_hash(
+            super.hash(),
+            computeStringHash(this.parameter),
+            computeHashFloat(this.defaultValue)
+        );
+
+        const children = this.children;
+        for (let i = 0; i < children.length; i++) {
+            h = combine_hash(h, children[i].hash());
+        }
+
+        return h;
+    }
+
+    clone() {
+        const r = new SwitchContainerAudioClip();
+
+        r.copyBaseFrom(this);
+        r.parameter = this.parameter;
+        r.defaultValue = this.defaultValue;
+
+        for (let i = 0; i < this.children.length; i++) {
+            r.addChild(this.children[i].clone());
+        }
+
+        return r;
+    }
+
+    toJSON() {
+        return {
+            gain: this.gain,
+            pitch: this.pitch,
+            parameter: this.parameter,
+            defaultValue: this.defaultValue,
+            children: this.children.map(serializeAudioClipToJSON)
+        };
+    }
+
+    fromJSON({ gain = 0, pitch = 0, parameter = "", defaultValue = 0, children = [] }) {
+        this.gain = gain;
+        this.pitch = pitch;
+        this.parameter = parameter;
+        this.defaultValue = defaultValue;
+        this.children = children.map(deserializeAudioClipFromJSON);
+    }
+}
+
+SwitchContainerAudioClip.typeName = "SopraSwitchContainerAudioClip";

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClipSerializationAdapter.d.ts

@@ -0,0 +1,17 @@
+export class SwitchContainerAudioClipSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    klass: typeof SwitchContainerAudioClip;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {SwitchContainerAudioClip} value
+     */
+    serialize(buffer: BinaryBuffer, value: SwitchContainerAudioClip): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {SwitchContainerAudioClip} value
+     */
+    deserialize(buffer: BinaryBuffer, value: SwitchContainerAudioClip): void;
+}
+import { ObjectBasedClassSerializationAdapter } from "../../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { SwitchContainerAudioClip } from "./SwitchContainerAudioClip.js";
+//# sourceMappingURL=SwitchContainerAudioClipSerializationAdapter.d.ts.map

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClipSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SwitchContainerAudioClipSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/clip/SwitchContainerAudioClipSerializationAdapter.js"],"names":[],"mappings":"AAGA;IACI,uCAAiC;IACjC,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,wBAAwB,QAalC;IAED;;;OAGG;IACH,yCAFW,wBAAwB,QAalC;CACJ;qDAxCoD,+EAA+E;yCAC3F,+BAA+B"}

package/src/engine/sound/sopra/definition/clip/SwitchContainerAudioClipSerializationAdapter.js

@@ -0,0 +1,41 @@
+import { ObjectBasedClassSerializationAdapter } from "../../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { SwitchContainerAudioClip } from "./SwitchContainerAudioClip.js";
+
+export class SwitchContainerAudioClipSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    klass = SwitchContainerAudioClip;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {SwitchContainerAudioClip} value
+     */
+    serialize(buffer, value) {
+        buffer.writeFloat32(value.gain);
+        buffer.writeFloat32(value.pitch);
+        buffer.writeUTF8String(value.parameter);
+        buffer.writeFloat32(value.defaultValue);
+
+        const children = value.children;
+        buffer.writeUintVar(children.length);
+        for (let i = 0; i < children.length; i++) {
+            this.objectAdapter.serialize(buffer, children[i]);
+        }
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {SwitchContainerAudioClip} value
+     */
+    deserialize(buffer, value) {
+        value.gain = buffer.readFloat32();
+        value.pitch = buffer.readFloat32();
+        value.parameter = buffer.readUTF8String();
+        value.defaultValue = buffer.readFloat32();
+
+        const n = buffer.readUintVar();
+        value.clearChildren();
+        for (let i = 0; i < n; i++) {
+            value.addChild(this.objectAdapter.deserialize(buffer));
+        }
+    }
+}

package/src/engine/sound/sopra/definition/effect/AbstractAudioEffect.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Base class for serializable bus insert effects.
+ *
+ * An effect is a DEFINITION; {@link build} turns it into a live WebAudio sub-graph. The returned
+ * `{ input, output }` lets the {@link BusGraph} splice the effect into a bus chain
+ * (`input → effect → output`); for single-node effects `input === output`.
+ */
+export class AbstractAudioEffect {
+    /**
+     * Construct the live WebAudio nodes for this effect.
+     * @param {BaseAudioContext} ctx
+     * @returns {{input: AudioNode, output: AudioNode}}
+     */
+    build(ctx: BaseAudioContext): {
+        input: AudioNode;
+        output: AudioNode;
+    };
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isAudioEffect: boolean;
+}
+//# sourceMappingURL=AbstractAudioEffect.d.ts.map

package/src/engine/sound/sopra/definition/effect/AbstractAudioEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbstractAudioEffect.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/AbstractAudioEffect.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,WAHW,gBAAgB,GACd;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,SAAS,CAAA;KAAC,CAIjD;IAGL;;;OAGG;IACH,wBAFU,OAAO,CAE0B;CAN1C"}

package/src/engine/sound/sopra/definition/effect/AbstractAudioEffect.js

@@ -0,0 +1,24 @@
+/**
+ * Base class for serializable bus insert effects.
+ *
+ * An effect is a DEFINITION; {@link build} turns it into a live WebAudio sub-graph. The returned
+ * `{ input, output }` lets the {@link BusGraph} splice the effect into a bus chain
+ * (`input → effect → output`); for single-node effects `input === output`.
+ */
+export class AbstractAudioEffect {
+
+    /**
+     * Construct the live WebAudio nodes for this effect.
+     * @param {BaseAudioContext} ctx
+     * @returns {{input: AudioNode, output: AudioNode}}
+     */
+    build(ctx) {
+        throw new Error('Implementation must override build()');
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+AbstractAudioEffect.prototype.isAudioEffect = true;

package/src/engine/sound/sopra/definition/effect/CompressorEffect.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Dynamics compressor bus insert, backed by a {@link DynamicsCompressorNode}.
+ * NOTE: this is a per-bus insert; the engine's master compressor (in SoundEngine) is separate
+ * master-glue and is not duplicated here.
+ */
+export class CompressorEffect extends AbstractAudioEffect {
+    /**
+     *
+     * @param {{threshold?:number, knee?:number, ratio?:number, attack?:number, release?:number}} [options]
+     * @returns {CompressorEffect}
+     */
+    static from({ threshold, knee, ratio, attack, release }?: {
+        threshold?: number;
+        knee?: number;
+        ratio?: number;
+        attack?: number;
+        release?: number;
+    }): CompressorEffect;
+    /**
+     * dB.
+     * @type {number}
+     */
+    threshold: number;
+    /**
+     * dB.
+     * @type {number}
+     */
+    knee: number;
+    /**
+     * @type {number}
+     */
+    ratio: number;
+    /**
+     * Seconds.
+     * @type {number}
+     */
+    attack: number;
+    /**
+     * Seconds.
+     * @type {number}
+     */
+    release: number;
+    /**
+     *
+     * @param {CompressorEffect} other
+     * @returns {boolean}
+     */
+    equals(other: CompressorEffect): boolean;
+    hash(): number;
+    clone(): CompressorEffect;
+    toJSON(): {
+        threshold: number;
+        knee: number;
+        ratio: number;
+        attack: number;
+        release: number;
+    };
+    fromJSON({ threshold, knee, ratio, attack, release }: {
+        threshold?: number;
+        knee?: number;
+        ratio?: number;
+        attack?: number;
+        release?: number;
+    }): void;
+}
+export namespace CompressorEffect {
+    let typeName: string;
+}
+import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
+//# sourceMappingURL=CompressorEffect.d.ts.map

package/src/engine/sound/sopra/definition/effect/CompressorEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompressorEffect.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/CompressorEffect.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;IA+BI;;;;OAIG;IACH,0DAHW;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,IAAI,CAAC,EAAC,MAAM,CAAC;QAAC,KAAK,CAAC,EAAC,MAAM,CAAC;QAAC,MAAM,CAAC,EAAC,MAAM,CAAC;QAAC,OAAO,CAAC,EAAC,MAAM,CAAA;KAAC,GAC/E,gBAAgB,CAY5B;IA5CD;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;OAEG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf;;;OAGG;IACH,SAFU,MAAM,CAED;IAmCf;;;;OAIG;IACH,cAHW,gBAAgB,GACd,OAAO,CAQnB;IAED,eAQC;IAED,0BAEC;IAED;;;;;;MAQC;IAED;;;;;;aAMC;CACJ;;;;oCAnHmC,0BAA0B"}

package/src/engine/sound/sopra/definition/effect/CompressorEffect.js

@@ -0,0 +1,120 @@
+import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
+import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
+
+/**
+ * Dynamics compressor bus insert, backed by a {@link DynamicsCompressorNode}.
+ * NOTE: this is a per-bus insert; the engine's master compressor (in SoundEngine) is separate
+ * master-glue and is not duplicated here.
+ */
+export class CompressorEffect extends AbstractAudioEffect {
+
+    /**
+     * dB.
+     * @type {number}
+     */
+    threshold = -24;
+
+    /**
+     * dB.
+     * @type {number}
+     */
+    knee = 30;
+
+    /**
+     * @type {number}
+     */
+    ratio = 12;
+
+    /**
+     * Seconds.
+     * @type {number}
+     */
+    attack = 0.003;
+
+    /**
+     * Seconds.
+     * @type {number}
+     */
+    release = 0.25;
+
+    /**
+     *
+     * @param {{threshold?:number, knee?:number, ratio?:number, attack?:number, release?:number}} [options]
+     * @returns {CompressorEffect}
+     */
+    static from({ threshold = -24, knee = 30, ratio = 12, attack = 0.003, release = 0.25 } = {}) {
+        const r = new CompressorEffect();
+
+        r.threshold = threshold;
+        r.knee = knee;
+        r.ratio = ratio;
+        r.attack = attack;
+        r.release = release;
+
+        return r;
+    }
+
+    /**
+     * @param {BaseAudioContext} ctx
+     * @returns {{input: AudioNode, output: AudioNode}}
+     */
+    build(ctx) {
+        const node = ctx.createDynamicsCompressor();
+
+        node.threshold.value = this.threshold;
+        node.knee.value = this.knee;
+        node.ratio.value = this.ratio;
+        node.attack.value = this.attack;
+        node.release.value = this.release;
+
+        return { input: node, output: node };
+    }
+
+    /**
+     *
+     * @param {CompressorEffect} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.threshold === other.threshold
+            && this.knee === other.knee
+            && this.ratio === other.ratio
+            && this.attack === other.attack
+            && this.release === other.release;
+    }
+
+    hash() {
+        return combine_hash(
+            computeHashFloat(this.threshold),
+            computeHashFloat(this.knee),
+            computeHashFloat(this.ratio),
+            computeHashFloat(this.attack),
+            computeHashFloat(this.release)
+        );
+    }
+
+    clone() {
+        return CompressorEffect.from(this);
+    }
+
+    toJSON() {
+        return {
+            threshold: this.threshold,
+            knee: this.knee,
+            ratio: this.ratio,
+            attack: this.attack,
+            release: this.release
+        };
+    }
+
+    fromJSON({ threshold = -24, knee = 30, ratio = 12, attack = 0.003, release = 0.25 }) {
+        this.threshold = threshold;
+        this.knee = knee;
+        this.ratio = ratio;
+        this.attack = attack;
+        this.release = release;
+    }
+}
+
+CompressorEffect.typeName = "SopraCompressorEffect";

package/src/engine/sound/sopra/definition/effect/CompressorEffectSerializationAdapter.d.ts

@@ -0,0 +1,18 @@
+export class CompressorEffectSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof CompressorEffect;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {CompressorEffect} value
+     */
+    serialize(buffer: BinaryBuffer, value: CompressorEffect): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {CompressorEffect} value
+     */
+    deserialize(buffer: BinaryBuffer, value: CompressorEffect): void;
+}
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { CompressorEffect } from "./CompressorEffect.js";
+//# sourceMappingURL=CompressorEffectSerializationAdapter.d.ts.map

package/src/engine/sound/sopra/definition/effect/CompressorEffectSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CompressorEffectSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/CompressorEffectSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IACI,+BAAyB;IACzB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,gBAAgB,QAQ1B;IAED;;;OAGG;IACH,yCAFW,gBAAgB,QAQ1B;CACJ;gDA9B+C,mEAAmE;iCAClF,uBAAuB"}

package/src/engine/sound/sopra/definition/effect/CompressorEffectSerializationAdapter.js

@@ -0,0 +1,31 @@
+import { BinaryClassSerializationAdapter } from "../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { CompressorEffect } from "./CompressorEffect.js";
+
+export class CompressorEffectSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = CompressorEffect;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {CompressorEffect} value
+     */
+    serialize(buffer, value) {
+        buffer.writeFloat32(value.threshold);
+        buffer.writeFloat32(value.knee);
+        buffer.writeFloat32(value.ratio);
+        buffer.writeFloat32(value.attack);
+        buffer.writeFloat32(value.release);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {CompressorEffect} value
+     */
+    deserialize(buffer, value) {
+        value.threshold = buffer.readFloat32();
+        value.knee = buffer.readFloat32();
+        value.ratio = buffer.readFloat32();
+        value.attack = buffer.readFloat32();
+        value.release = buffer.readFloat32();
+    }
+}

package/src/engine/sound/sopra/definition/effect/EqEffect.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Filter type, mapped to a WebAudio {@link BiquadFilterType }.
+ */
+export type EqFilterType = number;
+export namespace EqFilterType {
+    let Lowpass: number;
+    let Highpass: number;
+    let Bandpass: number;
+    let Lowshelf: number;
+    let Highshelf: number;
+    let Peaking: number;
+    let Notch: number;
+    let Allpass: number;
+}
+/**
+ * Equalizer / filter bus insert, backed by a {@link BiquadFilterNode}.
+ */
+export class EqEffect extends AbstractAudioEffect {
+    /**
+     *
+     * @param {{filterType?:EqFilterType|number, frequency?:number, Q?:number, gainDb?:number}} [options]
+     * @returns {EqEffect}
+     */
+    static from({ filterType, frequency, Q, gainDb }?: {
+        filterType?: EqFilterType | number;
+        frequency?: number;
+        Q?: number;
+        gainDb?: number;
+    }): EqEffect;
+    /**
+     * @type {EqFilterType|number}
+     */
+    filterType: EqFilterType | number;
+    /**
+     * Cutoff/center frequency in Hz.
+     * @type {number}
+     */
+    frequency: number;
+    /**
+     * Quality factor.
+     * @type {number}
+     */
+    Q: number;
+    /**
+     * Boost/cut in decibels (only used by peaking / shelf filters).
+     * @type {number}
+     */
+    gainDb: number;
+    /**
+     *
+     * @param {EqEffect} other
+     * @returns {boolean}
+     */
+    equals(other: EqEffect): boolean;
+    hash(): number;
+    clone(): EqEffect;
+    toJSON(): {
+        filterType: number;
+        frequency: number;
+        Q: number;
+        gainDb: number;
+    };
+    fromJSON({ filterType, frequency, Q, gainDb }: {
+        filterType?: number;
+        frequency?: number;
+        Q?: number;
+        gainDb?: number;
+    }): void;
+}
+export namespace EqEffect {
+    let typeName: string;
+}
+import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
+//# sourceMappingURL=EqEffect.d.ts.map

package/src/engine/sound/sopra/definition/effect/EqEffect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EqEffect.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/EqEffect.js"],"names":[],"mappings":";;;2BAMU,MAAM;;;;;;;;;;;AAoBhB;;GAEG;AACH;IAyBI;;;;OAIG;IACH,mDAHW;QAAC,UAAU,CAAC,EAAC,YAAY,GAAC,MAAM,CAAC;QAAC,SAAS,CAAC,EAAC,MAAM,CAAC;QAAC,CAAC,CAAC,EAAC,MAAM,CAAC;QAAC,MAAM,CAAC,EAAC,MAAM,CAAA;KAAC,GAC7E,QAAQ,CAWpB;IArCD;;OAEG;IACH,YAFU,YAAY,GAAC,MAAM,CAEK;IAElC;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,GAFU,MAAM,CAEV;IAEN;;;OAGG;IACH,QAFU,MAAM,CAEL;IAiCX;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAOnB;IAED,eAOC;IAED,kBAEC;IAED;;;;;MAOC;IAED;;;;;aAKC;CACJ;;;;oCA3HmC,0BAA0B"}