@woosh/meep-engine 2.163.11 → 2.164.0

package/src/engine/sound/simulation/definition/AcousticMaterial.js

@@ -0,0 +1,122 @@
+import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
+
+/**
+ * Frequency-dependent acoustic properties of a surface, mirroring Steam Audio's material model. All
+ * coefficients are in [0, 1] and given in three frequency bands (low / mid / high).
+ *
+ * A pure value type — attached to an occluder (`AcousticBody`) and read at a ray hit to shape the
+ * occlusion / transmission of sound interacting with that surface. No WebAudio, no geometry, no ECS.
+ */
+export class AcousticMaterial {
+    /**
+     * Fraction of energy ABSORBED on reflection, per band (low/mid/high). Higher = deader surface.
+     * Used by reflections (P6).
+     * @type {Float32Array}
+     */
+    absorption = new Float32Array([0.1, 0.1, 0.1]);
+
+    /**
+     * Fraction of reflected energy scattered diffusely (vs. specular), [0, 1]. Used by reflections (P6).
+     * @type {number}
+     */
+    scattering = 0.5;
+
+    /**
+     * Fraction of energy passing THROUGH the surface, per band (low/mid/high). 0 = fully blocking.
+     * @type {Float32Array}
+     */
+    transmission = new Float32Array([0, 0, 0]);
+
+    /**
+     * @param {{absorption?:number[]|Float32Array, scattering?:number, transmission?:number[]|Float32Array}} [spec]
+     * @returns {AcousticMaterial}
+     */
+    static from({ absorption, scattering, transmission } = {}) {
+        const m = new AcousticMaterial();
+
+        if (absorption !== undefined) {
+            m.absorption[0] = absorption[0];
+            m.absorption[1] = absorption[1];
+            m.absorption[2] = absorption[2];
+        }
+
+        if (scattering !== undefined) {
+            m.scattering = scattering;
+        }
+
+        if (transmission !== undefined) {
+            m.transmission[0] = transmission[0];
+            m.transmission[1] = transmission[1];
+            m.transmission[2] = transmission[2];
+        }
+
+        return m;
+    }
+
+    /**
+     * @param {AcousticMaterial} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.absorption[0] === other.absorption[0]
+            && this.absorption[1] === other.absorption[1]
+            && this.absorption[2] === other.absorption[2]
+            && this.scattering === other.scattering
+            && this.transmission[0] === other.transmission[0]
+            && this.transmission[1] === other.transmission[1]
+            && this.transmission[2] === other.transmission[2];
+    }
+
+    hash() {
+        return combine_hash(
+            computeHashFloat(this.absorption[0]),
+            computeHashFloat(this.absorption[1]),
+            computeHashFloat(this.absorption[2]),
+            computeHashFloat(this.scattering),
+            computeHashFloat(this.transmission[0]),
+            computeHashFloat(this.transmission[1]),
+            computeHashFloat(this.transmission[2])
+        );
+    }
+
+    /**
+     * @returns {AcousticMaterial}
+     */
+    clone() {
+        const m = new AcousticMaterial();
+
+        m.absorption[0] = this.absorption[0];
+        m.absorption[1] = this.absorption[1];
+        m.absorption[2] = this.absorption[2];
+        m.scattering = this.scattering;
+        m.transmission[0] = this.transmission[0];
+        m.transmission[1] = this.transmission[1];
+        m.transmission[2] = this.transmission[2];
+
+        return m;
+    }
+
+    toJSON() {
+        return {
+            absorption: [this.absorption[0], this.absorption[1], this.absorption[2]],
+            scattering: this.scattering,
+            transmission: [this.transmission[0], this.transmission[1], this.transmission[2]]
+        };
+    }
+
+    /**
+     * @param {{absorption:number[], scattering:number, transmission:number[]}} json
+     */
+    fromJSON({ absorption, scattering, transmission }) {
+        this.absorption[0] = absorption[0];
+        this.absorption[1] = absorption[1];
+        this.absorption[2] = absorption[2];
+        this.scattering = scattering;
+        this.transmission[0] = transmission[0];
+        this.transmission[1] = transmission[1];
+        this.transmission[2] = transmission[2];
+    }
+}
+
+AcousticMaterial.typeName = "AcousticMaterial";

package/src/engine/sound/simulation/definition/AcousticMaterialSerializationAdapter.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Binary (de)serialization for {@link AcousticMaterial}: the per-band absorption/transmission and the scalar
+ * scattering. Mirrors the class's `toJSON`/`fromJSON`. Used standalone and delegated to by
+ * {@link AcousticBodySerializationAdapter}.
+ */
+export class AcousticMaterialSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof AcousticMaterial;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticMaterial} value
+     */
+    serialize(buffer: BinaryBuffer, value: AcousticMaterial): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticMaterial} value mutated in place
+     */
+    deserialize(buffer: BinaryBuffer, value: AcousticMaterial): void;
+}
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AcousticMaterial } from "./AcousticMaterial.js";
+//# sourceMappingURL=AcousticMaterialSerializationAdapter.d.ts.map

package/src/engine/sound/simulation/definition/AcousticMaterialSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticMaterialSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/definition/AcousticMaterialSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;;IACI,+BAAyB;IACzB,gBAAY;IAEZ;;;OAGG;IACH,uCAFW,gBAAgB,QAM1B;IAED;;;OAGG;IACH,yCAFW,gBAAgB,QAM1B;CACJ;gDA/B+C,gEAAgE;iCAC/E,uBAAuB"}

package/src/engine/sound/simulation/definition/AcousticMaterialSerializationAdapter.js

@@ -0,0 +1,32 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AcousticMaterial } from "./AcousticMaterial.js";
+
+/**
+ * Binary (de)serialization for {@link AcousticMaterial}: the per-band absorption/transmission and the scalar
+ * scattering. Mirrors the class's `toJSON`/`fromJSON`. Used standalone and delegated to by
+ * {@link AcousticBodySerializationAdapter}.
+ */
+export class AcousticMaterialSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = AcousticMaterial;
+    version = 0;
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticMaterial} value
+     */
+    serialize(buffer, value) {
+        buffer.writeFloat32Array(value.absorption, 0, 3);
+        buffer.writeFloat32(value.scattering);
+        buffer.writeFloat32Array(value.transmission, 0, 3);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticMaterial} value mutated in place
+     */
+    deserialize(buffer, value) {
+        buffer.readFloat32Array(value.absorption, 0, 3);
+        value.scattering = buffer.readFloat32();
+        buffer.readFloat32Array(value.transmission, 0, 3);
+    }
+}

package/src/engine/sound/simulation/ecs/AcousticBody.d.ts

@@ -0,0 +1,39 @@
+/**
+ * ECS component marking an entity as an acoustic occluder. It carries the surface's
+ * {@link AcousticMaterial}; the OCCLUDING GEOMETRY comes from the entity's existing `Collider` (its
+ * shape is triangulated into the simulation), and the world placement from its `Transform`. Adding this
+ * component to a wall/floor entity is what makes it block & filter sound — nothing is an occluder unless
+ * it has one.
+ *
+ * Plain serializable data; runtime occluder state lives in the `AcousticSimulator`, not here.
+ */
+export class AcousticBody {
+    /**
+     * @param {AcousticMaterial} [material]
+     * @returns {AcousticBody}
+     */
+    static from(material?: AcousticMaterial): AcousticBody;
+    /**
+     * Acoustic properties of this surface.
+     * @type {AcousticMaterial}
+     */
+    material: AcousticMaterial;
+    toJSON(): {
+        material: {
+            absorption: number[];
+            scattering: number;
+            transmission: number[];
+        };
+    };
+    /**
+     * @param {{material:object}} json
+     */
+    fromJSON(json: {
+        material: object;
+    }): void;
+}
+export namespace AcousticBody {
+    let typeName: string;
+}
+import { AcousticMaterial } from "../definition/AcousticMaterial.js";
+//# sourceMappingURL=AcousticBody.d.ts.map

package/src/engine/sound/simulation/ecs/AcousticBody.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticBody.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticBody.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IAOI;;;OAGG;IACH,uBAHW,gBAAgB,GACd,YAAY,CAUxB;IAlBD;;;OAGG;IACH,UAFU,gBAAgB,CAEQ;IAgBlC;;;;;;MAIC;IAED;;OAEG;IACH,eAFW;QAAC,QAAQ,EAAC,MAAM,CAAA;KAAC,QAK3B;CACJ;;;;iCA7CgC,mCAAmC"}

package/src/engine/sound/simulation/ecs/AcousticBody.js

@@ -0,0 +1,48 @@
+import { AcousticMaterial } from "../definition/AcousticMaterial.js";
+
+/**
+ * ECS component marking an entity as an acoustic occluder. It carries the surface's
+ * {@link AcousticMaterial}; the OCCLUDING GEOMETRY comes from the entity's existing `Collider` (its
+ * shape is triangulated into the simulation), and the world placement from its `Transform`. Adding this
+ * component to a wall/floor entity is what makes it block & filter sound — nothing is an occluder unless
+ * it has one.
+ *
+ * Plain serializable data; runtime occluder state lives in the `AcousticSimulator`, not here.
+ */
+export class AcousticBody {
+    /**
+     * Acoustic properties of this surface.
+     * @type {AcousticMaterial}
+     */
+    material = new AcousticMaterial();
+
+    /**
+     * @param {AcousticMaterial} [material]
+     * @returns {AcousticBody}
+     */
+    static from(material) {
+        const b = new AcousticBody();
+
+        if (material !== undefined) {
+            b.material = material;
+        }
+
+        return b;
+    }
+
+    toJSON() {
+        return {
+            material: this.material.toJSON()
+        };
+    }
+
+    /**
+     * @param {{material:object}} json
+     */
+    fromJSON(json) {
+        this.material = new AcousticMaterial();
+        this.material.fromJSON(json.material);
+    }
+}
+
+AcousticBody.typeName = "AcousticBody";

package/src/engine/sound/simulation/ecs/AcousticBodySerializationAdapter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Binary (de)serialization for the {@link AcousticBody} component. It carries a single fixed value type — its
+ * {@link AcousticMaterial} — so it delegates straight to the material adapter (no polymorphism, no type tag).
+ * Mirrors the component's `toJSON`/`fromJSON`.
+ */
+export class AcousticBodySerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof AcousticBody;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticBody} value
+     */
+    serialize(buffer: BinaryBuffer, value: AcousticBody): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticBody} value mutated in place (its `material` is filled)
+     */
+    deserialize(buffer: BinaryBuffer, value: AcousticBody): void;
+    #private;
+}
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AcousticBody } from "./AcousticBody.js";
+//# sourceMappingURL=AcousticBodySerializationAdapter.d.ts.map

package/src/engine/sound/simulation/ecs/AcousticBodySerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticBodySerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticBodySerializationAdapter.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH;;IACI,2BAAqB;IACrB,gBAAY;IAOZ;;;OAGG;IACH,uCAFW,YAAY,QAItB;IAED;;;OAGG;IACH,yCAFW,YAAY,QAItB;;CACJ;gDAjC+C,gEAAgE;6BAEnF,mBAAmB"}

package/src/engine/sound/simulation/ecs/AcousticBodySerializationAdapter.js

@@ -0,0 +1,34 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AcousticMaterialSerializationAdapter } from "../definition/AcousticMaterialSerializationAdapter.js";
+import { AcousticBody } from "./AcousticBody.js";
+
+/**
+ * Binary (de)serialization for the {@link AcousticBody} component. It carries a single fixed value type — its
+ * {@link AcousticMaterial} — so it delegates straight to the material adapter (no polymorphism, no type tag).
+ * Mirrors the component's `toJSON`/`fromJSON`.
+ */
+export class AcousticBodySerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = AcousticBody;
+    version = 0;
+
+    /**
+     * @type {AcousticMaterialSerializationAdapter}
+     */
+    #material = new AcousticMaterialSerializationAdapter();
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticBody} value
+     */
+    serialize(buffer, value) {
+        this.#material.serialize(buffer, value.material);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticBody} value mutated in place (its `material` is filled)
+     */
+    deserialize(buffer, value) {
+        this.#material.deserialize(buffer, value.material);
+    }
+}

package/src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Wires the baked {@link AcousticProbeField} into the shared {@link AcousticSimulator}: its visibility graph
+ * drives corner-leakage pathing and its baked reverb feeds the probe-reverb renderer. Because the field is a
+ * serializable ECS component ({@link AcousticProbeField.typeName} + `toJSON`/`fromJSON` +
+ * `AcousticProbeFieldSerializationAdapter`), attaching it to an entity is also how a baked field saves/loads
+ * with the scene.
+ *
+ * **v1 single-field assumption:** the FIRST field linked is wired into the simulator; any others are silently
+ * ignored (no error, no extra checks). When the wired field unlinks, the simulator's field is cleared.
+ *
+ * TODO (multiple probe fields): support more than one — e.g. per-region/streamed fields with spatial
+ * selection of the active field by listener position, or merging fields into one graph. Until then a scene
+ * has exactly one field. See `IMPLEMENTATION_PLAN.md`.
+ */
+export class AcousticProbeFieldSystem extends System<any, any, any, any, any> {
+    /**
+     * @param {AcousticSimulator} simulator the shared simulation engine
+     */
+    constructor(simulator: AcousticSimulator);
+    dependencies: (typeof AcousticProbeField)[];
+    /**
+     * @type {AcousticSimulator}
+     */
+    simulator: AcousticSimulator;
+    /**
+     * @param {AcousticProbeField} field
+     * @param {number} entity
+     */
+    link(field: AcousticProbeField, entity: number): void;
+    /**
+     * @param {AcousticProbeField} field
+     * @param {number} entity
+     */
+    unlink(field: AcousticProbeField, entity: number): void;
+    #private;
+}
+import { System } from "../../../ecs/System.js";
+import { AcousticProbeField } from "../probe/AcousticProbeField.js";
+//# sourceMappingURL=AcousticProbeFieldSystem.d.ts.map

package/src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticProbeFieldSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH;IASI;;OAEG;IACH,0CAOC;IAlBD,4CAAoC;IAchC;;OAEG;IACH,6BAA0B;IAG9B;;;OAGG;IACH,YAHW,kBAAkB,UAClB,MAAM,QAShB;IAED;;;OAGG;IACH,cAHW,kBAAkB,UAClB,MAAM,QAShB;;CACJ;uBA/DsB,wBAAwB;mCACZ,gCAAgC"}

package/src/engine/sound/simulation/ecs/AcousticProbeFieldSystem.js

@@ -0,0 +1,64 @@
+import { System } from "../../../ecs/System.js";
+import { AcousticProbeField } from "../probe/AcousticProbeField.js";
+
+/**
+ * Wires the baked {@link AcousticProbeField} into the shared {@link AcousticSimulator}: its visibility graph
+ * drives corner-leakage pathing and its baked reverb feeds the probe-reverb renderer. Because the field is a
+ * serializable ECS component ({@link AcousticProbeField.typeName} + `toJSON`/`fromJSON` +
+ * `AcousticProbeFieldSerializationAdapter`), attaching it to an entity is also how a baked field saves/loads
+ * with the scene.
+ *
+ * **v1 single-field assumption:** the FIRST field linked is wired into the simulator; any others are silently
+ * ignored (no error, no extra checks). When the wired field unlinks, the simulator's field is cleared.
+ *
+ * TODO (multiple probe fields): support more than one — e.g. per-region/streamed fields with spatial
+ * selection of the active field by listener position, or merging fields into one graph. Until then a scene
+ * has exactly one field. See `IMPLEMENTATION_PLAN.md`.
+ */
+export class AcousticProbeFieldSystem extends System {
+    dependencies = [AcousticProbeField];
+
+    /**
+     * The one wired field (the first linked); kept so unlink only clears the field it actually wired.
+     * @type {AcousticProbeField|null}
+     */
+    #field = null;
+
+    /**
+     * @param {AcousticSimulator} simulator the shared simulation engine
+     */
+    constructor(simulator) {
+        super();
+
+        /**
+         * @type {AcousticSimulator}
+         */
+        this.simulator = simulator;
+    }
+
+    /**
+     * @param {AcousticProbeField} field
+     * @param {number} entity
+     */
+    link(field, entity) {
+        if (this.#field !== null) {
+            return; // already have one — single-field v1, silently ignore the rest
+        }
+
+        this.#field = field;
+        this.simulator.setProbeField(field);
+    }
+
+    /**
+     * @param {AcousticProbeField} field
+     * @param {number} entity
+     */
+    unlink(field, entity) {
+        if (field !== this.#field) {
+            return; // an ignored (never-wired) field
+        }
+
+        this.#field = null;
+        this.simulator.setProbeField(null);
+    }
+}

package/src/engine/sound/simulation/ecs/AcousticSimulationSystem.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Feeds {@link AcousticBody} occluders into the shared {@link AcousticSimulator}, reactively. On link it
+ * triangulates the entity's `Collider` shape, registers it at the `Transform`'s world matrix, and
+ * subscribes to position changes so a moving occluder updates the index in O(1) (no geometry rebuild).
+ * On unlink it detaches and removes the occluder.
+ *
+ * Does NOT tick the simulation itself — `AudioEmitterSystem` drives `simulator.apply(...)` once per
+ * frame against the bounded live-voice set.
+ */
+export class AcousticSimulationSystem extends System<any, any, any, any, any> {
+    /**
+     * @param {AcousticSimulator} simulator the shared simulation engine
+     */
+    constructor(simulator: AcousticSimulator);
+    dependencies: (typeof Transform | typeof Collider | typeof AcousticBody)[];
+    /**
+     * Per-entity records: { handle, transform, onMove }.
+     * @type {object[]}
+     */
+    data: object[];
+    /**
+     * @type {AcousticSimulator}
+     */
+    simulator: AcousticSimulator;
+    /**
+     * @param {AcousticBody} body
+     * @param {Collider} collider
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(body: AcousticBody, collider: Collider, transform: Transform, entity: number): void;
+    /**
+     * @param {AcousticBody} body
+     * @param {Collider} collider
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(body: AcousticBody, collider: Collider, transform: Transform, entity: number): void;
+}
+import { System } from "../../../ecs/System.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { Collider } from "../../../physics/ecs/Collider.js";
+import { AcousticBody } from "./AcousticBody.js";
+//# sourceMappingURL=AcousticSimulationSystem.d.ts.map

package/src/engine/sound/simulation/ecs/AcousticSimulationSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticSimulationSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticSimulationSystem.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH;IAUI;;OAEG;IACH,0CASC;IApBD,2EAAmD;IAEnD;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IASN;;OAEG;IACH,6BAA0B;IAI9B;;;;;OAKG;IACH,WALW,YAAY,YACZ,QAAQ,aACR,SAAS,UACT,MAAM,QAWhB;IAED;;;;;OAKG;IACH,aALW,YAAY,YACZ,QAAQ,aACR,SAAS,UACT,MAAM,QAchB;CACJ;uBA1EsB,wBAAwB;0BACrB,qCAAqC;yBACtC,kCAAkC;6BAC9B,mBAAmB"}

package/src/engine/sound/simulation/ecs/AcousticSimulationSystem.js

@@ -0,0 +1,75 @@
+import { System } from "../../../ecs/System.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { Collider } from "../../../physics/ecs/Collider.js";
+import { AcousticBody } from "./AcousticBody.js";
+
+/**
+ * Feeds {@link AcousticBody} occluders into the shared {@link AcousticSimulator}, reactively. On link it
+ * triangulates the entity's `Collider` shape, registers it at the `Transform`'s world matrix, and
+ * subscribes to position changes so a moving occluder updates the index in O(1) (no geometry rebuild).
+ * On unlink it detaches and removes the occluder.
+ *
+ * Does NOT tick the simulation itself — `AudioEmitterSystem` drives `simulator.apply(...)` once per
+ * frame against the bounded live-voice set.
+ */
+export class AcousticSimulationSystem extends System {
+
+    dependencies = [AcousticBody, Collider, Transform];
+
+    /**
+     * Per-entity records: { handle, transform, onMove }.
+     * @type {object[]}
+     */
+    data = [];
+
+    /**
+     * @param {AcousticSimulator} simulator the shared simulation engine
+     */
+    constructor(simulator) {
+        super();
+
+
+        /**
+         * @type {AcousticSimulator}
+         */
+        this.simulator = simulator;
+
+    }
+
+    /**
+     * @param {AcousticBody} body
+     * @param {Collider} collider
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(body, collider, transform, entity) {
+        // the collider's shape IS the occluder geometry — raycast exactly, no triangulation
+        const handle = this.simulator.addOccluder(collider.shape, body.material, transform.matrix);
+
+        const onMove = () => this.simulator.setOccluderTransform(handle, transform.matrix);
+
+        transform.position.onChanged.add(onMove);
+
+        this.data[entity] = { handle, transform, onMove };
+    }
+
+    /**
+     * @param {AcousticBody} body
+     * @param {Collider} collider
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(body, collider, transform, entity) {
+        const record = this.data[entity];
+
+        if (record === undefined) {
+            return;
+        }
+
+        delete this.data[entity];
+
+        transform.position.onChanged.remove(record.onMove);
+
+        this.simulator.removeOccluder(record.handle);
+    }
+}

package/src/engine/sound/simulation/ecs/AcousticVolume.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ECS component marking a region of space with a propagation {@link AcousticMedium} (air absorption,
+ * …). Its `shape` (centred on the entity's `Transform`) defines the region; `transition` is the boundary
+ * blend band over which it fades into the surrounding medium. Overlapping volumes blend (see
+ * `VolumeField`), so e.g. a "cave" volume and the open-air default cross-fade smoothly at the mouth.
+ *
+ * Plain serializable data; the live region lives in the `AcousticSimulator`, fed by
+ * `AcousticVolumeSystem`. (Reverb is NOT a volume property — it is the P6 probe-baked / geometry-traced
+ * output.)
+ */
+export class AcousticVolume {
+    /**
+     * @param {AbstractShape3D} [shape]
+     * @param {number} [transition]
+     * @param {AcousticMedium} [medium]
+     * @returns {AcousticVolume}
+     */
+    static from(shape?: AbstractShape3D, transition?: number, medium?: AcousticMedium): AcousticVolume;
+    /**
+     * Region shape, centred at the entity's local origin (sphere, box, …).
+     * @type {AbstractShape3D}
+     */
+    shape: AbstractShape3D;
+    /**
+     * Boundary blend band in metres: the region's influence fades to zero over this distance just inside
+     * the surface. 0 = a hard edge.
+     * @type {number}
+     */
+    transition: number;
+    /**
+     * The medium inside this region.
+     * @type {AcousticMedium}
+     */
+    medium: AcousticMedium;
+    toJSON(): {
+        transition: number;
+        medium: {
+            airAbsorption: number[];
+        };
+    };
+    /**
+     * @param {{transition:number, medium:object}} json
+     */
+    fromJSON(json: {
+        transition: number;
+        medium: object;
+    }): void;
+}
+export namespace AcousticVolume {
+    let typeName: string;
+}
+import { AcousticMedium } from "../core/AcousticMedium.js";
+//# sourceMappingURL=AcousticVolume.d.ts.map

package/src/engine/sound/simulation/ecs/AcousticVolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticVolume.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticVolume.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH;IAoBI;;;;;OAKG;IACH,kDAJW,MAAM,WACN,cAAc,GACZ,cAAc,CAgB1B;IAvCD;;;OAGG;IACH,uBAA+B;IAE/B;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,QAFU,cAAc,CAEM;IAwB9B;;;;;MAMC;IAED;;OAEG;IACH,eAFW;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAA;KAAC,QAM5C;CACJ;;;;+BAtE8B,2BAA2B"}