@woosh/meep-engine 2.109.1 → 2.109.3

package/src/core/collection/array/array_quick_sort_by_lookup_map.js

@@ -0,0 +1,79 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../SCRATCH_UINT32_TRAVERSAL_STACK.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ * @template T
+ * @param {T[]} data
+ * @param {Map<T,number>} lookup
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_lookup_map(
+    data,
+    lookup,
+    start, end
+) {
+    if (start >= end) {
+        // section of 0 size, nothing to sort
+        return;
+    }
+
+    const stack_frame = start.pointer;
+    let stackPointer = stack_frame;
+
+    let i, j;
+
+    stack[stackPointer++] = start;
+    stack[stackPointer++] = end;
+
+    while (stackPointer > stack_frame) {
+        stackPointer -= 2;
+
+        const right = stack[stackPointer + 1];
+        const left = stack[stackPointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        const pivot = data[pivotIndex];
+        const pivot_score = lookup.get(pivot);
+
+        /* partition */
+        while (i <= j) {
+            while (lookup.get(data[i]) < pivot_score) {
+                i++;
+            }
+
+            while (lookup.get(data[j]) > pivot_score) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    const tmp = data[i];
+                    data[i] = data[j];
+                    data[j] = tmp;
+
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack[stackPointer++] = left;
+            stack[stackPointer++] = j;
+        }
+        if (i < right) {
+            stack[stackPointer++] = i;
+            stack[stackPointer++] = right;
+        }
+    }
+}

package/src/core/collection/array/array_quick_sort_by_lookup_uint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {number[]|Uint32Array} data
+ * @param {number[]|Uint32Array} lookup
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_lookup_uint(data: number[] | Uint32Array, lookup: number[] | Uint32Array, start: number, end: number): void;
+//# sourceMappingURL=array_quick_sort_by_lookup_uint.d.ts.map

package/src/core/collection/array/array_quick_sort_by_lookup_uint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array_quick_sort_by_lookup_uint.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_quick_sort_by_lookup_uint.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,sDALW,MAAM,EAAE,GAAC,WAAW,UACpB,MAAM,EAAE,GAAC,WAAW,SACpB,MAAM,OACN,MAAM,QAqEhB"}

package/src/core/collection/array/{array_quick_sort_by_lookup.js → array_quick_sort_by_lookup_uint.js}

@@ -8,7 +8,7 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @param {number} start
  * @param {number} end
  */
-export function array_quick_sort_by_lookup(
+export function array_quick_sort_by_lookup_uint(
     data,
     lookup,
     start, end

package/src/core/collection/array/array_shuffle.js

@@ -10,7 +10,7 @@ import { array_swap_one } from "./array_swap_one.js";
 export function array_shuffle(random, array) {
     const n = array.length;
 
-    for (let source_index = 0; source_index < n; source_index++) {
+    for (let source_index = 0; source_index < n; ++source_index) {
         const target_index = randomIntegerBetween(random, 0, n - (source_index + 1));
 
         if (target_index === source_index) {

package/src/core/collection/array/array_swap_one.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"array_swap_one.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_swap_one.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,sDAHW,MAAM,UACN,MAAM,QAOhB"}
+{"version":3,"file":"array_swap_one.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_swap_one.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,sDAHW,MAAM,UACN,MAAM,QAWhB"}

package/src/core/collection/array/array_swap_one.js

@@ -1,3 +1,5 @@
+import { assert } from "../../assert.js";
+
 /**
  * @template T
  * @param {T[]} array
@@ -5,6 +7,10 @@
  * @param {number} index1
  */
 export function array_swap_one(array, index0, index1) {
+    assert.isArrayLike(array, 'array');
+    assert.isNonNegativeInteger(index0, 'index0');
+    assert.isNonNegativeInteger(index1, 'index1');
+
     const t = array[index0];
 
     array[index0] = array[index1];

package/src/core/collection/map/HashMap.js

@@ -337,11 +337,11 @@ export class HashMap {
             return true;
         }
 
-        assert.equal(record.hash, this.#build_key_hash(record.key), `Key hash has diverged for key ${record.key}, likely key was mutated or hash function is unstable`);
+        // assert.equal(record.hash, this.#build_key_hash(record.key), `Key hash has diverged for key ${record.key}, likely key was mutated or hash function is unstable`);
 
         const result = this.keyEqualityFunction(record.key, key);
 
-        assert.isBoolean(result, `result(a=${record.key},b=${key})`);
+        // assert.isBoolean(result, `result(a=${record.key},b=${key})`);
 
         return result;
     }

package/src/core/events/signal/Signal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/signal/Signal.js"],"names":[],"mappings":"AAulBA;;;;;;GAMG;AACH,yDALW,aAAa,EAAE,+BAGb,MAAM,CAoBlB;AAED;;;;;;GAMG;AACH,mEALW,aAAa,EAAE,0BAGb,MAAM,CAclB;AAiDD;;;;GAIG;AACH,2CAHW,aAAa,EAAE,sBA8BzB;AAnsBD;;;;GAIG;AACH;IACI;;;OAGG;IACH,iBAAc;IAEd;;;;OAIG;IACH,cAAU;IAWV;;;OAGG;IACH,yBAEC;IAfD;;;OAGG;IACH,sBAEC;IAYD;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,SAClB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,OAAO,CAInB;IAGD;;;;;OAKG;IACH,4CAFa,OAAO,CAQnB;IAED,aAEC;IAED,eAEC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yCAQC;IAED;;;;OAIG;IACH,sCAYC;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAUnB;IAED;;;;;;OAMG;IACH,kBAGC;IAED;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,cA4CC;IAED;;;;OAIG;IACH,sBA6CC;IAED;;;;OAIG;IACH,4BA4CC;IAED;;;;;OAKG;IACH,oCA4CC;IAED;;;;;;OAMG;IACH,4CA4CC;IAED;;;;;;;;OAQG;IACH,4DA4CC;IAED;;;;;;;;;;OAUG;IACH,4EA4CC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAalB;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;CAPxB;;8BArkBiD,oBAAoB"}
+{"version":3,"file":"Signal.d.ts","sourceRoot":"","sources":["../../../../../src/core/events/signal/Signal.js"],"names":[],"mappings":"AAglBA;;;;;;GAMG;AACH,yDALW,aAAa,EAAE,+BAGb,MAAM,CAoBlB;AAED;;;;;;GAMG;AACH,mEALW,aAAa,EAAE,0BAGb,MAAM,CAelB;AAuDD;;;;GAIG;AACH,2CAHW,aAAa,EAAE,sBA8BzB;AA1sBD;;;;GAIG;AACH;IACI;;;OAGG;IACH,iBAAc;IAEd;;;;OAIG;IACH,cAAU;IAWV;;;OAGG;IACH,yBAEC;IAfD;;;OAGG;IACH,sBAEC;IAYD;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,GAChB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM;;KAAY,SAClB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM;;KAAY,GAChB,OAAO,CAInB;IAGD;;;;;OAKG;IACH,4CAFa,OAAO,CAQnB;IAED,aAEC;IAED,eAEC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,yCAQC;IAED;;;;OAIG;IACH,sCAYC;IAED;;;;;OAKG;IACH,oCAFa,OAAO,CAUnB;IAED;;;;;;OAMG;IACH,kBAGC;IAED;;;OAGG;IACH,+BAQC;IAED;;;OAGG;IACH,cA4CC;IAED;;;;OAIG;IACH,sBA6CC;IAED;;;;OAIG;IACH,4BA4CC;IAED;;;;;OAKG;IACH,oCA4CC;IAED;;;;;;OAMG;IACH,4CA4CC;IAED;;;;;;;;OAQG;IACH,4DA4CC;IAED;;;;;;;;;;OAUG;IACH,4EA4CC;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,MAAM,CAalB;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;CAPxB;;8BArkBiD,oBAAoB"}

package/src/core/events/signal/Signal.js

@@ -1,10 +1,3 @@
-/**
- *
- * @author Alex Goldring
- * @copyright Alex Goldring 2014
- */
-
-
 import { assert } from "../../assert.js";
 import { SignalFlags } from "./SignalFlags.js";
 import { SignalHandler, SignalHandlerFlags } from "./SignalHandler.js";
@@ -635,11 +628,12 @@ export function findSignalHandlerIndexByHandleAndContext(handlers, f, ctx) {
     const l = handlers.length;
 
     for (let i = 0; i < l; i++) {
-        const signalHandler = handlers[i];
+        const handler = handlers[i];
 
-        if (signalHandler.handle === f && signalHandler.context === ctx) {
+        if (handler.handle === f && handler.context === ctx) {
             return i;
         }
+
     }
 
     return -1;
@@ -672,7 +666,7 @@ function removeHandlerByHandler(signal, h) {
  */
 function removeHandlerByHandlerAndContext(signal, h, ctx) {
     const handlers = signal.handlers;
-    let i = findSignalHandlerIndexByHandleAndContext(handlers, h, ctx);
+    const i = findSignalHandlerIndexByHandleAndContext(handlers, h, ctx);
 
     if (i >= 0) {
         handlers.splice(i, 1);
@@ -682,6 +676,12 @@ function removeHandlerByHandlerAndContext(signal, h, ctx) {
     return false;
 }
 
+/**
+ *
+ * @param {function} f
+ * @param {*} context
+ * @param {Array} args
+ */
 function dispatchCallback(f, context, args) {
     assert.isFunction(f, 'f');
 

package/src/core/geom/2d/compute_triangle_area_2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_triangle_area_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/compute_triangle_area_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,6CARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAYlB"}
+{"version":3,"file":"compute_triangle_area_2d.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/compute_triangle_area_2d.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,6CARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAclB"}

package/src/core/geom/2d/compute_triangle_area_2d.js

@@ -14,8 +14,10 @@ export function compute_triangle_area_2d(
     x2, y2
 ) {
 
-    return 0.5 * (
-        (x0 * y1 - y0 * x1) + (x1 * y2 - y1 * x2) + (x2 * y0 - y2 * x0)
-    );
+    return (
+        (x0 * y1 - y0 * x1)
+        + (x1 * y2 - y1 * x2)
+        + (x2 * y0 - y2 * x0)
+    ) * 0.5;
 
 }

package/src/core/geom/3d/Ray3.d.ts

@@ -4,6 +4,12 @@
 export class Ray3 {
     origin: Vector3;
     direction: Vector3;
+    get 0(): number;
+    get 1(): number;
+    get 2(): number;
+    get 3(): number;
+    get 4(): number;
+    get 5(): number;
     /**
      *
      * @param {number[]|mat4|Float32Array} m4

package/src/core/geom/3d/Ray3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/Ray3.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI,gBAAsB;IACtB,mBAAyB;IAEzB;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAKpC;IAED;;;OAGG;IACH,YAFW,IAAI,QAKd;CACJ;oBA1BmB,eAAe"}
+{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/Ray3.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IACI,gBAAsB;IACtB,mBAAyB;IAEzB,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED,gBAEC;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAKpC;IAED;;;OAGG;IACH,YAFW,IAAI,QAKd;CACJ;oBAlDmB,eAAe"}

package/src/core/geom/3d/Ray3.js

@@ -7,6 +7,30 @@ export class Ray3 {
     origin = new Vector3()
     direction = new Vector3()
 
+    get 0() {
+        return this.origin.x
+    }
+
+    get 1() {
+        return this.origin.y
+    }
+
+    get 2() {
+        return this.origin.z
+    }
+
+    get 3() {
+        return this.direction.x
+    }
+
+    get 4() {
+        return this.direction.y
+    }
+
+    get 5() {
+        return this.direction.z
+    }
+
     /**
      *
      * @param {number[]|mat4|Float32Array} m4

package/src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Distance of the nearest point along the plane normal from the plane
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ * @param {number} _x0
+ * @param {number} _y0
+ * @param {number} _z0
+ * @param {number} _x1
+ * @param {number} _y1
+ * @param {number} _z1
+ * @returns {number}
+ */
+export function aabb3_compute_distance_above_plane_min(plane_normal_x: number, plane_normal_y: number, plane_normal_z: number, plane_constant: number, _x0: number, _y0: number, _z0: number, _x1: number, _y1: number, _z1: number): number;
+//# sourceMappingURL=aabb3_compute_distance_above_plane_min.d.ts.map

package/src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_compute_distance_above_plane_min.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,uEAZW,MAAM,kBACN,MAAM,kBACN,MAAM,kBACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,MAAM,CAelB"}

package/src/core/geom/3d/aabb/aabb3_compute_distance_above_plane_min.js

@@ -0,0 +1,29 @@
+/**
+ * Distance of the nearest point along the plane normal from the plane
+ * @param {number} plane_normal_x
+ * @param {number} plane_normal_y
+ * @param {number} plane_normal_z
+ * @param {number} plane_constant
+ * @param {number} _x0
+ * @param {number} _y0
+ * @param {number} _z0
+ * @param {number} _x1
+ * @param {number} _y1
+ * @param {number} _z1
+ * @returns {number}
+ */
+export function aabb3_compute_distance_above_plane_min(
+    plane_normal_x, plane_normal_y, plane_normal_z, plane_constant,
+    _x0, _y0, _z0,
+    _x1, _y1, _z1
+) {
+
+    // pick a corner point that is the closest along the plane normal
+    const px = plane_normal_x > 0 ? _x0 : _x1;
+    const py = plane_normal_y > 0 ? _y0 : _y1;
+    const pz = plane_normal_z > 0 ? _z0 : _z1;
+
+    // dot(v4,v4) inlined for speed
+    return plane_constant + plane_normal_x * px + plane_normal_y * py + plane_normal_z * pz;
+}
+

package/src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.d.ts

@@ -3,7 +3,7 @@
  * @param {AABB3} result
  * @param {number[]|ArrayLike<number>} input
  * @param {number} input_length
- * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix 4x4 transformation matrix
  */
-export function aabb3_from_v3_array_transformed(result: AABB3, input: number[] | ArrayLike<number>, input_length: number, e: ArrayLike<number> | number[] | Float32Array): void;
+export function aabb3_from_v3_array_transformed(result: AABB3, input: number[] | ArrayLike<number>, input_length: number, matrix: ArrayLike<number> | number[] | Float32Array): void;
 //# sourceMappingURL=aabb3_from_v3_array_transformed.d.ts.map

package/src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_from_v3_array_transformed.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,sEAJW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,KACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QA8BjD"}
+{"version":3,"file":"aabb3_from_v3_array_transformed.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,sEAJW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,gBAC1B,MAAM,UACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QA8BjD"}

package/src/core/geom/3d/aabb/aabb3_from_v3_array_transformed.js

@@ -1,14 +1,14 @@
-import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
 
 /**
  *
  * @param {AABB3} result
  * @param {number[]|ArrayLike<number>} input
  * @param {number} input_length
- * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @param {ArrayLike<number>|number[]|Float32Array} matrix 4x4 transformation matrix
  */
-export function aabb3_from_v3_array_transformed(result, input, input_length, e) {
+export function aabb3_from_v3_array_transformed(result, input, input_length, matrix) {
     let x0 = Infinity;
     let y0 = Infinity;
     let z0 = Infinity;
@@ -22,9 +22,9 @@ export function aabb3_from_v3_array_transformed(result, input, input_length, e)
         const y = input[i + 1];
         const z = input[i + 2];
 
-        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
-        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
-        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+        const _x = matrix[0] * x + matrix[4] * y + matrix[8] * z + matrix[12];
+        const _y = matrix[1] * x + matrix[5] * y + matrix[9] * z + matrix[13];
+        const _z = matrix[2] * x + matrix[6] * y + matrix[10] * z + matrix[14];
 
         x0 = min2(_x, x0);
         y0 = min2(_y, y0);

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray_segment(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, min_distance: number, max_distance: number): boolean;
+//# sourceMappingURL=aabb3_intersects_ray_segment.d.ts.map

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,iDAjBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,OAAO,CA+CnB"}

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js

@@ -0,0 +1,67 @@
+import { max2 } from "../../../math/max2.js";
+import { min2 } from "../../../math/min2.js";
+
+/**
+ * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray_segment(
+    x0, y0, z0,
+    x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    min_distance, max_distance
+) {
+
+    // move aabb into ray space
+    const _x0 = x0 - origin_x;
+    const _y0 = y0 - origin_y;
+    const _z0 = z0 - origin_z;
+
+    const _x1 = x1 - origin_x;
+    const _y1 = y1 - origin_y;
+    const _z1 = z1 - origin_z;
+
+    const inv_direction_x = 1 / direction_x;
+    const inv_direction_y = 1 / direction_y;
+    const inv_direction_z = 1 / direction_z;
+
+    // Absolute distances to lower and upper box coordinates
+    const t_lower_x = _x0 * inv_direction_x;
+    const t_lower_y = _y0 * inv_direction_y;
+    const t_lower_z = _z0 * inv_direction_z;
+
+    const t_upper_x = _x1 * inv_direction_x;
+    const t_upper_y = _y1 * inv_direction_y;
+    const t_upper_z = _z1 * inv_direction_z;
+
+    // The four t-intervals (for x-/y-/z-slabs, and ray p(t))
+    const t_min_x = min2(t_lower_x, t_upper_x);
+    const t_min_y = min2(t_lower_y, t_upper_y);
+    const t_min_z = min2(t_lower_z, t_upper_z);
+
+    const t_max_x = max2(t_lower_x, t_upper_x);
+    const t_max_y = max2(t_lower_y, t_upper_y);
+    const t_max_z = max2(t_lower_z, t_upper_z);
+
+    // Easy to remember: ``max of mins, and min of maxes''
+    const t_box_min = Math.max(t_min_x, t_min_y, t_min_z, min_distance);
+    const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
+
+    return t_box_min <= t_box_max;
+}

package/src/core/geom/3d/eulerAnglesFromMatrix.d.ts

@@ -21,8 +21,8 @@
  * @param {number[]} res
  * @param {number[]|Float32Array|mat4} m4
  * @param {number} a0 axis index
- * @param {number} a1
- * @param {number} a2
+ * @param {number} a1 axis index
+ * @param {number} a2 axis index
  */
 export function eulerAnglesFromMatrix(res: number[], m4: number[] | Float32Array | mat4, a0: number, a1: number, a2: number): void;
 //# sourceMappingURL=eulerAnglesFromMatrix.d.ts.map

package/src/core/geom/3d/eulerAnglesFromMatrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA6DhB"}
+{"version":3,"file":"eulerAnglesFromMatrix.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/eulerAnglesFromMatrix.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,2CANW,MAAM,EAAE,MACR,MAAM,EAAE,GAAC,YAAY,OAAK,MAC1B,MAAM,MACN,MAAM,MACN,MAAM,QA2EhB"}

package/src/core/geom/3d/eulerAnglesFromMatrix.js

@@ -1,10 +1,5 @@
-//
-
 import { v2_magnitude } from "../vec2/v2_magnitude.js";
 
-function atan2(a, b) {
-    return Math.atan2(a, b);
-}
 
 /**
  *
@@ -17,15 +12,9 @@ function coeff(mat4, row_index, column_index) {
     return mat4[row_index + column_index * 4];
 }
 
-function sin(a) {
-    return Math.sin(a);
-}
-
-function cos(a) {
-    return Math.cos(a);
-}
-
-const EIGEN_PI = Math.PI;
+const sin = Math.sin;
+const cos = Math.cos;
+const atan2 = Math.atan2;
 
 /**
  *
@@ -50,10 +39,14 @@ const EIGEN_PI = Math.PI;
  * @param {number[]} res
  * @param {number[]|Float32Array|mat4} m4
  * @param {number} a0 axis index
- * @param {number} a1
- * @param {number} a2
+ * @param {number} a1 axis index
+ * @param {number} a2 axis index
  */
-export function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
+export function eulerAnglesFromMatrix(
+    res, m4,
+    a0, a1, a2
+) {
+
     const odd = ((a0 + 1) % 3 === a1) ? 0 : 1;
 
     const i = a0;
@@ -62,11 +55,12 @@ export function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
 
     if (a0 === a2) {
         res[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
-        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+
+        if ((odd && res[0] < 0) || ((~odd) && res[0] > 0)) {
             if (res[0] > 0) {
-                res[0] -= EIGEN_PI;
+                res[0] -= Math.PI;
             } else {
-                res[0] += EIGEN_PI;
+                res[0] += Math.PI;
             }
             const s2 = v2_magnitude(coeff(m4, j, i), coeff(m4, k, i));
             res[1] = -atan2(s2, coeff(m4, i, i));
@@ -87,25 +81,34 @@ export function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
 
         const s1 = sin(res[0]);
         const c1 = cos(res[0]);
+
         res[2] = atan2(c1 * coeff(m4, j, k) - s1 * coeff(m4, k, k), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
     } else {
+
         res[0] = atan2(coeff(m4, j, k), coeff(m4, k, k));
+
         const c2 = v2_magnitude(coeff(m4, i, i), coeff(m4, i, j));
-        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+
+        if ((odd && res[0] < 0) || ((~odd) && res[0] > 0)) {
             if (res[0] > 0) {
-                res[0] -= EIGEN_PI;
+                res[0] -= Math.PI;
             } else {
-                res[0] += EIGEN_PI;
+                res[0] += Math.PI;
             }
             res[1] = atan2(-coeff(m4, i, k), -c2);
-        } else
+        } else {
             res[1] = atan2(-coeff(m4, i, k), c2);
+        }
+
         const s1 = sin(res[0]);
         const c1 = cos(res[0]);
+
         res[2] = atan2(s1 * coeff(m4, k, i) - c1 * coeff(m4, j, i), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
     }
 
-    if (!odd) {
+    if (odd === 0) {
         // invert result
         res[0] = -res[0];
         res[1] = -res[1];

package/src/core/geom/3d/morton/v3_morton_encode_bounded.d.ts

@@ -2,8 +2,8 @@
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} bounds
+ * @param {number[]|AABB3} bounds
  * @returns {number}
  */
-export function v3_morton_encode_bounded(x: number, y: number, z: number, bounds: number[]): number;
+export function v3_morton_encode_bounded(x: number, y: number, z: number, bounds: number[] | AABB3): number;
 //# sourceMappingURL=v3_morton_encode_bounded.d.ts.map

package/src/core/geom/3d/morton/v3_morton_encode_bounded.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_morton_encode_bounded.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/v3_morton_encode_bounded.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,GACN,MAAM,CA0BlB"}
+{"version":3,"file":"v3_morton_encode_bounded.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/morton/v3_morton_encode_bounded.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,QAAM,GACZ,MAAM,CA0BlB"}

package/src/core/geom/3d/morton/v3_morton_encode_bounded.js

@@ -4,7 +4,7 @@ import { mortonEncode_magicbits } from "./mortonEncode_magicbits.js";
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} bounds
+ * @param {number[]|AABB3} bounds
  * @returns {number}
  */
 export function v3_morton_encode_bounded(x, y, z, bounds) {

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts

@@ -1,10 +1,10 @@
 /**
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
  * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
- * @param {number[]} output
+ * @param {number[]|Vector3} output
  * @param {number} output_offset
  * @param {number} x range [0,1]
  * @param {number} y range [0,1]
  */
-export function decode_octahedron_to_unit(output: number[], output_offset: number, x: number, y: number): void;
+export function decode_octahedron_to_unit(output: number[] | Vector3, output_offset: number, x: number, y: number): void;
 //# sourceMappingURL=decode_octahedron_to_unit.d.ts.map

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,kDALW,MAAM,EAAE,iBACR,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB"}
+{"version":3,"file":"decode_octahedron_to_unit.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,kDALW,MAAM,EAAE,UAAQ,iBAChB,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB"}

package/src/core/geom/3d/normal/octahedron/decode_octahedron_to_unit.js

@@ -3,7 +3,7 @@ import { sign_not_zero } from "../../../../math/sign_not_zero.js";
 /**
  * @see A Survey of Efficient Representations for Independent Unit Vectors (Journal of Computer Graphics Techniques Vol. 3, No. 2, 2014) - page 13
  * @see https://gamedev.stackexchange.com/questions/169508/octahedral-impostors-octahedral-mapping
- * @param {number[]} output
+ * @param {number[]|Vector3} output
  * @param {number} output_offset
  * @param {number} x range [0,1]
  * @param {number} y range [0,1]