@woosh/meep-engine 2.109.1 → 2.109.2

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/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