@woosh/meep-engine 2.119.127 → 2.119.129

package/package.json

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

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":"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"}
+{"version":3,"file":"BVH.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/BVH.js"],"names":[],"mappings":"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"}

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

@@ -1066,6 +1066,30 @@ export class BVH {
         return iA;
     }
 
+    /**
+     * Utility method for assigning both children at once
+     * Children must be valid nodes (non-null)
+     * @param {number} parent
+     * @param {number} child_1
+     * @param {number} child_2
+     */
+    node_assign_children(parent, child_1, child_2) {
+        this.node_set_child1(parent, child_1);
+        this.node_set_child2(parent, child_2);
+
+        this.node_set_parent(child_1, parent);
+        this.node_set_parent(child_2, parent);
+
+        this.node_set_height(parent,
+            Math.max(
+                this.node_get_height(child_1),
+                this.node_get_height(child_2),
+            ) + 1
+        );
+
+        this.node_set_combined_aabb(parent, child_1, child_2);
+    }
+
     /**
      * Release all nodes, this essentially resets the tree to empty state
      * NOTE: For performance reasons, released memory is not reset, this means that attempting to access cleared nodes' memory will yield garbage data

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":"AAMA;;;;;;;;;;;;GAYG;AACH,0CATW,GAAG,qBACH,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,2BACN,MAAM,0BACN,MAAM,GACJ,MAAM,CAkFlB"}
+{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;GAYG;AACH,0CATW,GAAG,qBACH,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,2BACN,MAAM,0BACN,MAAM,GACJ,MAAM,CAmFlB"}

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

@@ -3,7 +3,6 @@ import { max2 } from "../../math/max2.js";
 import { NULL_NODE } from "./BVH.js";
 import { ebvh_nodes_sort_sah_local4 } from "./ebvh_nodes_sort_sah_local4.js";
 
-
 /**
  * Given a set of leaves, build intermediate node hierarchy on top, all the way up to the root
  * Assumes nodes are spatially sorted, if not - no guarantees can be made about quality
@@ -43,7 +42,8 @@ export function ebvh_build_hierarchy(
 
         for (let i = 0; i < sah_optimization_cycle_count; i++) {
 
-            // sort intermediate nodes using small locality and SAH metric
+            // Sort intermediate nodes using small locality and SAH metric
+            // Sorting progressively larger distance pairs yields best results, based on empirical tests (AG - 2024/12/28)
             const swap_distance = (i + 1) * 2;
 
             ebvh_nodes_sort_sah_local4(

package/src/core/bvh2/bvh3/ebvh_optimize_treelet.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Perform linear optimization across the tree, similar to rotations, but we support somewhat arbitrary depth and all possible permutations
+ * Note that the root does not move, but everything below the root is subject to change
+ * @see "Fast Parallel Construction of High-Quality Bounding Volume Hierarchies" by Kerras, NVIDIA 2013
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number} [treelet_size]
+ */
+export function ebvh_optimize_treelet(bvh: BVH, root: number, treelet_size?: number): void;
+//# sourceMappingURL=ebvh_optimize_treelet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAoNA;;;;;;;GAOG;AACH,2CAJW,GAAG,QACH,MAAM,iBACN,MAAM,QA0IhB"}

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

@@ -0,0 +1,357 @@
+import { assert } from "../../assert.js";
+import { lsb_32 } from "../../binary/lsb_32.js";
+import { bitCount } from "../../binary/operations/bitCount.js";
+import { NULL_NODE } from "./BVH.js";
+
+const scratch_areas = new Float32Array(256);
+const scratch_cost = new Float32Array(256);
+const scratch_partitions = new Uint32Array(256);
+const scratch_treelet = new Uint32Array(16);
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number[]} leaves
+ * @param {number} mask
+ */
+function assemble_mask(bvh, leaves, mask) {
+
+    const leaf_count = bitCount(mask);
+
+    if (leaf_count === 1) {
+        const leaf_index = lsb_32(mask);
+        return leaves[leaf_index];
+    }
+
+    let partitioning_left = scratch_partitions[mask];
+    let partition_right = mask & ~(partitioning_left);
+
+    const parent = bvh.allocate_node();
+
+    const left_node = assemble_mask(bvh, leaves, partitioning_left);
+    const right_node = assemble_mask(bvh, leaves, partition_right);
+
+    bvh.node_assign_children(parent, left_node, right_node);
+
+    return parent;
+}
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number[]} leaves
+ * @param {number} mask
+ */
+function rebuild_treelet(bvh, root, leaves, mask) {
+
+    let partitioning_left = scratch_partitions[mask];
+    let partition_right = mask & ~(partitioning_left);
+
+    bvh.node_assign_children(root,
+        assemble_mask(bvh, leaves, partitioning_left),
+        assemble_mask(bvh, leaves, partition_right),
+    );
+}
+
+//cost of traversing an intermediate node
+const SAH_COST_INTERMEDIATE = 1.2;
+// cost of performing ray/triangle test
+const SAH_COST_TRIANGLE = 1;
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number[]|Uint32Array} leaves
+ * @param {number} leaf_count
+ */
+function optimize_treelet(bvh, root, leaves, leaf_count) {
+    // console.log(`TREELET(${leaf_count}): ${leaves.slice(0, leaf_count).join(', ')}`); // DEBUG
+
+    // see "Fast Parallel Construction of High-Quality Bounding Volume Hierarchies", Algorithm 2
+
+    // Calculate surface area for each subset
+    for (let i = 0; i < leaf_count; i++) {
+        const leaf_0 = leaves[i];
+        for (let j = i + 1; j < leaf_count; j++) {
+            const leaf_1 = leaves[j];
+
+            const s = (1 << i) | (1 << j);
+
+            scratch_areas[s] = bvh.node_get_combined_surface_area(leaf_0, leaf_1)
+        }
+    }
+
+    // Initialize costs of individual leaves
+    for (let i = 0; i < leaf_count; i++) {
+        // TODO implement a full cost heuristic
+        const leaf = leaves[i];
+
+        // we use height, which is available, as a proxy for triangle count
+        const triangle_count = bvh.node_get_height(leaf);
+
+        scratch_cost[1 << i] = SAH_COST_TRIANGLE * bvh.node_get_surface_area(leaf) * triangle_count;
+    }
+
+    // Optimize every subset of leaves
+    for (let k = 2; k <= leaf_count; k++) {
+        for (let s = 1; s <= (1 << leaf_count) - 1; s++) {
+            if (bitCount(s) !== k) {
+                continue;
+            }
+
+            // Try each way of partitioning the leaves
+            let best_cost = Infinity;
+            let best_partition = 0;
+
+            const delta = (s - 1) & s;
+            let partition = (-delta) & s;
+
+            do {
+                const cost = scratch_cost[partition] + scratch_cost[s ^ partition];
+
+                if (cost < best_cost) {
+                    best_cost = cost;
+                    best_partition = partition;
+                }
+
+                partition = (partition - delta) & s;
+
+            } while (partition !== 0)
+
+            //  Calculate final SAH cost (Equation 2)
+            const sah_heuristic = SAH_COST_INTERMEDIATE * scratch_areas[s] + best_cost
+
+            scratch_cost[s] = sah_heuristic;
+            scratch_partitions[s] = best_partition;
+        }
+    }
+
+    // build tree
+    rebuild_treelet(bvh, root, leaves, (1 << leaf_count) - 1);
+}
+
+
+/**
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number} treelet_max_size
+ */
+function optimize_at_node(bvh, root, treelet_max_size) {
+    if (bvh.node_is_leaf(root)) {
+        return;
+    }
+
+    const left = bvh.node_get_child1(root);
+    const right = bvh.node_get_child2(root);
+
+    let treelet_size = 0;
+
+    if (left !== NULL_NODE) {
+        scratch_treelet[treelet_size++] = left;
+    }
+
+    if (right !== NULL_NODE) {
+        scratch_treelet[treelet_size++] = right;
+    }
+
+    if (treelet_size === 0) {
+        return;
+    }
+
+    while (treelet_size < treelet_max_size) {
+        // pick node with the largest surface area
+        let best_node_index = -1;
+        let best_area = 0; //note that this is deliberate, expanding node with 0 area is pointless
+
+        for (let i = 0; i < treelet_size; i++) {
+            const n = scratch_treelet[i];
+
+            if (bvh.node_is_leaf(n)) {
+                // can't expand
+                continue;
+            }
+
+            // TODO maintain list of areas instead of computing them every time
+            const area = bvh.node_get_surface_area(n);
+            if (area > best_area) {
+                best_area = area;
+                best_node_index = i;
+            }
+        }
+
+        if (best_node_index === -1) {
+            break;
+        }
+
+        // expand candidate
+        const victim = scratch_treelet[best_node_index];
+
+        const c0 = bvh.node_get_child1(victim);
+        const c1 = bvh.node_get_child2(victim);
+
+        scratch_treelet[best_node_index] = c0;
+        scratch_treelet[treelet_size++] = c1;
+
+        bvh.release_node(victim);
+    }
+
+    if (treelet_size <= 2) {
+        // nothing to do
+        return;
+    }
+
+    optimize_treelet(bvh, root, scratch_treelet, treelet_size);
+}
+
+const CAME_FROM_TYPE_PARENT = 0;
+const CAME_FROM_TYPE_CHILD_1 = 1;
+const CAME_FROM_TYPE_CHILD_2 = 2;
+
+/**
+ * Perform linear optimization across the tree, similar to rotations, but we support somewhat arbitrary depth and all possible permutations
+ * Note that the root does not move, but everything below the root is subject to change
+ * @see "Fast Parallel Construction of High-Quality Bounding Volume Hierarchies" by Kerras, NVIDIA 2013
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number} [treelet_size]
+ */
+export function ebvh_optimize_treelet(bvh, root, treelet_size = 7) {
+    assert.isNonNegativeInteger(treelet_size, 'treelet_size');
+    assert.lessThanOrEqual(treelet_size, 8, 'limit is 8');
+
+    if (root === NULL_NODE) {
+        // special case
+        return;
+    }
+
+    if (bvh.node_is_leaf(root)) {
+        // special case
+        return;
+    }
+
+    // we traverse depth-first using stack-less scheme
+    let came_from_node = root;
+
+    let came_from_type = CAME_FROM_TYPE_PARENT;
+
+    let node = bvh.node_get_child1(came_from_node);
+    if (node === NULL_NODE) {
+        node = bvh.node_get_child2(came_from_node);
+    }
+
+    if (node === NULL_NODE) {
+        // no children, done
+        return;
+    }
+
+    const min_height = Math.ceil(Math.log2(treelet_size));
+
+    while (true) {
+
+
+        if (
+            came_from_type === CAME_FROM_TYPE_CHILD_2
+            && bvh.node_get_height(node) >= min_height
+        ) {
+            // only form treelets when moving up
+            optimize_at_node(bvh, node, treelet_size);
+        }
+
+        // only add to treelet when traversing up, not down
+
+        if (bvh.node_is_leaf(node)) {
+
+            assert.equal(came_from_type, CAME_FROM_TYPE_PARENT);
+
+            const parent = came_from_node;
+            const parent_child_1 = bvh.node_get_child1(parent);
+
+            if (parent_child_1 === node) {
+                came_from_type = CAME_FROM_TYPE_CHILD_1;
+            } else {
+                came_from_type = CAME_FROM_TYPE_CHILD_2;
+            }
+
+            came_from_node = node;
+
+            node = parent;
+        } else if (came_from_type === CAME_FROM_TYPE_CHILD_2) {
+            // finishing traversal of this branch
+            came_from_node = node;
+            const parent = bvh.node_get_parent(node);
+
+            if (bvh.node_get_child1(parent) === node) {
+                came_from_type = CAME_FROM_TYPE_CHILD_1;
+            } else {
+                came_from_type = CAME_FROM_TYPE_CHILD_2;
+            }
+
+            if (node === root) {
+                // traversed all the way back up
+                break;
+            }
+
+            node = parent;
+
+        } else if (came_from_type === CAME_FROM_TYPE_CHILD_1) {
+            // traversing up from left child
+            const child2 = bvh.node_get_child2(node);
+
+            came_from_node = node;
+
+            if (child2 === NULL_NODE) {
+                // no right child, finish this branch
+                came_from_type = CAME_FROM_TYPE_CHILD_2; // indicate end
+
+                node = bvh.node_get_parent(node);
+            } else {
+                came_from_type = CAME_FROM_TYPE_PARENT;
+                node = child2;
+            }
+
+        } else if (came_from_type === CAME_FROM_TYPE_PARENT) {
+            const child1 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child1(node);
+
+            if (child1 !== NULL_NODE) {
+                came_from_type = CAME_FROM_TYPE_PARENT;
+                came_from_node = node;
+                node = child1;
+            } else if (child2 !== NULL_NODE) {
+                came_from_type = CAME_FROM_TYPE_PARENT;
+                came_from_node = node;
+                node = child2;
+            } else {
+                // this should not happen, as this would mean that node is empty and completely pointless
+                // we remove the node and traverse up
+
+
+                const parent_child1 = bvh.node_get_child1(came_from_node);
+
+                bvh.release_node(node);
+
+                if (parent_child1 === node) {
+                    // we are left child
+                    bvh.node_set_child1(came_from_node, NULL_NODE);
+                    came_from_node = NULL_NODE;
+                    came_from_type = CAME_FROM_TYPE_CHILD_1;
+                } else {
+                    bvh.node_set_child2(came_from_node, NULL_NODE);
+                    came_from_node = NULL_NODE;
+                    came_from_type = CAME_FROM_TYPE_CHILD_2;
+                }
+
+                node = came_from_node;
+            }
+
+
+        }
+
+    }
+
+    // optimize last collected treelet
+    optimize_at_node(bvh, root, treelet_size);
+}