@woosh/meep-engine 2.131.46 → 2.131.47

package/package.json

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

package/src/core/collection/heap/BinaryHeap.d.ts

@@ -1,16 +1,21 @@
 export default BinaryHeap;
 /**
  * Min-Heap implementation with a score function.
- * The data structure is a binary heap where elements are removed in order defined by scoring function
+ * Elements are removed in ascending order by their score, meaning that the item with the lowest score is removed first.
+ * The data structure is a binary heap where elements are removed in order defined by scoring function.
+ *
+ * The most common use case for this structure is for a priority queue.
+ *
  * @template T
+ * @see Uint32Heap
  */
 declare class BinaryHeap<T> {
     /**
      * @template T
-     * @param {function(el:T):number} scoreFunction
+     * @param {function(el:T):number} min_score_function
      * @constructor
      */
-    constructor(scoreFunction: any);
+    constructor(min_score_function: any);
     /**
      * @private
      * @type {T[]}

package/src/core/collection/heap/BinaryHeap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;GAIG;AACH;IAaI;;;;OAIG;IACH,gCAQC;IAzBD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IASP;;;OAGG;IACH,8BAFuB,MAAM,CAEK;IAItC;;;OAGG;IACH,iBA8BC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}
+{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;;;;;;GASG;AACH;IAaI;;;;OAIG;IACH,qCAUC;IA3BD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IAWP;;;OAGG;IACH,8BAFuB,MAAM,CAEU;IAI3C;;;OAGG;IACH,iBAkCC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}

package/src/core/collection/heap/BinaryHeap.js

@@ -2,8 +2,13 @@ import { assert } from "../../assert.js";
 
 /**
  * Min-Heap implementation with a score function.
- * The data structure is a binary heap where elements are removed in order defined by scoring function
+ * Elements are removed in ascending order by their score, meaning that the item with the lowest score is removed first.
+ * The data structure is a binary heap where elements are removed in order defined by scoring function.
+ *
+ * The most common use case for this structure is for a priority queue.
+ *
  * @template T
+ * @see Uint32Heap
  */
 class BinaryHeap {
     /**
@@ -20,16 +25,18 @@ class BinaryHeap {
 
     /**
      * @template T
-     * @param {function(el:T):number} scoreFunction
+     * @param {function(el:T):number} min_score_function
      * @constructor
      */
-    constructor(scoreFunction) {
+    constructor(min_score_function) {
+
+        assert.isFunction(min_score_function, "scoreFunction");
 
         /**
          *
          * @type {function(T): number}
          */
-        this.scoreFunction = scoreFunction;
+        this.scoreFunction = min_score_function;
 
     }
 
@@ -46,8 +53,10 @@ class BinaryHeap {
 
         let index = pos;
 
-        let value = data[index];
-        let score = this.scoreFunction(value);
+        const value = data[index];
+        const score = this.scoreFunction(value);
+
+        assert.isNumber(score, "score");
 
         while (index > 0) {
 
@@ -56,6 +65,8 @@ class BinaryHeap {
             const parentValue = data[parentIndex];
             const parentScore = this.scoreFunction(parentValue);
 
+            assert.isNumber(parentScore, "parentScore");
+
             if (score < parentScore) {
                 //swap
 

package/src/core/collection/heap/Uint32Heap.d.ts

@@ -1,7 +1,8 @@
 /**
- * Binary Heap implementation that stores uin32 ID along with a floating point score value
- * Very fast and compact
- * Inspired by Blender's heap implementation found here: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/BLI_heap.c
+ * Binary Heap implementation that stores uin32 ID along with a floating point score value.
+ * Very fast and compact.
+ *
+ * @see BinaryHeap
  */
 export class Uint32Heap {
     /**

package/src/core/collection/heap/Uint32Heap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Uint32Heap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/Uint32Heap.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH;IACI;;;OAGG;IACH,+BAFW,MAAM,EAkChB;IA7BG,2BAA0E;IAE1E;;;;OAIG;IACH,sBAAwD;IAExD;;;;OAIG;IACH,uBAA0D;IAE1D;;;;OAIG;IACH,mBAAkC;IAElC;;;;OAIG;IACH,eAAe;IAGnB;;;OAGG;IACH,wBAsBC;IAED;;;;;OAKG;IACH,gBAOC;IAED;;;;;OAKG;IACH,aAiBC;IAED;;;OAGG;IACH,kBA6BC;IAED;;;;OAIG;IACH,gBAeC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED,mBAEC;IAED,kBAoBC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAWnB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAehB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,SACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CAYlB;IAGD;;;;OAIG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,WAHW,MAAM,SACN,MAAM,QA0BhB;CAGJ"}
+{"version":3,"file":"Uint32Heap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/Uint32Heap.js"],"names":[],"mappings":"AAiDA;;;;;GAKG;AACH;IAGI;;;OAGG;IACH,+BAFW,MAAM,EAkChB;IA7BG,2BAA0E;IAE1E;;;;OAIG;IACH,sBAAwD;IAExD;;;;OAIG;IACH,uBAA0D;IAE1D;;;;OAIG;IACH,mBAAkC;IAElC;;;;OAIG;IACH,eAAe;IAGnB;;;OAGG;IACH,wBAsBC;IAED;;;;;OAKG;IACH,gBAOC;IAED;;;;;OAKG;IACH,aAiBC;IAED;;;OAGG;IACH,kBA6BC;IAED;;;;OAIG;IACH,gBAeC;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,YAFa,OAAO,CAInB;IAED,mBAEC;IAED,kBAoBC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACJ,OAAO,CAWnB;IAED;;;OAGG;IACH,yBAFW,MAAM,QAehB;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,+BAHW,MAAM,SACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,MAAM,CAYlB;IAGD;;;;OAIG;IACH,qBAHW,MAAM,SACN,MAAM,QAUhB;IAED;;;;OAIG;IACH,WAHW,MAAM,SACN,MAAM,QA0BhB;CAGJ"}

package/src/core/collection/heap/Uint32Heap.js

@@ -48,11 +48,14 @@ function HEAP_RIGHT(i) {
 }
 
 /**
- * Binary Heap implementation that stores uin32 ID along with a floating point score value
- * Very fast and compact
- * Inspired by Blender's heap implementation found here: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/BLI_heap.c
+ * Binary Heap implementation that stores uin32 ID along with a floating point score value.
+ * Very fast and compact.
+ *
+ * @see BinaryHeap
  */
 export class Uint32Heap {
+    // Inspired by Blender's heap implementation found here: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/BLI_heap.c
+
     /**
      *
      * @param {number} [initial_capacity] Can supply initial capacity, heap will still grow when necessary. This allows to prevent needless re-allocations when max heap size is known in advance

package/src/core/geom/3d/plane/plane3_matrix4_project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plane3_matrix4_project.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/plane3_matrix4_project.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,oDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAyBhB"}
+{"version":3,"file":"plane3_matrix4_project.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/plane3_matrix4_project.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,oDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB"}

package/src/core/geom/3d/plane/plane3_matrix4_project.js

@@ -1,7 +1,10 @@
-import { m4_invert } from "../mat4/m4_invert.js";
-
-const mat_inv = new Float32Array(16);
+import { v3_dot_array_array } from "../../vec3/v3_dot_array_array.js";
+import { v3_matrix4_multiply } from "../../vec3/v3_matrix4_multiply.js";
+import { v3_matrix4_rotate } from "../../vec3/v3_matrix4_rotate.js";
+import { v3_matrix4_rotate_normal } from "../../vec3/v3_matrix4_rotate_normal.js";
+import { v3_multiply_scalar } from "../../vec3/v3_multiply_scalar.js";
 
+const scratch_v3_0 = new Float32Array(3);
 
 /**
  *
@@ -19,21 +22,13 @@ export function plane3_matrix4_project(
     x, y, z, w,
 ) {
 
-    // the formula is = vec4*T(-mat4)
-
-    m4_invert(mat_inv, matrix);
-
-    // multiply by transpose
-    const nx = x * mat_inv[0] + y * mat_inv[1] + z * mat_inv[2] + w * mat_inv[3];
-    const ny = x * mat_inv[4] + y * mat_inv[5] + z * mat_inv[6] + w * mat_inv[7];
-    const nz = x * mat_inv[8] + y * mat_inv[9] + z * mat_inv[10] + w * mat_inv[11];
-    const nw = x * mat_inv[12] + y * mat_inv[13] + z * mat_inv[14] + w * mat_inv[15];
+    // build reference point in the new pane
+    v3_multiply_scalar(scratch_v3_0, 0, x, y, z, -w);
+    v3_matrix4_multiply(scratch_v3_0, 0, scratch_v3_0, 0, matrix);
 
-    // Re-normalize
-    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    // rotate normal vector
+    v3_matrix4_rotate_normal(destination, destination_offset, x, y, z, matrix);
 
-    destination[destination_offset] = nx / len;
-    destination[destination_offset + 1] = ny / len;
-    destination[destination_offset + 2] = nz / len;
-    destination[destination_offset + 3] = nw / len;
+    // figure out the new planar offset using new orientation and a reference point
+    destination[destination_offset + 3] = -v3_dot_array_array(scratch_v3_0, 0, destination, destination_offset);
 }

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts

@@ -1,5 +1,10 @@
 /**
- * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ *
+ * Perform rotation on a direction vector using a 4x4 affine transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
  * @param {number[]|Float32Array} output
  * @param {number} output_offset
  * @param {number} x

package/src/core/geom/vec3/v3_matrix4_rotate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAoB/B"}
+{"version":3,"file":"v3_matrix4_rotate.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,0CAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAkC/B"}

package/src/core/geom/vec3/v3_matrix4_rotate.js

@@ -1,10 +1,12 @@
-import { m4_invert } from "../3d/mat4/m4_invert.js";
 import { v3_length } from "./v3_length.js";
 
-const m4_inv = new Float32Array(16);
-
 /**
- * Perform rotation on a direction vector using 3x3 portion of a 4x4 matrix
+ *
+ * Perform rotation on a direction vector using a 4x4 affine transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
  * @param {number[]|Float32Array} output
  * @param {number} output_offset
  * @param {number} x
@@ -18,16 +20,32 @@ export function v3_matrix4_rotate(
     m4
 ) {
 
-    m4_invert(m4_inv, m4);
-
-    const _x = m4_inv[0] * x + m4_inv[1] * y + m4_inv[2] * z;
-    const _y = m4_inv[4] * x + m4_inv[5] * y + m4_inv[6] * z;
-    const _z = m4_inv[8] * x + m4_inv[9] * y + m4_inv[10] * z;
+    const _x = m4[0] * x + m4[4] * y + m4[8] * z;
+    const _y = m4[1] * x + m4[5] * y + m4[9] * z;
+    const _z = m4[2] * x + m4[6] * y + m4[10] * z;
 
     // perform normalization
-    const norm = 1 / v3_length(_x, _y, _z);
+    const length = v3_length(_x, _y, _z);
+
+    if (length > 1e-7) {
+
+        // re-normalize
+        const norm = 1 / length;
+
+        output[output_offset] = _x * norm;
+        output[output_offset + 1] = _y * norm;
+        output[output_offset + 2] = _z * norm;
+
+    } else {
+
+        // The transform is invalid.
+        // Provide arbitrary vector.
+
+        output[output_offset] = 0;
+        output[output_offset + 1] = 0;
+        output[output_offset + 2] = 0;
+
+    }
+}
+
 
-    output[output_offset] = _x * norm;
-    output[output_offset + 1] = _y * norm;
-    output[output_offset + 2] = _z * norm;
-}

package/src/core/geom/vec3/v3_matrix4_rotate_normal.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * Perform rotation on a normal vector using a 4x4 affine transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate_normal(output: number[] | Float32Array, output_offset: number, x: number, y: number, z: number, m4: number[] | Float32Array): void;
+//# sourceMappingURL=v3_matrix4_rotate_normal.d.ts.map

package/src/core/geom/vec3/v3_matrix4_rotate_normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_matrix4_rotate_normal.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_matrix4_rotate_normal.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,iDAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,EAAE,GAAC,YAAY,QAqC/B"}

package/src/core/geom/vec3/v3_matrix4_rotate_normal.js

@@ -0,0 +1,55 @@
+import { m4_invert } from "../3d/mat4/m4_invert.js";
+import { v3_length } from "./v3_length.js";
+
+const m4_inv = new Float32Array(16);
+
+/**
+ *
+ * Perform rotation on a normal vector using a 4x4 affine transform matrix.
+ * Input is expected to be normalized.
+ * Correctly handles non-uniform scaling.
+ * Output is normalized.
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]|Float32Array} m4
+ */
+export function v3_matrix4_rotate_normal(
+    output, output_offset,
+    x, y, z,
+    m4
+) {
+
+    m4_invert(m4_inv, m4);
+
+    // this is transposed multiplication: T(M) * vec3
+    const _x = m4_inv[0] * x + m4_inv[1] * y + m4_inv[2] * z;
+    const _y = m4_inv[4] * x + m4_inv[5] * y + m4_inv[6] * z;
+    const _z = m4_inv[8] * x + m4_inv[9] * y + m4_inv[10] * z;
+
+    // perform normalization
+    const length = v3_length(_x, _y, _z);
+
+    if (length > 1e-7) {
+
+        // re-normalize
+        const norm = 1 / length;
+
+        output[output_offset] = _x * norm;
+        output[output_offset + 1] = _y * norm;
+        output[output_offset + 2] = _z * norm;
+
+    } else {
+
+        // The transform is invalid.
+        // Provide arbitrary vector.
+
+        output[output_offset] = 0;
+        output[output_offset + 1] = 0;
+        output[output_offset + 2] = 0;
+
+    }
+}