@woosh/meep-engine 2.131.34 → 2.131.35

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.131.34",
+  "version": "2.131.35",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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

@@ -1 +1 @@
-{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAuNA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QA+IhB"}
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAgRA;;;;;;;GAOG;AACH,uDAHW,MAAM,iBACN,MAAM,QA+IhB"}

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

@@ -1,15 +1,16 @@
 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";
+import { ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 
 // Common continuous memory region for better cache performance
-const scratch_memory = new ArrayBuffer((256 * 3 + 16) * 4);
+const scratch_memory = new ArrayBuffer((256 * 3 + 16) * 4 + 256 * 6 * 4);
 
-const scratch_areas = new Float32Array(scratch_memory, 0, 256);
-const scratch_cost = new Float32Array(scratch_memory, 1024, 256);
-const scratch_partitions = new Uint32Array(scratch_memory, 2048, 256);
-const scratch_treelet = new Uint32Array(scratch_memory, 3072, 16);
+const scratch_bounds = new Float32Array(scratch_memory, 0, 256 * 6);
+const scratch_areas = new Float32Array(scratch_memory, 6144, 256);
+const scratch_cost = new Float32Array(scratch_memory, 7168, 256);
+const scratch_partitions = new Uint32Array(scratch_memory, 8192, 256);
+const scratch_treelet = new Uint32Array(scratch_memory, 9216, 16);
 
 /**
  *
@@ -74,28 +75,84 @@ function optimize_treelet(bvh, root, leaves, leaf_count) {
 
     // see "Fast Parallel Construction of High-Quality Bounding Volume Hierarchies", Algorithm 2
 
+    const bvh_float32 = bvh.data_float32;
+
     // 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 mask_limit = (1 << leaf_count) - 1;
+
+    for (let s = 1; s <= mask_limit; s++) {
+        let min_x, min_y, min_z, max_x, max_y, max_z;
+
+        // Check if 's' is a power of 2 (i.e., a single leaf)
+        // (s & (s-1)) === 0 is the standard trick for this
+        const is_a_leaf = (s & (s - 1)) === 0;
+
+        if (is_a_leaf) {
+            // --- CASE A: LEAF ---
+            // Map the mask bit back to a linear index (0..7)
+            const leaf_index = lsb_32(s);
+
+            // Read from your compact linear array
+            const node = leaves[leaf_index];
+
+            const source_offset = node * ELEMENT_WORD_COUNT;
+
+            min_x = bvh_float32[source_offset];
+            min_y = bvh_float32[source_offset + 1];
+            min_z = bvh_float32[source_offset + 2];
+            max_x = bvh_float32[source_offset + 3];
+            max_y = bvh_float32[source_offset + 4];
+            max_z = bvh_float32[source_offset + 5];
+
+            // Initialize base cost for leaf (SAH_COST_TRIANGLE * Area)
+            // (Calculated below)
+        } else {
+            // --- CASE B: SUBSET ---
+            // Split s into: LSB (Leaf) + Rest (Subset)
+            // Both of these are < s, so they are guaranteed to be initialized.
+            const mask_lsb = s & -s;       // Extract lowest set bit
+            const mask_rest = s ^ mask_lsb; // The rest of the bits
+
+            const i_lsb = mask_lsb * 6;
+            const i_rest = mask_rest * 6;
+
+            // Merge bounds
+            min_x = Math.min(scratch_bounds[i_lsb],     scratch_bounds[i_rest]);
+            min_y = Math.min(scratch_bounds[i_lsb + 1], scratch_bounds[i_rest + 1]);
+            min_z = Math.min(scratch_bounds[i_lsb + 2], scratch_bounds[i_rest + 2]);
+            max_x = Math.max(scratch_bounds[i_lsb + 3], scratch_bounds[i_rest + 3]);
+            max_y = Math.max(scratch_bounds[i_lsb + 4], scratch_bounds[i_rest + 4]);
+            max_z = Math.max(scratch_bounds[i_lsb + 5], scratch_bounds[i_rest + 5]);
+        }
 
-            const s = (1 << i) | (1 << j);
+        // --- STORE ---
+        const dest_offset = s * 6;
 
-            scratch_areas[s] = bvh.node_get_combined_surface_area(leaf_0, leaf_1)
-        }
-    }
+        scratch_bounds[dest_offset]     = min_x;
+        scratch_bounds[dest_offset + 1] = min_y;
+        scratch_bounds[dest_offset + 2] = min_z;
+        scratch_bounds[dest_offset + 3] = max_x;
+        scratch_bounds[dest_offset + 4] = max_y;
+        scratch_bounds[dest_offset + 5] = max_z;
 
-    // Initialize costs of individual leaves
-    for (let i = 0; i < leaf_count; i++) {
-        const leaf = leaves[i];
+        // Calculate Surface Area
+        const dx = max_x - min_x;
+        const dy = max_y - min_y;
+        const dz = max_z - min_z;
 
-        scratch_cost[1 << i] = SAH_COST_TRIANGLE * bvh.node_get_surface_area(leaf);
+        const area = 2.0 * (dx * dy + dy * dz + dz * dx);
+
+        scratch_areas[s] = area;
+
+        if(is_a_leaf){
+            // Initialize costs of individual leaves
+            scratch_cost[s] = SAH_COST_TRIANGLE * area;
+        }
     }
 
     // Optimize every subset of leaves
     for (let k = 2; k <= leaf_count; k++) {
-        for (let s = 1; s <= (1 << leaf_count) - 1; s++) {
+        for (let s = 1; s <= mask_limit; s++) {
             if (bitCount(s) !== k) {
                 continue;
             }
@@ -322,7 +379,7 @@ export function ebvh_optimize_treelet(
 
         } else if (came_from_type === CAME_FROM_TYPE_PARENT) {
             const child1 = bvh.node_get_child1(node);
-            const child2 = bvh.node_get_child1(node);
+            const child2 = bvh.node_get_child2(node);
 
             if (child1 !== NULL_NODE) {
                 came_from_type = CAME_FROM_TYPE_PARENT;