@woosh/meep-engine 2.109.1 → 2.109.3

package/src/core/binary/reverse_bits_uint32.js

@@ -0,0 +1,17 @@
+/**
+ * Reverses order of bits in an unsigned 32bit integer
+ * @example 1110 would become 0111
+ * @param {number} input
+ * @returns {number}
+ */
+export function reverse_bits_uint32(input) {
+    let x = input;
+
+    x = ((x << 16) | (x >>> 16))
+    x = ((x & 0x55555555) << 1) | ((x & 0xAAAAAAAA) >>> 1)
+    x = ((x & 0x33333333) << 2) | ((x & 0xCCCCCCCC) >>> 2)
+    x = ((x & 0x0F0F0F0F) << 4) | ((x & 0xF0F0F0F0) >>> 4)
+    x = ((x & 0x00FF00FF) << 8) | ((x & 0xFF00FF00) >>> 8)
+
+    return x
+}

package/src/core/binary/reverse_bits_uint32.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reverse_bits_uint32.spec.d.ts.map

package/src/core/binary/reverse_bits_uint32.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse_bits_uint32.spec.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/reverse_bits_uint32.spec.js"],"names":[],"mappings":""}

package/src/core/binary/reverse_bits_uint32.spec.js

@@ -0,0 +1,18 @@
+import { reverse_bits_uint32 } from "./reverse_bits_uint32.js";
+
+test("basics", () => {
+
+    expect(reverse_bits_uint32(1 << 31)).toEqual(1);
+    expect(reverse_bits_uint32(1)).toEqual(1 << 31);
+
+    expect(reverse_bits_uint32(2)).toEqual(1 << 30);
+    expect(reverse_bits_uint32(1 << 30)).toEqual(2);
+
+    expect(reverse_bits_uint32(0b1111)).toEqual(
+        (1 << 31) | (1 << 30) | (1 << 29) | (1 << 28)
+    );
+    expect(reverse_bits_uint32(
+        (1 << 31) | (1 << 30) | (1 << 29) | (1 << 28)
+    )).toEqual(0b1111);
+
+});

package/src/core/bvh2/bvh3/BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"AAQA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAE/B;;;;;GAKG;AACH,+BAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEqB;AAgBrC;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAEnB;;;OAGG;IACH,mBAEC;IAUD;;;OAGG;IACH,+BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBAqBC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAqDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAsBpC;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QA2ChB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA0GhB;IAED;;;;;OAKG;IACH,wBAuBC;IAED;;;;OAIG;IACH,yBA4BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAoMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,yCA8BC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}
+{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"AAQA,8BAA+B;AAC/B,+BAAgC;AAChC,+BAAgC;AAChC,8BAA+B;AAE/B;;;;;GAKG;AACH,+BAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,wBAFU,MAAM,CAEoB;AAcpC;;;;;GAKG;AACH,iCAFU,MAAM,CAEqB;AAgBrC;;;;;;GAMG;AACH;IAEI;;;;OAIG;IACH,sBAA2E;IAE3E;;;;OAIG;IACH,uBAAsD;IAEtD;;;;OAIG;IACH,sBAAoD;IAEpD;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,eAAW;IAEX;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,eAAmB;IAEnB;;;OAGG;IACH,mBAEC;IAUD;;;OAGG;IACH,+BAMC;IAlBD;;;OAGG;IACH,4BAEC;IAcD,wBAgBC;IAED;;;;OAIG;IACH,uBAqBC;IAED;;OAEG;IACH,aAIC;IAED;;;OAGG;IACH,iBAFa,MAAM,CAqDlB;IAED;;;;OAIG;IACH,iBAFW,MAAM,QAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAOnB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,uBAHW,MAAM,SACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAGD;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;OAIG;IACH,kBAHW,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,QAe/B;IAED;;;;OAIG;IACH,kBAHW,MAAM,QACN,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,QAAM,QAsB1C;IAED;;;;OAIG;IACH,mBAHW,MAAM,QACN,MAAM,EAAE,QAWlB;IAED;;;;;;;;;OASG;IACH,4BARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAoBlB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,WACN,MAAM,GACJ,MAAM,CAoClB;IAED;;;;;OAKG;IACH,oCAJW,MAAM,WACN,MAAM,WACN,MAAM,QAwChB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA0GhB;IAED;;;;;OAKG;IACH,wBAqBC;IAED;;;;OAIG;IACH,yBA4BC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;OAMG;IACH,gBAoMC;IAED;;;OAGG;IACH,oBAIC;IAED;;;;OAIG;IACH,yCA8BC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAWlB;IAED;;;;;OAKG;IACH,0BA6BC;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAsCnB;CACJ"}

package/src/core/bvh2/bvh3/BVH.js

@@ -410,7 +410,7 @@ export class BVH {
     /**
      *
      * @param {number} id
-     * @param {number[]|ArrayLike<number>} aabb
+     * @param {number[]|ArrayLike<number>|AABB3} aabb
      */
     node_set_aabb(id, aabb) {
         assert.isNonNegativeInteger(id, 'id');
@@ -562,27 +562,24 @@ export class BVH {
         const float32 = this.__data_float32;
 
         const a_x0 = float32[address_a];
-        const b_x0 = float32[address_b];
-        const x0 = min2(a_x0, b_x0);
-
         const a_y0 = float32[address_a + 1];
-        const b_y0 = float32[address_b + 1];
-        const y0 = min2(a_y0, b_y0);
-
         const a_z0 = float32[address_a + 2];
-        const b_z0 = float32[address_b + 2];
-        const z0 = min2(a_z0, b_z0);
-
         const a_x1 = float32[address_a + 3];
-        const b_x1 = float32[address_b + 3];
-        const x1 = max2(a_x1, b_x1);
-
         const a_y1 = float32[address_a + 4];
-        const b_y1 = float32[address_b + 4];
-        const y1 = max2(a_y1, b_y1);
-
         const a_z1 = float32[address_a + 5];
+
+        const b_x0 = float32[address_b];
+        const b_y0 = float32[address_b + 1];
+        const b_z0 = float32[address_b + 2];
+        const b_x1 = float32[address_b + 3];
+        const b_y1 = float32[address_b + 4];
         const b_z1 = float32[address_b + 5];
+
+        const x0 = min2(a_x0, b_x0);
+        const y0 = min2(a_y0, b_y0);
+        const z0 = min2(a_z0, b_z0);
+        const x1 = max2(a_x1, b_x1);
+        const y1 = max2(a_y1, b_y1);
         const z1 = max2(a_z1, b_z1);
 
 
@@ -718,8 +715,6 @@ export class BVH {
         const uint32 = this.__data_uint32;
 
         do {
-            index = this.balance(index);
-
             const address = index * ELEMENT_WORD_COUNT;
 
             const child1 = uint32[address + COLUMN_CHILD_1];

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_for_geometry_incremental.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,2EAJW,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,QA8BhB"}
+{"version":3,"file":"ebvh_build_for_geometry_incremental.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,2EAJW,MAAM,EAAE,GAAC,YAAY,mBACrB,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,QA8BhB"}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js

@@ -1,4 +1,6 @@
-import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
+import {
+    compute_triangle_group_aabb3
+} from "../../../engine/graphics/sh3/path_tracer/geometry/compute_triangle_group_aabb3.js";
 import { min2 } from "../../math/min2.js";
 
 /**

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_for_geometry_morton.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,sEALW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,iBACrB,WAAW,WACX,KAAK,QA2Ff;sBA1GqB,6BAA6B"}
+{"version":3,"file":"ebvh_build_for_geometry_morton.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js"],"names":[],"mappings":"AAWA;;;;;;;;GAQG;AACH,sEALW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,iBACrB,WAAW,WACX,KAAK,QA0Ff;sBAzGqB,6BAA6B"}

package/src/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -1,6 +1,6 @@
 import { assert } from "../../assert.js";
 import { array_copy } from "../../collection/array/array_copy.js";
-import { array_quick_sort_by_lookup } from "../../collection/array/array_quick_sort_by_lookup.js";
+import { array_quick_sort_by_lookup_uint } from "../../collection/array/array_quick_sort_by_lookup_uint.js";
 import { AABB3 } from "../../geom/3d/aabb/AABB3.js";
 import { aabb3_from_v3_array } from "../../geom/3d/aabb/aabb3_from_v3_array.js";
 import { aabb3_compute_from_triangle } from "../../geom/3d/aabb3_compute_from_triangle.js";
@@ -73,7 +73,7 @@ export function ebvh_build_for_geometry_morton(
     build_triangle_morton_codes(morton_codes, tri_count, index_array, position_array, bounds.x0, bounds.y0, bounds.z0, bounds.x1, bounds.y1, bounds.z1);
 
     // sort leaves by morton codes
-    array_quick_sort_by_lookup(sorted_triangle_order, morton_codes, 0, tri_count - 1);
+    array_quick_sort_by_lookup_uint(sorted_triangle_order, morton_codes, 0, tri_count - 1);
 
     // assign leaves
     for (let i = 0; i < tri_count; i++) {
@@ -81,11 +81,6 @@ export function ebvh_build_for_geometry_morton(
 
         const triangle_index = sorted_triangle_order[i];
 
-        bvh.node_set_child1(node, NULL_NODE); //mark node as a leaf
-        bvh.node_set_user_data(node, triangle_index);
-
-        bvh.node_set_height(node, 0);
-
         const triangle_index3 = triangle_index * 3;
 
         const a_index = index_array[triangle_index3];
@@ -99,6 +94,10 @@ export function ebvh_build_for_geometry_morton(
             position_array, a_index, b_index, c_index
         );
 
+        bvh.node_set_child1(node, NULL_NODE); //mark node as a leaf
+        bvh.node_set_user_data(node, triangle_index);
+
+        bvh.node_set_height(node, 0);
     }
 
     // record newly generated nodes as "unprocessed"

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,kEANW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,GACJ,MAAM,CAyDlB"}
+{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,kEANW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,GACJ,MAAM,CA4DlB"}

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.js

@@ -1,5 +1,6 @@
 import { assert } from "../../assert.js";
 import { max2 } from "../../math/max2.js";
+import { NULL_NODE } from "./BVH.js";
 
 /**
  * Given a set of leaves, build intermediate node hierarchy on top, all the way up to the root
@@ -66,5 +67,8 @@ export function ebvh_build_hierarchy(
         unprocessed_node_count = added_nodes;
     }
 
+    // set the root to have no parent
+    bvh.node_set_parent(unprocessed_nodes[0], NULL_NODE);
+
     return unprocessed_nodes[0];
 }

package/src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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: BVH, starting_node: number, result: number[], result_offset: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number): number;
+//# sourceMappingURL=bvh_backtracking_query_leaves_ray.d.ts.map

package/src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_backtracking_query_leaves_ray.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/bvh2/bvh3/query/backtracking/bvh_backtracking_query_leaves_ray.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,2EAXW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,MAAM,CA6GlB"}

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

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @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
+ * @param {number} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_leaves_ray_segment(bvh: BVH, root: number, result: number[], result_offset: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, t_min: number, t_max: number): number;
+//# sourceMappingURL=bvh_query_leaves_ray_segment.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_leaves_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;GAeG;AACH,6DAbW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,MAAM,CAwElB"}

package/src/core/bvh2/bvh3/query/bvh_query_leaves_ray_segment.js

@@ -0,0 +1,94 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_intersects_ray_segment } from "../../../geom/3d/aabb/aabb3_intersects_ray_segment.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @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
+ * @param {number} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_leaves_ray_segment(
+    bvh, root,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    t_min, t_max
+) {
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    stack[stack_top] = root;
+
+    let result_cursor = result_offset;
+
+    /*
+     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;
+
+    do {
+        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_segment(
+            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,
+            t_min, t_max
+        );
+
+        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;
+        }
+    } while (stack.pointer > stack_top);
+
+    return result_cursor - result_offset;
+}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.d.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @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
+ * @param {number} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_user_data_ray_segment(bvh: BVH, root: number, result: number[], result_offset: number, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, t_min: number, t_max: number): number;
+//# sourceMappingURL=bvh_query_user_data_ray_segment.d.ts.map

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh_query_user_data_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,gEAbW,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,MAAM,CA+ElB"}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_ray_segment.js

@@ -0,0 +1,100 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import { aabb3_intersects_ray_segment } from "../../../geom/3d/aabb/aabb3_intersects_ray_segment.js";
+import { COLUMN_CHILD_1, COLUMN_CHILD_2, COLUMN_USER_DATA, ELEMENT_WORD_COUNT, NULL_NODE } from "../BVH.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @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
+ * @param {number} t_min
+ * @param {number} t_max
+ * @returns {number}
+ */
+export function bvh_query_user_data_ray_segment(
+    bvh, root,
+    result, result_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    t_min, t_max
+) {
+
+    if (root === NULL_NODE) {
+        return 0;
+    }
+
+    /**
+     * Move stack pointer to local variable scope to avoid de-referencing inside the loop
+     * @type {number}
+     */
+    let pointer = stack.pointer;
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = pointer;
+
+    stack[pointer++] = root;
+
+    let result_cursor = result_offset;
+
+    /*
+     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;
+
+    do {
+        --pointer;
+
+        /**
+         *
+         * @type {number}
+         */
+        const node = stack[pointer];
+
+        const address = node * ELEMENT_WORD_COUNT;
+
+        // test node against the ray
+        const intersects = aabb3_intersects_ray_segment(
+            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,
+            t_min, t_max
+        );
+
+        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
+            const child_2 = uint32[address + COLUMN_CHILD_2];
+
+            stack[pointer++] = child_2;
+            stack[pointer++] = child_1;
+
+        } else {
+            // leaf node
+
+            result[result_cursor++] = uint32[address + COLUMN_USER_DATA];
+        }
+    } while (pointer > stack_top);
+
+    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"}