@woosh/meep-engine 3.55.0 → 3.57.0

package/src/engine/sound/simulation/probe/AcousticProbeField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticProbeField.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/AcousticProbeField.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAmDI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAwBD;;;;;;;;;OASG;IACH,wBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB;IAED;;;;;;;;OAQG;IACH,2BALW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,gCAHW,MAAM,cACN,YAAY,GAAC,MAAM,EAAE,QAS/B;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,cAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,QACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAS/B;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,uBANW,MAAM,KACN,MAAM,KACN,MAAM,yCAEJ,MAAM,CAyBlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,2BARW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAe/B;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAkB/B;IAmCD;;;;;;OAMG;IACH,0CAEC;IAED;;;;;;OAMG;IACH,kBAHW,WAAW,QACX,YAAY,QAKtB;IAED;;;;;;;;;;;;OAYG;IACH,mBATW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QAQhB;IAED;;;;;;;OAOG;IACH,mBAJW,MAAM,MACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAQzB;IAED;;;;;;;;MA0BC;IAED;;;;OAIG;IACH,eAFW;QAAC,MAAM,EAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,WAAW,EAAC,MAAM,EAAE,CAAC;YAAA,eAAe,EAAC,MAAM,EAAE,CAAA;SAAC,EAAE,CAAA;KAAC,QAoB/F;;CACJ"}
+{"version":3,"file":"AcousticProbeField.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/AcousticProbeField.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAmDI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAwBD;;;;;;;;;OASG;IACH,wBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB;IAED;;;;;;;;OAQG;IACH,2BALW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,gCAHW,MAAM,cACN,YAAY,GAAC,MAAM,EAAE,QAS/B;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,cAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,QACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAS/B;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,uBANW,MAAM,KACN,MAAM,KACN,MAAM,yCAEJ,MAAM,CAelB;IAED;;;;;;;;;;;;;;;OAeG;IACH,2BARW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAe/B;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAkB/B;IAmCD;;;;;;OAMG;IACH,0CAEC;IAED;;;;;;OAMG;IACH,kBAHW,WAAW,QACX,YAAY,QAKtB;IAED;;;;;;;;;;;;OAYG;IACH,mBATW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QAQhB;IAED;;;;;;;OAOG;IACH,mBAJW,MAAM,MACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAQzB;IAED;;;;;;;;MA0BC;IAED;;;;OAIG;IACH,eAFW;QAAC,MAAM,EAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,WAAW,EAAC,MAAM,EAAE,CAAC;YAAA,eAAe,EAAC,MAAM,EAAE,CAAA;SAAC,EAAE,CAAA;KAAC,QAoB/F;;CACJ"}

package/src/engine/sound/simulation/probe/AcousticProbeField.js

@@ -8,7 +8,7 @@ import {
 import {
     bvh_query_user_data_nearest_to_point_filtered
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_nearest_to_point_filtered.js";
-import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+import { probe_segment_visible } from "./probe_edge_visible.js";
 import { csr_graph_find_shortest_path } from "../../../../core/graph/csr/csr_graph_find_shortest_path.js";
 import { acoustic_probe_transfer, LOBE_STRIDE } from "./acoustic_probe_transfer.js";
 
@@ -30,9 +30,6 @@ const DEFAULT_CAPACITY = 8;
 // module scratch for a point-leaf AABB during BVH build
 const LEAF_BOUNDS = new Float32Array(6);
 
-// module scratch — the query→probe line-of-sight ray for nearestVisibleIndex
-const VISIBILITY_RAY = new Ray3();
-
 /**
  * The baked probe volume: the set of acoustic probes covering a scene, plus the connectivity between them.
  * Carries everything an offline bake produces about the field and everything the runtime reads back from
@@ -327,21 +324,11 @@ export class AcousticProbeField {
 
         return bvh_query_user_data_nearest_to_point_filtered(this.#bvh, x, y, z, (probeIndex) => {
             const base = probeIndex * STRIDE;
-            const dx = data[base + OFFSET_X] - x;
-            const dy = data[base + OFFSET_Y] - y;
-            const dz = data[base + OFFSET_Z] - z;
-
-            const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
-            if (d === 0) {
-                return true; // the query point coincides with the probe — trivially visible
-            }
-
-            const inv = 1 / d;
-            VISIBILITY_RAY.setOrigin(x, y, z);
-            VISIBILITY_RAY.setDirection(dx * inv, dy * inv, dz * inv);
-            VISIBILITY_RAY.tMax = d;
-
-            return !occluderIndex.anyHit(VISIBILITY_RAY);
+            return probe_segment_visible(
+                occluderIndex,
+                x, y, z,
+                data[base + OFFSET_X], data[base + OFFSET_Y], data[base + OFFSET_Z]
+            );
         });
     }
 

package/src/engine/sound/simulation/probe/probe_edge_visible.d.ts

@@ -1,3 +1,18 @@
+/**
+ * Whether points `(ax, ay, az)` and `(bx, by, bz)` have clear line of sight in `index` — a single shadow ray
+ * along the segment between them, true if no occluder blocks it. Coincident points are trivially visible.
+ * Allocation-free; no WebAudio.
+ *
+ * @param {AcousticOccluderIndex} index
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @returns {boolean}
+ */
+export function probe_segment_visible(index: AcousticOccluderIndex, ax: number, ay: number, az: number, bx: number, by: number, bz: number): boolean;
 /**
  * Whether probes `a` and `b` have clear line of sight in the current `index` — a single shadow ray along the
  * segment between them, true if no occluder blocks it. This is the one visibility test shared by the offline

package/src/engine/sound/simulation/probe/probe_edge_visible.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_edge_visible.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_edge_visible.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,oGAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAuBnB"}
+{"version":3,"file":"probe_edge_visible.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_edge_visible.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,wEARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmBnB;AAED;;;;;;;;;;;;;GAaG;AACH,oGAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAQnB"}

package/src/engine/sound/simulation/probe/probe_edge_visible.js

@@ -1,41 +1,59 @@
-import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
-
-// module-static scratch — the shadow ray between two probes (allocation-free)
-const RAY = new Ray3();
-
-/**
- * Whether probes `a` and `b` have clear line of sight in the current `index` — a single shadow ray along the
- * segment between them, true if no occluder blocks it. This is the one visibility test shared by the offline
- * bake ({@link bakeVisibility}) and the runtime {@link ProbeVisibilityRecheck}, so they agree exactly.
- * Coincident probes are trivially "visible" (a zero-length segment blocks nothing). Allocation-free; no
- * WebAudio.
- *
- * @param {AcousticProbeField} probeField
- * @param {AcousticOccluderIndex} index the acoustic scene (live geometry — a door that has since closed will
- *        block the ray even though the baked graph still has the edge)
- * @param {number} a probe index
- * @param {number} b probe index
- * @returns {boolean}
- */
-export function probe_edge_visible(probeField, index, a, b) {
-    const ax = probeField.probeX(a);
-    const ay = probeField.probeY(a);
-    const az = probeField.probeZ(a);
-
-    const dx = probeField.probeX(b) - ax;
-    const dy = probeField.probeY(b) - ay;
-    const dz = probeField.probeZ(b) - az;
-
-    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
-
-    if (distance === 0) {
-        return true;
-    }
-
-    const inv = 1 / distance;
-    RAY.setOrigin(ax, ay, az);
-    RAY.setDirection(dx * inv, dy * inv, dz * inv);
-    RAY.tMax = distance;
-
-    return !index.anyHit(RAY);
-}
+import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
+
+// module-static scratch — the shadow ray between two points (allocation-free)
+const RAY = new Ray3();
+
+/**
+ * Whether points `(ax, ay, az)` and `(bx, by, bz)` have clear line of sight in `index` — a single shadow ray
+ * along the segment between them, true if no occluder blocks it. Coincident points are trivially visible.
+ * Allocation-free; no WebAudio.
+ *
+ * @param {AcousticOccluderIndex} index
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @returns {boolean}
+ */
+export function probe_segment_visible(index, ax, ay, az, bx, by, bz) {
+    const dx = bx - ax;
+    const dy = by - ay;
+    const dz = bz - az;
+
+    const distance = Math.sqrt(dx * dx + dy * dy + dz * dz);
+
+    if (distance === 0) {
+        return true;
+    }
+
+    const inv = 1 / distance;
+    RAY.setOrigin(ax, ay, az);
+    RAY.setDirection(dx * inv, dy * inv, dz * inv);
+    RAY.tMax = distance;
+
+    return !index.anyHit(RAY);
+}
+
+/**
+ * Whether probes `a` and `b` have clear line of sight in the current `index` — a single shadow ray along the
+ * segment between them, true if no occluder blocks it. This is the one visibility test shared by the offline
+ * bake ({@link bakeVisibility}) and the runtime {@link ProbeVisibilityRecheck}, so they agree exactly.
+ * Coincident probes are trivially "visible" (a zero-length segment blocks nothing). Allocation-free; no
+ * WebAudio.
+ *
+ * @param {AcousticProbeField} probeField
+ * @param {AcousticOccluderIndex} index the acoustic scene (live geometry — a door that has since closed will
+ *        block the ray even though the baked graph still has the edge)
+ * @param {number} a probe index
+ * @param {number} b probe index
+ * @returns {boolean}
+ */
+export function probe_edge_visible(probeField, index, a, b) {
+    return probe_segment_visible(
+        index,
+        probeField.probeX(a), probeField.probeY(a), probeField.probeZ(a),
+        probeField.probeX(b), probeField.probeY(b), probeField.probeZ(b)
+    );
+}

package/src/engine/sound/simulation/probe/probe_refine_connectivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probe_refine_connectivity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_refine_connectivity.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+GAJW,MAAM,YACN;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAC,GACtD,MAAM,EAAE,CAiDpB"}
+{"version":3,"file":"probe_refine_connectivity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_refine_connectivity.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+GAJW,MAAM,YACN;IAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAC,GACtD,MAAM,EAAE,CAiDpB"}

package/src/engine/sound/simulation/probe/probe_refine_connectivity.js

@@ -1,181 +1,164 @@
-import { uf_find, uf_init, uf_union } from "../../../../core/collection/union-find/union_find.js";
-import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
-import { sphere_fibonacci_point } from "../../../../core/geom/3d/sphere/sphere_fibonacci_point.js";
-
-// Connectivity refinement may place probes finer than the spacing hint, down to minSpacing / this factor.
-const DEFAULT_MAX_REFINE_FACTOR = 4;
-// Two components are candidates to thread only if probes come within this multiple of minSpacing — beyond it
-// we assume they're genuinely sealed (a closed wall, not a bend). Also the SDF / waypoint search radius.
-const DEFAULT_CORRIDOR_REACH_FACTOR = 4;
-// Per-step waypoint search: directions on a Fibonacci sphere × these fractions of the segment length.
-const SAMPLE_DIRECTIONS = 24;
-const SAMPLE_RADII = [0.5, 0.25, 0.125];
-// Bound the greedy walk so a hopeless gap can't recurse forever.
-const MAX_THREAD_DEPTH = 12;
-
-// module-static scratch
-const RAY = new Ray3();
-const DIR = [0, 0, 0];
-
-/**
- * Connectivity refinement — the acoustic stage the reference GI placer lacks. After the SDF cover + a
- * provisional {@link bakeVisibility}, the graph may have islands a bend/throat separates even though sound
- * routes between them: `bakeVisibility` only links probes with STRAIGHT line of sight, so a corridor that
- * bends sharper than the cover's spacing leaves its two ends in different components. This inserts the
- * minimum extra probes so a chain of mutually-visible probes spans every such path — "ray bounces between
- * probes", as a bounded greedy walk through open air.
- *
- * For each pair of nearby components (within `corridorReachFactor · minSpacing`), it walks from one side
- * toward the other: at each step it samples open-air waypoints around the segment (a Fibonacci sphere × a
- * few radii), keeps those visible from the current point, and steps to the one nearest the target — until a
- * waypoint sees the target (chain complete) or no progress is possible (give up — a genuinely sealed wall
- * stays disconnected, correctly). It never subdivides below `minSpacing / maxRefineFactor`. The waypoints
- * are returned for the caller to append; the FINAL `bakeVisibility` then links them.
- *
- * @param {AcousticOccluderIndex} index the acoustic scene
- * @param {AcousticProbeField} field cover probes WITH a baked visibility graph (defines the components)
- * @param {number} minSpacing the placement spacing hint
- * @param {{maxRefineFactor?: number, corridorReachFactor?: number}} [options]
- * @returns {number[]} flat extra probe positions `[x,y,z, …]` (possibly empty)
- */
-export function probe_refine_connectivity(index, field, minSpacing, options = {}) {
-    const maxRefineFactor = options.maxRefineFactor ?? DEFAULT_MAX_REFINE_FACTOR;
-    const reach = (options.corridorReachFactor ?? DEFAULT_CORRIDOR_REACH_FACTOR) * minSpacing;
-    const floor = minSpacing / maxRefineFactor;
-
-    const n = field.size;
-    const graph = field.visibilityGraph;
-
-    // connected components of the provisional visibility graph
-    const parent = new Uint32Array(n);
-    uf_init(parent, n);
-    for (let v = 0; v < n; v++) {
-        for (let k = graph.edge_addresses[v]; k < graph.edge_addresses[v + 1]; k++) {
-            uf_union(parent, v, graph.adjacency[k]);
-        }
-    }
-
-    const waypoints = [];
-    const hits = [];
-
-    for (let i = 0; i < n; i++) {
-        const ix = field.probeX(i), iy = field.probeY(i), iz = field.probeZ(i);
-
-        const count = field.probesWithinRadius(hits, 0, ix, iy, iz, reach);
-
-        for (let h = 0; h < count; h++) {
-            const j = hits[h];
-            if (j <= i) {
-                continue;
-            }
-            // re-read roots each time — an earlier successful thread may have merged these components, directly
-            // or transitively (so we don't thread a redundant chain across 3+ mutually-near components)
-            if (uf_find(parent, i) === uf_find(parent, j)) {
-                continue;
-            }
-
-            const chain = thread(index, ix, iy, iz, field.probeX(j), field.probeY(j), field.probeZ(j), floor, reach, 0);
-            if (chain !== null) {
-                uf_union(parent, i, j); // merge → later pairs across these now-connected components are skipped
-                for (let w = 0; w < chain.length; w++) {
-                    waypoints.push(chain[w]);
-                }
-            }
-        }
-    }
-
-    return waypoints;
-}
-
-/**
- * Greedily walk from (ax,ay,az) toward (bx,by,bz) through open air, inserting waypoints, until a waypoint
- * sees the target. Returns the flat waypoint list `[x,y,z, …]`, or `null` if no open chain was found.
- */
-function thread(index, ax, ay, az, bx, by, bz, floor, reach, depth) {
-    if (segment_clear(index, ax, ay, az, bx, by, bz)) {
-        return []; // already mutually visible
-    }
-    if (depth >= MAX_THREAD_DEPTH) {
-        return null;
-    }
-
-    const w = open_waypoint_toward_target(index, ax, ay, az, bx, by, bz, reach);
-    if (w === null) {
-        return null; // no visible open point makes progress → sealed
-    }
-
-    const dx = w[0] - ax, dy = w[1] - ay, dz = w[2] - az;
-    if (Math.sqrt(dx * dx + dy * dy + dz * dz) < floor) {
-        return null; // would need probes finer than the refine floor
-    }
-
-    const rest = thread(index, w[0], w[1], w[2], bx, by, bz, floor, reach, depth + 1);
-    if (rest === null) {
-        return null;
-    }
-
-    return [w[0], w[1], w[2], ...rest];
-}
-
-/**
- * Among open-air points sampled around the (a→b) segment that are VISIBLE from `a`, return the one nearest
- * `b` that makes progress (closer to `b` than `a` is), or `null`. Sampled on a Fibonacci sphere around the
- * segment midpoint at a few fractions of the segment length, so both perpendicular detours (over a baffle)
- * and along-segment steps are covered.
- * @returns {number[]|null} `[x,y,z]` or null
- */
-function open_waypoint_toward_target(index, ax, ay, az, bx, by, bz, reach) {
-    const mx = (ax + bx) * 0.5, my = (ay + by) * 0.5, mz = (az + bz) * 0.5;
-    const segLen = Math.sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay) + (bz - az) * (bz - az));
-
-    let best = null;
-    // must improve on a's own distance to b (strict progress → the walk terminates)
-    let bestDistB = Math.sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay) + (bz - az) * (bz - az));
-
-    for (let d = 0; d < SAMPLE_DIRECTIONS; d++) {
-        sphere_fibonacci_point(DIR, 0, d, SAMPLE_DIRECTIONS);
-
-        for (let r = 0; r < SAMPLE_RADII.length; r++) {
-            const radius = segLen * SAMPLE_RADII[r];
-            const sx = mx + DIR[0] * radius;
-            const sy = my + DIR[1] * radius;
-            const sz = mz + DIR[2] * radius;
-
-            // must be in open air (clearance > a small margin so the reverb bake + visibility are valid)
-            if (index.signedDistanceAt(sx, sy, sz, reach) <= 1e-3) {
-                continue;
-            }
-
-            const distB = Math.sqrt((bx - sx) * (bx - sx) + (by - sy) * (by - sy) + (bz - sz) * (bz - sz));
-            if (distB >= bestDistB) {
-                continue; // no progress toward b
-            }
-
-            if (!segment_clear(index, ax, ay, az, sx, sy, sz)) {
-                continue; // a can't see this waypoint
-            }
-
-            bestDistB = distB;
-            best = best === null ? [sx, sy, sz] : best;
-            best[0] = sx; best[1] = sy; best[2] = sz;
-        }
-    }
-
-    return best;
-}
-
-/** Whether the open segment a→b is clear of occluders (one shadow ray; mirrors probe_edge_visible). */
-function segment_clear(index, ax, ay, az, bx, by, bz) {
-    const dx = bx - ax, dy = by - ay, dz = bz - az;
-    const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
-    if (d === 0) {
-        return true;
-    }
-
-    const inv = 1 / d;
-    RAY.setOrigin(ax, ay, az);
-    RAY.setDirection(dx * inv, dy * inv, dz * inv);
-    RAY.tMax = d;
-
-    return !index.anyHit(RAY);
-}
+import { uf_find, uf_init, uf_union } from "../../../../core/collection/union-find/union_find.js";
+import { sphere_fibonacci_point } from "../../../../core/geom/3d/sphere/sphere_fibonacci_point.js";
+import { probe_segment_visible } from "./probe_edge_visible.js";
+
+// Connectivity refinement may place probes finer than the spacing hint, down to minSpacing / this factor.
+const DEFAULT_MAX_REFINE_FACTOR = 4;
+// Two components are candidates to thread only if probes come within this multiple of minSpacing — beyond it
+// we assume they're genuinely sealed (a closed wall, not a bend). Also the SDF / waypoint search radius.
+const DEFAULT_CORRIDOR_REACH_FACTOR = 4;
+// Per-step waypoint search: directions on a Fibonacci sphere × these fractions of the segment length.
+const SAMPLE_DIRECTIONS = 24;
+const SAMPLE_RADII = [0.5, 0.25, 0.125];
+// Bound the greedy walk so a hopeless gap can't recurse forever.
+const MAX_THREAD_DEPTH = 12;
+
+// module-static scratch
+const DIR = [0, 0, 0];
+
+/**
+ * Connectivity refinement — the acoustic stage the reference GI placer lacks. After the SDF cover + a
+ * provisional {@link bakeVisibility}, the graph may have islands a bend/throat separates even though sound
+ * routes between them: `bakeVisibility` only links probes with STRAIGHT line of sight, so a corridor that
+ * bends sharper than the cover's spacing leaves its two ends in different components. This inserts the
+ * minimum extra probes so a chain of mutually-visible probes spans every such path — "ray bounces between
+ * probes", as a bounded greedy walk through open air.
+ *
+ * For each pair of nearby components (within `corridorReachFactor · minSpacing`), it walks from one side
+ * toward the other: at each step it samples open-air waypoints around the segment (a Fibonacci sphere × a
+ * few radii), keeps those visible from the current point, and steps to the one nearest the target — until a
+ * waypoint sees the target (chain complete) or no progress is possible (give up — a genuinely sealed wall
+ * stays disconnected, correctly). It never subdivides below `minSpacing / maxRefineFactor`. The waypoints
+ * are returned for the caller to append; the FINAL `bakeVisibility` then links them.
+ *
+ * @param {AcousticOccluderIndex} index the acoustic scene
+ * @param {AcousticProbeField} field cover probes WITH a baked visibility graph (defines the components)
+ * @param {number} minSpacing the placement spacing hint
+ * @param {{maxRefineFactor?: number, corridorReachFactor?: number}} [options]
+ * @returns {number[]} flat extra probe positions `[x,y,z, …]` (possibly empty)
+ */
+export function probe_refine_connectivity(index, field, minSpacing, options = {}) {
+    const maxRefineFactor = options.maxRefineFactor ?? DEFAULT_MAX_REFINE_FACTOR;
+    const reach = (options.corridorReachFactor ?? DEFAULT_CORRIDOR_REACH_FACTOR) * minSpacing;
+    const floor = minSpacing / maxRefineFactor;
+
+    const n = field.size;
+    const graph = field.visibilityGraph;
+
+    // connected components of the provisional visibility graph
+    const parent = new Uint32Array(n);
+    uf_init(parent, n);
+    for (let v = 0; v < n; v++) {
+        for (let k = graph.edge_addresses[v]; k < graph.edge_addresses[v + 1]; k++) {
+            uf_union(parent, v, graph.adjacency[k]);
+        }
+    }
+
+    const waypoints = [];
+    const hits = [];
+
+    for (let i = 0; i < n; i++) {
+        const ix = field.probeX(i), iy = field.probeY(i), iz = field.probeZ(i);
+
+        const count = field.probesWithinRadius(hits, 0, ix, iy, iz, reach);
+
+        for (let h = 0; h < count; h++) {
+            const j = hits[h];
+            if (j <= i) {
+                continue;
+            }
+            // re-read roots each time — an earlier successful thread may have merged these components, directly
+            // or transitively (so we don't thread a redundant chain across 3+ mutually-near components)
+            if (uf_find(parent, i) === uf_find(parent, j)) {
+                continue;
+            }
+
+            const chain = thread(index, ix, iy, iz, field.probeX(j), field.probeY(j), field.probeZ(j), floor, reach, 0);
+            if (chain !== null) {
+                uf_union(parent, i, j); // merge → later pairs across these now-connected components are skipped
+                for (let w = 0; w < chain.length; w++) {
+                    waypoints.push(chain[w]);
+                }
+            }
+        }
+    }
+
+    return waypoints;
+}
+
+/**
+ * Greedily walk from (ax,ay,az) toward (bx,by,bz) through open air, inserting waypoints, until a waypoint
+ * sees the target. Returns the flat waypoint list `[x,y,z, …]`, or `null` if no open chain was found.
+ */
+function thread(index, ax, ay, az, bx, by, bz, floor, reach, depth) {
+    if (probe_segment_visible(index, ax, ay, az, bx, by, bz)) {
+        return []; // already mutually visible
+    }
+    if (depth >= MAX_THREAD_DEPTH) {
+        return null;
+    }
+
+    const w = open_waypoint_toward_target(index, ax, ay, az, bx, by, bz, reach);
+    if (w === null) {
+        return null; // no visible open point makes progress → sealed
+    }
+
+    const dx = w[0] - ax, dy = w[1] - ay, dz = w[2] - az;
+    if (Math.sqrt(dx * dx + dy * dy + dz * dz) < floor) {
+        return null; // would need probes finer than the refine floor
+    }
+
+    const rest = thread(index, w[0], w[1], w[2], bx, by, bz, floor, reach, depth + 1);
+    if (rest === null) {
+        return null;
+    }
+
+    return [w[0], w[1], w[2], ...rest];
+}
+
+/**
+ * Among open-air points sampled around the (a→b) segment that are VISIBLE from `a`, return the one nearest
+ * `b` that makes progress (closer to `b` than `a` is), or `null`. Sampled on a Fibonacci sphere around the
+ * segment midpoint at a few fractions of the segment length, so both perpendicular detours (over a baffle)
+ * and along-segment steps are covered.
+ * @returns {number[]|null} `[x,y,z]` or null
+ */
+function open_waypoint_toward_target(index, ax, ay, az, bx, by, bz, reach) {
+    const mx = (ax + bx) * 0.5, my = (ay + by) * 0.5, mz = (az + bz) * 0.5;
+    const segLen = Math.sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay) + (bz - az) * (bz - az));
+
+    let best = null;
+    // must improve on a's own distance to b (strict progress → the walk terminates)
+    let bestDistB = Math.sqrt((bx - ax) * (bx - ax) + (by - ay) * (by - ay) + (bz - az) * (bz - az));
+
+    for (let d = 0; d < SAMPLE_DIRECTIONS; d++) {
+        sphere_fibonacci_point(DIR, 0, d, SAMPLE_DIRECTIONS);
+
+        for (let r = 0; r < SAMPLE_RADII.length; r++) {
+            const radius = segLen * SAMPLE_RADII[r];
+            const sx = mx + DIR[0] * radius;
+            const sy = my + DIR[1] * radius;
+            const sz = mz + DIR[2] * radius;
+
+            // must be in open air (clearance > a small margin so the reverb bake + visibility are valid)
+            if (index.signedDistanceAt(sx, sy, sz, reach) <= 1e-3) {
+                continue;
+            }
+
+            const distB = Math.sqrt((bx - sx) * (bx - sx) + (by - sy) * (by - sy) + (bz - sz) * (bz - sz));
+            if (distB >= bestDistB) {
+                continue; // no progress toward b
+            }
+
+            if (!probe_segment_visible(index, ax, ay, az, sx, sy, sz)) {
+                continue; // a can't see this waypoint
+            }
+
+            bestDistB = distB;
+            best = best === null ? [sx, sy, sz] : best;
+            best[0] = sx; best[1] = sy; best[2] = sz;
+        }
+    }
+
+    return best;
+}

package/src/engine/sound/simulation/render/FoaProbeReverbRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FoaProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/FoaProbeReverbRenderer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA0MI;;;OAGG;IACH,2BAHW,gBAAgB,eAChB,SAAS,EAkEnB;IA7QD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAEhB;;;;;;;;;;;OAWG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;;;;OAYG;IACH,iBAFU,MAAM,CAEI;IAgBpB,6BAUC;IAxBD;;;;;;;;;OASG;IACH,wBAEC;IAoND;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,oDAeC;IAED;;;;;;;;;OASG;IACH,UALW,MAAM,KACN,MAAM,KACN,MAAM,eACN;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAsB/C;;CA+FJ"}
+{"version":3,"file":"FoaProbeReverbRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/render/FoaProbeReverbRenderer.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA2MI;;;OAGG;IACH,2BAHW,gBAAgB,eAChB,SAAS,EAkEnB;IA9QD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,UAFU,MAAM,CAEA;IAEhB;;;;;;;;;;;OAWG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;;;;OAYG;IACH,iBAFU,MAAM,CAEI;IAgBpB,6BAUC;IAxBD;;;;;;;;;OASG;IACH,wBAEC;IAqND;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAEC;IAED;;OAEG;IACH,oDAeC;IAED;;;;;;;;;OASG;IACH,UALW,MAAM,KACN,MAAM,KACN,MAAM,eACN;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAsB/C;;CA6GJ"}

package/src/engine/sound/simulation/render/FoaProbeReverbRenderer.js

@@ -135,7 +135,8 @@ export class FoaProbeReverbRenderer {
      * @private
      * @type {Float64Array}
      */
-    #currentBands = new Float64Array([NaN, NaN, NaN]);
+    #currentBands = new Float64Array([NaN, NaN, NaN]);
+    #currentDirs = new Float64Array([NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN, NaN]);
 
     /**
      * Whether the baked IR is audible, i.e. whether the last crossfade went to the send level or to
@@ -408,10 +409,23 @@ export class FoaProbeReverbRenderer {
                 dirs[band * 3 + 2] = this.#tmpDir[2];
             }
 
-            audible = Math.max(bands[0], bands[1], bands[2]) >= this.minDecay;
+            audible = Math.max(bands[0], bands[1], bands[2]) >= this.minDecay;
+        } else {
+            bands[0] = 0;
+            bands[1] = 0;
+            bands[2] = 0;
+            dirs.fill(0);
         }
 
-        const current = this.#currentBands;
+        const current = this.#currentBands;
+        const currentDirs = this.#currentDirs;
+        let dirsClose = true;
+        for (let k = 0; k < 9; k++) {
+            if (!(Math.abs(dirs[k] - currentDirs[k]) < this.changeThreshold)) {
+                dirsClose = false;
+                break;
+            }
+        }
 
         const bandsClose = Math.abs(bands[0] - current[0]) < this.changeThreshold
             && Math.abs(bands[1] - current[1]) < this.changeThreshold
@@ -423,13 +437,14 @@ export class FoaProbeReverbRenderer {
          crossing smaller than `changeThreshold` (0.1 > 0.05) and leave the reverb stuck on or off
          across that boundary — the same reasoning as ProbeReverbRenderer#setBands.
         */
-        if (bandsClose && audible === this.#currentlyAudible) {
+        if (bandsClose && (!audible || dirsClose) && audible === this.#currentlyAudible) {
             return;
         }
 
         current[0] = bands[0];
         current[1] = bands[1];
-        current[2] = bands[2];
+        current[2] = bands[2];
+        currentDirs.set(dirs);
         this.#currentlyAudible = audible;
 
         const inactive = 1 - this.#active;