@woosh/meep-engine 2.43.17 → 2.43.19

package/core/assert.js

@@ -380,7 +380,9 @@ assert.notNaN = function (value, name = "value") {
  * @param {string} name
  */
 assert.isFiniteNumber = function (value, name = "value") {
-    assert.ok(Number.isFinite(value), `${name} must be a finite number, instead was ${value}`);
+    if (!Number.isFinite(value)) {
+        throw new Error(`${name} must be a finite number, instead was ${value}`);
+    }
 };
 
 export {

package/core/bvh2/aabb3/aabb3_intersects_ray.js

@@ -1,5 +1,6 @@
 import { fabsf } from "../../math/fabsf.js";
 
+
 /**
  * NOTES:
  *      https://web.archive.org/web/20090803054252/http://tog.acm.org/resources/GraphicsGems/gems/RayBox.c
@@ -20,41 +21,46 @@ import { fabsf } from "../../math/fabsf.js";
  * @param {number} dirZ
  * @returns {boolean}
  */
-function aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, dirZ) {
+export function aabb3_intersects_ray(
+    x0, y0, z0,
+    x1, y1, z1,
+    oX, oY, oZ,
+    dirX, dirY, dirZ
+) {
 
     // Z Projection
-    const boxExtentsX = (x1 - x0) / 2;
+    const boxExtentsX = (x1 - x0) * 0.5;
 
     const centerX = x0 + boxExtentsX;
 
     const diffX = oX - centerX;
 
 
-    if (fabsf(diffX) > boxExtentsX && diffX * dirX >= 0.0) {
+    if (diffX * dirX >= 0.0 && fabsf(diffX) > boxExtentsX) {
         return false;
     }
 
     // Y projection
-    const boxExtentsY = (y1 - y0) / 2;
+    const boxExtentsY = (y1 - y0) * 0.5;
 
     const centerY = y0 + boxExtentsY;
 
     const diffY = oY - centerY;
 
 
-    if (fabsf(diffY) > boxExtentsY && diffY * dirY >= 0.0) {
+    if (diffY * dirY >= 0.0 && fabsf(diffY) > boxExtentsY) {
         return false;
     }
 
     // Z projection
-    const boxExtentsZ = (z1 - z0) / 2;
+    const boxExtentsZ = (z1 - z0) * 0.5;
 
     const centerZ = z0 + boxExtentsZ;
 
     const diffZ = oZ - centerZ;
 
 
-    if (fabsf(diffZ) > boxExtentsZ && diffZ * dirZ >= 0.0) {
+    if (diffZ * dirZ >= 0.0 && fabsf(diffZ) > boxExtentsZ) {
         return false;
     }
 
@@ -64,9 +70,9 @@ function aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, di
     //b = fabsf(Dir.y);
     //if(fabsf(Diff.y)>BoxExtents.y + b)	return false;
 
-    const a = fabsf(dirX);
     const b = fabsf(dirY);
     const c = fabsf(dirZ);
+    const a = fabsf(dirX);
 
     const f0 = dirY * diffZ - dirZ * diffY;
 
@@ -89,4 +95,3 @@ function aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, oX, oY, oZ, dirX, dirY, di
     return true;
 }
 
-export { aabb3_intersects_ray };

package/core/bvh2/aabb3/aabb3_intersects_ray_branchless.js

@@ -0,0 +1,52 @@
+import { min2 } from "../../math/min2.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ * SLOW, don't use in production
+ * It is branchless on systems where min/max instructions exist.
+ * Unfortunately in JS that's not the case, so this is just a curiosity
+ * @see https://tavianator.com/2011/ray_box.html
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} oX
+ * @param {number} oY
+ * @param {number} oZ
+ * @param {number} dirX
+ * @param {number} dirY
+ * @param {number} dirZ
+ * @returns {boolean}
+ */
+export function aabb3_intersects_ray_branchless(
+    x0, y0, z0,
+    x1, y1, z1,
+    oX, oY, oZ,
+    dirX, dirY, dirZ
+) {
+    const inv_dir_x = 1 / dirX;
+    const inv_dir_y = 1 / dirY;
+    const inv_dir_z = 1 / dirZ;
+
+    const tx1 = (x0 - oX) * inv_dir_x;
+    const tx2 = (x1 - oX) * inv_dir_x;
+
+    let tmin = min2(tx1, tx2);
+    let tmax = max2(tx1, tx2);
+
+    const ty1 = (y0 - oY) * inv_dir_y;
+    const ty2 = (y1 - oY) * inv_dir_y;
+
+    tmin = max2(tmin, min2(ty1, ty2));
+    tmax = min2(tmax, max2(ty1, ty2));
+
+    const tz1 = (z0 - oZ) * inv_dir_z;
+    const tz2 = (z1 - oZ) * inv_dir_z;
+
+    tmin = max2(tmin, min2(tz1, tz2));
+    tmax = min2(tmax, max2(tz1, tz2));
+
+    return tmax >= tmin;
+}

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.d.ts

@@ -20,4 +20,6 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     node_get_user_data(node: number): number
 
     release_all(): void
+
+    trim(): void
 }

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -2,11 +2,13 @@ import { aabb3_compute_surface_area } from "../aabb3/aabb3_compute_surface_area.
 import { min2 } from "../../math/min2.js";
 import { max2 } from "../../math/max2.js";
 import { assert } from "../../assert.js";
+import { typed_array_copy } from "../../collection/array/typed/typed_array_copy.js";
+import { array_copy } from "../../collection/array/copyArray.js";
 
-const COLUMN_PARENT = 6;
-const COLUMN_CHILD_1 = 7;
-const COLUMN_CHILD_2 = 8;
-const COLUMN_HEIGHT = 9;
+export const COLUMN_PARENT = 6;
+export const COLUMN_CHILD_1 = 7;
+export const COLUMN_CHILD_2 = 8;
+export const COLUMN_HEIGHT = 9;
 
 /**
  * A non-leaf node have both CHILD_1 and CHILD_2 set, when CHILD_1 is not set - it's a leaf node
@@ -40,7 +42,7 @@ const CAPACITY_GROW_MIN_STEP = 64;
  * @readonly
  * @type {number}
  */
-const ELEMENT_WORD_COUNT = 10;
+export const ELEMENT_WORD_COUNT = 10;
 
 /**
  * How many nodes can be stored in the newly constructed tree before allocation needs to take place
@@ -134,6 +136,16 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             this.__capacity + CAPACITY_GROW_MIN_STEP
         ));
 
+        this.__set_capacity(new_capacity);
+    }
+
+    /**
+     *
+     * @param {number} new_capacity
+     * @private
+     */
+    __set_capacity(new_capacity) {
+
         const old_data_uint32 = this.__data_uint32;
 
         const new_data_buffer = new ArrayBuffer(new_capacity * ELEMENT_WORD_COUNT * 4);
@@ -144,11 +156,20 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         this.__data_uint32 = new Uint32Array(new_data_buffer);
 
         // copy old data into new buffer
-        this.__data_uint32.set(old_data_uint32);
+        typed_array_copy(old_data_uint32, this.__data_uint32);
 
         this.__capacity = new_capacity;
     }
 
+    /**
+     * Trim allocated memory region to only contain allocated nodes
+     */
+    trim() {
+        if (this.__capacity > this.__size) {
+            this.__set_capacity(this.__size);
+        }
+    }
+
     /**
      *
      * @returns {number}
@@ -260,6 +281,15 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_CHILD_1];
     }
 
+    /**
+     *
+     * @param {number} node
+     * @param {number} child1
+     */
+    node_set_child1(node, child1) {
+        this.__data_uint32[ELEMENT_WORD_COUNT * node + COLUMN_CHILD_1] = child1;
+    }
+
     /**
      *
      * @param {number} id
@@ -270,6 +300,54 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_CHILD_2];
     }
 
+    /**
+     *
+     * @param {number} node
+     * @param {number} child2
+     */
+    node_set_child2(node, child2) {
+        this.__data_uint32[ELEMENT_WORD_COUNT * node + COLUMN_CHILD_2] = child2;
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_parent(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_PARENT];
+    }
+
+    /**
+     *
+     * @param {number} node
+     * @param {number} parent
+     */
+    node_set_parent(node, parent) {
+        this.__data_uint32[ELEMENT_WORD_COUNT * node + COLUMN_PARENT] = parent;
+    }
+
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_height(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_HEIGHT];
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} height
+     */
+    node_set_height(id, height) {
+        assert.isNonNegativeInteger(id, 'id');
+        this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_HEIGHT] = height;
+    }
 
     /**
      *
@@ -946,10 +1024,84 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     }
 
     /**
-     * Sort live nodes in the traversal order.
-     * This makes most queries have linear access, resulting in near-optimal cache usage
+     * Update parent and child links of a given node to point to a new location, useful for re-locating nodes
+     * @param {number} node node to update
+     * @param {number} destination Where updated links should point to
+     * @private
      */
-    sort_for_traversal_depth_first() {
-        throw new Error('Not Implemented');
+    __move_node_links(node, destination) {
+
+        const uint32 = this.__data_uint32;
+
+        const source_address = node * ELEMENT_WORD_COUNT;
+
+        // update children of a
+        const child1 = uint32[source_address + COLUMN_CHILD_1];
+        const child2 = uint32[source_address + COLUMN_CHILD_2];
+
+        if (child1 !== NULL_NODE) {
+
+            uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_PARENT] = destination;
+            uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_PARENT] = destination;
+
+        }
+
+        // update parent of a
+        const parent = uint32[source_address + COLUMN_PARENT];
+
+        if (parent !== NULL_NODE) {
+            const parent_child1 = uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+
+            if (parent_child1 === node) {
+                uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = destination;
+            } else {
+                uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = destination;
+            }
+        }
+    }
+
+    /**
+     * Swap two nodes in memory
+     * @param {number} a
+     * @param {number} b
+     * @returns {boolean}
+     */
+    swap_nodes(a, b) {
+        // console.log(`swap ${a} - ${b}`)
+
+        const uint32 = this.__data_uint32;
+
+        const address_a = a * ELEMENT_WORD_COUNT;
+        const address_b = b * ELEMENT_WORD_COUNT;
+
+
+        if (uint32[address_a + COLUMN_PARENT] === b) {
+            // attempting to swap direct parent/child, this is unsupported
+            return false;
+        }
+        if (uint32[address_b + COLUMN_PARENT] === a) {
+            // attempting to swap direct parent/child, this is unsupported
+            return false;
+        }
+
+        this.__move_node_links(a, b);
+        this.__move_node_links(b, a);
+
+        // copy A to temp buffer
+        array_copy(uint32, address_a, this.__free, this.__free_pointer, ELEMENT_WORD_COUNT);
+
+        // write data
+        array_copy(uint32, address_b, uint32, address_a, ELEMENT_WORD_COUNT);
+        array_copy(this.__free, this.__free_pointer, uint32, address_b, ELEMENT_WORD_COUNT);
+
+        // update root as necessary
+        if (this.__root === a) {
+            this.__root = b;
+        } else if (this.__root === b) {
+            this.__root = a;
+        }
+
+        return true;
     }
 }
+

package/core/bvh2/bvh3/ebvh_build_for_geometry_incremental.js

@@ -0,0 +1,34 @@
+import { min2 } from "../../math/min2.js";
+import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
+
+/**
+ * Build the BVH by relying on BVH's own incremental insertion mechanism
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|Float32Array} index_array
+ * @param {number[]|Float32Array} positions_array
+ * @param {number} [batch_size] can batch triangles in groups of up-to this many triangles per BVH leaf
+ */
+export function ebvh_build_for_geometry_incremental(bvh, index_array, positions_array, batch_size = 1) {
+    bvh.release_all();
+    const triangle_count = index_array.length / 3;
+
+    const leaf_node_count = Math.ceil(triangle_count / batch_size);
+
+    const leaf_aabb = [];
+
+    for (let i = 0; i < leaf_node_count; i++) {
+
+        const index_start = i * batch_size;
+        const index_end = min2(triangle_count, index_start + batch_size);
+
+        const group_size = index_end - index_start;
+
+        compute_triangle_group_aabb3(leaf_aabb, 0, index_array, positions_array, index_start * 3, group_size, 3);
+
+        const node_index = bvh.allocate_node();
+        bvh.node_set_aabb(node_index, leaf_aabb);
+        bvh.node_set_user_data(node_index, i);
+
+        bvh.insert_leaf(node_index);
+    }
+}

package/core/bvh2/bvh3/ebvh_build_for_geometry_morton.js

@@ -0,0 +1,175 @@
+import { AABB3 } from "../aabb3/AABB3.js";
+import { aabb3_from_v3_array } from "../aabb3/aabb3_from_v3_array.js";
+import morton from "../../geom/3d/morton/Morton.js";
+import { arrayQuickSort } from "../../collection/array/arrayQuickSort.js";
+import { compute_triangle_group_aabb3 } from "../../../engine/graphics/sh3/path_tracer/compute_triangle_group_aabb3.js";
+import { NULL_NODE } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ * Build the BVH bottom-up using spatial hash sorting
+ * Resulting BVH is produced very quickly, has perfect balance and is of decent quality
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ * @param {number[]|Float32Array} index_array
+ * @param {number[]|Float32Array} position_array
+ */
+export function ebvh_build_for_geometry_morton(bvh, index_array, position_array) {
+    // clear out existing BVH
+    bvh.release_all();
+
+    const aabb3 = new AABB3();
+
+    // get bounds for the entire geometry
+    aabb3_from_v3_array(aabb3, position_array, position_array.length);
+
+    const aabb_x0 = aabb3.x0;
+    const aabb_y0 = aabb3.y0;
+    const aabb_z0 = aabb3.z0;
+
+    const aabb_size_x = aabb3.getExtentsX();
+    const aabb_size_y = aabb3.getExtentsY();
+    const aabb_size_z = aabb3.getExtentsZ();
+
+    const morton_scale_x = aabb_size_x === 0 ? 0 : 1023 / aabb_size_x;
+    const morton_scale_y = aabb_size_y === 0 ? 0 : 1023 / aabb_size_y;
+    const morton_scale_z = aabb_size_z === 0 ? 0 : 1023 / aabb_size_z;
+
+    // allocate nodes
+    const tri_count = index_array.length / 3;
+    const node_leaf_count = tri_count;
+    const node_bin_count = Math.ceil(node_leaf_count / 2) * 2 - 1;
+
+    const node_total_count = node_leaf_count + node_bin_count;
+
+    const nodes = new Uint32Array(node_total_count);
+
+    // skip allocation calls, allocate exactly as many nodes as we need
+    bvh.__set_capacity(node_total_count);
+    bvh.__size = node_total_count;
+
+    for (let i = 0; i < node_total_count; i++) {
+        // store nodes in reverse order so that top-level nodes end up on top
+        nodes[i] = (node_total_count - 1) - i;
+    }
+
+    // for (let i = node_total_count - 1; i >= 0; i--) {
+    //     // store nodes in reverse order so that top-level nodes end up on top
+    //     nodes[i] = bvh.allocate_node();
+    // }
+
+    const morton_codes = new Uint32Array(tri_count);
+    const sorted_triangle_order = new Uint32Array(tri_count);
+
+    // compute morton codes
+    for (let i = 0; i < tri_count; i++) {
+
+        sorted_triangle_order[i] = i;
+
+        const i3 = i * 3;
+
+        const a = index_array[i3];
+        const b = index_array[i3 + 1];
+        const c = index_array[i3 + 2];
+
+        const a_address = a * 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];
+
+        const center_x = (ax + bx + cx) * 0.333333333;
+        const center_y = (ay + by + cy) * 0.333333333;
+        const center_z = (az + bz + cz) * 0.333333333;
+
+
+        // normalize to bounds
+        const ncx = (center_x - aabb_x0) * morton_scale_x;
+        const ncy = (center_y - aabb_y0) * morton_scale_y;
+        const ncz = (center_z - aabb_z0) * morton_scale_z;
+
+        const morton_code = morton(
+            Math.round(ncx),
+            Math.round(ncy),
+            Math.round(ncz)
+        );
+
+        morton_codes[i] = morton_code;
+    }
+
+    // sort leaves by morton codes
+    arrayQuickSort(sorted_triangle_order, (triangle_index) => morton_codes[triangle_index], null, 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 triangle_index = sorted_triangle_order[i];
+
+        bvh.node_set_child1(node, NULL_NODE);
+        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);
+
+        bvh.node_set_aabb(node, aabb_array);
+
+        unprocessed_nodes[i] = node;
+    }
+
+    // Assemble hierarchy
+    let unprocessed_node_count = tri_count;
+
+
+    while (used_index < node_total_count) {
+
+        let added_nodes = 0;
+        let cursor = 0;
+
+        while (cursor + 1 < unprocessed_node_count) {
+            const child_1 = unprocessed_nodes[cursor++];
+            const child_2 = unprocessed_nodes[cursor++];
+
+            const parent = nodes[used_index++];
+
+            bvh.node_set_combined_aabb(parent, child_1, child_2);
+
+            bvh.node_set_parent(child_1, parent);
+            bvh.node_set_parent(child_2, parent);
+
+            bvh.node_set_child1(parent, child_1);
+            bvh.node_set_child2(parent, child_2);
+
+            bvh.node_set_height(parent,
+                1 + max2(
+                    bvh.node_get_height(child_1),
+                    bvh.node_get_height(child_2)
+                )
+            );
+
+            unprocessed_nodes[added_nodes++] = parent;
+        }
+
+        while (cursor < unprocessed_node_count) {
+            // dangling nodes, push them onto the next level
+            unprocessed_nodes[added_nodes++] = unprocessed_nodes[cursor++];
+        }
+
+        unprocessed_node_count = added_nodes;
+    }
+
+    // assign root
+    bvh.__root = nodes[nodes.length - 1];
+}

package/core/bvh2/bvh3/ebvh_sort_for_traversal_depth_first.js

@@ -0,0 +1,122 @@
+import {
+    COLUMN_CHILD_1,
+    COLUMN_HEIGHT,
+    COLUMN_PARENT,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE
+} from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+
+/**
+ * Sort live nodes in the traversal order.
+ * This makes most queries have linear access, resulting in near-optimal cache usage
+ * NOTE: assumes that there are no free nodes
+ * @param {ExplicitBinaryBoundingVolumeHierarchy} bvh
+ */
+export function ebvh_sort_for_traversal_depth_first(bvh) {
+    const stack = [];
+
+    stack[0] = 0;
+    stack[1] = bvh.__size - 1;
+
+    let stack_pointer = 2;
+    let i, j;
+
+    const uint32 = bvh.__data_uint32;
+    const float32 = bvh.__data_float32;
+
+    while (stack_pointer > 0) {
+        stack_pointer -= 2;
+
+        const right = stack[stack_pointer + 1];
+        const left = stack[stack_pointer];
+
+        i = left;
+        j = right;
+
+        const pivotIndex = (left + right) >> 1;
+
+        /* partition */
+        while (i <= j) {
+
+            while (traversal_sort_compare_nodes(uint32, float32, i, pivotIndex) > 0) {
+                i++;
+            }
+
+            while (traversal_sort_compare_nodes(uint32, float32, j, pivotIndex) < 0) {
+                j--;
+            }
+
+            if (i <= j) {
+
+                if (i !== j) {
+                    //do swap
+                    bvh.swap_nodes(i, j);
+                }
+
+                i++;
+                j--;
+            }
+        }
+
+        /* recursion */
+        if (left < j) {
+            stack[stack_pointer++] = left;
+            stack[stack_pointer++] = j;
+        }
+        if (i < right) {
+            stack[stack_pointer++] = i;
+            stack[stack_pointer++] = right;
+        }
+    }
+}
+
+/**
+ *
+ * @param {Uint32Array} uint32
+ * @param {number} node_index
+ * @return {number}
+ */
+function compute_traversal_index_upper_bound(uint32, node_index) {
+    let n = node_index;
+
+    let parent = uint32[node_index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+
+    let result = 0;
+    let x = 0;
+
+    while (parent !== NULL_NODE) {
+
+        if (uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === n) {
+            result += Math.pow(2, x);
+        }
+
+        x++;
+
+        n = parent;
+        parent = uint32[n * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {Uint32Array} uint32
+ * @param {Float32Array} float32
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function traversal_sort_compare_nodes(uint32, float32, a, b) {
+    const a_height = uint32[a * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
+    const b_height = uint32[b * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
+
+    const height_delta = a_height - b_height;
+
+    if (height_delta !== 0) {
+        return height_delta;
+    }
+
+    return compute_traversal_index_upper_bound(uint32, a) - compute_traversal_index_upper_bound(uint32, b);
+
+}