@woosh/meep-engine 3.14.6 → 3.16.0

package/src/engine/sound/ecs/trigger/AudioEventTriggerSystem.js

@@ -1,184 +1,185 @@
-import { GameAssetType } from "../../../asset/GameAssetType.js";
-import { SoundAssetLoader } from "../../../asset/loaders/SoundAssetLoader.js";
-import { System } from "../../../ecs/System.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
-import { AssetManagerBufferProvider } from "../../sopra/asset/AssetManagerBufferProvider.js";
-import { AudioEventTrigger } from "./AudioEventTrigger.js";
-
-/**
- * Drives {@link AudioEventTrigger} components: on link it subscribes each rule to its entity event, and
- * plays the rule's authored event through the shared sopra engine when that event arrives.
- *
- * Instances started by a rule are held until they end (a one-shot self-releases) or until the rule's
- * `stopEvent` arrives; unlinking removes every listener and stops everything still sounding, so a
- * destroyed entity is silent and leaves nothing subscribed.
- *
- * Shares the single {@link SopraEngine} owned by {@link SoundEngine} (created on demand, idempotent).
- * It deliberately has **no** `update`: the per-frame sopra tick and the listener pose belong to
- * {@link AudioEmitterSystem}, which is the single tick owner — a second ticker would advance the same
- * instances twice per frame. Register this system alongside it.
- */
-export class AudioEventTriggerSystem extends System {
-    dependencies = [AudioEventTrigger, Transform];
-
-    /**
-     * Per-entity records: { listeners: [{name, handler}], live: Map<AudioEventTriggerRule, Set<EventInstance>> }.
-     * @type {object[]}
-     */
-    data = [];
-
-    /**
-     * @param {AssetManager} assetManager
-     * @param {SoundEngine} soundEngine owns the AudioContext + master destination + sopra engine
-     */
-    constructor(assetManager, soundEngine) {
-        super();
-
-        /**
-         * @type {SoundEngine}
-         */
-        this.soundEngine = soundEngine;
-
-        /**
-         * @type {AssetManager}
-         */
-        this.assetManager = assetManager;
-
-        // Self-sufficient, like AudioEmitterSystem: register the Sound asset loader if nothing has yet,
-        // guarded so registering both systems does not double-register it.
-        if (!assetManager.hasLoaderForType(GameAssetType.Sound)) {
-            assetManager.registerLoader(GameAssetType.Sound, new SoundAssetLoader(soundEngine.context));
-        }
-
-        /**
-         * The shared sopra engine (idempotent create — reused if another sound system already made it).
-         * @type {SopraEngine}
-         */
-        this.sopra = soundEngine.obtainSopra(new AssetManagerBufferProvider(assetManager));
-    }
-
-    /**
-     * @param {AudioEventTrigger} trigger
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    link(trigger, transform, entity) {
-        const dataset = this.entityManager.dataset;
-
-        const record = { listeners: [], live: new Map() };
-
-        const rules = trigger.rules;
-
-        for (let i = 0; i < rules.length; i++) {
-            const rule = rules[i];
-
-            const live = new Set();
-            record.live.set(rule, live);
-
-            const onStart = () => this.#start(rule, transform, live);
-
-            dataset.addEntityEventListener(entity, rule.startEvent, onStart);
-            record.listeners.push({ name: rule.startEvent, handler: onStart });
-
-            if (rule.stopEvent !== null) {
-                const onStop = () => this.#stopAll(live);
-
-                dataset.addEntityEventListener(entity, rule.stopEvent, onStop);
-                record.listeners.push({ name: rule.stopEvent, handler: onStop });
-            }
-        }
-
-        this.data[entity] = record;
-    }
-
-    /**
-     * @param {AudioEventTrigger} trigger
-     * @param {Transform} transform
-     * @param {number} entity
-     */
-    unlink(trigger, transform, entity) {
-        const record = this.data[entity];
-
-        if (record === undefined) {
-            return;
-        }
-
-        delete this.data[entity];
-
-        const dataset = this.entityManager.dataset;
-
-        const listeners = record.listeners;
-        for (let i = 0; i < listeners.length; i++) {
-            const listener = listeners[i];
-            dataset.removeEntityEventListener(entity, listener.name, listener.handler);
-        }
-
-        record.live.forEach(live => this.#stopAll(live));
-    }
-
-    /**
-     * Instances a given rule currently has sounding on an entity, in start order. The observation point
-     * for callers that need to reach a triggered sound (there is no component-level handle by design —
-     * a trigger is fire-and-forget).
-     * @param {number} entity
-     * @param {AudioEventTriggerRule} rule
-     * @returns {EventInstance[]}
-     */
-    instancesFor(entity, rule) {
-        const record = this.data[entity];
-
-        if (record === undefined) {
-            return [];
-        }
-
-        const live = record.live.get(rule);
-
-        return live === undefined ? [] : [...live];
-    }
-
-    /**
-     * @param {AudioEventTriggerRule} rule
-     * @param {Transform} transform
-     * @param {Set<EventInstance>} live instances this rule currently has sounding
-     */
-    #start(rule, transform, live) {
-        const event = rule.event;
-
-        // A looping event is a persistent source that plays until its stopEvent (or unlink); a finite one
-        // is a one-shot that self-releases. oneShot ALSO arms the max-lifetime backstop, so marking a
-        // loop oneShot would wrongly kill it after maxLifetimeSeconds — same rule as AudioEmitterSystem.
-        const oneShot = !event.rootClip.loops();
-
-        const instance = this.sopra.playEvent(event, {
-            busId: event.busId,
-            position: transform.position, // shared Vector3 — tracks the entity as it moves
-            oneShot
-        });
-
-        if (instance === null) {
-            // play denied (instance limit) — drop, matching the steal/limit policy
-            return;
-        }
-
-        live.add(instance);
-
-        // stop() fires onEnded synchronously, so #stopAll clears the set before stopping and this only
-        // ever prunes an instance that finished on its own
-        instance.onEnded.addOne(() => live.delete(instance));
-    }
-
-    /**
-     * @param {Set<EventInstance>} live emptied
-     */
-    #stopAll(live) {
-        // snapshot and clear BEFORE stopping: stop() fires onEnded synchronously, which would otherwise
-        // mutate the set being iterated
-        const instances = [...live];
-
-        live.clear();
-
-        for (let i = 0; i < instances.length; i++) {
-            instances[i].stop();
-        }
-    }
-}
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import { SoundAssetLoader } from "../../../asset/loaders/SoundAssetLoader.js";
+import { System } from "../../../ecs/System.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
+import { AssetManagerBufferProvider } from "../../sopra/asset/AssetManagerBufferProvider.js";
+import { AudioEventTrigger } from "./AudioEventTrigger.js";
+
+/**
+ * Drives {@link AudioEventTrigger} components: on link it subscribes each rule to its entity event, and
+ * plays the rule's authored event through the shared sopra engine when that event arrives.
+ *
+ * Instances started by a rule are held until they end (a one-shot self-releases) or until the rule's
+ * `stopEvent` arrives; unlinking removes every listener and stops everything still sounding, so a
+ * destroyed entity is silent and leaves nothing subscribed.
+ *
+ * Shares the single {@link SopraEngine} owned by {@link SoundEngine} (created on demand, idempotent).
+ * It deliberately has **no** `update`: the per-frame sopra tick and the listener pose belong to
+ * {@link AudioEmitterSystem}, which is the single tick owner — a second ticker would advance the same
+ * instances twice per frame. Register this system alongside it.
+ */
+export class AudioEventTriggerSystem extends System {
+    dependencies = [AudioEventTrigger, Transform64];
+
+    /**
+     * Per-entity records: { listeners: [{name, handler}], live: Map<AudioEventTriggerRule, Set<EventInstance>> }.
+     * @type {object[]}
+     */
+    data = [];
+
+    /**
+     * @param {AssetManager} assetManager
+     * @param {SoundEngine} soundEngine owns the AudioContext + master destination + sopra engine
+     */
+    constructor(assetManager, soundEngine) {
+        super();
+
+        /**
+         * @type {SoundEngine}
+         */
+        this.soundEngine = soundEngine;
+
+        /**
+         * @type {AssetManager}
+         */
+        this.assetManager = assetManager;
+
+        // Self-sufficient, like AudioEmitterSystem: register the Sound asset loader if nothing has yet,
+        // guarded so registering both systems does not double-register it.
+        if (!assetManager.hasLoaderForType(GameAssetType.Sound)) {
+            assetManager.registerLoader(GameAssetType.Sound, new SoundAssetLoader(soundEngine.context));
+        }
+
+        /**
+         * The shared sopra engine (idempotent create — reused if another sound system already made it).
+         * @type {SopraEngine}
+         */
+        this.sopra = soundEngine.obtainSopra(new AssetManagerBufferProvider(assetManager));
+    }
+
+    /**
+     * @param {AudioEventTrigger} trigger
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    link(trigger, transform, entity) {
+        const dataset = this.entityManager.dataset;
+
+        const record = { listeners: [], live: new Map() };
+
+        const rules = trigger.rules;
+
+        for (let i = 0; i < rules.length; i++) {
+            const rule = rules[i];
+
+            const live = new Set();
+            record.live.set(rule, live);
+
+            const onStart = () => this.#start(rule, transform, live);
+
+            dataset.addEntityEventListener(entity, rule.startEvent, onStart);
+            record.listeners.push({ name: rule.startEvent, handler: onStart });
+
+            if (rule.stopEvent !== null) {
+                const onStop = () => this.#stopAll(live);
+
+                dataset.addEntityEventListener(entity, rule.stopEvent, onStop);
+                record.listeners.push({ name: rule.stopEvent, handler: onStop });
+            }
+        }
+
+        this.data[entity] = record;
+    }
+
+    /**
+     * @param {AudioEventTrigger} trigger
+     * @param {Transform64} transform
+     * @param {number} entity
+     */
+    unlink(trigger, transform, entity) {
+        const record = this.data[entity];
+
+        if (record === undefined) {
+            return;
+        }
+
+        delete this.data[entity];
+
+        const dataset = this.entityManager.dataset;
+
+        const listeners = record.listeners;
+        for (let i = 0; i < listeners.length; i++) {
+            const listener = listeners[i];
+            dataset.removeEntityEventListener(entity, listener.name, listener.handler);
+        }
+
+        record.live.forEach(live => this.#stopAll(live));
+    }
+
+    /**
+     * Instances a given rule currently has sounding on an entity, in start order. The observation point
+     * for callers that need to reach a triggered sound (there is no component-level handle by design —
+     * a trigger is fire-and-forget).
+     * @param {number} entity
+     * @param {AudioEventTriggerRule} rule
+     * @returns {EventInstance[]}
+     */
+    instancesFor(entity, rule) {
+        const record = this.data[entity];
+
+        if (record === undefined) {
+            return [];
+        }
+
+        const live = record.live.get(rule);
+
+        return live === undefined ? [] : [...live];
+    }
+
+    /**
+     * @param {AudioEventTriggerRule} rule
+     * @param {Transform64} transform
+     * @param {Set<EventInstance>} live instances this rule currently has sounding
+     */
+    #start(rule, transform, live) {
+        const event = rule.event;
+
+        // A looping event is a persistent source that plays until its stopEvent (or unlink); a finite one
+        // is a one-shot that self-releases. oneShot ALSO arms the max-lifetime backstop, so marking a
+        // loop oneShot would wrongly kill it after maxLifetimeSeconds — same rule as AudioEmitterSystem.
+        const oneShot = !event.rootClip.loops();
+
+        const instance = this.sopra.playEvent(event, {
+            busId: event.busId,
+            // a live view over the transform buffer, so it still tracks the entity as it moves
+            position: transform.translation,
+            oneShot
+        });
+
+        if (instance === null) {
+            // play denied (instance limit) — drop, matching the steal/limit policy
+            return;
+        }
+
+        live.add(instance);
+
+        // stop() fires onEnded synchronously, so #stopAll clears the set before stopping and this only
+        // ever prunes an instance that finished on its own
+        instance.onEnded.addOne(() => live.delete(instance));
+    }
+
+    /**
+     * @param {Set<EventInstance>} live emptied
+     */
+    #stopAll(live) {
+        // snapshot and clear BEFORE stopping: stop() fires onEnded synchronously, which would otherwise
+        // mutate the set being iterated
+        const instances = [...live];
+
+        live.clear();
+
+        for (let i = 0; i < instances.length; i++) {
+            instances[i].stop();
+        }
+    }
+}

package/src/engine/sound/material/detector/terrain/TerrainSoundMaterialSurfaceDetector.js

@@ -92,7 +92,7 @@ export class TerrainSoundMaterialSurfaceDetector extends SoundMaterialSurfaceDet
 
     detect(thing, point, interaction) {
 
-        this.__terrain.mapPointWorld2Grid(point, v2_temp);
+        this.__terrain.mapPointWorld2Grid(point.x, point.z, v2_temp);
 
         const u = v2_temp.x / this.__terrain.size.x;
         const v = v2_temp.y / this.__terrain.size.y;

package/src/engine/sound/simulation/core/AcousticRegionIndex.d.ts

@@ -6,7 +6,8 @@
  * shape (weight 0 outside, see {@link AcousticVolumeRegion#weightAt}), so the shape's world AABB tightly
  * bounds it.
  *
- * Regions track their entity's `Transform.position` BY REFERENCE (a volume moves with no subscription), so a
+ * Regions track their entity's translation BY REFERENCE - a `Float64Array` view over the transform's own
+ * buffer, so a volume still moves with no subscription - and so a
  * leaf goes stale when its volume moves — call {@link refit} once per frame (before queries) to re-fit the
  * live positions. ECS-agnostic, WebAudio-agnostic. PRECONDITION: regions are axis-aligned (position only, no
  * rotation — matching {@link AcousticVolumeRegion}).

package/src/engine/sound/simulation/core/AcousticRegionIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticRegionIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticRegionIndex.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;GAYG;AACH;IA+BI;;;;OAIG;IACH,mBAEC;IAED;;;;OAIG;IACH,wDAYC;IAED;;;OAGG;IACH,2CAWC;IAED;;;;;;;OAOG;IACH,cAUC;IAmBD;;;;;;;;;;;OAWG;IACH,eAPW,sBAAsB,iBACtB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;;CACJ"}
+{"version":3,"file":"AcousticRegionIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticRegionIndex.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH;IA+BI;;;;OAIG;IACH,mBAEC;IAED;;;;OAIG;IACH,wDAYC;IAED;;;OAGG;IACH,2CAWC;IAED;;;;;;;OAOG;IACH,cAUC;IAmBD;;;;;;;;;;;OAWG;IACH,eAPW,sBAAsB,iBACtB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;;CACJ"}

package/src/engine/sound/simulation/core/AcousticRegionIndex.js

@@ -15,7 +15,8 @@ const LOCAL_AABB = [0, 0, 0, 0, 0, 0];
  * shape (weight 0 outside, see {@link AcousticVolumeRegion#weightAt}), so the shape's world AABB tightly
  * bounds it.
  *
- * Regions track their entity's `Transform.position` BY REFERENCE (a volume moves with no subscription), so a
+ * Regions track their entity's translation BY REFERENCE - a `Float64Array` view over the transform's own
+ * buffer, so a volume still moves with no subscription - and so a
  * leaf goes stale when its volume moves — call {@link refit} once per frame (before queries) to re-fit the
  * live positions. ECS-agnostic, WebAudio-agnostic. PRECONDITION: regions are axis-aligned (position only, no
  * rotation — matching {@link AcousticVolumeRegion}).
@@ -128,8 +129,8 @@ export class AcousticRegionIndex {
         const p = region.position;
 
         client.resize(
-            LOCAL_AABB[0] + p.x, LOCAL_AABB[1] + p.y, LOCAL_AABB[2] + p.z,
-            LOCAL_AABB[3] + p.x, LOCAL_AABB[4] + p.y, LOCAL_AABB[5] + p.z
+            LOCAL_AABB[0] + p[0], LOCAL_AABB[1] + p[1], LOCAL_AABB[2] + p[2],
+            LOCAL_AABB[3] + p[0], LOCAL_AABB[4] + p[1], LOCAL_AABB[5] + p[2]
         );
     }
 

package/src/engine/sound/simulation/core/AcousticVolumeRegion.d.ts

@@ -21,9 +21,10 @@ export class AcousticVolumeRegion {
      */
     shape: AbstractShape3D;
     /**
-     * @type {Vector3}
+     * Live view over the owning transform buffer - the region moves with the entity.
+     * @type {Float64Array}
      */
-    position: Vector3;
+    position: Float64Array;
     /**
      * @type {number}
      */

package/src/engine/sound/simulation/core/AcousticVolumeRegion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticVolumeRegion.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticVolumeRegion.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IACI;;;;;OAKG;IACH,mEAHW,MAAM,0BAuBhB;IAnBG;;OAEG;IACH,uBAAkB;IAElB;;OAEG;IACH,kBAAwB;IAExB;;OAEG;IACH,YAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,uBAAoB;IAGxB;;;;;;;OAOG;IACH,YALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;CACJ"}
+{"version":3,"file":"AcousticVolumeRegion.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticVolumeRegion.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IACI;;;;;OAKG;IACH,mEAHW,MAAM,0BAwBhB;IApBG;;OAEG;IACH,uBAAkB;IAElB;;;OAGG;IACH,UAFU,YAAY,CAEE;IAExB;;OAEG;IACH,YAFU,MAAM,CAEY;IAE5B;;OAEG;IACH,uBAAoB;IAGxB;;;;;;;OAOG;IACH,YALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;CACJ"}

package/src/engine/sound/simulation/core/AcousticVolumeRegion.js

@@ -27,7 +27,8 @@ export class AcousticVolumeRegion {
         this.shape = shape;
 
         /**
-         * @type {Vector3}
+         * Live view over the owning transform buffer - the region moves with the entity.
+         * @type {Float64Array}
          */
         this.position = position;
 
@@ -51,9 +52,10 @@ export class AcousticVolumeRegion {
      * @returns {number} weight in [0, 1]
      */
     weightAt(x, y, z) {
-        LOCAL_POINT[0] = x - this.position.x;
-        LOCAL_POINT[1] = y - this.position.y;
-        LOCAL_POINT[2] = z - this.position.z;
+        // the position is a live view over the owning transform, so it reads by index
+        LOCAL_POINT[0] = x - this.position[0];
+        LOCAL_POINT[1] = y - this.position[1];
+        LOCAL_POINT[2] = z - this.position[2];
 
         const sd = this.shape.signed_distance_at_point(LOCAL_POINT);
 

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

@@ -12,7 +12,11 @@ export class AcousticSimulationSystem extends System<any> {
      * @param {AcousticSimulator} simulator the shared simulation engine
      */
     constructor(simulator: AcousticSimulator);
-    dependencies: (typeof Transform | typeof Collider | typeof AcousticBody)[];
+    /**
+     * @param {EntityManager} entityManager
+     */
+    startup(entityManager: EntityManager): void;
+    dependencies: (typeof Transform64 | typeof Collider | typeof AcousticBody)[];
     /**
      * Per-entity records: { handle, transform, onMove }.
      * @type {object[]}
@@ -25,20 +29,20 @@ export class AcousticSimulationSystem extends System<any> {
     /**
      * @param {AcousticBody} body
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(body: AcousticBody, collider: Collider, transform: Transform, entity: number): void;
+    link(body: AcousticBody, collider: Collider, transform: Transform64, entity: number): void;
     /**
      * @param {AcousticBody} body
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(body: AcousticBody, collider: Collider, transform: Transform, entity: number): void;
+    unlink(body: AcousticBody, collider: Collider, transform: Transform64, entity: number): void;
 }
 import { System } from "../../../ecs/System.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.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

@@ -1 +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"}
+{"version":3,"file":"AcousticSimulationSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticSimulationSystem.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH;IAwBI;;OAEG;IACH,0CASC;IA3BD;;OAEG;IACH,4CAEC;IAED,6EAAqD;IAErD;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IASN;;OAEG;IACH,6BAA0B;IAI9B;;;;;OAKG;IACH,WALW,YAAY,YACZ,QAAQ,aACR,WAAW,UACX,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,aALW,YAAY,YACZ,QAAQ,aACR,WAAW,UACX,MAAM,QAgBhB;CACJ;uBAnGsB,wBAAwB;4BACnB,uCAAuC;yBAC1C,kCAAkC;6BAC9B,mBAAmB"}

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

@@ -1,7 +1,8 @@
 import { System } from "../../../ecs/System.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { Collider } from "../../../physics/ecs/Collider.js";
 import { AcousticBody } from "./AcousticBody.js";
+import { EventType } from "../../../ecs/EventType.js";
 
 /**
  * Feeds {@link AcousticBody} occluders into the shared {@link AcousticSimulator}, reactively. On link it
@@ -14,7 +15,21 @@ import { AcousticBody } from "./AcousticBody.js";
  */
 export class AcousticSimulationSystem extends System {
 
-    dependencies = [AcousticBody, Collider, Transform];
+    /**
+     * Kept so {@link link} can reach the dataset: the occluder pose is announced there now rather
+     * than through the transform's own signals.
+     * @type {EntityManager|null}
+     */
+    entityManager = null;
+
+    /**
+     * @param {EntityManager} entityManager
+     */
+    startup(entityManager) {
+        this.entityManager = entityManager;
+    }
+
+    dependencies = [AcousticBody, Collider, Transform64];
 
     /**
      * Per-entity records: { handle, transform, onMove }.
@@ -39,7 +54,7 @@ export class AcousticSimulationSystem extends System {
     /**
      * @param {AcousticBody} body
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     link(body, collider, transform, entity) {
@@ -48,15 +63,23 @@ export class AcousticSimulationSystem extends System {
 
         const onMove = () => this.simulator.setOccluderTransform(handle, transform.matrix);
 
-        transform.position.onChanged.add(onMove);
+        const on_transform_changed = event => {
+            if (event.klass === Transform64) {
+                onMove();
+            }
+        };
+
+        this.entityManager.dataset.addEntityEventListener(
+            entity, EventType.ComponentChanged, on_transform_changed
+        );
 
-        this.data[entity] = { handle, transform, onMove };
+        this.data[entity] = { handle, transform, onMove, on_transform_changed };
     }
 
     /**
      * @param {AcousticBody} body
      * @param {Collider} collider
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
     unlink(body, collider, transform, entity) {
@@ -68,7 +91,9 @@ export class AcousticSimulationSystem extends System {
 
         delete this.data[entity];
 
-        transform.position.onChanged.remove(record.onMove);
+        this.entityManager.dataset.removeEntityEventListener(
+            entity, EventType.ComponentChanged, record.on_transform_changed
+        );
 
         this.simulator.removeOccluder(record.handle);
     }

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

@@ -1,6 +1,6 @@
 /**
  * Feeds {@link AcousticVolume} medium regions into the shared {@link AcousticSimulator}. On link it
- * registers a region holding the entity's `Transform.position` BY REFERENCE — so a moving volume is
+ * registers a region holding the entity's `Transform64.position` BY REFERENCE — so a moving volume is
  * tracked live each sample, with no subscription (the region reads the shared vector). On unlink it
  * removes the region.
  */
@@ -9,7 +9,7 @@ export class AcousticVolumeSystem extends System<any> {
      * @param {AcousticSimulator} simulator the shared simulation engine
      */
     constructor(simulator: AcousticSimulator);
-    dependencies: (typeof Transform | typeof AcousticVolume)[];
+    dependencies: (typeof Transform64 | typeof AcousticVolume)[];
     /**
      * entity -> the registered region.
      * @type {AcousticVolumeRegion[]}
@@ -21,19 +21,19 @@ export class AcousticVolumeSystem extends System<any> {
     simulator: AcousticSimulator;
     /**
      * @param {AcousticVolume} volume
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(volume: AcousticVolume, transform: Transform, entity: number): void;
+    link(volume: AcousticVolume, transform: Transform64, entity: number): void;
     /**
      * @param {AcousticVolume} volume
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(volume: AcousticVolume, transform: Transform, entity: number): void;
+    unlink(volume: AcousticVolume, transform: Transform64, entity: number): void;
 }
 import { System } from "../../../ecs/System.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { AcousticVolume } from "./AcousticVolume.js";
 import { AcousticVolumeRegion } from "../core/AcousticVolumeRegion.js";
 //# sourceMappingURL=AcousticVolumeSystem.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AcousticVolumeSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticVolumeSystem.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IASI;;OAEG;IACH,0CASC;IApBD,2DAA2C;IAE3C;;;OAGG;IACH,MAFU,oBAAoB,EAAE,CAEtB;IASN;;OAEG;IACH,6BAA0B;IAI9B;;;;OAIG;IACH,aAJW,cAAc,aACd,SAAS,UACT,MAAM,QAUhB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,SAAS,UACT,MAAM,QAYhB;CACJ;uBAjEsB,wBAAwB;0BACrB,qCAAqC;+BAEhC,qBAAqB;qCADf,iCAAiC"}
+{"version":3,"file":"AcousticVolumeSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticVolumeSystem.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IASI;;OAEG;IACH,0CASC;IApBD,6DAA6C;IAE7C;;;OAGG;IACH,MAFU,oBAAoB,EAAE,CAEtB;IASN;;OAEG;IACH,6BAA0B;IAI9B;;;;OAIG;IACH,aAJW,cAAc,aACd,WAAW,UACX,MAAM,QAUhB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,WAAW,UACX,MAAM,QAYhB;CACJ;uBAjEsB,wBAAwB;4BACnB,uCAAuC;+BAEpC,qBAAqB;qCADf,iCAAiC"}