@woosh/meep-engine 3.16.0 → 3.17.1

package/src/engine/sound/simulation/AcousticSimulator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticSimulator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/simulation/AcousticSimulator.js"],"names":[],"mappings":"AA0CA;;;;;;;;;GASG;AACH;IACI;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;OAMG;IACH,gBAFU,OAAO,CAEM;IAEvB;;;;OAIG;IACH,eAFU,MAAM,CAEE;IAgGlB,6BAGC;IAZD;;;;OAIG;IACH,0BAEC;IAiBD,gCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAMD;;;;OAIG;IACH,2CAEC;IAED;;;;;;;OAOG;IACH,yEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAIlB;IAED;;;OAGG;IACH,6BAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAI/B;IAED;;OAEG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8DAEC;IAED;;OAEG;IACH,iDAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;OAKG;IACH,qBAFW,qBAAmB,IAAI,QAMjC;IAED;;;;;;;;OAQG;IACH,mBAPW,OAAO,UACP,OAAO,gBACP,MAAM,SAEN,mBAAmB,OACnB,gBAAgB,QAkB1B;IAED;;;;;;OAMG;IACH,qBAHW,eAAe,YACf,OAAO,QAuFjB;IAgPD;;;OAGG;IACH,sCAOC;;CACJ;+BA/nB8B,0BAA0B;sCACnB,iCAAiC;wBAN/C,+BAA+B;oCASW,+BAA+B;iCADhE,4BAA4B"}
+{"version":3,"file":"AcousticSimulator.d.ts","sourceRoot":"","sources":["../../../../../src/engine/sound/simulation/AcousticSimulator.js"],"names":[],"mappings":"AA6CA;;;;;;;;;GASG;AACH;IACI;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;OAMG;IACH,gBAFU,OAAO,CAEM;IAEvB;;;;OAIG;IACH,eAFU,MAAM,CAEE;IA2FlB,6BAGC;IAZD;;;;OAIG;IACH,0BAEC;IAiBD,gCAEC;IAZD;;;;;OAKG;IACH,6BAEC;IAMD;;;;OAIG;IACH,2CAEC;IAED;;;;;;;OAOG;IACH,yEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAIlB;IAED;;;OAGG;IACH,6BAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAI/B;IAED;;OAEG;IACH,uBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8DAEC;IAED;;OAEG;IACH,iDAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;OAKG;IACH,qBAFW,qBAAmB,IAAI,QAMjC;IAED;;;;;;;;;;;;OAYG;IACH,mBAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SAEN,mBAAmB,OACnB,gBAAgB,QAkB1B;IAED;;;;;;OAMG;IACH,sBAHW,eAAe,YACf,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAyF5C;IAqPD;;;OAGG;IACH,sCAOC;;CACJ;+BAroB8B,0BAA0B;sCACnB,iCAAiC;oCAGL,+BAA+B;iCADhE,4BAA4B"}

package/src/engine/sound/simulation/AcousticSimulator.js

@@ -1,15 +1,18 @@
+import { assert } from "../../../core/assert.js";
+import {
+    line3_compute_segment_closest_point_t
+} from "../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
 import { BinaryElementPool } from "../../../core/geom/3d/topology/struct/binary/BinaryElementPool.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
 import { Vector3 } from "../../../core/geom/Vector3.js";
-import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { INVALID_NODE } from "../../../core/graph/csr/csr_graph_build_distance_field.js";
-import { line3_compute_segment_closest_point_t } from "../../../core/geom/3d/line/line3_compute_segment_closest_point_t.js";
-import { v3_length } from "../../../core/geom/vec3/v3_length.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { AcousticMedium } from "./core/AcousticMedium.js";
 import { AcousticOccluderIndex } from "./core/AcousticOccluderIndex.js";
 import { AcousticRegionIndex } from "./core/AcousticRegionIndex.js";
 import { AcousticSolution } from "./core/AcousticSolution.js";
 import { ACOUSTIC_SOURCE_STATE_FLOATS, AcousticSourceState } from "./core/AcousticSourceState.js";
-import { OcclusionSolver } from "./core/OcclusionSolver.js";
+import { acoustic_occlusion_solve } from "./core/acoustic_occlusion_solve.js";
 import { VolumeField } from "./core/VolumeField.js";
 import { ProbeFieldPathingSolution } from "./probe/ProbeFieldPathingSolution.js";
 import { ProbeVisibilityRecheck } from "./probe/ProbeVisibilityRecheck.js";
@@ -105,11 +108,6 @@ export class AcousticSimulator {
      */
     #volumeField = new VolumeField(AcousticMedium.from(DEFAULT_AIR_ABSORPTION));
 
-    /**
-     * @type {OcclusionSolver}
-     */
-    #occlusionSolver = new OcclusionSolver();
-
     /**
      * Live-instance → its temporal-state record id in {@link #statePool}. The state DATA lives in the
      * pool (flat floats); this map only holds the id relation. Audio events are highly transient (a
@@ -274,26 +272,30 @@ export class AcousticSimulator {
 
     /**
      * Compute the full acoustic solution for a source at `source`, given `listener`, into `out`.
-     * @param {Vector3} listener
-     * @param {Vector3} source
-     * @param {number} sourceRadius apparent radius of the source (per-source; 0 = point source). For
+     *
+     * Both positions are read BY INDEX rather than through `.x/.y/.z`: they are live views over
+     * {@link Transform64} buffers (plain `Float64Array`s, no component accessors). A {@link Vector3}
+     * is a `Float64Array` subclass whose `[0..2]` alias `x/y/z`, so indexing reads both shapes.
+     * @param {number[]|Float32Array|Float64Array} listener listener world position, 3 elements
+     * @param {number[]|Float32Array|Float64Array} source source world position, 3 elements
+     * @param {number} source_radius apparent radius of the source (per-source; 0 = point source). For
      *        volumetric (fractional) occlusion.
      * @param {AcousticSourceState} state per-source temporal accumulation (mutated)
      * @param {AcousticSolution} out
      */
-    solveFor(listener, source, sourceRadius, state, out) {
+    solveFor(listener, source, source_radius, state, out) {
         out.reset();
 
         // air absorption integrated over the actual source→listener path (distance-dependent, per band)
         this.#volumeField.integrateAbsorption(
             this.#region_index,
-            source.x, source.y, source.z,
-            listener.x, listener.y, listener.z,
+            source[0], source[1], source[2],
+            listener[0], listener[1], listener[2],
             out.airLoss
         );
 
-        this.#occlusionSolver.solve(
-            listener, source, sourceRadius,
+        acoustic_occlusion_solve(
+            listener, source, source_radius,
             this.#occluder_index, this.rayCount, this.smoothing, this.#random,
             state, out
         );
@@ -303,10 +305,12 @@ export class AcousticSimulator {
      * Solve + push the result to every live instance. Each instance must expose a `position` (Vector3)
      * and `setAcoustic(solution)`. Called once per frame by the `AudioEmitterSystem`, between the live-set
      * refresh and the sopra tick.
-     * @param {EventInstance[]} liveInstances bounded set (≤ voice budget)
-     * @param {Vector3} listener
+     * @param {EventInstance[]} live_instances bounded set (≤ voice budget)
+     * @param {number[]|Float32Array|Float64Array} listener listener world position, 3 elements
      */
-    apply(liveInstances, listener) {
+    apply(live_instances, listener) {
+        assert.defined(listener, 'listener');
+
         const live = this.#liveScratch;
         live.clear();
 
@@ -328,7 +332,7 @@ export class AcousticSimulator {
             }
             // Snap to the nearest probe the listener can SEE — never one occluded by a wall/floor (a different
             // acoustic region), which would route a spurious cross-occluder detour or none at all.
-            const listenerProbe = this.#probeField.nearestVisibleIndex(listener.x, listener.y, listener.z, this.#occluder_index);
+            const listenerProbe = this.#probeField.nearestVisibleIndex(listener[0], listener[1], listener[2], this.#occluder_index);
             if (listenerProbe >= 0) {
                 this.#pathingSolution.computeExitField(this.#probeField.visibilityGraph, listenerProbe);
                 exitFieldReady = true;
@@ -338,8 +342,8 @@ export class AcousticSimulator {
         const pool = this.#statePool;
         const cursor = this.#stateCursor;
 
-        for (let i = 0; i < liveInstances.length; i++) {
-            const instance = liveInstances[i];
+        for (let i = 0; i < live_instances.length; i++) {
+            const instance = live_instances[i];
 
             live.add(instance);
 
@@ -414,14 +418,18 @@ export class AcousticSimulator {
      * the first hop (the corner it leaks through), not the blocked listener.
      * @param {AcousticSolution} solution (occlusion already solved)
      * @param {EventInstance} instance the source (position + attenuation + orientation + directivity)
-     * @param {Vector3} listener the listener world position (the leak's far endpoint)
+     * @param {number[]|Float32Array|Float64Array} listener the listener world position (the leak's far endpoint)
      */
     #applyPath(solution, instance, listener) {
         const field = this.#probeField;
         const pathingSolution = this.#pathingSolution;
         const source = instance.position;
 
-        const sourceProbe = field.nearestVisibleIndex(source.x, source.y, source.z, this.#occluder_index);
+        // both endpoints are live Transform64 translation views (bare Float64Arrays) — read by index
+        const source_x = source[0], source_y = source[1], source_z = source[2];
+        const listener_x = listener[0], listener_y = listener[1], listener_z = listener[2];
+
+        const sourceProbe = field.nearestVisibleIndex(source_x, source_y, source_z, this.#occluder_index);
 
         if (sourceProbe < 0) {
             return;
@@ -450,14 +458,14 @@ export class AcousticSimulator {
         // to the probe vertex: (a) avoids the spurious there-and-back bend a probe sitting just past the
         // endpoint would fold into the route (the transfer gate would wrongly refuse it), and (b) lets the
         // attachment legs count toward the routed distance, so a standoff / oblique endpoint attenuates.
-        const tS = line3_compute_segment_closest_point_t(spx, spy, spz, fhx, fhy, fhz, source.x, source.y, source.z);
+        const tS = line3_compute_segment_closest_point_t(spx, spy, spz, fhx, fhy, fhz, source_x, source_y, source_z);
         const sX = spx + (fhx - spx) * tS, sY = spy + (fhy - spy) * tS, sZ = spz + (fhz - spz) * tS;
-        const sourceLeg = Math.hypot(source.x - sX, source.y - sY, source.z - sZ);
+        const sourceLeg = Math.hypot(source_x - sX, source_y - sY, source_z - sZ);
         const firstEdgeLen = Math.hypot(fhx - spx, fhy - spy, fhz - spz);
 
-        const tL = line3_compute_segment_closest_point_t(lhx, lhy, lhz, lpx, lpy, lpz, listener.x, listener.y, listener.z);
+        const tL = line3_compute_segment_closest_point_t(lhx, lhy, lhz, lpx, lpy, lpz, listener_x, listener_y, listener_z);
         const lX = lhx + (lpx - lhx) * tL, lY = lhy + (lpy - lhy) * tL, lZ = lhz + (lpz - lhz) * tL;
-        const listenerLeg = Math.hypot(listener.x - lX, listener.y - lY, listener.z - lZ);
+        const listenerLeg = Math.hypot(listener_x - lX, listener_y - lY, listener_z - lZ);
         const lastEdgeLen = Math.hypot(lpx - lhx, lpy - lhy, lpz - lhz);
 
         // Corridor span between the two virtual attach points. A SINGLE-edge route (firstHop IS the listener's
@@ -493,8 +501,8 @@ export class AcousticSimulator {
         // endpoint ON the corridor passes straight through (degenerate leg → gain 1), one off to the side or
         // behind it bends and attenuates. (Interior turns: Phase 0b.)
         if (field.hasTransfer) {
-            pathGain *= this.#turnGain(sourceProbe, sX - source.x, sY - source.y, sZ - source.z, fhx - spx, fhy - spy, fhz - spz);
-            pathGain *= this.#turnGain(listenerProbe, lpx - lhx, lpy - lhy, lpz - lhz, listener.x - lX, listener.y - lY, listener.z - lZ);
+            pathGain *= this.#turnGain(sourceProbe, sX - source_x, sY - source_y, sZ - source_z, fhx - spx, fhy - spy, fhz - spz);
+            pathGain *= this.#turnGain(listenerProbe, lpx - lhx, lpy - lhy, lpz - lhz, listener_x - lX, listener_y - lY, listener_z - lZ);
         }
 
         // Walk the leaked polyline (source-probe → … → listener-probe) once, now that the leak is audible:
@@ -599,9 +607,10 @@ export class AcousticSimulator {
     #directivityGainToward(instance, tx, ty, tz) {
         const source = instance.position;
 
-        let dx = tx - source.x;
-        let dy = ty - source.y;
-        let dz = tz - source.z;
+        // a live Transform64 translation view (a bare Float64Array) — read by index
+        let dx = tx - source[0];
+        let dy = ty - source[1];
+        let dz = tz - source[2];
 
         const len = v3_length(dx, dy, dz);
 
@@ -625,10 +634,10 @@ export class AcousticSimulator {
      * Fill `solution.directivityGain` — the source's radiation toward the LISTENER (the direct path).
      * @param {AcousticSolution} solution (occlusion already solved; `directivityGain` written)
      * @param {EventInstance} instance the source — position + orientation + directivity
-     * @param {Vector3} listener
+     * @param {number[]|Float32Array|Float64Array} listener listener world position, 3 elements
      */
     #applyDirectivity(solution, instance, listener) {
-        solution.directivityGain = this.#directivityGainToward(instance, listener.x, listener.y, listener.z);
+        solution.directivityGain = this.#directivityGainToward(instance, listener[0], listener[1], listener[2]);
     }
 
     /**

package/src/engine/sound/simulation/README.md

@@ -49,7 +49,7 @@ simulation/
     AcousticOccluderIndex.js      dynamic ray index — a TLAS BVH over OccluderBody shapes (exact shape.raycast)
     OccluderBody.js               one occluder: shape + material + world transform (+ cached inverse / AABB)
     RayHit.js                     reusable closest-hit result (caller-allocated): point + normal + t + material
-    OcclusionSolver.js            volumetric occlusion + transmission for one source (temporally smoothed)
+    acoustic_occlusion_solve.js   volumetric occlusion + transmission for one source (temporally smoothed)
     VolumeField.js                blends AcousticVolume regions into a medium at a point + integrates air
                                   absorption along the source→listener path (distance-dependent, per band)
     AcousticVolumeRegion.js       a shape + medium + transition band (boundary blend)
@@ -197,7 +197,7 @@ real-time-direct / baked-indirect split.
 
 ## The simulation, in one paragraph each
 
-**Occlusion + transmission.** For each live source, `OcclusionSolver` shoots `rayCount` rays from the
+**Occlusion + transmission.** For each live source, `acoustic_occlusion_solve` shoots `rayCount` rays from the
 listener toward points spread over the source's sphere (Fibonacci distribution, randomly re-oriented per
 tick). The fraction blocked is the occlusion; the blocked rays' material `transmission` (3 bands) is what
 leaks through. The result is folded into a temporal EMA, so a low ray count integrates over frames and

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

@@ -1 +1 @@
-{"version":3,"file":"OcclusionSolver.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/OcclusionSolver.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;;;OAUG;IACH,wDARW,MAAM,0CAEN,MAAM,aACN,MAAM,gBACK,MAAM,2DAyE3B;CACJ"}
+{"version":3,"file":"OcclusionSolver.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/OcclusionSolver.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH;IACI;;;;;;;;;;OAUG;IACH,wDARW,MAAM,0CAEN,MAAM,aACN,MAAM,gBACK,MAAM,2DA4F3B;CACJ"}

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

@@ -32,8 +32,8 @@ export class VolumeField {
      */
     sample(regionIndex: AcousticRegionIndex, x: number, y: number, z: number, out: AcousticMedium): void;
     /**
-     * Integrate per-band air absorption along the segment from the source `(sx, sy, sz)` to the listener
-     * `(lx, ly, lz)`, through the blended media, into `outLoss` (per-band **total dB** attenuation over the
+     * Integrate per-band air absorption along the segment from the source `(source_x, source_y, source_z)` to the listener
+     * `(listener_x, listener_y, listener_z)`, through the blended media, into `outLoss` (per-band **total dB** attenuation over the
      * path). Each `AcousticMedium.airAbsorption` is in dB per metre, so the line integral `∫ α ds` gives the
      * total dB lost per band — i.e. distance-dependent atmospheric absorption (highs accumulate loss faster,
      * so they die over distance while lows carry), plus extra loss along whatever painted region the path
@@ -44,15 +44,15 @@ export class VolumeField {
      * midpoints, blending the medium at each via {@link sample}. Allocation-free (module scratch).
      *
      * @param {AcousticRegionIndex} regionIndex
-     * @param {number} sx source position x
-     * @param {number} sy source position y
-     * @param {number} sz source position z
-     * @param {number} lx listener position x
-     * @param {number} ly listener position y
-     * @param {number} lz listener position z
+     * @param {number} source_x source position x
+     * @param {number} source_y source position y
+     * @param {number} source_z source position z
+     * @param {number} listener_x listener position x
+     * @param {number} listener_y listener position y
+     * @param {number} listener_z listener position z
      * @param {Float32Array} outLoss `[low, mid, high]` total dB attenuation over the path
      */
-    integrateAbsorption(regionIndex: AcousticRegionIndex, sx: number, sy: number, sz: number, lx: number, ly: number, lz: number, outLoss: Float32Array): void;
+    integrateAbsorption(regionIndex: AcousticRegionIndex, source_x: number, source_y: number, source_z: number, listener_x: number, listener_y: number, listener_z: number, outLoss: Float32Array): void;
     #private;
 }
 import { AcousticMedium } from "./AcousticMedium.js";

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

@@ -1 +1 @@
-{"version":3,"file":"VolumeField.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/VolumeField.js"],"names":[],"mappings":"AAaA;;;;;GAKG;AACH;IAMI;;OAEG;IACH,4BAFW,cAAc,EAIxB;IASD;;OAEG;IACH,uCAEC;IAZD;;OAEG;IACH,oCAEC;IASD;;;;;;;;;;;;OAYG;IACH,4CALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,cAAc,QA0BxB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,0DARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,YAAY,QA2CtB;;CACJ;+BApJ8B,qBAAqB"}
+{"version":3,"file":"VolumeField.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/VolumeField.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH;IAMI;;OAEG;IACH,4BAFW,cAAc,EAIxB;IASD;;OAEG;IACH,uCAEC;IAZD;;OAEG;IACH,oCAEC;IASD;;;;;;;;;;;;OAYG;IACH,4CALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,cAAc,QA0BxB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gEARW,MAAM,YACN,MAAM,YACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,WACN,YAAY,QA0DtB;;CACJ;+BAnK8B,qBAAqB"}

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

@@ -1,3 +1,4 @@
+import { assert } from "../../../../core/assert.js";
 import { AcousticMedium } from "./AcousticMedium.js";
 
 // Samples along a source→listener segment for the air-absorption line integral (midpoint rule). The
@@ -84,8 +85,8 @@ export class VolumeField {
     }
 
     /**
-     * Integrate per-band air absorption along the segment from the source `(sx, sy, sz)` to the listener
-     * `(lx, ly, lz)`, through the blended media, into `outLoss` (per-band **total dB** attenuation over the
+     * Integrate per-band air absorption along the segment from the source `(source_x, source_y, source_z)` to the listener
+     * `(listener_x, listener_y, listener_z)`, through the blended media, into `outLoss` (per-band **total dB** attenuation over the
      * path). Each `AcousticMedium.airAbsorption` is in dB per metre, so the line integral `∫ α ds` gives the
      * total dB lost per band — i.e. distance-dependent atmospheric absorption (highs accumulate loss faster,
      * so they die over distance while lows carry), plus extra loss along whatever painted region the path
@@ -96,18 +97,33 @@ export class VolumeField {
      * midpoints, blending the medium at each via {@link sample}. Allocation-free (module scratch).
      *
      * @param {AcousticRegionIndex} regionIndex
-     * @param {number} sx source position x
-     * @param {number} sy source position y
-     * @param {number} sz source position z
-     * @param {number} lx listener position x
-     * @param {number} ly listener position y
-     * @param {number} lz listener position z
+     * @param {number} source_x source position x
+     * @param {number} source_y source position y
+     * @param {number} source_z source position z
+     * @param {number} listener_x listener position x
+     * @param {number} listener_y listener position y
+     * @param {number} listener_z listener position z
      * @param {Float32Array} outLoss `[low, mid, high]` total dB attenuation over the path
      */
-    integrateAbsorption(regionIndex, sx, sy, sz, lx, ly, lz, outLoss) {
-        const dx = lx - sx;
-        const dy = ly - sy;
-        const dz = lz - sz;
+    integrateAbsorption(
+        regionIndex,
+        source_x, source_y, source_z,
+        listener_x, listener_y, listener_z,
+        outLoss
+    ) {
+
+        assert.isNumber(source_x, 'source_x');
+        assert.isNumber(source_y, 'source_y');
+        assert.isNumber(source_z, 'source_z');
+
+        assert.isNumber(listener_x, 'listener_x');
+        assert.isNumber(listener_y, 'listener_y');
+        assert.isNumber(listener_z, 'listener_z');
+
+        const dx = listener_x - source_x;
+        const dy = listener_y - source_y;
+        const dz = listener_z - source_z;
+
         const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
 
         if (distance === 0) {
@@ -134,7 +150,7 @@ export class VolumeField {
 
         for (let i = 0; i < AIR_INTEGRAL_SAMPLES; i++) {
             const t = (i + 0.5) / AIR_INTEGRAL_SAMPLES;
-            this.sample(regionIndex, sx + dx * t, sy + dy * t, sz + dz * t, STEP_MEDIUM);
+            this.sample(regionIndex, source_x + dx * t, source_y + dy * t, source_z + dz * t, STEP_MEDIUM);
 
             const air = STEP_MEDIUM.airAbsorption;
             low += air[0];

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

@@ -0,0 +1,31 @@
+/**
+ * Computes per-source occlusion + transmission by shooting rays from the listener toward points spread
+ * over the source's sphere and counting how many are blocked by the {@link AcousticOccluderIndex}.
+ *
+ * - Volumetric (not boolean): occlusion is the FRACTION of blocked rays, so partially-hidden sources
+ *   attenuate smoothly instead of popping on/off.
+ * - Transmission: blocked rays accumulate their occluder's per-band transmission; the average is the
+ *   energy that leaks through.
+ * - Temporal: the fibonacci sample set is randomly re-oriented each tick (seeded), and the result is
+ *   folded into an {@link AcousticSourceState} via EMA — so a low per-tick ray count integrates over
+ *   frames and the output stays frame-stable.
+ *
+ * Both positions are read BY INDEX, never as `.x/.y/.z`: production hands us live views over
+ * {@link Transform64} buffers (plain `Float64Array`s, which carry no component accessors), while a
+ * {@link Vector3} is itself a `Float64Array` subclass whose `[0..2]` alias `x/y/z`. Indexing is the one
+ * form that reads both.
+ *
+ * Pure: geometry in, numbers out. No WebAudio, no ECS, no allocation.
+ *
+ * @param {number[]|Float32Array|Float64Array} listener listener world position, 3 elements
+ * @param {number[]|Float32Array|Float64Array} source source world position, 3 elements
+ * @param {number} source_radius apparent radius of the source (0 = point source → boolean occlusion)
+ * @param {AcousticOccluderIndex} index
+ * @param {number} ray_count rays shot this tick (≥ 1)
+ * @param {number} smoothing EMA factor in (0, 1] — 1 = no smoothing
+ * @param {function():number} random seeded RNG; decorrelates the sample set per call
+ * @param {AcousticSourceState} state per-source temporal accumulation (mutated)
+ * @param {AcousticSolution} out occlusion + transmission written here (medium untouched)
+ */
+export function acoustic_occlusion_solve(listener: number[] | Float32Array | Float64Array, source: number[] | Float32Array | Float64Array, source_radius: number, index: AcousticOccluderIndex, ray_count: number, smoothing: number, random: () => number, state: AcousticSourceState, out: AcousticSolution): void;
+//# sourceMappingURL=acoustic_occlusion_solve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"acoustic_occlusion_solve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/acoustic_occlusion_solve.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,mDAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,2CAEN,MAAM,aACN,MAAM,gBACK,MAAM,2DA4F3B"}

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

@@ -0,0 +1,134 @@
+import { assert } from "../../../../core/assert.js";
+import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+import { sphere_fibonacci_point } from "../../../../core/geom/3d/sphere/sphere_fibonacci_point.js";
+import { random_orthonormal_basis } from "../../../../core/geom/random/random_orthonormal_basis.js";
+import { v3_matrix3_rotate } from "../../../../core/geom/vec3/v3_matrix3_rotate.js";
+import { RayHit } from "./RayHit.js";
+
+// module-static scratch — reused across calls so a solve allocates nothing. Typed throughout (the
+// vectors carry direction cosines / band ratios, so Float64 native precision is free here).
+const RAY = new Ray3();
+const HIT = new RayHit();
+const FIBONACCI = new Float64Array(3);
+const DIRECTION = new Float64Array(3);
+const ROTATION = new Float64Array(9);
+const TRANSMISSION = new Float64Array(3);
+
+/**
+ * Computes per-source occlusion + transmission by shooting rays from the listener toward points spread
+ * over the source's sphere and counting how many are blocked by the {@link AcousticOccluderIndex}.
+ *
+ * - Volumetric (not boolean): occlusion is the FRACTION of blocked rays, so partially-hidden sources
+ *   attenuate smoothly instead of popping on/off.
+ * - Transmission: blocked rays accumulate their occluder's per-band transmission; the average is the
+ *   energy that leaks through.
+ * - Temporal: the fibonacci sample set is randomly re-oriented each tick (seeded), and the result is
+ *   folded into an {@link AcousticSourceState} via EMA — so a low per-tick ray count integrates over
+ *   frames and the output stays frame-stable.
+ *
+ * Both positions are read BY INDEX, never as `.x/.y/.z`: production hands us live views over
+ * {@link Transform64} buffers (plain `Float64Array`s, which carry no component accessors), while a
+ * {@link Vector3} is itself a `Float64Array` subclass whose `[0..2]` alias `x/y/z`. Indexing is the one
+ * form that reads both.
+ *
+ * Pure: geometry in, numbers out. No WebAudio, no ECS, no allocation.
+ *
+ * @param {number[]|Float32Array|Float64Array} listener listener world position, 3 elements
+ * @param {number[]|Float32Array|Float64Array} source source world position, 3 elements
+ * @param {number} source_radius apparent radius of the source (0 = point source → boolean occlusion)
+ * @param {AcousticOccluderIndex} index
+ * @param {number} ray_count rays shot this tick (≥ 1)
+ * @param {number} smoothing EMA factor in (0, 1] — 1 = no smoothing
+ * @param {function():number} random seeded RNG; decorrelates the sample set per call
+ * @param {AcousticSourceState} state per-source temporal accumulation (mutated)
+ * @param {AcousticSolution} out occlusion + transmission written here (medium untouched)
+ */
+export function acoustic_occlusion_solve(
+    listener,
+    source,
+    source_radius,
+    index,
+    ray_count,
+    smoothing,
+    random,
+    state,
+    out
+) {
+
+    // a per-tick random orientation for the fibonacci set (decorrelation over frames)
+    random_orthonormal_basis(ROTATION, 0, random);
+
+    const listener_x = listener[0];
+    const listener_y = listener[1];
+    const listener_z = listener[2];
+
+    assert.isNumber(listener_x, 'listener_x');
+    assert.isNumber(listener_y, 'listener_y');
+    assert.isNumber(listener_z, 'listener_z');
+
+    const source_x = source[0];
+    const source_y = source[1];
+    const source_z = source[2];
+
+    assert.isNumber(source_x, 'source_x');
+    assert.isNumber(source_y, 'source_y');
+    assert.isNumber(source_z, 'source_z');
+
+    let blocked = 0;
+    let t0 = 0;
+    let t1 = 0;
+    let t2 = 0;
+
+    for (let i = 0; i < ray_count; i++) {
+        sphere_fibonacci_point(FIBONACCI, 0, i, ray_count);
+        v3_matrix3_rotate(DIRECTION, 0, FIBONACCI[0], FIBONACCI[1], FIBONACCI[2], ROTATION);
+
+        // a sample point spread over the source's sphere
+        const px = source_x + DIRECTION[0] * source_radius;
+        const py = source_y + DIRECTION[1] * source_radius;
+        const pz = source_z + DIRECTION[2] * source_radius;
+
+        const dx = px - listener_x;
+        const dy = py - listener_y;
+        const dz = pz - listener_z;
+
+        const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+        if (distance <= 1e-6) {
+            // listener sitting on the source — treat as unoccluded for this ray
+            continue;
+        }
+
+        const inv = 1 / distance;
+
+        RAY.setOrigin(listener_x, listener_y, listener_z);
+        RAY.setDirection(dx * inv, dy * inv, dz * inv);
+        RAY.tMax = distance;
+
+        if (index.closestHit(RAY, HIT)) {
+            blocked++;
+
+            const transmission = HIT.material.transmission;
+            t0 += transmission[0];
+            t1 += transmission[1];
+            t2 += transmission[2];
+        }
+    }
+
+    const occlusion = blocked / ray_count;
+
+    // instantaneous transmission = average blocker transmission; transparent when nothing blocked
+    if (blocked > 0) {
+        const inv = 1 / blocked;
+        TRANSMISSION[0] = t0 * inv;
+        TRANSMISSION[1] = t1 * inv;
+        TRANSMISSION[2] = t2 * inv;
+    } else {
+        TRANSMISSION[0] = 1;
+        TRANSMISSION[1] = 1;
+        TRANSMISSION[2] = 1;
+    }
+
+    state.integrate(occlusion, TRANSMISSION, smoothing);
+    state.writeTo(out);
+}

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

@@ -12,10 +12,6 @@ export class AcousticSimulationSystem extends System<any> {
      * @param {AcousticSimulator} simulator the shared simulation engine
      */
     constructor(simulator: AcousticSimulator);
-    /**
-     * @param {EntityManager} entityManager
-     */
-    startup(entityManager: EntityManager): void;
     dependencies: (typeof Transform64 | typeof Collider | typeof AcousticBody)[];
     /**
      * Per-entity records: { handle, transform, onMove }.

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

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

@@ -2,7 +2,7 @@ import { System } from "../../../ecs/System.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";
+import { TRANSFORM64_EVENT_CHANGE } from "../../../ecs/transform/TRANSFORM64_EVENT_CHANGE.js";
 
 /**
  * Feeds {@link AcousticBody} occluders into the shared {@link AcousticSimulator}, reactively. On link it
@@ -25,7 +25,7 @@ export class AcousticSimulationSystem extends System {
     /**
      * @param {EntityManager} entityManager
      */
-    startup(entityManager) {
+    async startup(entityManager) {
         this.entityManager = entityManager;
     }
 
@@ -63,17 +63,11 @@ export class AcousticSimulationSystem extends System {
 
         const onMove = () => this.simulator.setOccluderTransform(handle, transform.matrix);
 
-        const on_transform_changed = event => {
-            if (event.klass === Transform64) {
-                onMove();
-            }
-        };
-
         this.entityManager.dataset.addEntityEventListener(
-            entity, EventType.ComponentChanged, on_transform_changed
+            entity, TRANSFORM64_EVENT_CHANGE, onMove
         );
 
-        this.data[entity] = { handle, transform, onMove, on_transform_changed };
+        this.data[entity] = { handle, transform, onMove };
     }
 
     /**
@@ -92,7 +86,7 @@ export class AcousticSimulationSystem extends System {
         delete this.data[entity];
 
         this.entityManager.dataset.removeEntityEventListener(
-            entity, EventType.ComponentChanged, record.on_transform_changed
+            entity, TRANSFORM64_EVENT_CHANGE, record.onMove
         );
 
         this.simulator.removeOccluder(record.handle);