@woosh/meep-engine 2.169.2 → 2.169.3

package/package.json

@@ -6,7 +6,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.169.2",
+  "version": "2.169.3",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/3d/mat4/m4_decompose.d.ts

@@ -1,17 +1,13 @@
 /**
  * Decompose a 4x4 transform into position, rotation and scale.
  *
- * The three column magnitudes are computed the same way {@link m4_extract_scale} computes them, but this
- * is deliberately NOT delegated: `m4_extract_scale` reports the raw column lengths, whereas this folds a
- * reflection (negative upper-left determinant) into one scale axis so the extracted rotation is proper.
- * The two therefore return different scale values for a mirrored matrix and are not interchangeable —
- * only the three `v3_length` calls coincide, and this function needs the raw `m11..m33` components again
- * for the determinant and the rotation extraction.
+ * The three outputs are written through their setters, so `Vector3`/`Quaternion` change signals fire.
+ * Use {@link m4_decompose_array} instead when the destinations are flat arrays.
  *
- * @param {number[]} mat4
+ * @param {number[]|Float32Array|Float64Array|mat4} mat4
  * @param {Vector3|{set(x:number,y:number,z:number)}} position
- * @param {Quaternion} rotation
+ * @param {Quaternion|{set(x:number,y:number,z:number,w:number)}} rotation
  * @param {Vector3|{set(x:number,y:number,z:number)}} scale
  */
-export function m4_decompose(mat4: number[], position: any, rotation: Quaternion, scale: any): void;
+export function m4_decompose(mat4: any, position: any, rotation: any, scale: any): void;
 //# sourceMappingURL=m4_decompose.d.ts.map

package/src/core/geom/3d/mat4/m4_decompose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"m4_decompose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,mCALW,MAAM,EAAE,yDAuElB"}
+{"version":3,"file":"m4_decompose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,wFA6CC"}

package/src/core/geom/3d/mat4/m4_decompose.js

@@ -1,84 +1,64 @@
-import { v3_length } from "../../vec3/v3_length.js";
+import { m4_decompose_array } from "./m4_decompose_array.js";
+
+/**
+ * @type {Float64Array}
+ */
+const scratch = new Float64Array(10);
 
 /**
  * Decompose a 4x4 transform into position, rotation and scale.
  *
- * The three column magnitudes are computed the same way {@link m4_extract_scale} computes them, but this
- * is deliberately NOT delegated: `m4_extract_scale` reports the raw column lengths, whereas this folds a
- * reflection (negative upper-left determinant) into one scale axis so the extracted rotation is proper.
- * The two therefore return different scale values for a mirrored matrix and are not interchangeable —
- * only the three `v3_length` calls coincide, and this function needs the raw `m11..m33` components again
- * for the determinant and the rotation extraction.
+ * The three outputs are written through their setters, so `Vector3`/`Quaternion` change signals fire.
+ * Use {@link m4_decompose_array} instead when the destinations are flat arrays.
  *
- * @param {number[]} mat4
+ * @param {number[]|Float32Array|Float64Array|mat4} mat4
  * @param {Vector3|{set(x:number,y:number,z:number)}} position
- * @param {Quaternion} rotation
+ * @param {Quaternion|{set(x:number,y:number,z:number,w:number)}} rotation
  * @param {Vector3|{set(x:number,y:number,z:number)}} scale
  */
 export function m4_decompose(mat4, position, rotation, scale) {
-    const m11 = mat4[0];
-    const m12 = mat4[1];
-    const m13 = mat4[2];
-
-    const scale_x = v3_length(m11, m12, m13);
-
-    const m21 = mat4[4];
-    const m22 = mat4[5];
-    const m23 = mat4[6];
-
-    const scale_y = v3_length(m21, m22, m23);
 
-    const m31 = mat4[8];
-    const m32 = mat4[9];
-    const m33 = mat4[10];
-
-    const scale_z = v3_length(m31, m32, m33);
-
-    // If the upper-left 3x3 has a negative determinant the matrix encodes a reflection; fold that sign into
-    // one scale axis (matching three.js, which negates scale.x) so the extracted rotation is a proper rotation
-    // rather than a mirror (which __setFromRotationMatrix would decode incorrectly).
-    const det =
-        m11 * (m22 * m33 - m23 * m32)
-        - m12 * (m21 * m33 - m23 * m31)
-        + m13 * (m21 * m32 - m22 * m31);
-
-    const signed_scale_x = det < 0 ? -scale_x : scale_x;
-
-    // extract rotation matrix
-    // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
-    const is1 = signed_scale_x !== 0 ? 1 / signed_scale_x : 1e7;
-    const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
-    const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
-
-    const sm11 = m11 * is1;
-    const sm12 = m12 * is1;
-    const sm13 = m13 * is1;
+    // the scratch is what lets this share the decomposition math with `m4_decompose_array`
+    // instead of carrying a second copy of it, laid out as [translation:3, rotation:4, scale:3]
+    m4_decompose_array(
+        mat4,
+        scratch, 0,
+        scratch, 3,
+        scratch, 7
+    );
 
-    const sm21 = m21 * is2;
-    const sm22 = m22 * is2;
-    const sm23 = m23 * is2;
+    // Drain the scratch before writing anything out. The setters below dispatch change signals, and a
+    // handler is free to call this function again - that would overwrite the module-static scratch
+    // part-way through, and the rest of this call would read the re-entrant call's numbers.
+    const position_x = scratch[0];
+    const position_y = scratch[1];
+    const position_z = scratch[2];
 
-    const sm31 = m31 * is3;
-    const sm32 = m32 * is3;
-    const sm33 = m33 * is3;
+    const rotation_x = scratch[3];
+    const rotation_y = scratch[4];
+    const rotation_z = scratch[5];
+    const rotation_w = scratch[6];
 
-    // write out results
+    const scale_x = scratch[7];
+    const scale_y = scratch[8];
+    const scale_z = scratch[9];
 
     position.set(
-        mat4[12],
-        mat4[13],
-        mat4[14]
+        position_x,
+        position_y,
+        position_z
     );
 
     scale.set(
-        signed_scale_x,
+        scale_x,
         scale_y,
         scale_z
     );
 
-    rotation.__setFromRotationMatrix(
-        sm11, sm21, sm31,
-        sm12, sm22, sm32,
-        sm13, sm23, sm33
+    rotation.set(
+        rotation_x,
+        rotation_y,
+        rotation_z,
+        rotation_w
     );
 }

package/src/core/geom/3d/mat4/m4_decompose_array.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Decompose a 4x4 transform into a translation, a rotation quaternion and a (non-uniform) scale,
+ * written into flat arrays at explicit offsets.
+ *
+ * Array-argument companion to {@link m4_decompose}, which takes `Vector3`/`Quaternion` objects instead.
+ * Use this one when the destinations are already flat arrays, such as {@link Transform64} which packs
+ * all four of these in a single buffer.
+ *
+ * The three destinations may all be the same array, as long as the ranges do not overlap, and they may
+ * overlap `m4` itself - every component of `m4` is read before the first write.
+ *
+ * A reflection (negative upper-left determinant) is folded into one scale axis, so that the extracted
+ * rotation is always proper. Note that this makes the scale reported here differ from
+ * {@link m4_extract_scale}, which reports raw column lengths; the two are not interchangeable.
+ *
+ * @param {number[]|Float32Array|Float64Array|mat4} m4 source 4x4 matrix
+ * @param {number[]|Float32Array|Float64Array} translation receives 3 numbers (x, y, z)
+ * @param {number} translation_offset offset into `translation`
+ * @param {number[]|Float32Array|Float64Array} rotation receives 4 numbers (x, y, z, w)
+ * @param {number} rotation_offset offset into `rotation`
+ * @param {number[]|Float32Array|Float64Array} scale receives 3 numbers (x, y, z)
+ * @param {number} scale_offset offset into `scale`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_decompose_array(m4: number[] | Float32Array | Float64Array | mat4, translation: number[] | Float32Array | Float64Array, translation_offset: number, rotation: number[] | Float32Array | Float64Array, rotation_offset: number, scale: number[] | Float32Array | Float64Array, scale_offset: number): void;
+//# sourceMappingURL=m4_decompose_array.d.ts.map

package/src/core/geom/3d/mat4/m4_decompose_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_decompose_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose_array.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uCAXW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,OAAK,eACvC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,QAqIhB"}

package/src/core/geom/3d/mat4/m4_decompose_array.js

@@ -0,0 +1,157 @@
+import { v3_length } from "../../vec3/v3_length.js";
+
+/**
+ * Decompose a 4x4 transform into a translation, a rotation quaternion and a (non-uniform) scale,
+ * written into flat arrays at explicit offsets.
+ *
+ * Array-argument companion to {@link m4_decompose}, which takes `Vector3`/`Quaternion` objects instead.
+ * Use this one when the destinations are already flat arrays, such as {@link Transform64} which packs
+ * all four of these in a single buffer.
+ *
+ * The three destinations may all be the same array, as long as the ranges do not overlap, and they may
+ * overlap `m4` itself - every component of `m4` is read before the first write.
+ *
+ * A reflection (negative upper-left determinant) is folded into one scale axis, so that the extracted
+ * rotation is always proper. Note that this makes the scale reported here differ from
+ * {@link m4_extract_scale}, which reports raw column lengths; the two are not interchangeable.
+ *
+ * @param {number[]|Float32Array|Float64Array|mat4} m4 source 4x4 matrix
+ * @param {number[]|Float32Array|Float64Array} translation receives 3 numbers (x, y, z)
+ * @param {number} translation_offset offset into `translation`
+ * @param {number[]|Float32Array|Float64Array} rotation receives 4 numbers (x, y, z, w)
+ * @param {number} rotation_offset offset into `rotation`
+ * @param {number[]|Float32Array|Float64Array} scale receives 3 numbers (x, y, z)
+ * @param {number} scale_offset offset into `scale`
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function m4_decompose_array(
+    m4,
+    translation, translation_offset,
+    rotation, rotation_offset,
+    scale, scale_offset
+) {
+    const m11 = m4[0];
+    const m12 = m4[1];
+    const m13 = m4[2];
+
+    const scale_x = v3_length(m11, m12, m13);
+
+    const m21 = m4[4];
+    const m22 = m4[5];
+    const m23 = m4[6];
+
+    const scale_y = v3_length(m21, m22, m23);
+
+    const m31 = m4[8];
+    const m32 = m4[9];
+    const m33 = m4[10];
+
+    const scale_z = v3_length(m31, m32, m33);
+
+    const translation_x = m4[12];
+    const translation_y = m4[13];
+    const translation_z = m4[14];
+
+    // If the upper-left 3x3 has a negative determinant the matrix encodes a reflection; fold that sign into
+    // one scale axis (matching three.js, which negates scale.x) so the extracted rotation is a proper rotation
+    // rather than a mirror (which the quaternion extraction below would decode incorrectly).
+    const det =
+        m11 * (m22 * m33 - m23 * m32)
+        - m12 * (m21 * m33 - m23 * m31)
+        + m13 * (m21 * m32 - m22 * m31);
+
+    const signed_scale_x = det < 0 ? -scale_x : scale_x;
+
+    // extract rotation matrix
+    // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
+    const is1 = signed_scale_x !== 0 ? 1 / signed_scale_x : 1e7;
+    const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
+    const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
+
+    const sm11 = m11 * is1;
+    const sm12 = m12 * is1;
+    const sm13 = m13 * is1;
+
+    const sm21 = m21 * is2;
+    const sm22 = m22 * is2;
+    const sm23 = m23 * is2;
+
+    const sm31 = m31 * is3;
+    const sm32 = m32 * is3;
+    const sm33 = m33 * is3;
+
+    // Convert the rotation matrix to a quaternion.
+    // This algorithm comes from "Quaternion Calculus and Fast Animation", Ken Shoemake, 1987 SIGGRAPH course notes
+    // @see https://gitlab.com/libeigen/eigen/-/blob/master/Eigen/src/Geometry/Quaternion.h#L813
+    // NOTE: `sm` is stored column-major, so the row-major element `m_ij` used by the algorithm is `sm_ji`
+    const trace = sm11 + sm22 + sm33;
+
+    let x, y, z, w, s;
+
+    if (trace > 0) {
+
+        s = Math.sqrt(trace + 1.0);
+
+        w = 0.5 * s;
+
+        s = 0.5 / s;
+
+        x = (sm23 - sm32) * s;
+        y = (sm31 - sm13) * s;
+        z = (sm12 - sm21) * s;
+
+    } else if (sm11 > sm22 && sm11 > sm33) {
+
+        s = Math.sqrt(1.0 + sm11 - sm22 - sm33);
+
+        x = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (sm23 - sm32) * s;
+        y = (sm21 + sm12) * s;
+        z = (sm31 + sm13) * s;
+
+    } else if (sm22 > sm33) {
+
+        s = Math.sqrt(1.0 + sm22 - sm11 - sm33);
+
+        y = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (sm31 - sm13) * s;
+        x = (sm21 + sm12) * s;
+        z = (sm32 + sm23) * s;
+
+    } else {
+
+        s = Math.sqrt(1.0 + sm33 - sm11 - sm22);
+
+        z = 0.5 * s;
+
+        s = 0.5 / s;
+
+        w = (sm12 - sm21) * s;
+        x = (sm31 + sm13) * s;
+        y = (sm32 + sm23) * s;
+
+    }
+
+    // write out results
+
+    translation[translation_offset] = translation_x;
+    translation[translation_offset + 1] = translation_y;
+    translation[translation_offset + 2] = translation_z;
+
+    rotation[rotation_offset] = x;
+    rotation[rotation_offset + 1] = y;
+    rotation[rotation_offset + 2] = z;
+    rotation[rotation_offset + 3] = w;
+
+    scale[scale_offset] = signed_scale_x;
+    scale[scale_offset + 1] = scale_y;
+    scale[scale_offset + 2] = scale_z;
+}

package/src/core/primitives/strings/string_jaro_distance.d.ts

@@ -3,8 +3,8 @@
  * Higher value means more similarity.
  * @param {string} first
  * @param {string} second
- * @param {number} first_length
- * @param {number} second_length
+ * @param {number} first_length length of the first string
+ * @param {number} second_length length of the second string
  * @return {number}
  */
 export function string_jaro_distance(first: string, second: string, first_length: number, second_length: number): number;

package/src/core/primitives/strings/string_jaro_distance.js

@@ -8,16 +8,16 @@ import { min2 } from "../../math/min2.js";
  * Higher value means more similarity.
  * @param {string} first
  * @param {string} second
- * @param {number} first_length
- * @param {number} second_length
+ * @param {number} first_length length of the first string
+ * @param {number} second_length length of the second string
  * @return {number}
  */
 export function string_jaro_distance(
     first, second,
     first_length, second_length
 ) {
-    assert.isString(first,'first');
-    assert.isString(second,'second');
+    assert.isString(first, 'first');
+    assert.isString(second, 'second');
 
     // TODO can do better for short strings under 32 characters by using int32 bitmask. This would avoid allocation entirely
     const matches1 = BitSet.fixedSize(first_length);

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";AAuDA;IAoEI;;;;;;;;OAQG;IACH,8FANW,aAAa,EA0OvB;IA3RD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAmBrC;;;OAGG;IACH,yBAAwB;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,mBAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAOtC,+BAA6E;IA4C7E;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IAaD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAiGhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eA6BC;IAED;;;OAGG;IACH,sBAmDC;IAqBD;;OAEG;IACH,sBA2BC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAhrB8B,8BAA8B;wBAUrC,wBAAwB;0BApBtB,0CAA0C;wCAc5B,iDAAiD;oCAGrD,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;6BAFnD,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAlC4B,sCAAsC;4DAHP,OAAO;sBA8B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;8BAItC,wBAAwB;4BAX1B,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";AAuDA;IAoEI;;;;;;;;OAQG;IACH,8FANW,aAAa,EAwOvB;IAzRD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAmBrC;;;OAGG;IACH,yBAAwB;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,mBAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IA4BF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAOtC,+BAA6E;IA4C7E;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;MAIC;IAWD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAiGhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BAgCC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eA6BC;IAED;;;OAGG;IACH,sBAmDC;IAqBD;;OAEG;IACH,sBA2BC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BA9qB8B,8BAA8B;wBAUrC,wBAAwB;0BApBtB,0CAA0C;wCAc5B,iDAAiD;oCAGrD,iCAAiC;mBAElD,wBAAwB;+BArBZ,gDAAgD;iCAO9C,+CAA+C;6BAFnD,yBAAyB;uCAIf,6DAA6D;4BASxE,0BAA0B;+BApBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAlC4B,sCAAsC;4DAHP,OAAO;sBA8B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BADhC,kCAAkC;sBAZ1C,+BAA+B;+BAKtB,qCAAqC;8BAItC,wBAAwB;4BAX1B,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -339,8 +339,6 @@ class Engine {
             gamepad: new GamepadDevice()
         };
 
-        //init level engine
-
         this.devices.pointer.start();
         this.devices.keyboard.start();
         this.devices.gamepad.start();

package/src/engine/asset/loaders/SoundAssetLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SoundAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/SoundAssetLoader.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,qBAFW,YAAY,EAUtB;IALG;;;OAGG;IACH,cAFU,YAAY,CAEK;IAG/B,6EA6BC;CACJ;4BAhD2B,kBAAkB"}
+{"version":3,"file":"SoundAssetLoader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/asset/loaders/SoundAssetLoader.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,qBAFW,YAAY,EAUtB;IALG;;;OAGG;IACH,cAFU,YAAY,CAEK;IAG/B,6EAwCC;CACJ;4BA3D2B,kBAAkB"}

package/src/engine/asset/loaders/SoundAssetLoader.js

@@ -20,13 +20,24 @@ export class SoundAssetLoader extends AssetLoader {
         // Load a sound file using an ArrayBuffer XMLHttpRequest.
         const request = new XMLHttpRequest();
 
-        request.open("GET", this.resolvePath(path), true);
+        const url = this.resolvePath(path);
+
+        request.open("GET", url, true);
 
         request.responseType = "arraybuffer";
 
         const context = this.audioContext;
 
         request.onload = function (e) {
+            //onload fires for any completed request, 404 included -- onerror only covers
+            //network-level failure. Without this check the error page's bytes reach
+            //decodeAudioData, which fails with "Unable to decode audio data": an error that
+            //blames the file's contents when the file was simply never found.
+            if (request.status !== 0 && (request.status < 200 || request.status >= 300)) {
+                failure(new Error(`failed to load sound '${url}': HTTP ${request.status} ${request.statusText}`));
+                return;
+            }
+
             //decode works asynchronously, this is important to prevent lag in main thread
             context.decodeAudioData(request.response, function (buffer) {
                 const byteSize = e.total;

package/src/engine/ecs/gui/GUIElementSystem.d.ts

@@ -15,6 +15,15 @@ declare class GUIElementSystem extends System<any> {
      * @type {Object<View>}
      */
     groups: any;
+    /**
+     * Contexts of {@link handleComponentVisibilityChange}, keyed by entity. Signal handlers are
+     * matched on the handle *and* the context, so the context has to survive until unlink,
+     * otherwise the handler stays subscribed for the lifetime of the component.
+     * @private
+     * @readonly
+     * @type {Map<number, object>}
+     */
+    private readonly visibilityContexts;
     containerView: View;
     /**
      * @type {ModuleRegistry}

package/src/engine/ecs/gui/GUIElementSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAiCA,gFAAiF;;AAEjF;IAyBI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IA9DD,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IA2BR,oBAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,gCAGC;IAED,iCAEC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAiDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAiBpB;CACJ;uBAhRsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}
+{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAiCA,gFAAiF;;AAEjF;IAmCI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IAxED,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IAEZ;;;;;;;OAOG;IACH,oCAA+B;IA2B3B,oBAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,gCAGC;IAED,iCAEC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAqDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAuBpB;CACJ;uBApSsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}

package/src/engine/ecs/gui/GUIElementSystem.js

@@ -58,6 +58,16 @@ class GUIElementSystem extends System {
      */
     groups = {};
 
+    /**
+     * Contexts of {@link handleComponentVisibilityChange}, keyed by entity. Signal handlers are
+     * matched on the handle *and* the context, so the context has to survive until unlink,
+     * otherwise the handler stays subscribed for the lifetime of the component.
+     * @private
+     * @readonly
+     * @type {Map<number, object>}
+     */
+    visibilityContexts = new Map();
+
     /**
      *
      * @param {View} containerView
@@ -245,11 +255,15 @@ class GUIElementSystem extends System {
             this.attachComponent(component, entity);
         }
 
-        component.visible.onChanged.add(handleComponentVisibilityChange, {
+        const visibilityContext = {
             el: component,
             system: this,
             entity
-        });
+        };
+
+        this.visibilityContexts.set(entity, visibilityContext);
+
+        component.visible.onChanged.add(handleComponentVisibilityChange, visibilityContext);
     }
 
     /**
@@ -258,7 +272,13 @@ class GUIElementSystem extends System {
      * @param entity
      */
     unlink(component, entity) {
-        component.visible.onChanged.remove(handleComponentVisibilityChange);
+        const visibilityContext = this.visibilityContexts.get(entity);
+
+        if (visibilityContext !== undefined) {
+            this.visibilityContexts.delete(entity);
+
+            component.visible.onChanged.remove(handleComponentVisibilityChange, visibilityContext);
+        }
 
         if (component.visible.getValue()) {
             this.detachComponent(component, entity);

package/src/engine/ecs/gui/position/ViewportPositionSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewportPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPositionSystem.js"],"names":[],"mappings":";AAwBA;IACI,+BAoBC;IAjBG,8DAAkD;IAElD,kEAEC;IAED,kBAAgC;IAEhC,yCAME;IAEF,SAAc;IAGlB,2CAEC;IAED,4CAEC;IAED;;;OAGG;IACH,sBAHW,UAAU,MACV,gBAAgB,QAkE1B;IAED;;;;;OAKG;IACH,SAJW,gBAAgB,MAChB,UAAU,qBA8BpB;IAED;;;;;OAKG;IACH,WAJW,gBAAgB,MAChB,UAAU,qBAmBpB;IAgGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CAjGxD;uBAlLsB,iBAAiB;uBACjB,kBAAkB;6BAEZ,uBAAuB;4CAJR,uDAAuD;8BALrE,iDAAiD"}
+{"version":3,"file":"ViewportPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPositionSystem.js"],"names":[],"mappings":";AAwBA;IACI,+BAoBC;IAjBG,8DAAkD;IAElD,kEAEC;IAED,kBAAgC;IAEhC,yCAME;IAEF,SAAc;IAGlB,2CAEC;IAED,4CAEC;IAED;;;OAGG;IACH,sBAHW,UAAU,MACV,gBAAgB,QAkE1B;IAED;;;;;OAKG;IACH,SAJW,gBAAgB,MAChB,UAAU,qBA8BpB;IAED;;;;;OAKG;IACH,WAJW,gBAAgB,MAChB,UAAU,qBAqBpB;IAgGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CAjGxD;uBApLsB,iBAAiB;uBACjB,kBAAkB;6BAEZ,uBAAuB;4CAJR,uDAAuD;8BALrE,iDAAiD"}

package/src/engine/ecs/gui/position/ViewportPositionSystem.js

@@ -175,9 +175,11 @@ class ViewportPositionSystem extends System {
             vp.offset.onChanged.remove(updatePosition, eventContext);
             vp.anchor.onChanged.remove(updatePosition, eventContext);
             vp.enabled.onChanged.remove(updatePosition, eventContext);
-        }
 
-        this.entityManager.dataset.removeEntityEventListener(entity, GUIElementEvent.Initialized, updatePosition, eventContext);
+            el.view.size.onChanged.remove(updatePosition, eventContext);
+
+            this.entityManager.dataset.removeEntityEventListener(entity, GUIElementEvent.Initialized, updatePosition, eventContext);
+        }
 
         el.view.removeClass(CSS_CLASS);
     }