@woosh/meep-engine 3.15.0 → 3.16.0

package/src/engine/sound/ecs/audio/SpatialAudioIndex.d.ts

@@ -32,9 +32,10 @@ export class SpatialAudioIndex {
      *
      * @param {number} entity non-negative integer id
      * @param {EventDescription} event read for `distanceMax` (and retained for later promotion)
-     * @param {Vector3} position shared position vector — its `onChanged` drives leaf refits
+     * @param {Float64Array} position shared translation view over the entity's transform. It has no
+     *        signals, so the owner calls {@link refresh} when the entity moves.
      */
-    add(entity: number, event: EventDescription, position: Vector3): void;
+    add(entity: number, event: EventDescription, position: Float64Array): void;
     /**
      * Unregister an emitter: stop tracking its position and drop its BVH leaf. No-op for an unknown
      * entity.
@@ -54,6 +55,26 @@ export class SpatialAudioIndex {
      * @returns {number} number of matches written to `out`
      */
     queryAudible(out: number[], out_offset: number, listenerPosition: Vector3): number;
+    /**
+     * Re-fit the entity's leaf to its current pose.
+     *
+     * The translation this index holds is a live view over the transform's buffer, so it is already
+     * up to date - what it cannot do is announce itself. The owner calls this when the dataset says
+     * the transform changed.
+     *
+     * @param {number} entity
+     */
+    /**
+     * Re-fit every leaf.
+     *
+     * The translations are live views over their transforms, so the data is already current - what
+     * is stale is the leaf AABB in the BVH. One pass per tick costs what the per-move refits cost
+     * before, and it is what the emitters' own "next tick re-attenuates" behaviour expects.
+     *
+     * @returns {void}
+     */
+    refresh_all(): void;
+    refresh(entity: any): void;
     #private;
 }
 //# sourceMappingURL=SpatialAudioIndex.d.ts.map

package/src/engine/sound/ecs/audio/SpatialAudioIndex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpatialAudioIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/SpatialAudioIndex.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAyBI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,YAJW,MAAM,oDAoBhB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAahB;IAcD;;;;;;;;;;;OAWG;IACH,kBALW,MAAM,EAAE,cACR,MAAM,8BAEJ,MAAM,CASlB;;CACJ"}
+{"version":3,"file":"SpatialAudioIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/SpatialAudioIndex.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAyBI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,YALW,MAAM,qCAEN,YAAY,QAgBtB;IAED;;;;OAIG;IACH,eAFW,MAAM,QAYhB;IAiBD;;;;;;;;;;;OAWG;IACH,kBALW,MAAM,EAAE,cACR,MAAM,8BAEJ,MAAM,CASlB;IACD;;;;;;;;OAQG;IACH;;;;;;;;OAQG;IACH,eAFa,IAAI,CAMhB;IAED,2BAQC;;CAEJ"}

package/src/engine/sound/ecs/audio/SpatialAudioIndex.js

@@ -1,140 +1,174 @@
-import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
-import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
-import { BVHQueryIntersectsSphere } from "../../../../core/bvh2/bvh3/query/BVHQueryIntersectsSphere.js";
-import { bvh_query_user_data_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_generic.js";
-
-/**
- * Spatial broadphase for 3D audio emitters (P5.1, cull-only).
- *
- * Holds a dynamic BVH whose leaves are each emitter's AUDIBLE region — an axis-aligned box of
- * half-extent `event.distanceMax` centred on the emitter. So "which emitters can possibly be heard
- * from point P" is one O(log n + k) BVH point-query instead of an O(n) scan over every emitter. This
- * is the registered/dormant tier: a registered emitter is a record plus one BVH leaf — no
- * `EventInstance`, no WebAudio nodes, no per-frame work. Promoting in-range emitters to live instances
- * (voice slots, stealing, fades) is layered on top later; this class only answers the cull.
- *
- * Leaf bounds track the emitter REACTIVELY: each leaf subscribes to its position's `onChanged`, so a
- * still emitter costs nothing per frame and a moving one refits only when it actually moves. (meep is
- * fully dynamic — there is no static/dynamic distinction and no per-tick refit loop.)
- *
- * The cull is conservative: the leaf is a cube of half-extent `distanceMax`, so its corners admit a
- * few emitters whose true (spherical) distance slightly exceeds `distanceMax`. That is correct
- * broadphase behaviour — the exact distance test belongs to the narrowphase (the live instance).
- */
-export class SpatialAudioIndex {
-
-    /**
-     * @type {BVH}
-     */
-    #bvh = new BVH();
-
-    /**
-     * entity id -> { entity, event, position, bvhClient, onMove }
-     * @type {Map<number, {entity:number, event:EventDescription, position:Vector3, bvhClient:BvhClient, onMove:function}>}
-     */
-    #records = new Map();
-
-    /**
-     * Reused point-query. The sphere `[x, y, z, radius]` is mutated in place each query; radius stays 0,
-     * so the test is "listener point inside the leaf AABB".
-     * @type {number[]}
-     */
-    #querySphere = [0, 0, 0, 0];
-
-    /**
-     * @type {BVHQueryIntersectsSphere}
-     */
-    #query = BVHQueryIntersectsSphere.from(this.#querySphere);
-
-    /**
-     * @returns {number} number of registered emitters
-     */
-    get size() {
-        return this.#records.size;
-    }
-
-    /**
-     * @param {number} entity
-     * @returns {boolean}
-     */
-    has(entity) {
-        return this.#records.has(entity);
-    }
-
-    /**
-     * Register an emitter: insert a BVH leaf sized to its audible region and start tracking its
-     * position. The entity id is the leaf's user data (so queries return entity ids).
-     *
-     * @param {number} entity non-negative integer id
-     * @param {EventDescription} event read for `distanceMax` (and retained for later promotion)
-     * @param {Vector3} position shared position vector — its `onChanged` drives leaf refits
-     */
-    add(entity, event, position) {
-        if (this.#records.has(entity)) {
-            throw new Error(`SpatialAudioIndex: entity ${entity} already registered`);
-        }
-
-        const bvhClient = new BvhClient();
-
-        const record = { entity, event, position, bvhClient, onMove: null };
-
-        this.#writeBounds(record);          // size the leaf AABB before linking (resize no-ops the write pre-link)
-        bvhClient.link(this.#bvh, entity);  // user_data = entity id
-
-        record.onMove = () => this.#writeBounds(record);
-        position.onChanged.add(record.onMove);
-
-        this.#records.set(entity, record);
-    }
-
-    /**
-     * Unregister an emitter: stop tracking its position and drop its BVH leaf. No-op for an unknown
-     * entity.
-     * @param {number} entity
-     */
-    remove(entity) {
-        const record = this.#records.get(entity);
-
-        if (record === undefined) {
-            return;
-        }
-
-        record.position.onChanged.remove(record.onMove);
-        record.bvhClient.unlink();
-
-        this.#records.delete(entity);
-    }
-
-    /**
-     * Refit a record's leaf to `position ± distanceMax`. Called once at registration and again
-     * (reactively) whenever the position changes.
-     * @param {{event:EventDescription, position:Vector3, bvhClient:BvhClient}} record
-     */
-    #writeBounds(record) {
-        const p = record.position;
-        const d = record.event.distanceMax;
-
-        record.bvhClient.resize(p.x - d, p.y - d, p.z - d, p.x + d, p.y + d, p.z + d);
-    }
-
-    /**
-     * Write the entity ids whose audible region contains `listenerPosition` into `out` (starting at
-     * `out_offset`) and return how many — every emitter that can possibly be heard from there (a
-     * conservative superset; see the class note), in unspecified order. Allocation-free: `out` is a
-     * caller-owned reusable buffer, grown as needed (never shrunk), so only `out[out_offset .. out_offset
-     * + count)` is meaningful — entries elsewhere may be stale from a prior query and must be ignored.
-     *
-     * @param {number[]} out caller-owned result buffer, reused across calls (grows, never shrinks)
-     * @param {number} out_offset index in `out` to start writing at
-     * @param {Vector3} listenerPosition
-     * @returns {number} number of matches written to `out`
-     */
-    queryAudible(out, out_offset, listenerPosition) {
-        this.#querySphere[0] = listenerPosition.x;
-        this.#querySphere[1] = listenerPosition.y;
-        this.#querySphere[2] = listenerPosition.z;
-        // radius stays 0 -> point-in-AABB
-
-        return bvh_query_user_data_generic(out, out_offset, this.#bvh, this.#bvh.root, this.#query);
-    }
-}
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
+import { BVHQueryIntersectsSphere } from "../../../../core/bvh2/bvh3/query/BVHQueryIntersectsSphere.js";
+import { bvh_query_user_data_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_generic.js";
+
+/**
+ * Spatial broadphase for 3D audio emitters (P5.1, cull-only).
+ *
+ * Holds a dynamic BVH whose leaves are each emitter's AUDIBLE region — an axis-aligned box of
+ * half-extent `event.distanceMax` centred on the emitter. So "which emitters can possibly be heard
+ * from point P" is one O(log n + k) BVH point-query instead of an O(n) scan over every emitter. This
+ * is the registered/dormant tier: a registered emitter is a record plus one BVH leaf — no
+ * `EventInstance`, no WebAudio nodes, no per-frame work. Promoting in-range emitters to live instances
+ * (voice slots, stealing, fades) is layered on top later; this class only answers the cull.
+ *
+ * Leaf bounds track the emitter REACTIVELY: each leaf subscribes to its position's `onChanged`, so a
+ * still emitter costs nothing per frame and a moving one refits only when it actually moves. (meep is
+ * fully dynamic — there is no static/dynamic distinction and no per-tick refit loop.)
+ *
+ * The cull is conservative: the leaf is a cube of half-extent `distanceMax`, so its corners admit a
+ * few emitters whose true (spherical) distance slightly exceeds `distanceMax`. That is correct
+ * broadphase behaviour — the exact distance test belongs to the narrowphase (the live instance).
+ */
+export class SpatialAudioIndex {
+
+    /**
+     * @type {BVH}
+     */
+    #bvh = new BVH();
+
+    /**
+     * entity id -> { entity, event, position, bvhClient, onMove }
+     * @type {Map<number, {entity:number, event:EventDescription, position:Vector3, bvhClient:BvhClient, onMove:function}>}
+     */
+    #records = new Map();
+
+    /**
+     * Reused point-query. The sphere `[x, y, z, radius]` is mutated in place each query; radius stays 0,
+     * so the test is "listener point inside the leaf AABB".
+     * @type {number[]}
+     */
+    #querySphere = [0, 0, 0, 0];
+
+    /**
+     * @type {BVHQueryIntersectsSphere}
+     */
+    #query = BVHQueryIntersectsSphere.from(this.#querySphere);
+
+    /**
+     * @returns {number} number of registered emitters
+     */
+    get size() {
+        return this.#records.size;
+    }
+
+    /**
+     * @param {number} entity
+     * @returns {boolean}
+     */
+    has(entity) {
+        return this.#records.has(entity);
+    }
+
+    /**
+     * Register an emitter: insert a BVH leaf sized to its audible region and start tracking its
+     * position. The entity id is the leaf's user data (so queries return entity ids).
+     *
+     * @param {number} entity non-negative integer id
+     * @param {EventDescription} event read for `distanceMax` (and retained for later promotion)
+     * @param {Float64Array} position shared translation view over the entity's transform. It has no
+     *        signals, so the owner calls {@link refresh} when the entity moves.
+     */
+    add(entity, event, position) {
+        if (this.#records.has(entity)) {
+            throw new Error(`SpatialAudioIndex: entity ${entity} already registered`);
+        }
+
+        const bvhClient = new BvhClient();
+
+        const record = { entity, event, position, bvhClient, onMove: null };
+
+        this.#writeBounds(record);          // size the leaf AABB before linking (resize no-ops the write pre-link)
+        bvhClient.link(this.#bvh, entity);  // user_data = entity id
+
+        this.#records.set(entity, record);
+    }
+
+    /**
+     * Unregister an emitter: stop tracking its position and drop its BVH leaf. No-op for an unknown
+     * entity.
+     * @param {number} entity
+     */
+    remove(entity) {
+        const record = this.#records.get(entity);
+
+        if (record === undefined) {
+            return;
+        }
+
+        record.bvhClient.unlink();
+
+        this.#records.delete(entity);
+    }
+
+    /**
+     * Refit a record's leaf to `position ± distanceMax`. Called once at registration and again
+     * (reactively) whenever the position changes.
+     * @param {{event:EventDescription, position:Vector3, bvhClient:BvhClient}} record
+     */
+    #writeBounds(record) {
+        const p = record.position;
+        const d = record.event.distanceMax;
+
+        record.bvhClient.resize(
+            p[0] - d, p[1] - d, p[2] - d,
+            p[0] + d, p[1] + d, p[2] + d
+        );
+    }
+
+    /**
+     * Write the entity ids whose audible region contains `listenerPosition` into `out` (starting at
+     * `out_offset`) and return how many — every emitter that can possibly be heard from there (a
+     * conservative superset; see the class note), in unspecified order. Allocation-free: `out` is a
+     * caller-owned reusable buffer, grown as needed (never shrunk), so only `out[out_offset .. out_offset
+     * + count)` is meaningful — entries elsewhere may be stale from a prior query and must be ignored.
+     *
+     * @param {number[]} out caller-owned result buffer, reused across calls (grows, never shrinks)
+     * @param {number} out_offset index in `out` to start writing at
+     * @param {Vector3} listenerPosition
+     * @returns {number} number of matches written to `out`
+     */
+    queryAudible(out, out_offset, listenerPosition) {
+        this.#querySphere[0] = listenerPosition[0];
+        this.#querySphere[1] = listenerPosition[1];
+        this.#querySphere[2] = listenerPosition[2];
+        // radius stays 0 -> point-in-AABB
+
+        return bvh_query_user_data_generic(out, out_offset, this.#bvh, this.#bvh.root, this.#query);
+    }
+    /**
+     * Re-fit the entity's leaf to its current pose.
+     *
+     * The translation this index holds is a live view over the transform's buffer, so it is already
+     * up to date - what it cannot do is announce itself. The owner calls this when the dataset says
+     * the transform changed.
+     *
+     * @param {number} entity
+     */
+    /**
+     * Re-fit every leaf.
+     *
+     * The translations are live views over their transforms, so the data is already current - what
+     * is stale is the leaf AABB in the BVH. One pass per tick costs what the per-move refits cost
+     * before, and it is what the emitters' own "next tick re-attenuates" behaviour expects.
+     *
+     * @returns {void}
+     */
+    refresh_all() {
+        for (const record of this.#records.values()) {
+            this.#writeBounds(record);
+        }
+    }
+
+    refresh(entity) {
+        const record = this.#records.get(entity);
+
+        if (record === undefined) {
+            return;
+        }
+
+        this.#writeBounds(record);
+    }
+
+}

package/src/engine/sound/ecs/trigger/AudioEventTriggerSystem.d.ts

@@ -17,7 +17,7 @@ export class AudioEventTriggerSystem extends System<any> {
      * @param {SoundEngine} soundEngine owns the AudioContext + master destination + sopra engine
      */
     constructor(assetManager: AssetManager, soundEngine: SoundEngine);
-    dependencies: (typeof Transform | typeof AudioEventTrigger)[];
+    dependencies: (typeof Transform64 | typeof AudioEventTrigger)[];
     /**
      * Per-entity records: { listeners: [{name, handler}], live: Map<AudioEventTriggerRule, Set<EventInstance>> }.
      * @type {object[]}
@@ -38,16 +38,16 @@ export class AudioEventTriggerSystem extends System<any> {
     sopra: SopraEngine;
     /**
      * @param {AudioEventTrigger} trigger
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    link(trigger: AudioEventTrigger, transform: Transform, entity: number): void;
+    link(trigger: AudioEventTrigger, transform: Transform64, entity: number): void;
     /**
      * @param {AudioEventTrigger} trigger
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {number} entity
      */
-    unlink(trigger: AudioEventTrigger, transform: Transform, entity: number): void;
+    unlink(trigger: AudioEventTrigger, transform: Transform64, entity: number): void;
     /**
      * 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 —
@@ -60,6 +60,6 @@ export class AudioEventTriggerSystem extends System<any> {
     #private;
 }
 import { System } from "../../../ecs/System.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
+import { Transform64 } from "../../../ecs/transform/Transform64.js";
 import { AudioEventTrigger } from "./AudioEventTrigger.js";
 //# sourceMappingURL=AudioEventTriggerSystem.d.ts.map

package/src/engine/sound/ecs/trigger/AudioEventTriggerSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AudioEventTriggerSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/trigger/AudioEventTriggerSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH;IASI;;;OAGG;IACH,kEAwBC;IApCD,8DAA8C;IAE9C;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IASN;;OAEG;IACH,yBAA8B;IAE9B;;OAEG;IACH,2BAAgC;IAQhC;;;OAGG;IACH,mBAAkF;IAGtF;;;;OAIG;IACH,cAJW,iBAAiB,aACjB,SAAS,UACT,MAAM,QA6BhB;IAED;;;;OAIG;IACH,gBAJW,iBAAiB,aACjB,SAAS,UACT,MAAM,QAoBhB;IAED;;;;;;;OAOG;IACH,qBAJW,MAAM,gCAEJ,eAAe,CAY3B;;CA+CJ;uBArLsB,wBAAwB;0BACrB,qCAAqC;kCAE7B,wBAAwB"}
+{"version":3,"file":"AudioEventTriggerSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/trigger/AudioEventTriggerSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH;IASI;;;OAGG;IACH,kEAwBC;IApCD,gEAAgD;IAEhD;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IASN;;OAEG;IACH,yBAA8B;IAE9B;;OAEG;IACH,2BAAgC;IAQhC;;;OAGG;IACH,mBAAkF;IAGtF;;;;OAIG;IACH,cAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QA6BhB;IAED;;;;OAIG;IACH,gBAJW,iBAAiB,aACjB,WAAW,UACX,MAAM,QAoBhB;IAED;;;;;;;OAOG;IACH,qBAJW,MAAM,gCAEJ,eAAe,CAY3B;;CAgDJ;uBAtLsB,wBAAwB;4BACnB,uCAAuC;kCAEjC,wBAAwB"}