@woosh/meep-engine 2.163.11 → 2.164.0

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

@@ -0,0 +1,314 @@
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
+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 { 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";
+import { v3_matrix4_rotate_array } from "../../../../core/geom/vec3/v3_matrix4_rotate_array.js";
+import { OccluderBody } from "./OccluderBody.js";
+
+// module-static scratch — the local-frame query ray and the shape hit [px,py,pz, nx,ny,nz]. Reused so a
+// query allocates nothing.
+const LOCAL_RAY = new Ray3();
+const SHAPE_HIT = new Float32Array(6);
+
+// module-static scratch — a world query point and its body-local image, for signedDistanceAt.
+const QUERY_WORLD = new Float32Array(3);
+const QUERY_LOCAL = new Float32Array(3);
+
+/**
+ * Dynamic spatial index of acoustic occluders, providing closest-hit / any-hit ray queries for the
+ * occlusion / transmission simulation. NOT a user-facing "scene" — it is an internal acceleration
+ * structure populated from `AcousticBody` components by the `AcousticSimulationSystem`.
+ *
+ * Each occluder is an {@link OccluderBody}: an {@link AbstractShape3D} + world transform. The shape is
+ * raycast EXACTLY in its own local frame — closed-form for sphere/box/capsule, an internal BLAS for
+ * meshes (`AbstractShape3D.raycast`) — so primitives need no triangulation.
+ *
+ * A top-level {@link BVH} over the bodies' world AABBs (leaf user-data = handle) makes a query
+ * O(log n + hits): the ray segment descends the tree, visiting only the bodies whose bounds it crosses,
+ * instead of scanning every registered occluder. The BVH is fully dynamic — adding, moving
+ * ({@link setTransform}, O(log n) leaf refit) and removing a body all update it in place. For each
+ * candidate the ray is localised into the body's frame, `shape.raycast` run, and the hit point + normal
+ * mapped back to world.
+ *
+ * WebAudio-agnostic and ECS-agnostic. PRECONDITION: body transforms are rigid (no scale).
+ */
+export class AcousticOccluderIndex {
+    /**
+     * Bodies indexed by handle. A removed slot holds null (handles stay stable).
+     * @type {(OccluderBody|null)[]}
+     */
+    #bodies = [];
+
+    /**
+     * BVH leaf clients parallel to {@link #bodies} (one per live body; null for a removed slot).
+     * @type {(BvhClient|null)[]}
+     */
+    #clients = [];
+
+    /**
+     * Top-level BVH over body world AABBs; leaf user-data is the body handle.
+     * @type {BVH}
+     */
+    #bvh = new BVH();
+
+    /**
+     * Reused gather buffer for the ray-segment query (grows, never shrinks; only `[0, count)` is valid
+     * after a query). Keeps a query allocation-free.
+     * @type {number[]}
+     */
+    #candidates = [];
+
+    /**
+     * Add an occluder shape, placed by `matrix` (identity = at the world origin).
+     * @param {AbstractShape3D} shape geometry in its canonical local frame
+     * @param {AcousticMaterial} material acoustic properties of the surface
+     * @param {Float32Array|number[]} [matrix] world transform (rigid)
+     * @returns {number} a stable handle
+     */
+    addBody(shape, material, matrix = M4_IDENTITY) {
+        const handle = this.#bodies.length;
+
+        const body = new OccluderBody(shape, material, matrix);
+
+        const client = new BvhClient();
+        this.#fitLeaf(client, body); // size the (margin-padded) leaf before linking
+        client.link(this.#bvh, handle); // leaf user-data = handle
+
+        this.#bodies.push(body);
+        this.#clients.push(client);
+
+        return handle;
+    }
+
+    /**
+     * Re-place a body's world transform — refits its BVH leaf in place (O(log n), no rebuild).
+     * @param {number} handle
+     * @param {Float32Array|number[]} matrix world transform (rigid)
+     */
+    setTransform(handle, matrix) {
+        const body = this.#bodies[handle];
+
+        body.setTransform(matrix);
+        this.#fitLeaf(this.#clients[handle], body);
+    }
+
+    /**
+     * Size a body's BVH leaf to its tight world AABB. The broadphase ray test behind
+     * {@link bvh_query_user_data_ray_segment} is robust at the axis-aligned-ray-exactly-on-a-face boundary
+     * (its slab test treats the degenerate `0 · ∞` axis as fully open), so no padding is needed here to
+     * keep a grazing crossing from being dropped before the exact `shape.raycast`.
+     * @param {BvhClient} client
+     * @param {OccluderBody} body
+     */
+    #fitLeaf(client, body) {
+        const b = body.worldAABB;
+
+        client.resize(b[0], b[1], b[2], b[3], b[4], b[5]);
+    }
+
+    /**
+     * Remove a body. Its leaf is unlinked from the BVH and its handle retired (queries skip it).
+     * @param {number} handle
+     */
+    removeBody(handle) {
+        this.#clients[handle].unlink();
+        this.#clients[handle] = null;
+        this.#bodies[handle] = null;
+    }
+
+    /**
+     * Nearest occluder hit by `ray` within `ray.tMax`, written into `out` (world hit point + normal +
+     * distance + material). Returns whether anything hit.
+     * @param {Ray3} ray world-space ray (tMax bounds the search)
+     * @param {RayHit} out result container (reset by this call)
+     * @returns {boolean}
+     */
+    closestHit(ray, out) {
+        out.reset();
+
+        const bodies = this.#bodies;
+        const candidates = this.#candidates;
+        const count = this.#gather(ray);
+
+        let bound = ray.tMax;
+        let found = false;
+
+        for (let c = 0; c < count; c++) {
+            const handle = candidates[c];
+            const body = bodies[handle];
+
+            const local = this.#localizeRay(ray, body, bound);
+
+            if (!body.shape.raycast(SHAPE_HIT, local)) {
+                continue;
+            }
+
+            // local hit distance = (hitPoint − origin)·direction (unit dir) — equals world distance for a
+            // rigid transform.
+            const t = (SHAPE_HIT[0] - local[0]) * local[3]
+                + (SHAPE_HIT[1] - local[1]) * local[4]
+                + (SHAPE_HIT[2] - local[2]) * local[5];
+
+            // inclusive at the bound to match the shape raycast's tMax gate (`t > tMax` rejects) and
+            // anyHit — so a hit landing exactly at ray.tMax registers on both paths, not just anyHit.
+            if (t <= bound) {
+                bound = t;
+                found = true;
+
+                out.t = t;
+                out.bodyHandle = handle;
+                out.material = body.material;
+
+                // local hit point → world (full transform); local normal → world (rotation only)
+                v3_matrix4_multiply(out.position, 0, SHAPE_HIT, 0, body.matrix);
+                v3_matrix4_rotate_array(out.normal, 0, SHAPE_HIT, 3, body.matrix);
+            }
+        }
+
+        return found;
+    }
+
+    /**
+     * Whether `ray` is blocked by ANY occluder within `ray.tMax`. Cheaper than {@link closestHit} —
+     * early-outs on the first body hit, no result detail.
+     * @param {Ray3} ray
+     * @returns {boolean}
+     */
+    anyHit(ray) {
+        const bodies = this.#bodies;
+        const candidates = this.#candidates;
+        const count = this.#gather(ray);
+
+        for (let c = 0; c < count; c++) {
+            const body = bodies[candidates[c]];
+
+            if (body.shape.raycast(SHAPE_HIT, this.#localizeRay(ray, body, ray.tMax))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Signed distance from a world point to the nearest occluder surface: NEGATIVE inside solid, POSITIVE in
+     * open air, magnitude = distance to the nearest surface. This is the union SDF — `min` over bodies of
+     * each shape's own signed distance (a point inside ANY occluder is inside the union → negative).
+     *
+     * Bounded by `maxDistance`: only bodies whose world AABB lies within that radius are considered (the BVH
+     * sphere query — the AABB bounds the shape, so this never misses a surface within range), so the result
+     * is EXACT when the nearest surface is ≤ `maxDistance` and CLAMPED to `+maxDistance` when nothing is
+     * nearer. Inside-ness is always detected (a containing body's AABB contains the point) and its depth is
+     * returned unclamped. O(log n + nearby bodies); allocation-free. The index is otherwise ray-only — this
+     * is the placement baker's clearance / air / inside query.
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} [maxDistance] search-radius cap (smaller = cheaper; the value beyond which "very open"
+     *        is good enough). Default unbounded (considers every body — pass a cap for per-voxel sweeps).
+     * @returns {number} signed distance (negative = inside an occluder; `maxDistance` if nothing is nearer)
+     */
+    signedDistanceAt(x, y, z, maxDistance = Infinity) {
+        const bodies = this.#bodies;
+        const candidates = this.#candidates;
+
+        const count = bvh_query_user_data_intersects_sphere(candidates, 0, this.#bvh, x, y, z, maxDistance);
+
+        QUERY_WORLD[0] = x;
+        QUERY_WORLD[1] = y;
+        QUERY_WORLD[2] = z;
+
+        let best = maxDistance;
+
+        for (let c = 0; c < count; c++) {
+            const body = bodies[candidates[c]];
+
+            // localise the world point into the body's frame (rigid inverse), then evaluate its exact SDF
+            v3_matrix4_multiply(QUERY_LOCAL, 0, QUERY_WORLD, 0, body.inverse);
+
+            const s = body.shape.signed_distance_at_point(QUERY_LOCAL);
+
+            if (s < best) {
+                best = s;
+            }
+        }
+
+        return best;
+    }
+
+    /**
+     * Combined world AABB of all live occluders, written into `out` as `[x0,y0,z0, x1,y1,z1]`. Returns the
+     * number of bodies unioned — 0 means the index is empty and `out` is left untouched. The probe bake
+     * derives its region from this (the occluder hull + a margin), so the region need not be configured.
+     * @param {Float32Array|number[]} out length ≥ 6
+     * @returns {number} number of live bodies
+     */
+    computeWorldBounds(out) {
+        const bodies = this.#bodies;
+        let n = 0;
+
+        for (let h = 0; h < bodies.length; h++) {
+            const body = bodies[h];
+            if (body === null) {
+                continue; // retired handle
+            }
+
+            const b = body.worldAABB;
+            if (n === 0) {
+                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];
+            }
+
+            n++;
+        }
+
+        return n;
+    }
+
+    /**
+     * Gather the handles of bodies whose world AABB the ray segment crosses, into {@link #candidates}.
+     * The BVH does the broadphase pruning — only bodies near the ray are returned.
+     * @param {Ray3} ray
+     * @returns {number} number of candidates written to {@link #candidates}
+     */
+    #gather(ray) {
+        return bvh_query_user_data_ray_segment(
+            this.#candidates, 0,
+            this.#bvh, this.#bvh.root,
+            ray[0], ray[1], ray[2],
+            ray[3], ray[4], ray[5],
+            0, ray.tMax
+        );
+    }
+
+    /**
+     * The world ray localised into a body's frame, bounded to `bound` (in the shared module scratch).
+     * The copy is transformed point+direction-only (tMax forced to Infinity for the transform), then
+     * re-bounded — for a rigid transform the local bound equals the world bound.
+     * @param {Ray3} ray world-space ray
+     * @param {OccluderBody} body
+     * @param {number} bound current best distance (world == local for rigid)
+     * @returns {Ray3}
+     */
+    #localizeRay(ray, body, bound) {
+        LOCAL_RAY.copy(ray);
+        LOCAL_RAY.tMax = Infinity;
+        LOCAL_RAY.applyMatrix4(body.inverse);
+        LOCAL_RAY.tMax = bound;
+
+        return LOCAL_RAY;
+    }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Dynamic spatial index of acoustic medium regions ({@link AcousticVolumeRegion}), the medium analogue of
+ * {@link AcousticOccluderIndex}. A top-level {@link BVH} over the regions' world AABBs (leaf user-data =
+ * handle) makes a blend query O(log n + hits): {@link gather} returns only the regions whose AABB contains
+ * the point, instead of scanning every registered region. A region's influence lives ENTIRELY inside its
+ * shape (weight 0 outside, see {@link AcousticVolumeRegion#weightAt}), so the shape's world AABB tightly
+ * bounds it.
+ *
+ * Regions track their entity's `Transform.position` BY REFERENCE (a volume moves with no subscription), so a
+ * leaf goes stale when its volume moves — call {@link refit} once per frame (before queries) to re-fit the
+ * live positions. ECS-agnostic, WebAudio-agnostic. PRECONDITION: regions are axis-aligned (position only, no
+ * rotation — matching {@link AcousticVolumeRegion}).
+ */
+export class AcousticRegionIndex {
+    /**
+     * Number of live regions. Zero ⇒ the whole space is the ambient default medium (the integrator's
+     * closed-form fast path).
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Register a region (its `position` is read live by reference; re-fit each frame via {@link refit}).
+     * @param {AcousticVolumeRegion} region
+     * @returns {AcousticVolumeRegion} the same region (the caller keeps it for {@link remove})
+     */
+    add(region: AcousticVolumeRegion): AcousticVolumeRegion;
+    /**
+     * Remove a region (unlinks its BVH leaf, retires its handle).
+     * @param {AcousticVolumeRegion} region
+     */
+    remove(region: AcousticVolumeRegion): void;
+    /**
+     * Re-fit every live region's leaf from its current (by-reference) world position. Volumes move with no
+     * notification, so a moved volume's leaf is stale until this runs — call it once per frame before any
+     * query. Static volumes re-fit to the same AABB (cheap; regions are few).
+     *
+     * TODO: refit only the regions that actually moved (needs move tracking on `AcousticVolumeSystem`) — fine
+     * while region counts are small.
+     */
+    refit(): void;
+    /**
+     * Gather the regions whose world AABB contains `(x, y, z)` into `result` from `result_offset` (as region
+     * objects), returning how many. A radius-0 sphere query: a point is "inside" an AABB exactly when its
+     * signed distance is ≤ 0, so this returns every region that could have non-zero weight at the point (the
+     * caller still applies {@link AcousticVolumeRegion#weightAt} to get the smoothstep boundary). O(log n + hits).
+     * @param {AcousticVolumeRegion[]} result
+     * @param {number} result_offset
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number} number of regions written
+     */
+    gather(result: AcousticVolumeRegion[], result_offset: number, x: number, y: number, z: number): number;
+    #private;
+}
+//# sourceMappingURL=AcousticRegionIndex.d.ts.map

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

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

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

@@ -0,0 +1,159 @@
+import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
+import { BvhClient } from "../../../../core/bvh2/bvh3/BvhClient.js";
+import {
+    bvh_query_user_data_intersects_sphere
+} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_intersects_sphere.js";
+
+// module-static scratch — one region's world AABB during a leaf (re)fit. Reused; fits are synchronous.
+const LOCAL_AABB = [0, 0, 0, 0, 0, 0];
+
+/**
+ * Dynamic spatial index of acoustic medium regions ({@link AcousticVolumeRegion}), the medium analogue of
+ * {@link AcousticOccluderIndex}. A top-level {@link BVH} over the regions' world AABBs (leaf user-data =
+ * handle) makes a blend query O(log n + hits): {@link gather} returns only the regions whose AABB contains
+ * the point, instead of scanning every registered region. A region's influence lives ENTIRELY inside its
+ * shape (weight 0 outside, see {@link AcousticVolumeRegion#weightAt}), so the shape's world AABB tightly
+ * bounds it.
+ *
+ * Regions track their entity's `Transform.position` BY REFERENCE (a volume moves with no subscription), so a
+ * leaf goes stale when its volume moves — call {@link refit} once per frame (before queries) to re-fit the
+ * live positions. ECS-agnostic, WebAudio-agnostic. PRECONDITION: regions are axis-aligned (position only, no
+ * rotation — matching {@link AcousticVolumeRegion}).
+ */
+export class AcousticRegionIndex {
+    /**
+     * Regions indexed by handle (null for a removed slot; handles stay stable).
+     * @type {(AcousticVolumeRegion|null)[]}
+     */
+    #regions = [];
+
+    /**
+     * BVH leaf clients parallel to {@link #regions} (null for a removed slot).
+     * @type {(BvhClient|null)[]}
+     */
+    #clients = [];
+
+    /**
+     * region -> its handle, for {@link remove} (the system holds regions, not handles).
+     * @type {Map<AcousticVolumeRegion, number>}
+     */
+    #handles = new Map();
+
+    /**
+     * Top-level BVH over region world AABBs; leaf user-data is the handle.
+     * @type {BVH}
+     */
+    #bvh = new BVH();
+
+    /**
+     * Reused gather buffer for the point query (handles); only `[0, count)` is valid after a query.
+     * @type {number[]}
+     */
+    #candidates = [];
+
+    /**
+     * Number of live regions. Zero ⇒ the whole space is the ambient default medium (the integrator's
+     * closed-form fast path).
+     * @returns {number}
+     */
+    get size() {
+        return this.#handles.size;
+    }
+
+    /**
+     * Register a region (its `position` is read live by reference; re-fit each frame via {@link refit}).
+     * @param {AcousticVolumeRegion} region
+     * @returns {AcousticVolumeRegion} the same region (the caller keeps it for {@link remove})
+     */
+    add(region) {
+        const handle = this.#regions.length;
+
+        const client = new BvhClient();
+        this.#fitLeaf(client, region);
+        client.link(this.#bvh, handle);
+
+        this.#regions.push(region);
+        this.#clients.push(client);
+        this.#handles.set(region, handle);
+
+        return region;
+    }
+
+    /**
+     * Remove a region (unlinks its BVH leaf, retires its handle).
+     * @param {AcousticVolumeRegion} region
+     */
+    remove(region) {
+        const handle = this.#handles.get(region);
+
+        if (handle === undefined) {
+            return;
+        }
+
+        this.#clients[handle].unlink();
+        this.#clients[handle] = null;
+        this.#regions[handle] = null;
+        this.#handles.delete(region);
+    }
+
+    /**
+     * Re-fit every live region's leaf from its current (by-reference) world position. Volumes move with no
+     * notification, so a moved volume's leaf is stale until this runs — call it once per frame before any
+     * query. Static volumes re-fit to the same AABB (cheap; regions are few).
+     *
+     * TODO: refit only the regions that actually moved (needs move tracking on `AcousticVolumeSystem`) — fine
+     * while region counts are small.
+     */
+    refit() {
+        const regions = this.#regions;
+        const clients = this.#clients;
+
+        for (let h = 0; h < regions.length; h++) {
+            const region = regions[h];
+            if (region !== null) {
+                this.#fitLeaf(clients[h], region);
+            }
+        }
+    }
+
+    /**
+     * Size a region's BVH leaf to its world AABB — the shape's local AABB (centred at the origin) translated
+     * by the region's world position (axis-aligned: position only).
+     * @param {BvhClient} client
+     * @param {AcousticVolumeRegion} region
+     */
+    #fitLeaf(client, region) {
+        region.shape.compute_bounding_box(LOCAL_AABB);
+
+        const p = region.position;
+
+        client.resize(
+            LOCAL_AABB[0] + p.x, LOCAL_AABB[1] + p.y, LOCAL_AABB[2] + p.z,
+            LOCAL_AABB[3] + p.x, LOCAL_AABB[4] + p.y, LOCAL_AABB[5] + p.z
+        );
+    }
+
+    /**
+     * Gather the regions whose world AABB contains `(x, y, z)` into `result` from `result_offset` (as region
+     * objects), returning how many. A radius-0 sphere query: a point is "inside" an AABB exactly when its
+     * signed distance is ≤ 0, so this returns every region that could have non-zero weight at the point (the
+     * caller still applies {@link AcousticVolumeRegion#weightAt} to get the smoothstep boundary). O(log n + hits).
+     * @param {AcousticVolumeRegion[]} result
+     * @param {number} result_offset
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number} number of regions written
+     */
+    gather(result, result_offset, x, y, z) {
+        const candidates = this.#candidates;
+        const count = bvh_query_user_data_intersects_sphere(candidates, 0, this.#bvh, x, y, z, 0);
+
+        const regions = this.#regions;
+        for (let i = 0; i < count; i++) {
+            result[result_offset + i] = regions[candidates[i]];
+        }
+
+        return count;
+    }
+}

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

@@ -0,0 +1,66 @@
+/**
+ * The per-source result of one simulation tick — what the render seam (`EventInstance.setAcoustic`)
+ * consumes. A reusable container: the system holds one per live instance and the solvers write into it.
+ *
+ * Pure data; no WebAudio. `occlusion` + `transmission` come from the {@link OcclusionSolver}; `airLoss`
+ * comes from the {@link VolumeField} (integrated over the source→listener path).
+ */
+export class AcousticSolution {
+    /**
+     * Fraction of the source occluded by geometry, [0, 1]. 0 = clear line of sight, 1 = fully blocked.
+     * @type {number}
+     */
+    occlusion: number;
+    /**
+     * Per-band (low/mid/high) fraction of energy that LEAKS through the occluder(s), [0, 1]. Only
+     * meaningful when `occlusion > 0`. 1 = transparent.
+     * @type {Float32Array}
+     */
+    transmission: Float32Array;
+    /**
+     * Per-band (low/mid/high) air absorption integrated over the source→listener path, in **total dB** of
+     * attenuation (0 = transparent). Highs accumulate faster than lows, so distant sources lose their top
+     * end while the low end carries. Rendered as a low-anchored spectral tilt (the high-vs-low excess), so
+     * it composes with — rather than competes with — the authored distance attenuation curve.
+     * @type {Float32Array}
+     */
+    airLoss: Float32Array;
+    /**
+     * Whether a propagation path to the listener exists (corner-leakage). Only set when engine-wide
+     * pathing is on; when true, the leaked sound is spatialized from the exit point below.
+     * @type {boolean}
+     */
+    hasPath: boolean;
+    /**
+     * Exit-point world position `[x, y, z]` — where the leaked sound emerges toward the listener (the
+     * path's last probe before the listener). Only meaningful when `hasPath`.
+     * @type {Float32Array}
+     */
+    exit: Float32Array;
+    /**
+     * Linear gain of the leaked (path) signal, [0, 1]. Grows with occlusion (the more the direct path is
+     * blocked, the more the sound arrives via the path) and falls with path length. Already folded with the
+     * source's radiation toward the leak's first hop (directivity-on-leak). Only meaningful when `hasPath`.
+     * @type {number}
+     */
+    pathGain: number;
+    /**
+     * Per-band air absorption integrated over the LEAKED route (source→…→exit→listener), in total dB — the
+     * leak travels a longer path than the direct line, so it darkens more. Rendered as a low-anchored tilt on
+     * the leak send. Only meaningful when `hasPath`.
+     * @type {Float32Array}
+     */
+    pathAirLoss: Float32Array;
+    /**
+     * Source-radiation directivity gain on the DIRECT path, ≥ 0 (1 = omnidirectional / no directivity).
+     * How much the source radiates toward the listener given where it faces (the {@link AcousticDirectivity}
+     * pattern). Multiplies the direct-path gain at the render seam.
+     * @type {number}
+     */
+    directivityGain: number;
+    /**
+     * Reset to the "no effect" state (clear, transparent, vacuum, no path, omni radiation).
+     */
+    reset(): void;
+}
+//# sourceMappingURL=AcousticSolution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticSolution.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/core/AcousticSolution.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;;OAIG;IACH,cAFU,YAAY,CAEqB;IAE3C;;;;;;OAMG;IACH,SAFU,YAAY,CAEgB;IAEtC;;;;OAIG;IACH,SAFU,OAAO,CAED;IAEhB;;;;OAIG;IACH,MAFU,YAAY,CAEK;IAE3B;;;;;OAKG;IACH,UAFU,MAAM,CAEH;IAEb;;;;;OAKG;IACH,aAFU,YAAY,CAEoB;IAE1C;;;;;OAKG;IACH,iBAFU,MAAM,CAEI;IAEpB;;OAEG;IACH,cAiBC;CACJ"}