@woosh/meep-engine 3.44.0 → 3.46.0

package/src/engine/physics/narrowphase/narrowphase_step.js

@@ -59,6 +59,7 @@ import {
     TRANSFORM64_ROTATION_OFFSET,
     TRANSFORM64_TRANSLATION_OFFSET
 } from "../../ecs/transform/Transform64.js";
+import { t64_read_pose_array } from "../../ecs/transform/t64_read_pose_array.js";
 import { rigid_subject_pose } from "./rigid_subject_pose.js";
 
 const posed_a = new PosedShape3D();
@@ -1081,7 +1082,7 @@ const tri_plane = new Float64Array(13);
  * @param {Transform64} concave_tr
  */
 function triangle_plane_world(tri, concave_tr) {
-    pose_pack(plane_pose, concave_tr);
+    t64_read_pose_array(plane_pose, 0, concave_tr);
     triangle_vertices_to_world(scratch_tri_world, triangle_buffer, tri, plane_pose);
 
     const w = scratch_tri_world;
@@ -1476,26 +1477,6 @@ const plane_pose = new Float64Array(7);
  */
 const convex_record = new Float64Array(10);
 
-/**
- * Pack a pose, `[px, py, pz, qx, qy, qz, qw]`, from a transform.
- *
- * Read off the transform's lanes (a Transform64 is a Float64Array), not through `translation_x` and
- * the rest: inlined into dispatch_pair, those accessor calls land on a branch too rarely taken for
- * TurboFan to inline them, and each then returns its number boxed.
- *
- * @param {Float64Array} out
- * @param {Transform64} tr
- */
-function pose_pack(out, tr) {
-    out[0] = tr[TRANSFORM64_TRANSLATION_OFFSET];
-    out[1] = tr[TRANSFORM64_TRANSLATION_OFFSET + 1];
-    out[2] = tr[TRANSFORM64_TRANSLATION_OFFSET + 2];
-    out[3] = tr[TRANSFORM64_ROTATION_OFFSET];
-    out[4] = tr[TRANSFORM64_ROTATION_OFFSET + 1];
-    out[5] = tr[TRANSFORM64_ROTATION_OFFSET + 2];
-    out[6] = tr[TRANSFORM64_ROTATION_OFFSET + 3];
-}
-
 // dispatch_pair branches on the shape pair, so each branch runs on a fraction of its calls: too few
 // for TurboFan to inline a call made there, small or not, and a call that is not inlined boxes each
 // number handed to it. The closed-form pair kernels therefore get their bodies packed into these
@@ -1543,7 +1524,7 @@ function sphere_record_pack(out, tr, shape) {
  * @param {CapsuleShape3D} shape
  */
 function capsule_record_pack(out, tr, shape) {
-    pose_pack(out, tr);
+    t64_read_pose_array(out, 0, tr);
     out[7] = shape.radius;
     out[8] = shape.height * 0.5;
 }
@@ -1611,14 +1592,14 @@ function append_manifold_contact(count, result, offset, first_is_a, feature_id)
 
 /**
  * Pack a box record, `[px, py, pz, qx, qy, qz, qw, hx, hy, hz]`: its centre and orientation from the
- * transform, then its half-extents, read off their lanes for {@link pose_pack}'s reason (a Vector3 is
- * a Float64Array).
+ * transform, then its half-extents, read off their lanes for {@link t64_read_pose_array}'s reason (a
+ * Vector3 is a Float64Array).
  * @param {Float64Array} out
  * @param {Transform64} tr
  * @param {Vector3} half_extents
  */
 function box_record_pack(out, tr, half_extents) {
-    pose_pack(out, tr);
+    t64_read_pose_array(out, 0, tr);
     out[7] = half_extents[0];
     out[8] = half_extents[1];
     out[9] = half_extents[2];
@@ -1793,8 +1774,8 @@ function sphere_box_voronoi_fid_array(sphere, sphere_offset, box, box_offset) {
 function hull_pair_contacts(count, hullA, trA, hullB, trB) {
     // Poses go to the posed shapes and the clip in arrays, read off the transforms' lanes: this is
     // called from a dispatch_pair branch, and numbers handed across a call there are boxed.
-    pose_pack(pair_pose_a, trA);
-    pose_pack(pair_pose_b, trB);
+    t64_read_pose_array(pair_pose_a, 0, trA);
+    t64_read_pose_array(pair_pose_b, 0, trB);
     posed_a.setup_pose(hullA, pair_pose_a, 0);
     posed_b.setup_pose(hullB, pair_pose_b, 0);
     const depth = gjk_epa_penetration(epa_result, posed_a, posed_b);
@@ -2163,7 +2144,7 @@ function dispatch_pair(count, colA, trA, colB, trB) {
     if ((shapeA.isConvexHullShape3D === true && isSphereB) || (isSphereA && shapeB.isConvexHullShape3D === true)) {
         const hull_is_a = isSphereB;
 
-        pose_pack(pair_pose, hull_is_a ? trA : trB);
+        t64_read_pose_array(pair_pose, 0, hull_is_a ? trA : trB);
         sphere_record_pack(pair_sphere_b, hull_is_a ? trB : trA, hull_is_a ? shapeB : shapeA);
 
         const ok = hull_sphere_contact_array(closed_form_result, hull_is_a ? shapeA : shapeB, pair_pose, 0, pair_sphere_b, 0);
@@ -2214,8 +2195,8 @@ function dispatch_pair(count, colA, trA, colB, trB) {
         // The two bodies' poses, packed once for the calls below and the per-triangle kernels: passed
         // as numbers to a call that is not inlined, every one would be boxed (see
         // triangle_vertices_to_world).
-        pose_pack(convex_pose, convex_tr);
-        pose_pack(concave_pose, concave_tr);
+        t64_read_pose_array(convex_pose, 0, convex_tr);
+        t64_read_pose_array(concave_pose, 0, concave_tr);
 
         // 1. Convex shape's world AABB.
         convex_col.shape.compute_bounding_box(concave_local_aabb);
@@ -2310,7 +2291,7 @@ function dispatch_pair(count, colA, trA, colB, trB) {
             convex_record[2] = convex_wz;
             convex_record[3] = sphere_radius;
         } else if (isBoxConvex || isCapsuleConvex) {
-            pose_pack(convex_record, convex_tr);
+            t64_read_pose_array(convex_record, 0, convex_tr);
 
             if (isBoxConvex) {
                 convex_record[7] = box_half_extents.x;
@@ -3130,7 +3111,7 @@ function collider_box(i, entry) {
 
     entry.collider.shape.compute_bounding_box(collider_local_box);
 
-    pose_pack(collider_pose, t);
+    t64_read_pose_array(collider_pose, 0, t);
     aabb3_transform_oriented_array(collider_boxes, i * 6, collider_local_box, 0, collider_pose, 0);
 }
 

package/src/engine/physics/narrowphase/sphere_box_contact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sphere_box_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_box_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAjBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmBnB;AASD;;;;;;;;;;;;GAYG;AACH,8CAPW,MAAM,EAAE,GAAC,YAAY,UACrB,YAAY,iBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CA8FnB"}
+{"version":3,"file":"sphere_box_contact.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/sphere_box_contact.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wCAjBW,MAAM,EAAE,GAAC,YAAY,MACrB,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmBnB;AASD;;;;;;;;;;;;GAYG;AACH,8CAPW,MAAM,EAAE,GAAC,YAAY,UACrB,YAAY,iBACZ,MAAM,OACN,YAAY,cACZ,MAAM,GACJ,OAAO,CA2FnB"}

package/src/engine/physics/narrowphase/sphere_box_contact.js

@@ -1,5 +1,5 @@
 import { v3_quaternion_apply_array } from "../../../core/geom/vec3/v3_quaternion_apply.js";
-import { v3_quaternion_apply_inverse_array } from "../../../core/geom/vec3/v3_quaternion_apply_inverse.js";
+import { pose3_apply_inverse_point_array } from "../../../core/geom/3d/pose/pose3_apply_inverse_point_array.js";
 
 /**
  * Scratch for the world→box-local rotation of the sphere centre at the
@@ -93,10 +93,7 @@ export function sphere_box_contact_array(out, sphere, sphere_offset, box, box_of
 
     // Step 1: bring the sphere centre into box-local space via the conjugate
     // quaternion. v_local = q* · (s - b) · q
-    scratch_local[0] = sx - bx;
-    scratch_local[1] = sy - by;
-    scratch_local[2] = sz - bz;
-    v3_quaternion_apply_inverse_array(scratch_local, 0, scratch_local, 0, box, rotation);
+    pose3_apply_inverse_point_array(scratch_local, 0, box, box_offset, box, rotation, sphere, sphere_offset);
     const lx = scratch_local[0];
     const ly = scratch_local[1];
     const lz = scratch_local[2];

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

@@ -1 +1 @@
-{"version":3,"file":"AudioEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/AudioEmitter.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH;IA4HI;;;OAGG;IACH,4BAFa,YAAY,CAMxB;IAlID;;;;;;;;;;;;OAYG;IACH,OAFU,gBAAgB,CAEK;IAE/B;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;;OAIG;IACH,UAFU,OAAO,CAED;IAEhB;;;;;OAKG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;OAKG;IACH,cAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,aAFU,mBAAmB,CAEW;IAExC;;;;;;;;;;;;;;;OAeG;IACH,aAFU;QAAC,KAAK,EAAE,OAAO,YAAY,CAAC,CAAA;KAAC,CAIrC;IAEF;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CASnB;IAED,eASC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASC;IAED,0BAaC;CAWJ;;;;iCAlJgC,4CAA4C;oBAHzD,kCAAkC;oCAElB,oDAAoD;mBAHrE,0CAA0C"}
+{"version":3,"file":"AudioEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/audio/AudioEmitter.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IAgII;;;OAGG;IACH,4BAFa,YAAY,CAMxB;IAtID;;;;;;;;;;;;OAYG;IACH,OAFU,gBAAgB,CAEK;IAE/B;;;OAGG;IACH,QAFU,OAAO,CAEO;IAExB;;;;OAIG;IACH,UAFU,OAAO,CAED;IAEhB;;;;;OAKG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;OAKG;IACH,cAFU,MAAM,CAEqB;IAErC;;;;;OAKG;IACH,aAFU,mBAAmB,CAEW;IAExC;;;;;;;;;;;;;;;OAeG;IACH,aAFU;QAAC,KAAK,EAAE,OAAO,YAAY,CAAC,CAAA;KAAC,CAIrC;IAEF;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CASnB;IAED,eAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MASC;IAED,0BAaC;CAWJ;;;;iCAtJgC,4CAA4C;oBAHzD,kCAAkC;oCAElB,oDAAoD;mBAHrE,0CAA0C"}

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

@@ -1,4 +1,5 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import Signal from "../../../../core/events/signal/Signal.js";
 import Vector1 from "../../../../core/geom/Vector1.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
@@ -104,12 +105,16 @@ export class AudioEmitter {
     }
 
     hash() {
-        return combine_hash(
-            this.event.hash(),
-            this.autoplay ? 1 : 0,
-            this.acoustic ? 1 : 0,
-            computeHashFloat(this.sourceRadius),
-            this.directivity.hash(),
+        return hash_mix2(
+            hash_mix3(
+                hash_mix3(
+                    this.event.hash(),
+                    this.autoplay ? 1 : 0,
+                    this.acoustic ? 1 : 0
+                ),
+                computeHashFloat(this.sourceRadius),
+                this.directivity.hash()
+            ),
             computeHashFloat(this.volume.getValue())
         );
     }

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

@@ -1 +1 @@
-{"version":3,"file":"AudioEventTrigger.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/trigger/AudioEventTrigger.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH;IAuBI;;;;;OAKG;IACH,wBALW,MAAM,SACN,gBAAgB,cAChB,MAAM,GAAC,IAAI,GACT,qBAAqB,CAUjC;IAuCD;;;OAGG;IACH,4BAFa,qBAAqB,CAMjC;IAlFD;;;;OAIG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;;;OAIG;IACH,OAFU,gBAAgB,CAEK;IAkB/B;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CAMnB;IAED,eAMC;IAED;;;;;;;;;;;;;;;;;;;;;;;MAMC;IAED,0BASC;CAWJ;AAED;;;;;;;;GAQG;AACH;IAcI;;;OAGG;IACH,mBAHW,qBAAqB,EAAE,GACrB,iBAAiB,CAQ7B;IA6CD;;;OAGG;IACH,4BAFa,iBAAiB,CAM7B;IA3ED;;;;;;;;;OASG;IACH,OAFU,qBAAqB,EAAE,CAEtB;IAcX;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAiBnB;IAED,eAUC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;MAIC;IAED,0BAEC;CAWJ;;;;iCA1LgC,4CAA4C"}
+{"version":3,"file":"AudioEventTrigger.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/ecs/trigger/AudioEventTrigger.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH;IAuBI;;;;;OAKG;IACH,wBALW,MAAM,SACN,gBAAgB,cAChB,MAAM,GAAC,IAAI,GACT,qBAAqB,CAUjC;IAuCD;;;OAGG;IACH,4BAFa,qBAAqB,CAMjC;IAlFD;;;;OAIG;IACH,YAFU,MAAM,CAEA;IAEhB;;;;OAIG;IACH,WAFU,MAAM,GAAC,IAAI,CAEJ;IAEjB;;;;OAIG;IACH,OAFU,gBAAgB,CAEK;IAkB/B;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CAMnB;IAED,eAMC;IAED;;;;;;;;;;;;;;;;;;;;;;;MAMC;IAED,0BASC;CAWJ;AAED;;;;;;;;GAQG;AACH;IAcI;;;OAGG;IACH,mBAHW,qBAAqB,EAAE,GACrB,iBAAiB,CAQ7B;IA6CD;;;OAGG;IACH,4BAFa,iBAAiB,CAM7B;IA3ED;;;;;;;;;OASG;IACH,OAFU,qBAAqB,EAAE,CAEtB;IAcX;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAiBnB;IAED,eAUC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;MAIC;IAED,0BAEC;CAWJ;;;;iCA1LgC,4CAA4C"}

package/src/engine/sound/ecs/trigger/AudioEventTrigger.js

@@ -1,191 +1,192 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
-import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
-import { EventDescription } from "../../sopra/definition/EventDescription.js";
-
-/**
- * One trigger rule: "when this entity receives `startEvent`, play `event`; when it receives
- * `stopEvent`, stop what this rule started".
- *
- * The legacy `SoundController.Rule` carried `tracks[] / loop / volume / channel` alongside its event
- * names, and its system did the picking and the routing at trigger time. Here all four collapse into
- * the {@link EventDescription} itself — a random pick is a `RandomContainerAudioClip`, looping is the
- * clip's own loop flag, volume is `gainDb`, and the channel is `busId`. That is the whole point of the
- * native model: what plays is authored data, not a rule the runtime re-interprets on every trigger.
- */
-export class AudioEventTriggerRule {
-
-    /**
-     * Entity event name that starts this rule's event. Required — a rule with nothing to start does
-     * nothing at all.
-     * @type {string}
-     */
-    startEvent = "";
-
-    /**
-     * Entity event name that stops whatever this rule started, or null for a fire-and-forget rule
-     * (a one-shot ends on its own; a looping event then lives until the component unlinks).
-     * @type {string|null}
-     */
-    stopEvent = null;
-
-    /**
-     * The authored event this rule plays. Same data an {@link AudioEmitter} would hold — the difference
-     * is only in what makes it sound: linking, versus receiving an entity event.
-     * @type {EventDescription}
-     */
-    event = new EventDescription();
-
-    /**
-     * @param {string} startEvent
-     * @param {EventDescription} event
-     * @param {string|null} [stopEvent]
-     * @returns {AudioEventTriggerRule}
-     */
-    static from(startEvent, event, stopEvent = null) {
-        const r = new AudioEventTriggerRule();
-
-        r.startEvent = startEvent;
-        r.event = event;
-        r.stopEvent = stopEvent;
-
-        return r;
-    }
-
-    /**
-     * @param {AudioEventTriggerRule} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        return this.startEvent === other.startEvent
-            && this.stopEvent === other.stopEvent
-            && this.event.equals(other.event);
-    }
-
-    hash() {
-        return combine_hash(
-            computeStringHash(this.startEvent),
-            this.stopEvent === null ? 0 : computeStringHash(this.stopEvent),
-            this.event.hash()
-        );
-    }
-
-    toJSON() {
-        return {
-            startEvent: this.startEvent,
-            stopEvent: this.stopEvent,
-            event: this.event.toJSON()
-        };
-    }
-
-    fromJSON(json) {
-        this.startEvent = json.startEvent !== undefined ? json.startEvent : "";
-        this.stopEvent = json.stopEvent !== undefined && json.stopEvent !== null ? json.stopEvent : null;
-
-        this.event = new EventDescription();
-
-        if (json.event !== undefined) {
-            this.event.fromJSON(json.event);
-        }
-    }
-
-    /**
-     * @param {*} json
-     * @returns {AudioEventTriggerRule}
-     */
-    static fromJSON(json) {
-        const r = new AudioEventTriggerRule();
-        r.fromJSON(json);
-        return r;
-    }
-}
-
-/**
- * Plays authored sopra events in response to entity events — the native replacement for the legacy
- * `SoundController`, whose system wrote `SoundTrack`s into the entity's `SoundEmitter` and so could not
- * outlive it.
- *
- * Where an {@link AudioEmitter} sounds because it was linked, an `AudioEventTrigger` sounds because the
- * entity received an event: "unit took damage" → a hurt sound. Driven by {@link AudioEventTriggerSystem};
- * the entity's {@link Transform} supplies position, exactly as for an emitter.
- */
-export class AudioEventTrigger {
-
-    /**
-     * Authored rules, evaluated independently — several may listen to the same event, and each owns the
-     * instances it started.
-     *
-     * Read once when the component links: the system registers one entity-event listener per rule then,
-     * so mutating this array on a linked component has no effect until it is re-linked (remove and
-     * re-add the component), which mirrors {@link AudioEmitter.event}.
-     *
-     * @type {AudioEventTriggerRule[]}
-     */
-    rules = [];
-
-    /**
-     * @param {AudioEventTriggerRule[]} rules
-     * @returns {AudioEventTrigger}
-     */
-    static from(rules) {
-        const r = new AudioEventTrigger();
-
-        r.rules = rules;
-
-        return r;
-    }
-
-    /**
-     * @param {AudioEventTrigger} other
-     * @returns {boolean}
-     */
-    equals(other) {
-        const rules = this.rules;
-        const otherRules = other.rules;
-
-        if (rules.length !== otherRules.length) {
-            return false;
-        }
-
-        for (let i = 0; i < rules.length; i++) {
-            if (!rules[i].equals(otherRules[i])) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    hash() {
-        const rules = this.rules;
-
-        let hash = rules.length;
-
-        for (let i = 0; i < rules.length; i++) {
-            hash = combine_hash(hash, rules[i].hash());
-        }
-
-        return hash;
-    }
-
-    toJSON() {
-        return {
-            rules: this.rules.map(rule => rule.toJSON())
-        };
-    }
-
-    fromJSON(json) {
-        this.rules = json.rules === undefined ? [] : json.rules.map(AudioEventTriggerRule.fromJSON);
-    }
-
-    /**
-     * @param {*} json
-     * @returns {AudioEventTrigger}
-     */
-    static fromJSON(json) {
-        const r = new AudioEventTrigger();
-        r.fromJSON(json);
-        return r;
-    }
-}
-
-AudioEventTrigger.typeName = "AudioEventTrigger";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { EventDescription } from "../../sopra/definition/EventDescription.js";
+
+/**
+ * One trigger rule: "when this entity receives `startEvent`, play `event`; when it receives
+ * `stopEvent`, stop what this rule started".
+ *
+ * The legacy `SoundController.Rule` carried `tracks[] / loop / volume / channel` alongside its event
+ * names, and its system did the picking and the routing at trigger time. Here all four collapse into
+ * the {@link EventDescription} itself — a random pick is a `RandomContainerAudioClip`, looping is the
+ * clip's own loop flag, volume is `gainDb`, and the channel is `busId`. That is the whole point of the
+ * native model: what plays is authored data, not a rule the runtime re-interprets on every trigger.
+ */
+export class AudioEventTriggerRule {
+
+    /**
+     * Entity event name that starts this rule's event. Required — a rule with nothing to start does
+     * nothing at all.
+     * @type {string}
+     */
+    startEvent = "";
+
+    /**
+     * Entity event name that stops whatever this rule started, or null for a fire-and-forget rule
+     * (a one-shot ends on its own; a looping event then lives until the component unlinks).
+     * @type {string|null}
+     */
+    stopEvent = null;
+
+    /**
+     * The authored event this rule plays. Same data an {@link AudioEmitter} would hold — the difference
+     * is only in what makes it sound: linking, versus receiving an entity event.
+     * @type {EventDescription}
+     */
+    event = new EventDescription();
+
+    /**
+     * @param {string} startEvent
+     * @param {EventDescription} event
+     * @param {string|null} [stopEvent]
+     * @returns {AudioEventTriggerRule}
+     */
+    static from(startEvent, event, stopEvent = null) {
+        const r = new AudioEventTriggerRule();
+
+        r.startEvent = startEvent;
+        r.event = event;
+        r.stopEvent = stopEvent;
+
+        return r;
+    }
+
+    /**
+     * @param {AudioEventTriggerRule} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.startEvent === other.startEvent
+            && this.stopEvent === other.stopEvent
+            && this.event.equals(other.event);
+    }
+
+    hash() {
+        return hash_mix3(
+            computeStringHash(this.startEvent),
+            this.stopEvent === null ? 0 : computeStringHash(this.stopEvent),
+            this.event.hash()
+        );
+    }
+
+    toJSON() {
+        return {
+            startEvent: this.startEvent,
+            stopEvent: this.stopEvent,
+            event: this.event.toJSON()
+        };
+    }
+
+    fromJSON(json) {
+        this.startEvent = json.startEvent !== undefined ? json.startEvent : "";
+        this.stopEvent = json.stopEvent !== undefined && json.stopEvent !== null ? json.stopEvent : null;
+
+        this.event = new EventDescription();
+
+        if (json.event !== undefined) {
+            this.event.fromJSON(json.event);
+        }
+    }
+
+    /**
+     * @param {*} json
+     * @returns {AudioEventTriggerRule}
+     */
+    static fromJSON(json) {
+        const r = new AudioEventTriggerRule();
+        r.fromJSON(json);
+        return r;
+    }
+}
+
+/**
+ * Plays authored sopra events in response to entity events — the native replacement for the legacy
+ * `SoundController`, whose system wrote `SoundTrack`s into the entity's `SoundEmitter` and so could not
+ * outlive it.
+ *
+ * Where an {@link AudioEmitter} sounds because it was linked, an `AudioEventTrigger` sounds because the
+ * entity received an event: "unit took damage" → a hurt sound. Driven by {@link AudioEventTriggerSystem};
+ * the entity's {@link Transform} supplies position, exactly as for an emitter.
+ */
+export class AudioEventTrigger {
+
+    /**
+     * Authored rules, evaluated independently — several may listen to the same event, and each owns the
+     * instances it started.
+     *
+     * Read once when the component links: the system registers one entity-event listener per rule then,
+     * so mutating this array on a linked component has no effect until it is re-linked (remove and
+     * re-add the component), which mirrors {@link AudioEmitter.event}.
+     *
+     * @type {AudioEventTriggerRule[]}
+     */
+    rules = [];
+
+    /**
+     * @param {AudioEventTriggerRule[]} rules
+     * @returns {AudioEventTrigger}
+     */
+    static from(rules) {
+        const r = new AudioEventTrigger();
+
+        r.rules = rules;
+
+        return r;
+    }
+
+    /**
+     * @param {AudioEventTrigger} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        const rules = this.rules;
+        const otherRules = other.rules;
+
+        if (rules.length !== otherRules.length) {
+            return false;
+        }
+
+        for (let i = 0; i < rules.length; i++) {
+            if (!rules[i].equals(otherRules[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    hash() {
+        const rules = this.rules;
+
+        let hash = rules.length;
+
+        for (let i = 0; i < rules.length; i++) {
+            hash = hash_mix2(hash, rules[i].hash());
+        }
+
+        return hash;
+    }
+
+    toJSON() {
+        return {
+            rules: this.rules.map(rule => rule.toJSON())
+        };
+    }
+
+    fromJSON(json) {
+        this.rules = json.rules === undefined ? [] : json.rules.map(AudioEventTriggerRule.fromJSON);
+    }
+
+    /**
+     * @param {*} json
+     * @returns {AudioEventTrigger}
+     */
+    static fromJSON(json) {
+        const r = new AudioEventTrigger();
+        r.fromJSON(json);
+        return r;
+    }
+}
+
+AudioEventTrigger.typeName = "AudioEventTrigger";

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

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 
 /**
@@ -80,7 +80,7 @@ export class AcousticMedium {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix3(
             computeHashFloat(this.airAbsorption[0]),
             computeHashFloat(this.airAbsorption[1]),
             computeHashFloat(this.airAbsorption[2])

package/src/engine/sound/simulation/definition/AcousticDirectivity.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 
 /**
@@ -79,7 +79,7 @@ export class AcousticDirectivity {
     }
 
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeHashFloat(this.dipoleWeight),
             computeHashFloat(this.dipolePower)
         );

package/src/engine/sound/simulation/definition/AcousticMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AcousticMaterial.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/definition/AcousticMaterial.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH;IA4BI;;;OAGG;IACH,uDAHW;QAAC,UAAU,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC1F,gBAAgB,CAsB5B;IAnDD;;;;OAIG;IACH,YAFU,YAAY,CAEyB;IAE/C;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,cAFU,YAAY,CAEqB;IA4B3C;;;OAGG;IACH,cAHW,gBAAgB,GACd,OAAO,CAUnB;IAED,eAUC;IAED;;OAEG;IACH,SAFa,gBAAgB,CAc5B;IAED;;;;MAMC;IAED;;OAEG;IACH,mDAFW;QAAC,UAAU,EAAC,MAAM,EAAE,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,EAAE,CAAA;KAAC,QAUzE;CACJ"}
+{"version":3,"file":"AcousticMaterial.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/definition/AcousticMaterial.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH;IA4BI;;;OAGG;IACH,uDAHW;QAAC,UAAU,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAC;QAAC,YAAY,CAAC,EAAC,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC1F,gBAAgB,CAsB5B;IAnDD;;;;OAIG;IACH,YAFU,YAAY,CAEyB;IAE/C;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;;;;;;;;;OAWG;IACH,cAFU,YAAY,CAEqB;IA4B3C;;;OAGG;IACH,cAHW,gBAAgB,GACd,OAAO,CAUnB;IAED,eAcC;IAED;;OAEG;IACH,SAFa,gBAAgB,CAc5B;IAED;;;;MAMC;IAED;;OAEG;IACH,mDAFW;QAAC,UAAU,EAAC,MAAM,EAAE,CAAC;QAAC,UAAU,EAAC,MAAM,CAAC;QAAC,YAAY,EAAC,MAAM,EAAE,CAAA;KAAC,QAUzE;CACJ"}

package/src/engine/sound/simulation/definition/AcousticMaterial.js

@@ -1,4 +1,4 @@
-import { combine_hash } from "../../../../core/collection/array/combine_hash.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 
 /**
@@ -77,12 +77,16 @@ export class AcousticMaterial {
     }
 
     hash() {
-        return combine_hash(
-            computeHashFloat(this.absorption[0]),
-            computeHashFloat(this.absorption[1]),
-            computeHashFloat(this.absorption[2]),
-            computeHashFloat(this.scattering),
-            computeHashFloat(this.transmission[0]),
+        return hash_mix3(
+            hash_mix3(
+                hash_mix3(
+                    computeHashFloat(this.absorption[0]),
+                    computeHashFloat(this.absorption[1]),
+                    computeHashFloat(this.absorption[2])
+                ),
+                computeHashFloat(this.scattering),
+                computeHashFloat(this.transmission[0])
+            ),
             computeHashFloat(this.transmission[1]),
             computeHashFloat(this.transmission[2])
         );