@woosh/meep-engine 2.155.0 → 2.157.0

package/src/engine/sound/sopra/definition/DuckingRule.js

@@ -0,0 +1,106 @@
+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";
+
+/**
+ * Emulated sidechain ducking: while any instance is playing on {@link triggerBusId}, the
+ * {@link targetBusId} bus is attenuated by {@link duckDb} (e.g. music ducks under dialogue), restored
+ * when the trigger goes quiet. WebAudio has no native sidechain, so this is **play-state** ducking
+ * (driven by active-instance count, not signal level) with smooth `setTargetAtTime` attack/release.
+ *
+ * Pure serializable definition; the runtime engage/release lives on {@link SopraEngine}.
+ */
+export class DuckingRule {
+
+    /**
+     * Activity on this bus engages the duck.
+     * @type {string}
+     */
+    triggerBusId = "";
+
+    /**
+     * This bus is attenuated while the trigger is active.
+     * @type {string}
+     */
+    targetBusId = "";
+
+    /**
+     * Attenuation applied to the target while ducked, in decibels (negative = quieter).
+     * @type {number}
+     */
+    duckDb = -12;
+
+    /**
+     * Duck-in time constant in seconds.
+     * @type {number}
+     */
+    attack = 0.05;
+
+    /**
+     * Duck-out (restore) time constant in seconds.
+     * @type {number}
+     */
+    release = 0.3;
+
+    /**
+     * @param {{triggerBusId?:string, targetBusId?:string, duckDb?:number, attack?:number, release?:number}} [options]
+     * @returns {DuckingRule}
+     */
+    static from({ triggerBusId = "", targetBusId = "", duckDb = -12, attack = 0.05, release = 0.3 } = {}) {
+        const r = new DuckingRule();
+
+        r.triggerBusId = triggerBusId;
+        r.targetBusId = targetBusId;
+        r.duckDb = duckDb;
+        r.attack = attack;
+        r.release = release;
+
+        return r;
+    }
+
+    /**
+     * @param {DuckingRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.triggerBusId === other.triggerBusId
+            && this.targetBusId === other.targetBusId
+            && this.duckDb === other.duckDb
+            && this.attack === other.attack
+            && this.release === other.release;
+    }
+
+    hash() {
+        return combine_hash(
+            computeStringHash(this.triggerBusId),
+            computeStringHash(this.targetBusId),
+            computeHashFloat(this.duckDb),
+            computeHashFloat(this.attack),
+            computeHashFloat(this.release)
+        );
+    }
+
+    clone() {
+        return DuckingRule.from(this);
+    }
+
+    toJSON() {
+        return {
+            triggerBusId: this.triggerBusId,
+            targetBusId: this.targetBusId,
+            duckDb: this.duckDb,
+            attack: this.attack,
+            release: this.release
+        };
+    }
+
+    fromJSON({ triggerBusId = "", targetBusId = "", duckDb = -12, attack = 0.05, release = 0.3 }) {
+        this.triggerBusId = triggerBusId;
+        this.targetBusId = targetBusId;
+        this.duckDb = duckDb;
+        this.attack = attack;
+        this.release = release;
+    }
+}
+
+DuckingRule.typeName = "SopraDuckingRule";

package/src/engine/sound/sopra/definition/DuckingRuleSerializationAdapter.d.ts

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

package/src/engine/sound/sopra/definition/DuckingRuleSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DuckingRuleSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/DuckingRuleSerializationAdapter.js"],"names":[],"mappings":"AAGA;;IACI,0BAAoB;IACpB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,WAAW,QAQrB;IAED;;;OAGG;IACH,yCAFW,WAAW,QAQrB;CACJ;gDA9B+C,gEAAgE;4BACpF,kBAAkB"}

package/src/engine/sound/sopra/definition/DuckingRuleSerializationAdapter.js

@@ -0,0 +1,31 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { DuckingRule } from "./DuckingRule.js";
+
+export class DuckingRuleSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = DuckingRule;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {DuckingRule} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUTF8String(value.triggerBusId);
+        buffer.writeUTF8String(value.targetBusId);
+        buffer.writeFloat32(value.duckDb);
+        buffer.writeFloat32(value.attack);
+        buffer.writeFloat32(value.release);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {DuckingRule} value
+     */
+    deserialize(buffer, value) {
+        value.triggerBusId = buffer.readUTF8String();
+        value.targetBusId = buffer.readUTF8String();
+        value.duckDb = buffer.readFloat32();
+        value.attack = buffer.readFloat32();
+        value.release = buffer.readFloat32();
+    }
+}

package/src/engine/sound/sopra/definition/EventDescription.d.ts

@@ -0,0 +1,132 @@
+/**
+ * The triggerable unit (FMOD EventDescription / Wwise Actor-Mixer object). Immutable authored data;
+ * playing it spawns a transient {@link EventInstance}. Held as data (e.g. by an `AudioEmitter`) and
+ * passed directly to {@link SopraEngine.playEvent} / `playOneShot`.
+ */
+export class EventDescription {
+    /**
+     *
+     * @param {string} label
+     * @param {AbstractAudioClip} rootClip
+     * @param {Partial<EventDescription>} [options]
+     * @returns {EventDescription}
+     */
+    static from(label: string, rootClip: AbstractAudioClip, { busId, gainDb, is3D, panningModel, distanceMin, distanceMax, attenuation, maxInstances, priority, stealMode, virtualThresholdDb }?: Partial<EventDescription>): EventDescription;
+    /**
+     * Human-readable label (need not be unique).
+     * @type {string}
+     */
+    label: string;
+    /**
+     * Root of the clip graph this event plays. Defaults to silence (a valid, audible-nothing clip).
+     * @type {AbstractAudioClip}
+     */
+    rootClip: AbstractAudioClip;
+    /**
+     * Id of the bus this event routes to.
+     * @type {string}
+     */
+    busId: string;
+    /**
+     * Event master gain, in decibels.
+     * @type {number}
+     */
+    gainDb: number;
+    /**
+     * @type {boolean}
+     */
+    is3D: boolean;
+    /**
+     * 3D panning algorithm (only used when {@link is3D}).
+     * @type {SopraPanningModel|number}
+     */
+    panningModel: SopraPanningModel | number;
+    /**
+     * @type {number}
+     */
+    distanceMin: number;
+    /**
+     * @type {number}
+     */
+    distanceMax: number;
+    /**
+     * Distance → gain-multiplier curve, used only when {@link is3D}. Always present (default flat 1).
+     * @type {AnimationCurve}
+     */
+    attenuation: AnimationCurve;
+    /**
+     * Maximum concurrent instances of this event before {@link stealMode} applies.
+     * @type {number}
+     */
+    maxInstances: number;
+    /**
+     * Higher wins when stealing.
+     * @type {number}
+     */
+    priority: number;
+    /**
+     * @type {VoiceStealMode|number}
+     */
+    stealMode: VoiceStealMode | number;
+    /**
+     * Below this post-attenuation gain (dB) a voice is virtualized.
+     * @type {number}
+     */
+    virtualThresholdDb: number;
+    /**
+     *
+     * @param {EventDescription} other
+     * @returns {boolean}
+     */
+    equals(other: EventDescription): boolean;
+    /**
+     * Content hash, consistent with {@link equals}: equal descriptions hash equally. Lets an
+     * EventDescription be used directly as a hash-map key (e.g. the VoiceManager groups instances by
+     * event content, so the `label` need not be unique).
+     * @returns {number}
+     */
+    hash(): number;
+    clone(): EventDescription;
+    toJSON(): {
+        label: string;
+        rootClip: {
+            type: string;
+            data: any;
+        };
+        busId: string;
+        gainDb: number;
+        is3D: boolean;
+        panningModel: number;
+        distanceMin: number;
+        distanceMax: number;
+        attenuation: {
+            keys: any[];
+        };
+        maxInstances: number;
+        priority: number;
+        stealMode: number;
+        virtualThresholdDb: number;
+    };
+    fromJSON({ label, rootClip, busId, gainDb, is3D, panningModel, distanceMin, distanceMax, attenuation, maxInstances, priority, stealMode, virtualThresholdDb }: {
+        label?: string;
+        rootClip: any;
+        busId?: string;
+        gainDb?: number;
+        is3D?: boolean;
+        panningModel?: number;
+        distanceMin?: number;
+        distanceMax?: number;
+        attenuation: any;
+        maxInstances?: number;
+        priority?: number;
+        stealMode?: number;
+        virtualThresholdDb?: number;
+    }): void;
+}
+export namespace EventDescription {
+    let typeName: string;
+}
+import { SopraPanningModel } from "./SopraPanningModel.js";
+import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+import { VoiceStealMode } from "./VoiceStealMode.js";
+//# sourceMappingURL=EventDescription.d.ts.map

package/src/engine/sound/sopra/definition/EventDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/EventDescription.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH;IA4EI;;;;;;OAMG;IACH,mBALW,MAAM,qKAEN,QAAQ,gBAAgB,CAAC,GACvB,gBAAgB,CAgC5B;IA/GD;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,4BAAkC;IAElC;;;OAGG;IACH,OAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,QAFU,MAAM,CAEL;IAEX;;OAEG;IACH,MAFU,OAAO,CAEJ;IAEb;;;OAGG;IACH,cAFU,iBAAiB,GAAC,MAAM,CAEI;IAEtC;;OAEG;IACH,aAFU,MAAM,CAEA;IAEhB;;OAEG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,aAFU,cAAc,CAEW;IAEnC;;;OAGG;IACH,cAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;OAEG;IACH,WAFU,cAAc,GAAC,MAAM,CAEG;IAElC;;;OAGG;IACH,oBAFU,MAAM,CAES;IAyCzB;;;;OAIG;IACH,cAHW,gBAAgB,GACd,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAkBlB;IAED,0BAkBC;IAED;;;;;;;;;;;;;;;;;;;MAgBC;IAED;;;;;;;;;;;;;;aAmCC;CACJ;;;;kCA3PiC,wBAAwB;+BAF3B,4CAA4C;+BAI5C,qBAAqB"}

package/src/engine/sound/sopra/definition/EventDescription.js

@@ -0,0 +1,259 @@
+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 { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+import { SilenceAudioClip } from "./clip/SilenceAudioClip.js";
+import { SopraPanningModel } from "./SopraPanningModel.js";
+import { deserializeAudioClipFromJSON, serializeAudioClipToJSON } from "../serialization/sopraJSON.js";
+import { VoiceStealMode } from "./VoiceStealMode.js";
+
+/**
+ * Constant flat-1 attenuation curve = "no attenuation". Used as the default for non-3D events.
+ * @returns {AnimationCurve}
+ */
+function defaultAttenuation() {
+    return AnimationCurve.constant(0, 1, 1);
+}
+
+/**
+ * The triggerable unit (FMOD EventDescription / Wwise Actor-Mixer object). Immutable authored data;
+ * playing it spawns a transient {@link EventInstance}. Held as data (e.g. by an `AudioEmitter`) and
+ * passed directly to {@link SopraEngine.playEvent} / `playOneShot`.
+ */
+export class EventDescription {
+
+    /**
+     * Human-readable label (need not be unique).
+     * @type {string}
+     */
+    label = "";
+
+    /**
+     * Root of the clip graph this event plays. Defaults to silence (a valid, audible-nothing clip).
+     * @type {AbstractAudioClip}
+     */
+    rootClip = new SilenceAudioClip();
+
+    /**
+     * Id of the bus this event routes to.
+     * @type {string}
+     */
+    busId = "effects";
+
+    /**
+     * Event master gain, in decibels.
+     * @type {number}
+     */
+    gainDb = 0;
+
+    /**
+     * @type {boolean}
+     */
+    is3D = false;
+
+    /**
+     * 3D panning algorithm (only used when {@link is3D}).
+     * @type {SopraPanningModel|number}
+     */
+    panningModel = SopraPanningModel.HRTF;
+
+    /**
+     * @type {number}
+     */
+    distanceMin = 1;
+
+    /**
+     * @type {number}
+     */
+    distanceMax = 10000;
+
+    /**
+     * Distance → gain-multiplier curve, used only when {@link is3D}. Always present (default flat 1).
+     * @type {AnimationCurve}
+     */
+    attenuation = defaultAttenuation();
+
+    /**
+     * Maximum concurrent instances of this event before {@link stealMode} applies.
+     * @type {number}
+     */
+    maxInstances = 32;
+
+    /**
+     * Higher wins when stealing.
+     * @type {number}
+     */
+    priority = 0;
+
+    /**
+     * @type {VoiceStealMode|number}
+     */
+    stealMode = VoiceStealMode.Oldest;
+
+    /**
+     * Below this post-attenuation gain (dB) a voice is virtualized.
+     * @type {number}
+     */
+    virtualThresholdDb = -60;
+
+    /**
+     *
+     * @param {string} label
+     * @param {AbstractAudioClip} rootClip
+     * @param {Partial<EventDescription>} [options]
+     * @returns {EventDescription}
+     */
+    static from(label, rootClip, {
+        busId = "effects",
+        gainDb = 0,
+        is3D = false,
+        panningModel = SopraPanningModel.HRTF,
+        distanceMin = 1,
+        distanceMax = 10000,
+        attenuation = defaultAttenuation(),
+        maxInstances = 32,
+        priority = 0,
+        stealMode = VoiceStealMode.Oldest,
+        virtualThresholdDb = -60
+    } = {}) {
+        const r = new EventDescription();
+
+        r.label = label;
+        r.rootClip = rootClip;
+        r.busId = busId;
+        r.gainDb = gainDb;
+        r.is3D = is3D;
+        r.panningModel = panningModel;
+        r.distanceMin = distanceMin;
+        r.distanceMax = distanceMax;
+        r.attenuation = attenuation;
+        r.maxInstances = maxInstances;
+        r.priority = priority;
+        r.stealMode = stealMode;
+        r.virtualThresholdDb = virtualThresholdDb;
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {EventDescription} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.label === other.label
+            && this.busId === other.busId
+            && this.gainDb === other.gainDb
+            && this.is3D === other.is3D
+            && this.panningModel === other.panningModel
+            && this.distanceMin === other.distanceMin
+            && this.distanceMax === other.distanceMax
+            && this.maxInstances === other.maxInstances
+            && this.priority === other.priority
+            && this.stealMode === other.stealMode
+            && this.virtualThresholdDb === other.virtualThresholdDb
+            && this.attenuation.equals(other.attenuation)
+            && this.rootClip.equals(other.rootClip);
+    }
+
+    /**
+     * Content hash, consistent with {@link equals}: equal descriptions hash equally. Lets an
+     * EventDescription be used directly as a hash-map key (e.g. the VoiceManager groups instances by
+     * event content, so the `label` need not be unique).
+     * @returns {number}
+     */
+    hash() {
+        return combine_hash(
+            computeStringHash(this.label),
+            computeStringHash(this.busId),
+            computeHashFloat(this.gainDb),
+            this.is3D ? 1 : 0,
+            this.panningModel,
+            computeHashFloat(this.distanceMin),
+            computeHashFloat(this.distanceMax),
+            this.maxInstances,
+            computeHashFloat(this.priority),
+            this.stealMode,
+            computeHashFloat(this.virtualThresholdDb),
+            this.attenuation.hash(),
+            this.rootClip.hash()
+        );
+    }
+
+    clone() {
+        const r = new EventDescription();
+
+        r.label = this.label;
+        r.rootClip = this.rootClip.clone();
+        r.busId = this.busId;
+        r.gainDb = this.gainDb;
+        r.is3D = this.is3D;
+        r.panningModel = this.panningModel;
+        r.distanceMin = this.distanceMin;
+        r.distanceMax = this.distanceMax;
+        r.attenuation = this.attenuation.clone();
+        r.maxInstances = this.maxInstances;
+        r.priority = this.priority;
+        r.stealMode = this.stealMode;
+        r.virtualThresholdDb = this.virtualThresholdDb;
+
+        return r;
+    }
+
+    toJSON() {
+        return {
+            label: this.label,
+            rootClip: serializeAudioClipToJSON(this.rootClip),
+            busId: this.busId,
+            gainDb: this.gainDb,
+            is3D: this.is3D,
+            panningModel: this.panningModel,
+            distanceMin: this.distanceMin,
+            distanceMax: this.distanceMax,
+            attenuation: this.attenuation.toJSON(),
+            maxInstances: this.maxInstances,
+            priority: this.priority,
+            stealMode: this.stealMode,
+            virtualThresholdDb: this.virtualThresholdDb
+        };
+    }
+
+    fromJSON({
+        label = "",
+        rootClip,
+        busId = "effects",
+        gainDb = 0,
+        is3D = false,
+        panningModel = SopraPanningModel.HRTF,
+        distanceMin = 1,
+        distanceMax = 10000,
+        attenuation,
+        maxInstances = 32,
+        priority = 0,
+        stealMode = VoiceStealMode.Oldest,
+        virtualThresholdDb = -60
+    }) {
+        this.label = label;
+        this.rootClip = rootClip === undefined ? new SilenceAudioClip() : deserializeAudioClipFromJSON(rootClip);
+        this.busId = busId;
+        this.gainDb = gainDb;
+        this.is3D = is3D;
+        this.panningModel = panningModel;
+        this.distanceMin = distanceMin;
+        this.distanceMax = distanceMax;
+
+        if (attenuation === undefined) {
+            this.attenuation = defaultAttenuation();
+        } else {
+            this.attenuation = new AnimationCurve();
+            this.attenuation.fromJSON(attenuation);
+        }
+
+        this.maxInstances = maxInstances;
+        this.priority = priority;
+        this.stealMode = stealMode;
+        this.virtualThresholdDb = virtualThresholdDb;
+    }
+}
+
+EventDescription.typeName = "SopraEventDescription";

package/src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.d.ts

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

package/src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventDescriptionSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.js"],"names":[],"mappings":"AAKA;IACI,+BAAyB;IACzB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,gBAAgB,QA2B1B;IAED;;;OAGG;IACH,yCAFW,gBAAgB,QA2B1B;CACJ;qDApEoD,4EAA4E;iCAChG,uBAAuB"}

package/src/engine/sound/sopra/definition/EventDescriptionSerializationAdapter.js

@@ -0,0 +1,71 @@
+import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+import { Keyframe } from "../../../animation/curve/Keyframe.js";
+import { ObjectBasedClassSerializationAdapter } from "../../../ecs/storage/binary/object/ObjectBasedClassSerializationAdapter.js";
+import { EventDescription } from "./EventDescription.js";
+
+export class EventDescriptionSerializationAdapter extends ObjectBasedClassSerializationAdapter {
+    klass = EventDescription;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {EventDescription} value
+     */
+    serialize(buffer, value) {
+        buffer.writeUTF8String(value.label);
+        this.objectAdapter.serialize(buffer, value.rootClip);
+        buffer.writeUTF8String(value.busId);
+        buffer.writeFloat32(value.gainDb);
+        buffer.writeUint8(value.is3D ? 1 : 0);
+        buffer.writeUint8(value.panningModel);
+        buffer.writeFloat32(value.distanceMin);
+        buffer.writeFloat32(value.distanceMax);
+
+        // AnimationCurve has no binary adapter of its own, so its keyframes are written inline here
+        const keys = value.attenuation.keys;
+        buffer.writeUintVar(keys.length);
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            buffer.writeFloat32(k.time);
+            buffer.writeFloat32(k.value);
+            buffer.writeFloat32(k.inTangent);
+            buffer.writeFloat32(k.outTangent);
+        }
+
+        buffer.writeUintVar(value.maxInstances);
+        buffer.writeFloat32(value.priority);
+        buffer.writeUint8(value.stealMode);
+        buffer.writeFloat32(value.virtualThresholdDb);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {EventDescription} value
+     */
+    deserialize(buffer, value) {
+        value.label = buffer.readUTF8String();
+        value.rootClip = this.objectAdapter.deserialize(buffer);
+        value.busId = buffer.readUTF8String();
+        value.gainDb = buffer.readFloat32();
+        value.is3D = buffer.readUint8() !== 0;
+        value.panningModel = buffer.readUint8();
+        value.distanceMin = buffer.readFloat32();
+        value.distanceMax = buffer.readFloat32();
+
+        const curve = new AnimationCurve();
+        const keyCount = buffer.readUintVar();
+        for (let i = 0; i < keyCount; i++) {
+            const time = buffer.readFloat32();
+            const v = buffer.readFloat32();
+            const inTangent = buffer.readFloat32();
+            const outTangent = buffer.readFloat32();
+            curve.add(Keyframe.from(time, v, inTangent, outTangent));
+        }
+        value.attenuation = curve;
+
+        value.maxInstances = buffer.readUintVar();
+        value.priority = buffer.readFloat32();
+        value.stealMode = buffer.readUint8();
+        value.virtualThresholdDb = buffer.readFloat32();
+    }
+}