@woosh/meep-engine 2.169.0 → 2.169.2

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

@@ -3,6 +3,7 @@ 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 { AcousticMedium } from "./core/AcousticMedium.js";
 import { AcousticOccluderIndex } from "./core/AcousticOccluderIndex.js";
 import { AcousticRegionIndex } from "./core/AcousticRegionIndex.js";
@@ -602,7 +603,7 @@ export class AcousticSimulator {
         let dy = ty - source.y;
         let dz = tz - source.z;
 
-        const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+        const len = v3_length(dx, dy, dz);
 
         if (len === 0) {
             return 1; // target at the source — radiation direction undefined

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

@@ -1 +1 @@
-{"version":3,"file":"AcousticOccluderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticOccluderIndex.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IA0BI;;;;;;OAMG;IACH,qEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAelB;IAED;;;;OAIG;IACH,qBAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAO/B;IAgBD;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,gBAJW,IAAI,gBAEF,OAAO,CA6CnB;IAED;;;;;OAKG;IACH,YAHW,IAAI,GACF,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAPW,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GAEJ,MAAM,CA4BlB;IAED;;;;;;OAMG;IACH,wBAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CA6BlB;;CAmCJ;qBAlToB,sCAAsC"}
+{"version":3,"file":"AcousticOccluderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticOccluderIndex.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IA0BI;;;;;;OAMG;IACH,qEAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CAelB;IAED;;;;OAIG;IACH,qBAHW,MAAM,UACN,YAAY,GAAC,MAAM,EAAE,QAO/B;IAgBD;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,gBAJW,IAAI,gBAEF,OAAO,CA6CnB;IAED;;;;;OAKG;IACH,YAHW,IAAI,GACF,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAPW,MAAM,KACN,MAAM,KACN,MAAM,gBACN,MAAM,GAEJ,MAAM,CA4BlB;IAED;;;;;;OAMG;IACH,wBAHW,YAAY,GAAC,MAAM,EAAE,GACnB,MAAM,CA0BlB;;CAmCJ;qBA/SoB,sCAAsC"}

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

@@ -4,6 +4,7 @@ import {
     bvh_query_user_data_intersects_sphere
 } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_sphere.js";
 import { bvh_query_user_data_ray_segment } from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js";
+import { aabb3_array_combine } from "../../../../core/geom/3d/aabb/aabb3_array_combine.js";
 import { M4_IDENTITY } from "../../../../core/geom/3d/mat4/M4_IDENTITY.js";
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
 import { v3_matrix4_multiply } from "../../../../core/geom/vec3/v3_matrix4_multiply.js";
@@ -261,15 +262,12 @@ export class AcousticOccluderIndex {
 
             const b = body.worldAABB;
             if (n === 0) {
+                // seed the accumulator; `out` is documented as untouched when there are no live bodies, so
+                // it cannot be pre-filled with ±Infinity and unconditionally combined
                 out[0] = b[0]; out[1] = b[1]; out[2] = b[2];
                 out[3] = b[3]; out[4] = b[4]; out[5] = b[5];
             } else {
-                if (b[0] < out[0]) out[0] = b[0];
-                if (b[1] < out[1]) out[1] = b[1];
-                if (b[2] < out[2]) out[2] = b[2];
-                if (b[3] > out[3]) out[3] = b[3];
-                if (b[4] > out[4]) out[4] = b[4];
-                if (b[5] > out[5]) out[5] = b[5];
+                aabb3_array_combine(out, 0, out, 0, b, 0);
             }
 
             n++;

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,2DAgF3B;CACJ"}
+{"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"}

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

@@ -1,7 +1,7 @@
 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 { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
 import { RayHit } from "./RayHit.js";
 
 // module-static scratch — reused across calls so a solve allocates nothing. Typed throughout (the
@@ -41,14 +41,7 @@ export class OcclusionSolver {
      */
     solve(listener, source, sourceRadius, index, rayCount, smoothing, random, state, out) {
         // a per-tick random orientation for the fibonacci set (decorrelation over frames)
-        const z = 2 * random() - 1;
-        const azimuth = 2 * Math.PI * random();
-        const ring = Math.sqrt(Math.max(0, 1 - z * z));
-
-        v3_orthonormal_matrix_from_normal(
-            ROTATION, 0,
-            ring * Math.cos(azimuth), ring * Math.sin(azimuth), z
-        );
+        random_orthonormal_basis(ROTATION, 0, random);
 
         const lx = listener.x;
         const ly = listener.y;

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

@@ -1 +1 @@
-{"version":3,"file":"ProbeVisibilityRecheck.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/ProbeVisibilityRecheck.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,kCAFU,MAAM,CAEyC;AAEzD;;;;;;;;;;GAUG;AACH;IAuBI;;;OAGG;IACH,qEAGC;IAED;;;OAGG;IACH,sBAEC;IAaD;;;;;;OAMG;IACH,YAHW,MAAM,KACN,MAAM,QAShB;IAED;;;;;;OAMG;IACH,eAHW,MAAM,GACJ,MAAM,CAsClB;;CACJ"}
+{"version":3,"file":"ProbeVisibilityRecheck.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/ProbeVisibilityRecheck.js"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,kCAFU,MAAM,CAEyC;AAEzD;;;;;;;;;;GAUG;AACH;IAuBI;;;OAGG;IACH,qEAGC;IAED;;;OAGG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,YAHW,MAAM,KACN,MAAM,QAShB;IAED;;;;;;OAMG;IACH,eAHW,MAAM,GACJ,MAAM,CAwClB;;CACJ"}

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

@@ -1,6 +1,10 @@
 import { csr_graph_find_edge } from "../../../../core/graph/csr/csr_graph_find_edge.js";
+import { probe_edge_key, probe_edge_key_decode } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
+// module-static scratch — the decoded `[low, high]` probe pair of the edge currently being rechecked
+const EDGE_PAIR = new Uint32Array(2);
+
 /**
  * Float32 max — a finite, in-range sentinel weight that makes a baked visibility edge **effectively
  * untraversable** without a topology change. Dijkstra still sees the edge, but its astronomically large
@@ -63,17 +67,6 @@ export class ProbeVisibilityRecheck {
         return this.#queue.length;
     }
 
-    /**
-     * Canonical undirected edge id (order-independent), `min·size + max`.
-     * @param {number} a
-     * @param {number} b
-     * @returns {number}
-     */
-    #edgeId(a, b) {
-        const size = this.#field.size;
-        return a < b ? a * size + b : b * size + a;
-    }
-
     /**
      * Mark the edge `(a, b)` — traversed by a leak this frame — as needing a visibility recheck. Cheap: just
      * enqueues (deduped); the ray is cast later in {@link update}. PRECONDITION: `(a, b)` is a real edge of
@@ -82,7 +75,7 @@ export class ProbeVisibilityRecheck {
      * @param {number} b probe index
      */
     markEdge(a, b) {
-        const id = this.#edgeId(a, b);
+        const id = probe_edge_key(a, b, this.#field.size);
 
         if (!this.#queued.has(id)) {
             this.#queued.add(id);
@@ -109,8 +102,10 @@ export class ProbeVisibilityRecheck {
             const id = this.#queue.shift();
             this.#queued.delete(id);
 
-            const a = (id / size) | 0;
-            const b = id % size;
+            probe_edge_key_decode(EDGE_PAIR, 0, id, size);
+
+            const a = EDGE_PAIR[0];
+            const b = EDGE_PAIR[1];
 
             const ka = csr_graph_find_edge(graph, a, b);
             const kb = csr_graph_find_edge(graph, b, a);

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

@@ -1 +1 @@
-{"version":3,"file":"bakeReverbBands.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeReverbBands.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iEARW,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,gBACK,MAAM,YACjB,YAAY,iBACZ,YAAY,QA2DtB"}
+{"version":3,"file":"bakeReverbBands.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeReverbBands.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iEARW,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,gBACK,MAAM,YACjB,YAAY,iBACZ,YAAY,QAuDtB"}

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

@@ -1,7 +1,7 @@
 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 { v3_orthonormal_matrix_from_normal } from "../../../../core/geom/vec3/v3_orthonormal_matrix_from_normal.js";
 import { acoustic_trace_energy, SPEED_OF_SOUND_MPS } from "./acoustic_trace_energy.js";
 import { echogram_band_rt60 } from "./echogram_band_rt60.js";
 
@@ -67,11 +67,7 @@ export function bakeReverbBands(
     DIRECTION_ACCUM.fill(0);
 
     // randomly orient the Fibonacci set so accumulation isn't biased by the fixed lattice
-    const rz = 2 * random() - 1;
-    const ra = 2 * Math.PI * random();
-    const rr = Math.sqrt(Math.max(0, 1 - rz * rz));
-
-    v3_orthonormal_matrix_from_normal(ROTATION, 0, rr * Math.cos(ra), rr * Math.sin(ra), rz);
+    random_orthonormal_basis(ROTATION, 0, random);
 
     for (let i = 0; i < rayCount; i++) {
         sphere_fibonacci_point(FIBONACCI, 0, i, rayCount);

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

@@ -1 +1 @@
-{"version":3,"file":"bakeVisibility.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeVisibility.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uGAJW,UAAU,MAAM,CAAC,eACjB,MAAM,sBAiHhB;AAED;;;;;;;;;;;;;;GAcG;AACH,qEARW,MAAM,WACN,MAAM,WACN,MAAM,aACN,MAAM,aACN,MAAM,aACN,MAAM,GACJ;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,EAAE,GAAC,IAAI,CAiB/C"}
+{"version":3,"file":"bakeVisibility.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/bakeVisibility.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uGAJW,UAAU,MAAM,CAAC,eACjB,MAAM,sBAiFhB;AAED;;;;;;;;;;;;;;GAcG;AACH,qEARW,MAAM,WACN,MAAM,WACN,MAAM,aACN,MAAM,aACN,MAAM,aACN,MAAM,GACJ;IAAC,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAC;IAAA,CAAC,EAAC,MAAM,CAAA;CAAC,EAAE,GAAC,IAAI,CAiB/C"}

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

@@ -1,4 +1,6 @@
-import { CSRGraph } from "../../../../core/graph/csr/CSRGraph.js";
+import {
+    csr_graph_from_undirected_edge_list
+} from "../../../../core/graph/csr/csr_graph_from_undirected_edge_list.js";
 import { probe_delaunay_edges } from "./probe_delaunay_edges.js";
 import { probe_densify_portals } from "./probe_densify_portals.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
@@ -106,39 +108,7 @@ export function bakeVisibility(probeField, index, portals = NO_PORTALS, minSpaci
         edgeW[e] = Math.sqrt(dx * dx + dy * dy + dz * dz);
     }
 
-    // build CSR adjacency: each undirected edge contributes a row entry at BOTH endpoints
-    const adjacency_length = edgeCount * 2;
-
-    const degree = new Uint32Array(n);
-    for (let e = 0; e < edgeCount; e++) {
-        degree[edgeA[e]]++;
-        degree[edgeB[e]]++;
-    }
-
-    const edge_addresses = new Uint32Array(n + 1);
-    for (let v = 0; v < n; v++) {
-        edge_addresses[v + 1] = edge_addresses[v] + degree[v];
-    }
-
-    const adjacency = new Uint32Array(adjacency_length);
-    const edge_weights = new Float32Array(adjacency_length);
-    const cursor = edge_addresses.slice(0, n); // per-vertex write cursor, starting at each row's offset
-
-    for (let e = 0; e < edgeCount; e++) {
-        const a = edgeA[e];
-        const b = edgeB[e];
-        const w = edgeW[e];
-
-        adjacency[cursor[a]] = b;
-        edge_weights[cursor[a]] = w;
-        cursor[a]++;
-
-        adjacency[cursor[b]] = a;
-        edge_weights[cursor[b]] = w;
-        cursor[b]++;
-    }
-
-    const graph = CSRGraph.fromArrays(n, edge_addresses, adjacency, edge_weights);
+    const graph = csr_graph_from_undirected_edge_list(n, edgeA, edgeB, edgeW);
 
     probeField.setVisibilityGraph(graph);
 

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

@@ -1 +1 @@
-{"version":3,"file":"probe_densify_portals.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_densify_portals.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CARW,OAAO,yBAAyB,EAAE,kBAAkB,SACpD,OAAO,kCAAkC,EAAE,qBAAqB,WAChE,UAAU,MAAM,CAAC,SACjB;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,cAC5C,MAAM;2BACkB,MAAM;mBAAiB,MAAM;iBAAe,MAAM;IACxE;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CAyEtC"}
+{"version":3,"file":"probe_densify_portals.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_densify_portals.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CARW,OAAO,yBAAyB,EAAE,kBAAkB,SACpD,OAAO,kCAAkC,EAAE,qBAAqB,WAChE,UAAU,MAAM,CAAC,SACjB;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,cAC5C,MAAM;2BACkB,MAAM;mBAAiB,MAAM;iBAAe,MAAM;IACxE;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CAyEtC"}

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

@@ -1,4 +1,5 @@
 import { line3_compute_segment_point_distance_sqr } from "../../../../core/geom/3d/line/line3_compute_segment_point_distance_sqr.js";
+import { probe_edge_key } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
 // Gather neighbours of a portal within this × minSpacing — far enough to reach probes on BOTH sides of a wall
@@ -55,7 +56,7 @@ export function probe_densify_portals(field, index, portals, edges, minSpacing,
     // existing + newly-added edges, keyed undirected, so a chord the base graph already has is not duplicated
     const seen = new Set();
     for (let i = 0; i < edges.a.length; i++) {
-        seen.add(edgeKey(edges.a[i], edges.b[i], n));
+        seen.add(probe_edge_key(edges.a[i], edges.b[i], n));
     }
 
     const hits = []; // probesWithinRadius scratch (auto-grows; valid length is the returned count)
@@ -82,7 +83,7 @@ export function probe_densify_portals(field, index, portals, edges, minSpacing,
             for (let b = a + 1; b < neighbours.length; b++) {
                 const j = neighbours[b];
 
-                const key = edgeKey(i, j, n);
+                const key = probe_edge_key(i, j, n);
                 if (seen.has(key)) {
                     continue;
                 }
@@ -137,7 +138,3 @@ function nearestVisible(field, index, p, px, py, pz, hits, count, max) {
     return found.map((o) => o.j);
 }
 
-/** Undirected edge key (order-independent). */
-function edgeKey(a, b, n) {
-    return a < b ? a * n + b : b * n + a;
-}

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

@@ -0,0 +1,31 @@
+/**
+ * Canonical (order-independent) integer key for an undirected pair of probe indices: `min·probe_count + max`.
+ *
+ * WHY this exists: the probe bake keys undirected pairs in four different modules (visibility augmentation's
+ * dedup set, portal densification's dedup set, component bridging's per-component-pair best-candidate map, and
+ * the runtime {@link ProbeVisibilityRecheck} dirty queue). The packing carries TWO invariants that are easy to
+ * break independently — the pair must be canonicalised (so `(a,b)` and `(b,a)` collide deliberately) and the
+ * radix must be the PROBE COUNT (so distinct pairs never collide). Re-deriving it per module meant a change of
+ * packing — say to bit-shifts once a field exceeds 2^26 probes and the product loses exact integer precision —
+ * would have to be found in four places. Encode and decode live together here so they cannot drift apart.
+ *
+ * PRECONDITION: `a` and `b` are in `[0, probe_count)` and `probe_count² ≤ Number.MAX_SAFE_INTEGER`.
+ *
+ * @param {number} a probe index
+ * @param {number} b probe index
+ * @param {number} probe_count number of probes in the field — the packing radix
+ * @returns {number} canonical key, equal for `(a,b)` and `(b,a)`
+ */
+export function probe_edge_key(a: number, b: number, probe_count: number): number;
+/**
+ * Unpack a {@link probe_edge_key} back into its two probe indices, written into `result` as
+ * `[low, high]`. The inverse of {@link probe_edge_key} — kept beside it so the radix convention has a
+ * single owner.
+ *
+ * @param {number[]|Uint32Array} result receives 2 elements: the lower then the higher probe index
+ * @param {number} result_offset
+ * @param {number} key a key produced by {@link probe_edge_key} with the same `probe_count`
+ * @param {number} probe_count the packing radix the key was built with
+ */
+export function probe_edge_key_decode(result: number[] | Uint32Array, result_offset: number, key: number, probe_count: number): void;
+//# sourceMappingURL=probe_edge_key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probe_edge_key.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_edge_key.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,kCALW,MAAM,KACN,MAAM,eACN,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;;GASG;AACH,8CALW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,OACN,MAAM,eACN,MAAM,QAKhB"}

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

@@ -0,0 +1,38 @@
+/**
+ * Canonical (order-independent) integer key for an undirected pair of probe indices: `min·probe_count + max`.
+ *
+ * WHY this exists: the probe bake keys undirected pairs in four different modules (visibility augmentation's
+ * dedup set, portal densification's dedup set, component bridging's per-component-pair best-candidate map, and
+ * the runtime {@link ProbeVisibilityRecheck} dirty queue). The packing carries TWO invariants that are easy to
+ * break independently — the pair must be canonicalised (so `(a,b)` and `(b,a)` collide deliberately) and the
+ * radix must be the PROBE COUNT (so distinct pairs never collide). Re-deriving it per module meant a change of
+ * packing — say to bit-shifts once a field exceeds 2^26 probes and the product loses exact integer precision —
+ * would have to be found in four places. Encode and decode live together here so they cannot drift apart.
+ *
+ * PRECONDITION: `a` and `b` are in `[0, probe_count)` and `probe_count² ≤ Number.MAX_SAFE_INTEGER`.
+ *
+ * @param {number} a probe index
+ * @param {number} b probe index
+ * @param {number} probe_count number of probes in the field — the packing radix
+ * @returns {number} canonical key, equal for `(a,b)` and `(b,a)`
+ */
+export function probe_edge_key(a, b, probe_count) {
+    return a < b
+        ? a * probe_count + b
+        : b * probe_count + a;
+}
+
+/**
+ * Unpack a {@link probe_edge_key} back into its two probe indices, written into `result` as
+ * `[low, high]`. The inverse of {@link probe_edge_key} — kept beside it so the radix convention has a
+ * single owner.
+ *
+ * @param {number[]|Uint32Array} result receives 2 elements: the lower then the higher probe index
+ * @param {number} result_offset
+ * @param {number} key a key produced by {@link probe_edge_key} with the same `probe_count`
+ * @param {number} probe_count the packing radix the key was built with
+ */
+export function probe_edge_key_decode(result, result_offset, key, probe_count) {
+    result[result_offset] = (key / probe_count) | 0;
+    result[result_offset + 1] = key % probe_count;
+}

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

@@ -28,9 +28,16 @@ export function build_sdf_grid(index: AcousticOccluderIndex, bounds: number[], m
 /** World position of the (fractional) voxel coordinate `(fx,fy,fz)`, written into `out`. */
 export function grid_voxel_to_world(grid: any, out: any, fx: any, fy: any, fz: any): void;
 /** SDF at a WORLD position via trilinear interpolation of the grid (edge-clamped). */
-export function grid_sample_world(grid: any, x: any, y: any, z: any): any;
-/** Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped). */
-export function grid_sample_trilinear(grid: any, x: any, y: any, z: any): any;
+export function grid_sample_world(grid: any, x: any, y: any, z: any): number;
+/**
+ * Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped).
+ *
+ * The grid is a plain `z·(rx·ry) + y·rx + x` single-channel Float32 volume — exactly the layout
+ * {@link scs3d_sample_linear} samples — so the interpolation is delegated rather than re-derived here.
+ * (Same clamp semantics: clamping the COORDINATE into `[0, res-1]` and clamping the two sample INDICES
+ * agree on every input, including out-of-range coordinates, where both collapse to the edge voxel.)
+ */
+export function grid_sample_trilinear(grid: any, x: any, y: any, z: any): number;
 /**
  * Gradient-ascend a voxel to the local SDF maximum (the most-open sub-voxel point), written into `out` as a
  * fractional voxel coordinate clamped to within ½ voxel of the start. Central-difference gradient on the

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

@@ -1 +1 @@
-{"version":3,"file":"probe_sdf_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_sdf_grid.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;GAUG;AACH,qEALW,MAAM,EAAE,cACR,MAAM,oBACN,MAAM,GACJ,OAAO,CA8CnB;AAED,4FAA4F;AAC5F,0FAIC;AAED,sFAAsF;AACtF,0EAKC;AAED,uFAAuF;AACvF,8EAkBC;AAED;;;;GAIG;AACH,yFAqBC;AAED;;;GAGG;AACH,yGAuBC;AA9KD,2BAA4B;AAE5B,mCAAoC;AAGpC,yCAA0C;;;;;;;;;;SAW5B,YAAY;QACZ,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;;;;aAClD,MAAM;;;;WAA6B,MAAM;QACzC,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;QAClD,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;SAClD,MAAM;SAAiB,MAAM;;;;SAAiB,MAAM;gBACpD,MAAM;;;;gBAAwB,MAAM;;;;oBACpC,MAAM"}
+{"version":3,"file":"probe_sdf_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_sdf_grid.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;GAUG;AACH,qEALW,MAAM,EAAE,cACR,MAAM,oBACN,MAAM,GACJ,OAAO,CA8CnB;AAED,4FAA4F;AAC5F,0FAIC;AAED,sFAAsF;AACtF,6EAKC;AAED;;;;;;;GAOG;AACH,iFAEC;AAED;;;;GAIG;AACH,yFAqBC;AAED;;;GAGG;AACH,yGAuBC;AArKD,2BAA4B;AAE5B,mCAAoC;AAGpC,yCAA0C;;;;;;;;;;SAW5B,YAAY;QACZ,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;;;;aAClD,MAAM;;;;WAA6B,MAAM;QACzC,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;QAClD,MAAM;QAAgB,MAAM;;;;QAAgB,MAAM;SAClD,MAAM;SAAiB,MAAM;;;;SAAiB,MAAM;gBACpD,MAAM;;;;gBAAwB,MAAM;;;;oBACpC,MAAM"}

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

@@ -1,5 +1,6 @@
 import { clamp } from "../../../../core/math/clamp.js";
 import { lerp } from "../../../../core/math/lerp.js";
+import { scs3d_sample_linear } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
 
 // Voxel grid is finer than the spacing hint so it resolves sub-`minSpacing` features (thin corridors).
 export const OVERSAMPLE = 2;
@@ -100,25 +101,16 @@ export function grid_sample_world(grid, x, y, z) {
     return grid_sample_trilinear(grid, fx, fy, fz);
 }
 
-/** Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped). */
+/**
+ * Trilinear sample of the SDF grid at fractional voxel coordinates (edge-clamped).
+ *
+ * The grid is a plain `z·(rx·ry) + y·rx + x` single-channel Float32 volume — exactly the layout
+ * {@link scs3d_sample_linear} samples — so the interpolation is delegated rather than re-derived here.
+ * (Same clamp semantics: clamping the COORDINATE into `[0, res-1]` and clamping the two sample INDICES
+ * agree on every input, including out-of-range coordinates, where both collapse to the edge voxel.)
+ */
 export function grid_sample_trilinear(grid, x, y, z) {
-    const { sdf, rx, ry, rz, strideZ } = grid;
-
-    const x0 = Math.floor(x), y0 = Math.floor(y), z0 = Math.floor(z);
-    const u = x - x0, v = y - y0, w = z - z0;
-
-    const sx0 = clampInt(x0, rx), sy0 = clampInt(y0, ry), sz0 = clampInt(z0, rz);
-    const sx1 = clampInt(x0 + 1, rx), sy1 = clampInt(y0 + 1, ry), sz1 = clampInt(z0 + 1, rz);
-
-    const c000 = sdf[sz0 * strideZ + sy0 * rx + sx0], c100 = sdf[sz0 * strideZ + sy0 * rx + sx1];
-    const c010 = sdf[sz0 * strideZ + sy1 * rx + sx0], c110 = sdf[sz0 * strideZ + sy1 * rx + sx1];
-    const c001 = sdf[sz1 * strideZ + sy0 * rx + sx0], c101 = sdf[sz1 * strideZ + sy0 * rx + sx1];
-    const c011 = sdf[sz1 * strideZ + sy1 * rx + sx0], c111 = sdf[sz1 * strideZ + sy1 * rx + sx1];
-
-    const c00 = c000 + (c100 - c000) * u, c01 = c001 + (c101 - c001) * u;
-    const c10 = c010 + (c110 - c010) * u, c11 = c011 + (c111 - c011) * u;
-    const c0 = c00 + (c10 - c00) * v, c1 = c01 + (c11 - c01) * v;
-    return c0 + (c1 - c0) * w;
+    return scs3d_sample_linear(grid.sdf, grid.rx, grid.ry, grid.rz, x, y, z);
 }
 
 /**
@@ -177,7 +169,3 @@ export function grid_claim_sphere(claimed, grid, px, py, pz, radius) {
         }
     }
 }
-
-function clampInt(i, res) {
-    return i < 0 ? 0 : (i > res - 1 ? res - 1 : i);
-}

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

@@ -1 +1 @@
-{"version":3,"file":"probe_visibility_augment.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_augment.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yGANW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,kBAC5C,MAAM,kBACN,MAAM,mBACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA4HtC"}
+{"version":3,"file":"probe_visibility_augment.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_augment.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yGANW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,kBAC5C,MAAM,kBACN,MAAM,mBACN,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA4GtC"}

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

@@ -1,3 +1,8 @@
+import { csr_graph_find_edge } from "../../../../core/graph/csr/csr_graph_find_edge.js";
+import {
+    csr_graph_from_undirected_edge_list
+} from "../../../../core/graph/csr/csr_graph_from_undirected_edge_list.js";
+import { probe_edge_key } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
 // A chord is worth adding when the straight line beats the existing 2-hop route through their shared
@@ -47,27 +52,11 @@ export function probe_visibility_augment(
         return { a: [], b: [] };
     }
 
-    // sorted CSR adjacency over the current edges (for 2-ring walks + O(log d) "already adjacent?" tests)
-    const degree = new Uint32Array(n);
-    for (let i = 0; i < m; i++) {
-        degree[edges.a[i]]++;
-        degree[edges.b[i]]++;
-    }
-    const addr = new Uint32Array(n + 1);
-    for (let v = 0; v < n; v++) {
-        addr[v + 1] = addr[v] + degree[v];
-    }
-    const adj = new Uint32Array(2 * m);
-    const cursor = addr.slice(0, n);
-    for (let i = 0; i < m; i++) {
-        const a = edges.a[i];
-        const b = edges.b[i];
-        adj[cursor[a]++] = b;
-        adj[cursor[b]++] = a;
-    }
-    for (let v = 0; v < n; v++) {
-        adj.subarray(addr[v], addr[v + 1]).sort();
-    }
+    // CSR adjacency over the current edges (for 2-ring walks + "already adjacent?" tests). Topology only —
+    // the walk never reads weights, so every edge is given the same (zero) weight.
+    const graph = csr_graph_from_undirected_edge_list(n, edges.a, edges.b, new Float32Array(m));
+    const addr = graph.edge_addresses;
+    const adj = graph.adjacency;
 
     // eligible chords (allowing duplicates from multiple shared neighbours; deduped at add-time)
     const candU = [];
@@ -96,7 +85,7 @@ export function probe_visibility_augment(
                 if (v <= u) {
                     continue; // canonical u<v (and skips v===u: u is a neighbour of w)
                 }
-                if (isNeighbour(adj, addr, u, v)) {
+                if (csr_graph_find_edge(graph, u, v) !== -1) {
                     continue; // already connected — a triangle, no shortcut needed
                 }
 
@@ -144,7 +133,7 @@ export function probe_visibility_augment(
         const idx = order[i];
         const u = candU[idx];
         const v = candV[idx];
-        const key = u * n + v;
+        const key = probe_edge_key(u, v, n);
         if (added.has(key)) {
             continue;
         }
@@ -155,28 +144,3 @@ export function probe_visibility_augment(
 
     return { a: outA, b: outB };
 }
-
-/**
- * Whether `v` is in `u`'s (sorted) adjacency slice — binary search.
- * @param {Uint32Array} adj
- * @param {Uint32Array} addr
- * @param {number} u
- * @param {number} v
- * @returns {boolean}
- */
-function isNeighbour(adj, addr, u, v) {
-    let lo = addr[u];
-    let hi = addr[u + 1] - 1;
-    while (lo <= hi) {
-        const mid = (lo + hi) >> 1;
-        const x = adj[mid];
-        if (x === v) {
-            return true;
-        } else if (x < v) {
-            lo = mid + 1;
-        } else {
-            hi = mid - 1;
-        }
-    }
-    return false;
-}

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

@@ -1 +1 @@
-{"version":3,"file":"probe_visibility_bridge_components.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_bridge_components.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mHALW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,WAC5C,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA8EtC"}
+{"version":3,"file":"probe_visibility_bridge_components.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/probe_visibility_bridge_components.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mHALW;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;IAAC,CAAC,EAAE,UAAU,MAAM,CAAC,CAAA;CAAC,WAC5C,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ;IAAC,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,CAAA;CAAC,CA8EtC"}

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

@@ -1,4 +1,5 @@
 import { uf_find, uf_init, uf_union } from "../../../../core/collection/union-find/union_find.js";
+import { probe_edge_key } from "./probe_edge_key.js";
 import { probe_edge_visible } from "./probe_edge_visible.js";
 
 // Search radius for a bridge, as a multiple of the median base-edge length (the probe spacing). A door/wall
@@ -81,9 +82,9 @@ export function probe_visibility_bridge_components(field, index, edges, sources,
                 const dz = field.probeZ(j) - iz;
                 const d = Math.sqrt(dx * dx + dy * dy + dz * dz);
 
-                const rlo = ri < rj ? ri : rj;
-                const rhi = ri < rj ? rj : ri;
-                const key = rlo * n + rhi;
+                // canonical per-component-PAIR key (component roots are probe indices, so the probe count is
+                // the right radix)
+                const key = probe_edge_key(ri, rj, n);
 
                 const prev = best.get(key);
                 if (prev === undefined || d < prev.d) {