@woosh/meep-engine 2.131.45 → 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.45",
+  "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/frustum/clipping_volume_matrix4_project.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Perform affine transform on a given frustum
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_offset
+ * @param {number} plane_count
+ * @param {number[]|Float32Array|Float64Array} matrix4
+ */
+export function clipping_volume_matrix4_project(output: number[] | Float32Array | Float64Array, output_offset: number, input: number[] | Float32Array | Float64Array, input_offset: number, plane_count: number, matrix4: number[] | Float32Array | Float64Array): void;
+//# sourceMappingURL=clipping_volume_matrix4_project.d.ts.map

package/src/core/geom/3d/frustum/clipping_volume_matrix4_project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipping_volume_matrix4_project.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/clipping_volume_matrix4_project.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,wDAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,eACN,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAkC5C"}

package/src/core/geom/3d/frustum/clipping_volume_matrix4_project.js

@@ -0,0 +1,45 @@
+import { assert } from "../../../assert.js";
+import { plane3_matrix4_project } from "../plane/plane3_matrix4_project.js";
+
+/**
+ * Perform affine transform on a given frustum
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array|Float64Array} input
+ * @param {number} input_offset
+ * @param {number} plane_count
+ * @param {number[]|Float32Array|Float64Array} matrix4
+ */
+export function clipping_volume_matrix4_project(
+    output, output_offset,
+    input, input_offset,
+    plane_count,
+    matrix4
+) {
+    assert.isArrayLike(output, 'output');
+    assert.isNonNegativeInteger(output_offset, "output_offset");
+
+    assert.isArrayLike(input, 'input');
+    assert.greaterThanOrEqual(input.length, input_offset + plane_count*4, 'input too small');
+    assert.isNonNegativeInteger(input_offset, "input_offset");
+
+    assert.isArrayLike(matrix4, 'matrix4');
+
+    for (let plane_index = 0; plane_index < plane_count; plane_index++) {
+        const frustum_offset = plane_index * 4;
+
+        const i = input_offset + frustum_offset;
+        const o = output_offset + frustum_offset;
+
+        plane3_matrix4_project(
+            output, o,
+            matrix4,
+            input[i],
+            input[i + 1],
+            input[i + 2],
+            input[i + 3],
+        );
+
+    }
+
+}

package/src/core/geom/3d/frustum/frustum_matrix4_project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"frustum_matrix4_project.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/frustum_matrix4_project.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAiC5C"}
+{"version":3,"file":"frustum_matrix4_project.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/frustum_matrix4_project.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,gDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,WACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAQ5C"}

package/src/core/geom/3d/frustum/frustum_matrix4_project.js

@@ -1,5 +1,5 @@
-import { assert } from "../../../assert.js";
-import { plane3_matrix4_project } from "../plane/plane3_matrix4_project.js";
+import { clipping_volume_matrix4_project } from "./clipping_volume_matrix4_project.js";
+
 
 /**
  * Perform affine transform on a given frustum
@@ -13,31 +13,6 @@ export function frustum_matrix4_project(
     output, output_offset,
     input, input_offset,
     matrix4
-) {
-    assert.isArrayLike(output, 'output');
-    assert.isNonNegativeInteger(output_offset, "output_offset");
-
-    assert.isArrayLike(input, 'input');
-    assert.greaterThanOrEqual(input.length, input_offset + 24, 'input too small');
-    assert.isNonNegativeInteger(input_offset, "input_offset");
-    
-    assert.isArrayLike(matrix4, 'matrix4');
-
-    for (let plane_index = 0; plane_index < 6; plane_index++) {
-        const frustum_offset = plane_index * 4;
-
-        const i = input_offset + frustum_offset;
-        const o = output_offset + frustum_offset;
-
-        plane3_matrix4_project(
-            output, o,
-            matrix4,
-            input[i],
-            input[i + 1],
-            input[i + 2],
-            input[i + 3],
-        );
-
-    }
-
+){
+    clipping_volume_matrix4_project(output, output_offset, input, input_offset, 6, matrix4);
 }

package/src/core/geom/3d/frustum/hexahedron_from_aabb.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Constructs an orthographic hexahedron from an Axis-Aligned Bounding Box.
+ * The planes are stored as 4-tuples (nx, ny, nz, d).
+ *
+ * Normals are facing inwards, i.e., the volume of positive.
+ *
+ * This can also be used for an orthographic camera frustum.
+ *
+ * @param {Float32Array|number[]} output
+ * @param {number} output_offset
+ * @param {number} x0 - Minimum X
+ * @param {number} y0 - Minimum Y
+ * @param {number} z0 - Minimum Z
+ * @param {number} x1 - Maximum X
+ * @param {number} y1 - Maximum Y
+ * @param {number} z1 - Maximum Z
+ */
+export function hexahedron_from_aabb(output: Float32Array | number[], output_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
+//# sourceMappingURL=hexahedron_from_aabb.d.ts.map

package/src/core/geom/3d/frustum/hexahedron_from_aabb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexahedron_from_aabb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/hexahedron_from_aabb.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,6CATW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA4ChB"}

package/src/core/geom/3d/frustum/{frustum_from_aabb.js → hexahedron_from_aabb.js}

@@ -1,6 +1,11 @@
 /**
- * Constructs an orthographic frustum from an Axis-Aligned Bounding Box.
+ * Constructs an orthographic hexahedron from an Axis-Aligned Bounding Box.
  * The planes are stored as 4-tuples (nx, ny, nz, d).
+ *
+ * Normals are facing inwards, i.e., the volume of positive.
+ *
+ * This can also be used for an orthographic camera frustum.
+ *
  * @param {Float32Array|number[]} output
  * @param {number} output_offset
  * @param {number} x0 - Minimum X
@@ -10,36 +15,36 @@
  * @param {number} y1 - Maximum Y
  * @param {number} z1 - Maximum Z
  */
-export function frustum_from_aabb(
+export function hexahedron_from_aabb(
     output,
     output_offset,
     x0, y0, z0,
     x1, y1, z1
 ){
-
-    // Left plane (x = x0): Normal points +X
-    output[output_offset + 0] = 1;
+    
+    // Right plane (x = x1): Normal points -X
+    output[output_offset + 0] = -1;
     output[output_offset + 1] = 0;
     output[output_offset + 2] = 0;
-    output[output_offset + 3] = -x0;
+    output[output_offset + 3] = x1;
 
-    // Right plane (x = x1): Normal points -X
-    output[output_offset + 4] = -1;
+    // Left plane (x = x0): Normal points +X
+    output[output_offset + 4] = 1;
     output[output_offset + 5] = 0;
     output[output_offset + 6] = 0;
-    output[output_offset + 7] = x1;
+    output[output_offset + 7] = -x0;
 
-    // Bottom plane (y = y0): Normal points +Y
+    // Top plane (y = y1): Normal points -Y
     output[output_offset + 8] = 0;
-    output[output_offset + 9] = 1;
+    output[output_offset + 9] = -1;
     output[output_offset + 10] = 0;
-    output[output_offset + 11] = -y0;
+    output[output_offset + 11] = y1;
 
-    // Top plane (y = y1): Normal points -Y
+    // Bottom plane (y = y0): Normal points +Y
     output[output_offset + 12] = 0;
-    output[output_offset + 13] = -1;
+    output[output_offset + 13] = 1;
     output[output_offset + 14] = 0;
-    output[output_offset + 15] = y1;
+    output[output_offset + 15] = -y0;
 
     // Near plane (z = z0): Normal points +Z
     output[output_offset + 16] = 0;

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,QAuBhB"}
+{"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,19 +22,13 @@ export function plane3_matrix4_project(
     x, y, z, w,
 ) {
 
-    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;
+
+    }
+}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh32_geometry_overlap_clipping_volume.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,uFAVW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,UACpC,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,GACJ,OAAO,CAmFnB"}
+{"version":3,"file":"bvh32_geometry_overlap_clipping_volume.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;GAYG;AACH,uFAVW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,iBAC1B,MAAM,iBACN,MAAM,0BACN,OAAO,WACP,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,SAAS,UACpC,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,GACJ,OAAO,CAuFnB"}

package/src/engine/graphics/geometry/buffered/query/bvh32_geometry_overlap_clipping_volume.js

@@ -32,6 +32,10 @@ export function bvh32_geometry_overlap_clipping_volume(
     planes, planes_offset, plane_count
 ) {
 
+    assert.isBoolean(vertex_data_normalized, 'vertex_data_normalized');
+    assert.isNonNegativeInteger(planes_offset, 'planes_offset');
+    assert.isNonNegativeInteger(plane_count, 'plane_count');
+
     const hit_count = bvh32_query_user_data_overlaps_clipping_volume(
         scratch_array, 0,
         bvh,
@@ -79,7 +83,7 @@ export function bvh32_geometry_overlap_clipping_volume(
         let cz = vertices[c_address + 2];
 
         // denormalize if necessary
-        if(vertex_data_normalized) {
+        if (vertex_data_normalized) {
             ax = typed_array_value_denormalize(ax, vertices);
             ay = typed_array_value_denormalize(ay, vertices);
             az = typed_array_value_denormalize(az, vertices);

package/src/core/geom/3d/frustum/frustum_from_aabb.d.ts

@@ -1,14 +0,0 @@
-/**
- * Constructs an orthographic frustum from an Axis-Aligned Bounding Box.
- * The planes are stored as 4-tuples (nx, ny, nz, d).
- * @param {Float32Array|number[]} output
- * @param {number} output_offset
- * @param {number} x0 - Minimum X
- * @param {number} y0 - Minimum Y
- * @param {number} z0 - Minimum Z
- * @param {number} x1 - Maximum X
- * @param {number} y1 - Maximum Y
- * @param {number} z1 - Maximum Z
- */
-export function frustum_from_aabb(output: Float32Array | number[], output_offset: number, x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
-//# sourceMappingURL=frustum_from_aabb.d.ts.map

package/src/core/geom/3d/frustum/frustum_from_aabb.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"frustum_from_aabb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/frustum_from_aabb.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,0CATW,YAAY,GAAC,MAAM,EAAE,iBACrB,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA4ChB"}