@woosh/meep-engine 2.109.0 → 2.109.2

package/src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.js

@@ -0,0 +1,130 @@
+import { assert } from "../../../../assert.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_intersects_ray } from "../../../../geom/3d/aabb/aabb3_intersects_ray.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+
+/**
+ * Traverses bvh starting from a given node, but can back-track all the way up to the root
+ * @param {BVH} bvh
+ * @param {number} starting_node
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {number}
+ */
+export function bvh_backtracking_query_leaves_ray(
+    bvh, starting_node,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+
+    assert.isNonNegativeInteger(starting_node, 'starting_node');
+
+    /*
+     For performance, we bind data directly to avoid extra copies required to read out AABB
+     */
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    let result_cursor = result_offset;
+
+    let came_from = NULL_NODE;
+
+    // starting point
+    let entry = starting_node;
+
+    do {
+
+        const address = entry * ELEMENT_WORD_COUNT;
+
+        const intersects = aabb3_intersects_ray(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        );
+
+        /**
+         *
+         * @type {number}
+         */
+        const stack_top = stack.pointer;
+
+        if (intersects) {
+            const child1 = bvh.node_get_child1(entry);
+
+            if (child1 === NULL_NODE) {
+                // leaf node
+                result[result_cursor++] = entry;
+            } else {
+
+                const child2 = bvh.node_get_child2(entry);
+
+                if (came_from !== child2) {
+                    stack[stack.pointer++] = child2;
+                }
+
+                if (came_from !== child1) {
+                    stack[stack.pointer++] = child1;
+                }
+
+            }
+        }
+
+
+        while (stack.pointer > stack_top) {
+            stack.pointer--;
+
+            /**
+             *
+             * @type {number}
+             */
+            const node = stack[stack.pointer];
+
+            const address = node * ELEMENT_WORD_COUNT;
+
+            // test node against the ray
+            const intersects = aabb3_intersects_ray(
+                float32[address], float32[address + 1], float32[address + 2],
+                float32[address + 3], float32[address + 4], float32[address + 5],
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
+
+            if (!intersects) {
+                continue;
+            }
+
+            // get fist child to check if this is a leaf node or not
+            const child_1 = uint32[address + COLUMN_CHILD_1];
+
+            if (child_1 !== NULL_NODE) {
+
+                // this is not a leaf node, push children onto traversal stack
+                stack[stack.pointer++] = uint32[address + COLUMN_CHILD_2];
+                stack[stack.pointer++] = child_1;
+
+            } else {
+                // leaf node
+
+                result[result_cursor++] = node;
+            }
+        }
+
+        // backtrack
+        came_from = entry;
+        entry = bvh.node_get_parent(entry);
+
+    } while (entry !== NULL_NODE);
+
+    return result_cursor - result_offset;
+}

package/src/core/bvh2/bvh3/query/cache/BVH_QUERY_CACHE_SIZE.d.ts

@@ -0,0 +1,2 @@
+export const BVH_QUERY_CACHE_SIZE: number;
+//# sourceMappingURL=BVH_QUERY_CACHE_SIZE.d.ts.map

package/src/core/bvh2/bvh3/query/cache/BVH_QUERY_CACHE_SIZE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BVH_QUERY_CACHE_SIZE.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/bvh2/bvh3/query/cache/BVH_QUERY_CACHE_SIZE.js"],"names":[],"mappings":"AAAA,0CAA0C"}

package/src/core/bvh2/bvh3/query/cache/BVH_QUERY_CACHE_SIZE.js

@@ -0,0 +1 @@
+export const BVH_QUERY_CACHE_SIZE = 2**12;

package/src/core/bvh2/bvh3/query/cache/bvh_query_cache_hash_v3.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+export function bvh_query_cache_hash_v3(x: number, y: number, z: number): number;
+//# sourceMappingURL=bvh_query_cache_hash_v3.d.ts.map

package/src/core/bvh2/bvh3/query/cache/bvh_query_cache_hash_v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_cache_hash_v3.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/bvh2/bvh3/query/cache/bvh_query_cache_hash_v3.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,2CALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAuBlB"}

package/src/core/bvh2/bvh3/query/cache/bvh_query_cache_hash_v3.js

@@ -0,0 +1,31 @@
+import { BVH_QUERY_CACHE_SIZE } from "./BVH_QUERY_CACHE_SIZE.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+export function bvh_query_cache_hash_v3(x, y, z) {
+
+    //
+    // const i0 = computeHashFloat(x);
+    // const i1 = computeHashFloat(y);
+    // const i2 = computeHashFloat(z);
+    //
+    // const key = ((i0 * 0xB5297A4D) ^ (i1 * 0x68E31DA4) ^ (i2 * 0x1B56C4E9))
+    //     & (BVH_QUERY_CACHE_SIZE - 1);
+
+    const s = 16;
+
+    const i0 = x*s;
+    const i1 = y*s;
+    const i2 = z*s;
+
+    const key = ((i0 * 73856093) ^ (i1 * 19349663) ^ (i2 * 83492791))
+        & (BVH_QUERY_CACHE_SIZE - 1);
+
+    // convert to unsigned
+    return key >>> 0;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * @template T
+ * @param {T[]} data
+ * @param {Map<T,number>} lookup
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_lookup_map<T>(data: T[], lookup: Map<T, number>, start: number, end: number): void;
+//# sourceMappingURL=array_quick_sort_by_lookup_map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_quick_sort_by_lookup_map.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_quick_sort_by_lookup_map.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,4FAHW,MAAM,OACN,MAAM,QAqEhB"}

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/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_overlaps_ray_segment.d.ts

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number[]} aabb
+ * @param {number} aabb_offset
+ * @param {number[]} ray
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ */
+export function aabb3_overlaps_ray_segment(aabb: number[], aabb_offset: number, ray: number[], min_distance: number, max_distance: number): boolean;
+//# sourceMappingURL=aabb3_overlaps_ray_segment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_overlaps_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_overlaps_ray_segment.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,iDAPW,MAAM,EAAE,eACR,MAAM,OACN,MAAM,EAAE,gBACR,MAAM,gBACN,MAAM,GACJ,OAAO,CAmDnB"}

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

@@ -0,0 +1,61 @@
+import { v3_dot } from "../../vec3/v3_dot.js";
+
+/**
+ *
+ * @param {number[]} aabb
+ * @param {number} aabb_offset
+ * @param {number[]} ray
+ * @param {number} min_distance
+ * @param {number} max_distance
+ * @returns {boolean}
+ */
+export function aabb3_overlaps_ray_segment(
+    aabb, aabb_offset, ray,
+    min_distance, max_distance
+) {
+
+    const dir_x = ray[3];
+    const dir_y = ray[4];
+    const dir_z = ray[5];
+
+    const plane_offset = v3_dot(
+        ray[0], ray[1], ray[2],
+        dir_x, dir_y, dir_z
+    );
+
+    let x0, y0, z0, x1, y1, z1;
+
+    if (dir_x > 0) {
+        x0 = aabb[0];
+        x1 = aabb[3];
+    } else {
+        x1 = aabb[0];
+        x0 = aabb[3];
+    }
+
+    if (dir_y > 0) {
+        y0 = aabb[1];
+        y1 = aabb[4];
+    } else {
+        y1 = aabb[1];
+        y0 = aabb[4];
+    }
+
+    if (dir_z > 0) {
+        z0 = aabb[2];
+        z1 = aabb[5];
+    } else {
+        z1 = aabb[2];
+        z0 = aabb[5];
+    }
+
+    const min = plane_offset + dir_x * x0 + dir_y * y0 + dir_z * z0;
+
+    if (min >= max_distance) {
+        return false;
+    }
+
+    const max = plane_offset + dir_x * x1 + dir_y * y1 + dir_z * z1;
+
+    return max > min_distance;
+}

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"}