@woosh/meep-engine 2.155.0 → 2.156.0

package/src/engine/sound/sopra/serialization/populateSopraSerializationRegistry.js

@@ -0,0 +1,42 @@
+import { BusDefinitionSerializationAdapter } from "../definition/BusDefinitionSerializationAdapter.js";
+import { CompressorEffectSerializationAdapter } from "../definition/effect/CompressorEffectSerializationAdapter.js";
+import { DuckingRuleSerializationAdapter } from "../definition/DuckingRuleSerializationAdapter.js";
+import { EqEffectSerializationAdapter } from "../definition/effect/EqEffectSerializationAdapter.js";
+import { ReverbEffectSerializationAdapter } from "../definition/effect/ReverbEffectSerializationAdapter.js";
+import { EventDescriptionSerializationAdapter } from "../definition/EventDescriptionSerializationAdapter.js";
+import { MixerSnapshotSerializationAdapter } from "../definition/MixerSnapshotSerializationAdapter.js";
+import { ParameterDefinitionSerializationAdapter } from "../definition/ParameterDefinitionSerializationAdapter.js";
+import { BlendContainerAudioClipSerializationAdapter } from "../definition/clip/BlendContainerAudioClipSerializationAdapter.js";
+import { RandomContainerAudioClipSerializationAdapter } from "../definition/clip/RandomContainerAudioClipSerializationAdapter.js";
+import { SampleAudioClipSerializationAdapter } from "../definition/clip/SampleAudioClipSerializationAdapter.js";
+import { SequenceContainerAudioClipSerializationAdapter } from "../definition/clip/SequenceContainerAudioClipSerializationAdapter.js";
+import { SilenceAudioClipSerializationAdapter } from "../definition/clip/SilenceAudioClipSerializationAdapter.js";
+import { SwitchContainerAudioClipSerializationAdapter } from "../definition/clip/SwitchContainerAudioClipSerializationAdapter.js";
+
+/**
+ * Register every sopra definition adapter on a {@link BinarySerializationRegistry}.
+ *
+ * In production this is called from `GameBinarySerializationRegistry.initializeGameBinarySerializationRegistry`
+ * (integration lands in P3); in P0 it backs the round-trip specs. Keeping the list here mirrors the
+ * behavior-tree `populateNodeRegistry` convention.
+ *
+ * @param {BinarySerializationRegistry} registry
+ */
+export function populateSopraSerializationRegistry(registry) {
+    registry.registerAdapters([
+        new SampleAudioClipSerializationAdapter(),
+        new SilenceAudioClipSerializationAdapter(),
+        new SequenceContainerAudioClipSerializationAdapter(),
+        new RandomContainerAudioClipSerializationAdapter(),
+        new SwitchContainerAudioClipSerializationAdapter(),
+        new BlendContainerAudioClipSerializationAdapter(),
+        new ParameterDefinitionSerializationAdapter(),
+        new EqEffectSerializationAdapter(),
+        new CompressorEffectSerializationAdapter(),
+        new ReverbEffectSerializationAdapter(),
+        new EventDescriptionSerializationAdapter(),
+        new BusDefinitionSerializationAdapter(),
+        new MixerSnapshotSerializationAdapter(),
+        new DuckingRuleSerializationAdapter()
+    ]);
+}

package/src/engine/sound/sopra/serialization/sopraJSON.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @param {AbstractAudioClip} clip
+ * @returns {{type:string, data:*}}
+ */
+export function serializeAudioClipToJSON(clip: AbstractAudioClip): {
+    type: string;
+    data: any;
+};
+/**
+ * @param {{type:string, data:*}} json
+ * @returns {AbstractAudioClip}
+ */
+export function deserializeAudioClipFromJSON({ type, data }: {
+    type: string;
+    data: any;
+}): AbstractAudioClip;
+/**
+ * @param {AbstractAudioEffect} effect
+ * @returns {{type:string, data:*}}
+ */
+export function serializeAudioEffectToJSON(effect: AbstractAudioEffect): {
+    type: string;
+    data: any;
+};
+/**
+ * @param {{type:string, data:*}} json
+ * @returns {AbstractAudioEffect}
+ */
+export function deserializeAudioEffectFromJSON({ type, data }: {
+    type: string;
+    data: any;
+}): AbstractAudioEffect;
+//# sourceMappingURL=sopraJSON.d.ts.map

package/src/engine/sound/sopra/serialization/sopraJSON.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sopraJSON.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/serialization/sopraJSON.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,mEAFa;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,IAAI,MAAE;CAAC,CAOjC;AAED;;;GAGG;AACH,6DAHW;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,IAAI,MAAE;CAAC,qBAgC/B;AAED;;;GAGG;AACH,yEAFa;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,IAAI,MAAE;CAAC,CAOjC;AAED;;;GAGG;AACH,+DAHW;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,IAAI,MAAE;CAAC,uBAuB/B"}

package/src/engine/sound/sopra/serialization/sopraJSON.js

@@ -0,0 +1,99 @@
+import { CompressorEffect } from "../definition/effect/CompressorEffect.js";
+import { EqEffect } from "../definition/effect/EqEffect.js";
+import { ReverbEffect } from "../definition/effect/ReverbEffect.js";
+import { BlendContainerAudioClip } from "../definition/clip/BlendContainerAudioClip.js";
+import { RandomContainerAudioClip } from "../definition/clip/RandomContainerAudioClip.js";
+import { SampleAudioClip } from "../definition/clip/SampleAudioClip.js";
+import { SequenceContainerAudioClip } from "../definition/clip/SequenceContainerAudioClip.js";
+import { SilenceAudioClip } from "../definition/clip/SilenceAudioClip.js";
+import { SwitchContainerAudioClip } from "../definition/clip/SwitchContainerAudioClip.js";
+
+/*
+ * Type-tagged polymorphic JSON (de)serialization for the sopra clip and effect hierarchies.
+ * Mirrors the dormant material/ subsystem's serializeSoundMaterialToJSON pattern. The switch
+ * statements reference class bindings at CALL time (not module-eval time), which keeps these safe
+ * under the import cycle with container clips (whose toJSON/fromJSON call back into here).
+ */
+
+/**
+ * @param {AbstractAudioClip} clip
+ * @returns {{type:string, data:*}}
+ */
+export function serializeAudioClipToJSON(clip) {
+    return {
+        type: Object.getPrototypeOf(clip).constructor.typeName,
+        data: clip.toJSON()
+    };
+}
+
+/**
+ * @param {{type:string, data:*}} json
+ * @returns {AbstractAudioClip}
+ */
+export function deserializeAudioClipFromJSON({ type, data }) {
+    let instance;
+
+    switch (type) {
+        case SampleAudioClip.typeName:
+            instance = new SampleAudioClip();
+            break;
+        case SilenceAudioClip.typeName:
+            instance = new SilenceAudioClip();
+            break;
+        case SequenceContainerAudioClip.typeName:
+            instance = new SequenceContainerAudioClip();
+            break;
+        case RandomContainerAudioClip.typeName:
+            instance = new RandomContainerAudioClip();
+            break;
+        case SwitchContainerAudioClip.typeName:
+            instance = new SwitchContainerAudioClip();
+            break;
+        case BlendContainerAudioClip.typeName:
+            instance = new BlendContainerAudioClip();
+            break;
+        default:
+            throw new Error(`Unsupported audio clip type '${type}'`);
+    }
+
+    instance.fromJSON(data);
+
+    return instance;
+}
+
+/**
+ * @param {AbstractAudioEffect} effect
+ * @returns {{type:string, data:*}}
+ */
+export function serializeAudioEffectToJSON(effect) {
+    return {
+        type: Object.getPrototypeOf(effect).constructor.typeName,
+        data: effect.toJSON()
+    };
+}
+
+/**
+ * @param {{type:string, data:*}} json
+ * @returns {AbstractAudioEffect}
+ */
+export function deserializeAudioEffectFromJSON({ type, data }) {
+    let instance;
+
+    switch (type) {
+        case EqEffect.typeName:
+            instance = new EqEffect();
+            break;
+        case CompressorEffect.typeName:
+            instance = new CompressorEffect();
+            break;
+        case ReverbEffect.typeName:
+            instance = new ReverbEffect();
+            break;
+        default:
+            throw new Error(`Unsupported audio effect type '${type}'`);
+    }
+
+    instance.fromJSON(data);
+
+    return instance;
+}

package/src/engine/sound/sopra/serialization/sopraSerializationHarness.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Build a binary object adapter backed by a registry with every sopra adapter registered — the real
+ * production (de)serialization path. Shared by the per-adapter round-trip specs.
+ * @returns {BinaryObjectSerializationAdapter}
+ */
+export function makeSopraObjectAdapter(): BinaryObjectSerializationAdapter;
+/**
+ * Serialize `value` to binary, deserialize a fresh copy, then re-serialize that copy. Returns the
+ * restored value and whether the bytes were byte-stable across the round-trip — the precision-agnostic
+ * correctness invariant: the adapter reads back exactly what it wrote (float64 fields are stored as
+ * float32, so byte-stability is the right check rather than a strict `.equals` on the originals).
+ *
+ * NOTE for callers: give each field a DISTINCT value. Byte-stability detects a swapped read/write of
+ * two same-type fields only when their values differ (the re-serialized bytes then diverge); equal
+ * values would hide such a swap.
+ *
+ * @template T
+ * @param {BinaryObjectSerializationAdapter} objectAdapter
+ * @param {T} value
+ * @returns {{restored: T, stable: boolean}}
+ */
+export function binaryRoundTrip<T>(objectAdapter: BinaryObjectSerializationAdapter, value: T): {
+    restored: T;
+    stable: boolean;
+};
+import { BinaryObjectSerializationAdapter } from "../../../ecs/storage/binary/object/BinaryObjectSerializationAdapter.js";
+//# sourceMappingURL=sopraSerializationHarness.d.ts.map

package/src/engine/sound/sopra/serialization/sopraSerializationHarness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sopraSerializationHarness.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/serialization/sopraSerializationHarness.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,0CAFa,gCAAgC,CAW5C;AAED;;;;;;;;;;;;;;GAcG;AACH,kDAJW,gCAAgC;;YAER,OAAO;EAczC;iDA/CgD,wEAAwE"}

package/src/engine/sound/sopra/serialization/sopraSerializationHarness.js

@@ -0,0 +1,49 @@
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { BinaryObjectSerializationAdapter } from "../../../ecs/storage/binary/object/BinaryObjectSerializationAdapter.js";
+import { BinarySerializationRegistry } from "../../../ecs/storage/binary/BinarySerializationRegistry.js";
+import { populateSopraSerializationRegistry } from "./populateSopraSerializationRegistry.js";
+
+/**
+ * Build a binary object adapter backed by a registry with every sopra adapter registered — the real
+ * production (de)serialization path. Shared by the per-adapter round-trip specs.
+ * @returns {BinaryObjectSerializationAdapter}
+ */
+export function makeSopraObjectAdapter() {
+    const registry = new BinarySerializationRegistry();
+
+    populateSopraSerializationRegistry(registry);
+
+    const objectAdapter = new BinaryObjectSerializationAdapter();
+    objectAdapter.initialize(registry);
+
+    return objectAdapter;
+}
+
+/**
+ * Serialize `value` to binary, deserialize a fresh copy, then re-serialize that copy. Returns the
+ * restored value and whether the bytes were byte-stable across the round-trip — the precision-agnostic
+ * correctness invariant: the adapter reads back exactly what it wrote (float64 fields are stored as
+ * float32, so byte-stability is the right check rather than a strict `.equals` on the originals).
+ *
+ * NOTE for callers: give each field a DISTINCT value. Byte-stability detects a swapped read/write of
+ * two same-type fields only when their values differ (the re-serialized bytes then diverge); equal
+ * values would hide such a swap.
+ *
+ * @template T
+ * @param {BinaryObjectSerializationAdapter} objectAdapter
+ * @param {T} value
+ * @returns {{restored: T, stable: boolean}}
+ */
+export function binaryRoundTrip(objectAdapter, value) {
+    const first = new BinaryBuffer();
+    objectAdapter.serialize(first, value);
+    const firstHex = first.toHexString();
+
+    first.position = 0;
+    const restored = objectAdapter.deserialize(first);
+
+    const second = new BinaryBuffer();
+    objectAdapter.serialize(second, restored);
+
+    return { restored, stable: second.toHexString() === firstHex };
+}

package/src/engine/sound/sopra/util/MockAudioContext.d.ts

@@ -0,0 +1,74 @@
+export class MockAudioParam {
+    /**
+     * @param {number} value
+     * @param {boolean} supportsCancelAndHold whether to expose cancelAndHoldAtTime (Firefox lacks it)
+     */
+    constructor(value?: number, supportsCancelAndHold?: boolean);
+    /**
+     * @type {{type:string}[]}
+     */
+    events: {
+        type: string;
+    }[];
+    value: number;
+    cancelAndHoldAtTime: (time: any) => this;
+    setValueAtTime(value: any, time: any): this;
+    linearRampToValueAtTime(value: any, time: any): this;
+    exponentialRampToValueAtTime(value: any, time: any): this;
+    setTargetAtTime(value: any, startTime: any, timeConstant: any): this;
+    setValueCurveAtTime(curve: any, startTime: any, duration: any): this;
+    cancelScheduledValues(time: any): this;
+}
+export class MockAudioContext {
+    /**
+     * @param {{supportsCancelAndHold?:boolean}} [options]
+     */
+    constructor({ supportsCancelAndHold }?: {
+        supportsCancelAndHold?: boolean;
+    });
+    currentTime: number;
+    sampleRate: number;
+    supportsCancelAndHold: boolean;
+    destination: MockAudioNode;
+    /**
+     * @private
+     */
+    private __param;
+    createGain(): MockAudioNode;
+    createBufferSource(): MockAudioNode;
+    createBiquadFilter(): MockAudioNode;
+    createDynamicsCompressor(): MockAudioNode;
+    createPanner(): MockAudioNode;
+    createConvolver(): MockAudioNode;
+    /**
+     * @param {number} numberOfChannels
+     * @param {number} length samples per channel
+     * @param {number} sampleRate
+     */
+    createBuffer(numberOfChannels: number, length: number, sampleRate: number): {
+        numberOfChannels: number;
+        length: number;
+        sampleRate: number;
+        duration: number;
+        getChannelData: (channel: any) => any;
+    };
+}
+declare class MockAudioNode {
+    constructor(kind: any, context: any);
+    /**
+     * @type {MockAudioNode[]}
+     */
+    connections: MockAudioNode[];
+    disconnected: boolean;
+    kind: any;
+    context: any;
+    connect(target: any): any;
+    disconnect(): void;
+    /**
+     * @param {MockAudioNode} target
+     * @returns {boolean}
+     */
+    isConnectedTo(target: MockAudioNode): boolean;
+}
+export {};
+//# sourceMappingURL=MockAudioContext.d.ts.map

package/src/engine/sound/sopra/util/MockAudioContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockAudioContext.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/util/MockAudioContext.js"],"names":[],"mappings":"AAOA;IAOI;;;OAGG;IACH,oBAHW,MAAM,0BACN,OAAO,EAWjB;IAlBD;;OAEG;IACH,QAFU;QAAC,IAAI,EAAC,MAAM,CAAA;KAAC,EAAE,CAEb;IAOR,cAAkB;IAGd,yCAGC;IAIT,4CAIC;IAED,qDAMC;IAED,0DAQC;IAED,qEAGC;IAED,qEAGC;IAED,uCAGC;CACJ;AAoCD;IAMI;;OAEG;IACH,wCAFW;QAAC,qBAAqB,CAAC,EAAC,OAAO,CAAA;KAAC,EAM1C;IAXD,oBAAgB;IAEhB,mBAAmB;IAMf,+BAAkD;IAElD,2BAAyD;IAG7D;;OAEG;IACH,gBAEC;IAED,4BAIC;IAED,oCAsBC;IAED,oCAOC;IAED,0CAQC;IAED,8BAYC;IAED,iCAKC;IAED;;;;OAIG;IACH,+BAJW,MAAM,UACN,MAAM,cACN,MAAM;;;;;;MAehB;CACJ;AAjJD;IASI,qCAGC;IAVD;;OAEG;IACH,aAFU,aAAa,EAAE,CAER;IAEjB,sBAAqB;IAGjB,UAAgB;IAChB,aAAsB;IAG1B,0BAIC;IAED,mBAGC;IAED;;;OAGG;IACH,sBAHW,aAAa,GACX,OAAO,CAInB;CACJ"}

package/src/engine/sound/sopra/util/MockAudioContext.js

@@ -0,0 +1,215 @@
+/*
+ * Minimal recording WebAudio test double for the ECS-free sopra core. NOT a spec (filename does not
+ * end in .spec/.test, so Jest does not execute it as a suite). Records the node graph and AudioParam
+ * automation so tests can assert routing, gain, effect order and scheduling without a real
+ * AudioContext.
+ */
+
+export class MockAudioParam {
+
+    /**
+     * @type {{type:string}[]}
+     */
+    events = [];
+
+    /**
+     * @param {number} value
+     * @param {boolean} supportsCancelAndHold whether to expose cancelAndHoldAtTime (Firefox lacks it)
+     */
+    constructor(value = 0, supportsCancelAndHold = true) {
+        this.value = value;
+
+        if (supportsCancelAndHold) {
+            this.cancelAndHoldAtTime = (time) => {
+                this.events.push({ type: 'cancelAndHold', time });
+                return this;
+            };
+        }
+    }
+
+    setValueAtTime(value, time) {
+        this.value = value;
+        this.events.push({ type: 'setValueAtTime', value, time });
+        return this;
+    }
+
+    linearRampToValueAtTime(value, time) {
+        // NB: a ramp does NOT change `.value` (which tracks the last *explicitly set* value —
+        // construction / setValueAtTime / cancelAndHold). The ramp target lives in `events[]`. This
+        // lets tests assert re-anchoring of chained/interrupting fades.
+        this.events.push({ type: 'linearRamp', value, time });
+        return this;
+    }
+
+    exponentialRampToValueAtTime(value, time) {
+        if (value === 0) {
+            // mirror the real WebAudio constraint so the click-trap is caught in tests
+            throw new Error('exponentialRampToValueAtTime: target must be non-zero');
+        }
+        // see linearRampToValueAtTime: ramps do not move `.value`; the target lives in `events[]`
+        this.events.push({ type: 'exponentialRamp', value, time });
+        return this;
+    }
+
+    setTargetAtTime(value, startTime, timeConstant) {
+        this.events.push({ type: 'setTarget', value, startTime, timeConstant });
+        return this;
+    }
+
+    setValueCurveAtTime(curve, startTime, duration) {
+        this.events.push({ type: 'curve', curve, startTime, duration });
+        return this;
+    }
+
+    cancelScheduledValues(time) {
+        this.events.push({ type: 'cancel', time });
+        return this;
+    }
+}
+
+class MockAudioNode {
+
+    /**
+     * @type {MockAudioNode[]}
+     */
+    connections = [];
+
+    disconnected = false;
+
+    constructor(kind, context) {
+        this.kind = kind;
+        this.context = context;
+    }
+
+    connect(target) {
+        this.disconnected = false; // track live state, not a sticky "was ever disconnected" flag
+        this.connections.push(target);
+        return target;
+    }
+
+    disconnect() {
+        this.disconnected = true;
+        this.connections = [];
+    }
+
+    /**
+     * @param {MockAudioNode} target
+     * @returns {boolean}
+     */
+    isConnectedTo(target) {
+        return this.connections.indexOf(target) !== -1;
+    }
+}
+
+export class MockAudioContext {
+
+    currentTime = 0;
+
+    sampleRate = 44100;
+
+    /**
+     * @param {{supportsCancelAndHold?:boolean}} [options]
+     */
+    constructor({ supportsCancelAndHold = true } = {}) {
+        this.supportsCancelAndHold = supportsCancelAndHold;
+
+        this.destination = new MockAudioNode('destination', this);
+    }
+
+    /**
+     * @private
+     */
+    __param(value) {
+        return new MockAudioParam(value, this.supportsCancelAndHold);
+    }
+
+    createGain() {
+        const node = new MockAudioNode('gain', this);
+        node.gain = this.__param(1);
+        return node;
+    }
+
+    createBufferSource() {
+        const node = new MockAudioNode('source', this);
+
+        node.buffer = null;
+        node.loop = false;
+        node.loopStart = 0;
+        node.loopEnd = 0;
+        node.playbackRate = this.__param(1);
+        node.detune = this.__param(0);
+        node.onended = null;
+        node.started = null;
+        node.stopped = null;
+
+        node.start = (when = 0, offset = 0, duration) => {
+            node.started = { when, offset, duration };
+        };
+
+        node.stop = (when = 0) => {
+            node.stopped = { when };
+        };
+
+        return node;
+    }
+
+    createBiquadFilter() {
+        const node = new MockAudioNode('biquad', this);
+        node.type = 'peaking';
+        node.frequency = this.__param(350);
+        node.Q = this.__param(1);
+        node.gain = this.__param(0);
+        return node;
+    }
+
+    createDynamicsCompressor() {
+        const node = new MockAudioNode('compressor', this);
+        node.threshold = this.__param(-24);
+        node.knee = this.__param(30);
+        node.ratio = this.__param(12);
+        node.attack = this.__param(0.003);
+        node.release = this.__param(0.25);
+        return node;
+    }
+
+    createPanner() {
+        const node = new MockAudioNode('panner', this);
+        node.panningModel = 'equalpower';
+        node.distanceModel = 'inverse';
+        node.rolloffFactor = 1;
+        node.refDistance = 1;
+        node.maxDistance = 10000;
+        node.lastPosition = null;
+        node.setPosition = (x, y, z) => {
+            node.lastPosition = { x, y, z };
+        };
+        return node;
+    }
+
+    createConvolver() {
+        const node = new MockAudioNode('convolver', this);
+        node.buffer = null;
+        node.normalize = true;
+        return node;
+    }
+
+    /**
+     * @param {number} numberOfChannels
+     * @param {number} length samples per channel
+     * @param {number} sampleRate
+     */
+    createBuffer(numberOfChannels, length, sampleRate) {
+        const channels = [];
+        for (let i = 0; i < numberOfChannels; i++) {
+            channels.push(new Float32Array(length));
+        }
+
+        return {
+            numberOfChannels,
+            length,
+            sampleRate,
+            duration: length / sampleRate,
+            getChannelData: (channel) => channels[channel]
+        };
+    }
+}

package/src/engine/sound/sopra/util/buildAttenuationCurve.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Author a distance→gain attenuation {@link AnimationCurve} by sampling a falloff function at evenly
+ * spaced distances between `distanceMin` and `distanceMax`. Lets the physically-based legacy falloffs
+ * (`interpolate_irradiance_linear/logarithmic/smith`) be reused to build attenuation presets that
+ * match the old engine at the sampled distances (D4), while the runtime just evaluates the curve.
+ *
+ * @param {number} distanceMin
+ * @param {number} distanceMax
+ * @param {function(distance:number, min:number, max:number):number} falloff
+ * @param {number} [sampleCount] number of keyframes (>= 2)
+ * @returns {AnimationCurve}
+ */
+export function buildAttenuationCurve(distanceMin: number, distanceMax: number, falloff: any, sampleCount?: number): AnimationCurve;
+import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+//# sourceMappingURL=buildAttenuationCurve.d.ts.map

package/src/engine/sound/sopra/util/buildAttenuationCurve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildAttenuationCurve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/util/buildAttenuationCurve.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,mDANW,MAAM,eACN,MAAM,8BAEN,MAAM,GACJ,cAAc,CA0B1B;+BAvC8B,4CAA4C"}

package/src/engine/sound/sopra/util/buildAttenuationCurve.js

@@ -0,0 +1,40 @@
+import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+import { Keyframe } from "../../../animation/curve/Keyframe.js";
+
+/**
+ * Author a distance→gain attenuation {@link AnimationCurve} by sampling a falloff function at evenly
+ * spaced distances between `distanceMin` and `distanceMax`. Lets the physically-based legacy falloffs
+ * (`interpolate_irradiance_linear/logarithmic/smith`) be reused to build attenuation presets that
+ * match the old engine at the sampled distances (D4), while the runtime just evaluates the curve.
+ *
+ * @param {number} distanceMin
+ * @param {number} distanceMax
+ * @param {function(distance:number, min:number, max:number):number} falloff
+ * @param {number} [sampleCount] number of keyframes (>= 2)
+ * @returns {AnimationCurve}
+ */
+export function buildAttenuationCurve(distanceMin, distanceMax, falloff, sampleCount = 8) {
+    // A degenerate range (max <= min) has no falloff region to sample: every keyframe would land at
+    // the same distance, so alignAllTangents would divide by a zero time-delta and emit NaN tangents
+    // (which serialize to JSON null). Fall back to a finite flat-1 (no-attenuation) curve.
+    if (distanceMax <= distanceMin) {
+        return AnimationCurve.constant(0, 1, 1);
+    }
+
+    const n = Math.max(2, sampleCount);
+
+    const curve = new AnimationCurve();
+
+    for (let i = 0; i < n; i++) {
+        const t = i / (n - 1);
+        const distance = distanceMin + (distanceMax - distanceMin) * t;
+        const gain = falloff(distance, distanceMin, distanceMax);
+
+        curve.add(Keyframe.from(distance, gain));
+    }
+
+    // smooth the segments between samples
+    curve.alignAllTangents();
+
+    return curve;
+}

package/src/engine/sound/sopra/util/fadeOutAndStop.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The ONE click-safe gain ramp. Anchor-then-ramp: pin the current value at the ramp start so the
+ * origin is well-defined and re-trigger-safe (D1). Prefers `cancelAndHoldAtTime` but FEATURE-DETECTS
+ * it (unimplemented in Firefox) and falls back to the portable `cancelScheduledValues` +
+ * `setValueAtTime` idiom. Linear-ramps to `targetLinear` (use {@link FADE_EPSILON}, never 0, for fades
+ * to silence). Shared by every fade so no call site hand-rolls one.
+ *
+ * @param {AudioParam} param the gain param to ramp
+ * @param {number} targetLinear target linear gain
+ * @param {number} duration ramp duration in seconds
+ * @param {BaseAudioContext} ctx
+ * @param {number} [startAfter=0] delay before the ramp begins, in seconds
+ * @returns {number} the absolute context time at which the ramp completes
+ */
+export function rampGain(param: AudioParam, targetLinear: number, duration: number, ctx: BaseAudioContext, startAfter?: number): number;
+/**
+ * Click-safe fade-out of a single gain that also stops a source node once silent. Used for node-level
+ * fades; EventInstance fades use {@link rampGain} directly on its instance gain.
+ *
+ * @param {GainNode} gainNode the gain to fade
+ * @param {AudioScheduledSourceNode|null} source source to stop once silent (may be null)
+ * @param {BaseAudioContext} ctx
+ * @param {number} duration fade duration in seconds
+ * @param {number} [startAfter=0] delay before the fade begins, in seconds
+ */
+export function fadeOutAndStop(gainNode: GainNode, source: AudioScheduledSourceNode | null, ctx: BaseAudioContext, duration: number, startAfter?: number): void;
+/**
+ * Smallest non-zero gain to ramp toward. Ramping a GainNode to exactly 0 (especially with an
+ * exponential ramp) is the classic WebAudio click/throw trap, so we always target this epsilon and
+ * stop the source just after the gain has effectively reached silence.
+ * @type {number}
+ */
+export const FADE_EPSILON: number;
+//# sourceMappingURL=fadeOutAndStop.d.ts.map

package/src/engine/sound/sopra/util/fadeOutAndStop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fadeOutAndStop.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/util/fadeOutAndStop.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,gCAPW,UAAU,gBACV,MAAM,YACN,MAAM,OACN,gBAAgB,eAChB,MAAM,GACJ,MAAM,CAoBlB;AAED;;;;;;;;;GASG;AACH,yCANW,QAAQ,UACR,wBAAwB,GAAC,IAAI,OAC7B,gBAAgB,YAChB,MAAM,eACN,MAAM,QAShB;AA3DD;;;;;GAKG;AACH,2BAFU,MAAM,CAEmB"}