@woosh/meep-engine 2.108.2 → 2.108.4

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.108.2",
+  "version": "2.108.4",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/bvh2/binary/2/BinaryUint32BVH.d.ts

@@ -78,6 +78,12 @@ export class BinaryUint32BVH {
      * @param {number} count
      */
     setLeafCount(count: number): void;
+    /**
+     *
+     * @param {number} index
+     * @return {number}
+     */
+    getLeafAddress(index: number): number;
     /**
      *
      * @param {number} index

package/src/core/bvh2/binary/2/BinaryUint32BVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,2BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAsChB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;;;;;OAOG;IACH,yCAYC;IAED;;;;;;OAMG;IACH,kDAuBC;IAED,wBAUC;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAkElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cAsEC;CACJ"}
+{"version":3,"file":"BinaryUint32BVH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/binary/2/BinaryUint32BVH.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,mCAFU,MAAM,CAEsB;AACtC;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAiDpC;IACI;;;;OAIG;IACH,sBAAc;IAEd;;;;OAIG;IACH,gCAAe;IAEf;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IA0CtB;;;OAGG;IACH,2BAOC;IAED,wBAEC;IAnDD;;;OAGG;IACH,oBAFa,MAAM,CAIlB;IAED,2BAEC;IAED,gCAEC;IAED,8BAEC;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED,4BAEC;IAED,0BAEC;IAmBD;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAalB;IAED,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAgBhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,MAAM,CASjB;IAED;;;;;;;;;;OAUG;IACH,mBATW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoChB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,sBACrB,MAAM,QAIhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAED,qCAoBC;IAED;;;;;;;OAOG;IACH,yCAYC;IAED;;;;;;OAMG;IACH,kDAuBC;IAED,wBAUC;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAkElB;IAED;;;;;OAKG;IACH,sBAUC;IAED;;OAEG;IACH,cAsEC;CACJ"}

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -219,6 +219,20 @@ export class BinaryUint32BVH {
 
     }
 
+    /**
+     *
+     * @param {number} index
+     * @return {number}
+     */
+    getLeafAddress(index) {
+        assert.isNonNegativeInteger(index, 'index');
+        assert.lessThan(index, this.__node_count_leaf, 'leaf index overflow');
+
+        const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
+
+        return index * BVH_LEAF_NODE_SIZE + leaf_block_address;
+    }
+
     /**
      *
      * @param {number} index
@@ -254,9 +268,7 @@ export class BinaryUint32BVH {
 
         assert.isNonNegativeInteger(payload, 'payload');
 
-        const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
-
-        const address = index * BVH_LEAF_NODE_SIZE + leaf_block_address;
+        const address = this.getLeafAddress(index);
 
         aabb3_array_set(
             this.__data_float32,

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

@@ -34,7 +34,6 @@ export function build_triangle_morton_codes(
     // compute morton codes
     for (let i = 0; i < tri_count; i++) {
 
-
         const i3 = i * 3;
 
         // read indices
@@ -44,16 +43,17 @@ export function build_triangle_morton_codes(
 
         // read vertex positions
         const a_address = a * 3;
+        const c_address = c * 3;
+        const b_address = b * 3;
+
         const ax = position_array[a_address];
         const ay = position_array[a_address + 1];
         const az = position_array[a_address + 2];
 
-        const b_address = b * 3;
         const bx = position_array[b_address];
         const by = position_array[b_address + 1];
         const bz = position_array[b_address + 2];
 
-        const c_address = c * 3;
         const cx = position_array[c_address];
         const cy = position_array[c_address + 1];
         const cz = position_array[c_address + 2];

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":"AAUA;;;;;;GAMG;AACH,sEAHW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,QA0E/B"}
+{"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;;;;;;GAMG;AACH,sEAHW,MAAM,EAAE,GAAC,YAAY,kBACrB,MAAM,EAAE,GAAC,YAAY,QAoF/B"}

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

@@ -1,11 +1,12 @@
-import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
 import { assert } from "../../assert.js";
-import { arrayQuickSort } from "../../collection/array/arrayQuickSort.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 { 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";
 import { max2 } from "../../math/max2.js";
 import { build_triangle_morton_codes } from "./build_triangle_morton_codes.js";
-import { NULL_NODE } from "./BVH.js";
+import { ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 import { ebvh_build_hierarchy } from "./ebvh_build_hierarchy.js";
 
 /**
@@ -50,7 +51,6 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         nodes[i] = (node_total_count - 1) - i;
     }
 
-    const morton_codes = new Uint32Array(tri_count);
 
     // indices of triangles, but sorted by morton codes
     const sorted_triangle_order = new Uint32Array(tri_count);
@@ -59,32 +59,43 @@ export function ebvh_build_for_geometry_morton(bvh, index_array, position_array)
         sorted_triangle_order[i] = i;
     }
 
+    const morton_codes = new Uint32Array(tri_count);
+
     build_triangle_morton_codes(morton_codes, tri_count, index_array, position_array, aabb3.x0, aabb3.y0, aabb3.z0, aabb3.x1, aabb3.y1, aabb3.z1);
 
     // sort leaves by morton codes
-    arrayQuickSort(sorted_triangle_order, (triangle_index) => morton_codes[triangle_index], null, 0, tri_count - 1);
+    array_quick_sort_by_lookup(sorted_triangle_order, morton_codes, 0, tri_count - 1);
 
-    let used_index = 0;
-    const unprocessed_nodes = new Uint32Array(tri_count);
     // assign leaves
-    const aabb_array = new Float32Array(6);
     for (let i = 0; i < tri_count; i++) {
-        const node = nodes[used_index++];
+        const node = nodes[i];
 
         const triangle_index = sorted_triangle_order[i];
 
-        bvh.node_set_child1(node, NULL_NODE);
+        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);
 
-        compute_triangle_group_aabb3(aabb_array, 0, index_array, position_array, triangle_index * 3, 1, 3);
+        const triangle_index3 = triangle_index * 3;
 
-        bvh.node_set_aabb(node, aabb_array);
+        const a_index = index_array[triangle_index3];
+        const b_index = index_array[triangle_index3 + 1];
+        const c_index = index_array[triangle_index3 + 2];
+
+        const aabb_address = ELEMENT_WORD_COUNT * node;
+
+        aabb3_compute_from_triangle(
+            bvh.__data_float32, aabb_address,
+            position_array, a_index, b_index, c_index
+        );
 
-        unprocessed_nodes[i] = node;
     }
 
+    // record newly generated nodes as "unprocessed"
+    const unprocessed_nodes = new Uint32Array(tri_count);
+    array_copy(nodes, 0, unprocessed_nodes, 0, tri_count);
+
     // assign root
-    bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, used_index);
+    bvh.__root = ebvh_build_hierarchy(bvh, unprocessed_nodes, tri_count, nodes, tri_count);
 }

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

@@ -9,13 +9,4 @@
  * @param {*} [swap_context]
  */
 export function arrayQuickSort<T>(data: ArrayLike<number> | Uint32Array | T[], score_function: (arg0: T) => number, score_function_context: any, start: number, end: number, swap_operator?: (arg0: T[], arg1: number, arg2: number) => any, swap_context?: any): void;
-/**
- * @template T
- * @param {T[]} data
- * @param {function(T,T):number} compare_function
- * @param {*} compare_function_context
- * @param {number} start
- * @param {number} end
- */
-export function array_quick_sort_by_comparator<T>(data: T[], compare_function: (arg0: T, arg1: T) => number, compare_function_context: any, start: number, end: number): void;
 //# sourceMappingURL=arrayQuickSort.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"arrayQuickSort.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/arrayQuickSort.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,4GAPuB,MAAM,sCAElB,MAAM,OACN,MAAM,oCACO,MAAM,QAAE,MAAM,oCAiErC;AAED;;;;;;;GAOG;AACH,qGALyB,MAAM,wCAEpB,MAAM,OACN,MAAM,QAkEhB"}
+{"version":3,"file":"arrayQuickSort.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/arrayQuickSort.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,4GAPuB,MAAM,sCAElB,MAAM,OACN,MAAM,oCACO,MAAM,QAAE,MAAM,oCAiErC"}

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

@@ -76,76 +76,3 @@ export function arrayQuickSort(
     }
 }
 
-/**
- * @template T
- * @param {T[]} data
- * @param {function(T,T):number} compare_function
- * @param {*} compare_function_context
- * @param {number} start
- * @param {number} end
- */
-export function array_quick_sort_by_comparator(
-    data,
-    compare_function, compare_function_context,
-    start, end
-) {
-    if (start >= end) {
-        // section of 0 size, nothing to sort
-        return;
-    }
-
-    let stackPointer = 2;
-    let i, j;
-
-    stack[0] = start;
-    stack[1] = end;
-
-    while (stackPointer > 0) {
-        stackPointer -= 2;
-
-        const right = stack[stackPointer + 1];
-        const left = stack[stackPointer];
-
-        i = left;
-        j = right;
-
-        const pivotIndex = (left + right) >> 1;
-
-        const pivot = data[pivotIndex];
-
-        /* partition */
-        while (i <= j) {
-            while (compare_function.call(compare_function_context, data[i], pivot) < 0) {
-                i++;
-            }
-
-            while (compare_function.call(compare_function_context, data[j], pivot) > 0) {
-                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_comparator.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @template T
+ * @param {T[]|Uint32Array} data
+ * @param {function(T,T):number} compare_function
+ * @param {*} compare_function_context
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_comparator<T>(data: Uint32Array | T[], compare_function: (arg0: T, arg1: T) => number, compare_function_context: any, start: number, end: number): void;
+//# sourceMappingURL=array_quick_sort_by_comparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_quick_sort_by_comparator.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_quick_sort_by_comparator.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,mHALyB,MAAM,wCAEpB,MAAM,OACN,MAAM,QAkEhB"}

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

@@ -0,0 +1,75 @@
+const stack = [];
+
+/**
+ * @template T
+ * @param {T[]|Uint32Array} data
+ * @param {function(T,T):number} compare_function
+ * @param {*} compare_function_context
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_comparator(
+    data,
+    compare_function, compare_function_context,
+    start, end
+) {
+    if (start >= end) {
+        // section of 0 size, nothing to sort
+        return;
+    }
+
+    let stackPointer = 2;
+    let i, j;
+
+    stack[0] = start;
+    stack[1] = end;
+
+    while (stackPointer > 0) {
+        stackPointer -= 2;
+
+        const right = stack[stackPointer + 1];
+        const left = stack[stackPointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        const pivot = data[pivotIndex];
+
+        /* partition */
+        while (i <= j) {
+            while (compare_function.call(compare_function_context, data[i], pivot) < 0) {
+                i++;
+            }
+
+            while (compare_function.call(compare_function_context, data[j], pivot) > 0) {
+                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.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(data: number[] | Uint32Array, lookup: number[] | Uint32Array, start: number, end: number): void;
+//# sourceMappingURL=array_quick_sort_by_lookup.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"array_quick_sort_by_lookup.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/array/array_quick_sort_by_lookup.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,iDALW,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

@@ -0,0 +1,78 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../SCRATCH_UINT32_TRAVERSAL_STACK.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ * @param {number[]|Uint32Array} data
+ * @param {number[]|Uint32Array} lookup
+ * @param {number} start
+ * @param {number} end
+ */
+export function array_quick_sort_by_lookup(
+    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[pivot];
+
+        /* partition */
+        while (i <= j) {
+            while (lookup[data[i]] < pivot_score) {
+                i++;
+            }
+
+            while (lookup[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/geom/2d/triangle2d_get_barycentric.d.ts

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} px
+ * @param {number} py
+ */
+export function triangle2d_get_barycentric(output: number[], output_offset: number, ax: number, ay: number, bx: number, by: number, cx: number, cy: number, px: number, py: number): void;
+//# sourceMappingURL=triangle2d_get_barycentric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"triangle2d_get_barycentric.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/2d/triangle2d_get_barycentric.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,mDAXW,MAAM,EAAE,iBACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkChB"}

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

@@ -0,0 +1,48 @@
+import { v2_dot } from "../vec2/v2_dot.js";
+
+/**
+ *
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} px
+ * @param {number} py
+ */
+export function triangle2d_get_barycentric(
+    output, output_offset,
+    ax, ay,
+    bx, by,
+    cx, cy,
+    px, py
+) {
+
+    const v0_x = bx - ax;
+    const v0_y = by - ay;
+
+    const v1_x = cx - ax;
+    const v1_y = cy - ay;
+
+    const v2_x = px - ax;
+    const v2_y = py - ay;
+
+    const d00 = v2_dot(v0_x, v0_y, v0_x, v0_y);
+    const d01 = v2_dot(v0_x, v0_y, v1_x, v1_y);
+    const d11 = v2_dot(v1_x, v1_y, v1_x, v1_y);
+    const d20 = v2_dot(v2_x, v2_y, v0_x, v0_y);
+    const d21 = v2_dot(v2_x, v2_y, v1_x, v1_y);
+
+    const denom = d00 * d11 - d01 * d01;
+
+    const v = (d11 * d20 - d01 * d21) / denom;
+    const w = (d00 * d21 - d01 * d20) / denom;
+    const u = 1.0 - v - w;
+
+    output[output_offset] = v;
+    output[output_offset + 1] = w;
+    output[output_offset + 2] = u;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_from_v3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,4CAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAAM,SAC7C,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,QAmChB"}
+{"version":3,"file":"aabb3_from_v3_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_from_v3_array.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,4CAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,QAAM,SAC7C,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,gBACvC,MAAM,QA6BhB"}

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

@@ -1,6 +1,7 @@
 import { assert } from "../../../assert.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
+import { aabb3_array_set } from "./aabb3_array_set.js";
 
 /**
  *
@@ -34,11 +35,5 @@ export function aabb3_from_v3_array(result, input, input_length) {
     }
 
     // read out
-    result[0] = x0;
-    result[1] = y0;
-    result[2] = z0;
-
-    result[3] = x1;
-    result[4] = y1;
-    result[5] = z1;
+    aabb3_array_set(result, 0, x0, y0, z0, x1, y1, z1);
 }

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

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} vertices
+ * @param {number} a_index
+ * @param {number} b_index
+ * @param {number} c_index
+ */
+export function aabb3_compute_from_triangle(output: number[] | Float32Array, output_offset: number, vertices: number[] | Float32Array, a_index: number, b_index: number, c_index: number): void;
+//# sourceMappingURL=aabb3_compute_from_triangle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aabb3_compute_from_triangle.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/3d/aabb3_compute_from_triangle.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,oDAPW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,WACN,MAAM,WACN,MAAM,QAgChB"}

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

@@ -0,0 +1,43 @@
+import { max3 } from "../../math/max3.js";
+import { min3 } from "../../math/min3.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} output
+ * @param {number} output_offset
+ * @param {number[]|Float32Array} vertices
+ * @param {number} a_index
+ * @param {number} b_index
+ * @param {number} c_index
+ */
+export function aabb3_compute_from_triangle(
+    output, output_offset,
+    vertices, a_index, b_index, c_index
+) {
+    const a = a_index * 3;
+    const b = b_index * 3;
+    const c = c_index * 3;
+
+    // read actual positions of each vertex
+    const aX = vertices[a];
+    const aY = vertices[a + 1];
+    const aZ = vertices[a + 2];
+
+    const bX = vertices[b];
+    const bY = vertices[b + 1];
+    const bZ = vertices[b + 2];
+
+    const cX = vertices[c];
+    const cY = vertices[c + 1];
+    const cZ = vertices[c + 2];
+
+    // compute bounds of the triangle
+    output[output_offset] = min3(aX, bX, cX);
+    output[output_offset + 1] = min3(aY, bY, cY);
+    output[output_offset + 2] = min3(aZ, bZ, cZ);
+
+    output[output_offset + 3] = max3(aX, bX, cX);
+    output[output_offset + 4] = max3(aY, bY, cY);
+    output[output_offset + 5] = max3(aZ, bZ, cZ);
+
+}

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -10,6 +10,7 @@ import { sh_index } from "./sh_index.js";
 @see https://github.com/Bestmaker602/olacziy/blob/212b64ea5f1856b390cdf7629801243f76a4466d/libs/ibl/src/CubemapSH.cpp
  */
 
+const scratch_sh3 = new Float32Array(9);
 
 /**
  * SH from environment with high dynamic range (or high frequencies -- high dynamic range creates
@@ -233,14 +234,13 @@ function windowSH(
         }
 
         cutoff = numBands * 4 + 1;// start at a large band
-        // We need to process each channel separately
-        const SH = new Float32Array(9);
 
+        // We need to process each channel separately
         for (let channel = 0; channel < channel_count; channel++) {
 
             for (let i = 0; i < numBands * numBands; i++) {
                 // copy this channel
-                SH[i] = output[output_offset + i * channel_count + channel];
+                scratch_sh3[i] = input[input_offset + i * channel_count + channel];
             }
 
             // find a cut-off band that works
@@ -251,9 +251,9 @@ function windowSH(
 
                 const m = 0.5 * (l + r);
 
-                windowing(SH, m, numBands);
+                windowing(scratch_sh3, m, numBands);
 
-                if (sh3_min(SH) < 0) {
+                if (sh3_min(scratch_sh3) < 0) {
                     r = m;
                 } else {
                     l = m;

package/src/core/geom/3d/sphere/harmonics/sh_compute_K.d.ts

@@ -0,0 +1,9 @@
+/**
+ * computes K(m,l) normalization constant
+ * @see "Deringing Spherical Harmonics" by Peter-Pike Sloan
+ * @param {number} m
+ * @param {number} l
+ * @returns {number}
+ */
+export function sh_compute_K(m: number, l: number): number;
+//# sourceMappingURL=sh_compute_K.d.ts.map

package/src/core/geom/3d/sphere/harmonics/sh_compute_K.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sh_compute_K.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/sphere/harmonics/sh_compute_K.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,gCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CASlB"}