@woosh/meep-engine 2.119.118 → 2.119.119

package/package.json

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

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

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

@@ -3,6 +3,12 @@ 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";
 
+/**
+ * Somewhat arbitrary, pulled from various papers
+ * @type {number}
+ */
+const SAH_MERGE_FRACTION = 0.93;
+
 /**
  * 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
@@ -36,6 +42,9 @@ export function ebvh_build_hierarchy(
 
     let current_construction_depth = 0;
 
+    const primitive_counts = new Uint32Array(input_node_count);
+    primitive_counts.fill(1);
+
     while (unprocessed_node_count > 1) {
 
         const sah_optimization_cycle_count = Math.floor(sah_optimization_level + sah_optimization_bias * current_construction_depth);
@@ -48,6 +57,7 @@ export function ebvh_build_hierarchy(
             ebvh_nodes_sort_sah_local4(
                 bvh,
                 unprocessed_nodes,
+                primitive_counts,
                 0,
                 swap_distance,
                 unprocessed_node_count
@@ -58,9 +68,17 @@ export function ebvh_build_hierarchy(
         let added_nodes = 0;
         let cursor = 0;
 
-        while (cursor + 1 < unprocessed_node_count) {
-            const child_2 = unprocessed_nodes[cursor++];
-            const child_1 = unprocessed_nodes[cursor++];
+        let merge_limit = unprocessed_node_count;
+        if (sah_optimization_cycle_count > 0) {
+            merge_limit = Math.ceil(unprocessed_node_count * SAH_MERGE_FRACTION);
+        }
+
+        while (cursor + 1 < merge_limit) {
+            const child_2_index = cursor++;
+            const child_1_index = cursor++;
+
+            const child_2 = unprocessed_nodes[child_2_index];
+            const child_1 = unprocessed_nodes[child_1_index];
 
             const parent = node_pool[used_index++];
 
@@ -79,7 +97,9 @@ export function ebvh_build_hierarchy(
                 )
             );
 
-            unprocessed_nodes[added_nodes++] = parent;
+            const parent_index = added_nodes++;
+            unprocessed_nodes[parent_index] = parent;
+            primitive_counts[parent_index] = primitive_counts[child_1_index] + primitive_counts[child_2_index];
         }
 
         while (cursor < unprocessed_node_count) {

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

@@ -3,9 +3,10 @@
  * Useful for optimizing topology for traversal.
  * @param {BVH} bvh
  * @param {number[]|Uint32Array} nodes
+ * @param {number[]|Uint32Array} primitive_counts
  * @param {number} offset
  * @param {number} distance
  * @param {number} count
  */
-export function ebvh_nodes_sort_sah_local4(bvh: BVH, nodes: number[] | Uint32Array, offset: number, distance: number, count: number): number;
+export function ebvh_nodes_sort_sah_local4(bvh: BVH, nodes: number[] | Uint32Array, primitive_counts: number[] | Uint32Array, offset: number, distance: number, count: number): number;
 //# sourceMappingURL=ebvh_nodes_sort_sah_local4.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ebvh_nodes_sort_sah_local4.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_nodes_sort_sah_local4.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,gDANW,GAAG,SACH,MAAM,EAAE,GAAC,WAAW,UACpB,MAAM,YACN,MAAM,SACN,MAAM,UAgDhB"}
+{"version":3,"file":"ebvh_nodes_sort_sah_local4.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_nodes_sort_sah_local4.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,gDAPW,GAAG,SACH,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,EAAE,GAAC,WAAW,UACpB,MAAM,YACN,MAAM,SACN,MAAM,UAqGhB"}

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

@@ -1,27 +1,47 @@
+import { array_swap } from "../../collection/array/array_swap.js";
+
+
 /**
  * Sort consequent 4 nodes to reduce SAH among each consequent pair.
  * Useful for optimizing topology for traversal.
  * @param {BVH} bvh
  * @param {number[]|Uint32Array} nodes
+ * @param {number[]|Uint32Array} primitive_counts
  * @param {number} offset
  * @param {number} distance
  * @param {number} count
  */
-export function ebvh_nodes_sort_sah_local4(bvh, nodes, offset, distance, count) {
+export function ebvh_nodes_sort_sah_local4(
+    bvh,
+    nodes,
+    primitive_counts,
+    offset,
+    distance,
+    count
+) {
 
     const swap_pair_limit = Math.floor((count - (distance + 2)) / 2);
     const end = offset + swap_pair_limit * 2;
 
     let swap_count = 0;
 
-    for (let i = offset; i < end; i += 2) {
-        const j = i + distance;
+    for (let index_a = offset; index_a < end; index_a += 2) {
+        const index_c = index_a + distance;
+
+        const index_b = index_a + 1;
+        const index_d = index_c + 1;
+
+        const node_a = nodes[index_a];
+        const node_b = nodes[index_b];
+
+        const node_c = nodes[index_c];
+        const node_d = nodes[index_d];
 
-        const a = nodes[i];
-        const b = nodes[i + 1];
+        const count_a = primitive_counts[index_a];
+        const count_b = primitive_counts[index_b];
 
-        const c = nodes[j];
-        const d = nodes[j + 1];
+        const count_c = primitive_counts[index_c];
+        const count_d = primitive_counts[index_d];
 
         /*
          possible combinations:
@@ -31,25 +51,62 @@ export function ebvh_nodes_sort_sah_local4(bvh, nodes, offset, distance, count)
 
          Other combinations are not of interest as order among each pair is irrelevant for traversal performance
          */
-        const cost0 = bvh.node_get_combined_surface_area(a, b) + bvh.node_get_combined_surface_area(c, d);
-        const cost1 = bvh.node_get_combined_surface_area(a, c) + bvh.node_get_combined_surface_area(b, d);
-        const cost2 = bvh.node_get_combined_surface_area(a, d) + bvh.node_get_combined_surface_area(c, b);
+
+        const area_ab = bvh.node_get_combined_surface_area(node_a, node_b);
+        const area_cd = bvh.node_get_combined_surface_area(node_c, node_d);
+
+        const area_ac = bvh.node_get_combined_surface_area(node_a, node_c);
+        const area_bd = bvh.node_get_combined_surface_area(node_b, node_d);
+
+        const area_ad = bvh.node_get_combined_surface_area(node_a, node_d);
+        const area_cb = bvh.node_get_combined_surface_area(node_c, node_b);
+
+        const cost_ab = area_ab * (count_a + count_b);
+        const cost_cd = area_cd * (count_c + count_d);
+
+        const cost_ac = area_ac * (count_a + count_c);
+        const cost_bd = area_bd * (count_b + count_d);
+
+        const cost_ad = area_ad * (count_a + count_d);
+        const cost_cb = area_cb * (count_c + count_b);
+
+        const cost0 = cost_ab + cost_cd;
+        const cost1 = cost_ac + cost_bd;
+        const cost2 = cost_ad + cost_cb;
+
+        let post_swap = false;
 
         if (cost0 <= cost1 && cost0 <= cost2) {
             // no change
-            continue;
+            post_swap = cost_cd < cost_ab;
+
         } else if (cost1 <= cost2) {
             // swap C and B
-            nodes[i + 1] = c;
-            nodes[j] = b;
+            nodes[index_b] = node_c;
+            nodes[index_c] = node_b;
+
+            primitive_counts[index_b] = count_c;
+            primitive_counts[index_c] = count_b;
 
+            swap_count++;
+
+            post_swap = cost_bd < cost_ac;
         } else {
             // swap B and D
-            nodes[i + 1] = d;
-            nodes[j + 1] = b;
+            nodes[index_b] = node_d;
+            nodes[index_d] = node_b;
+
+            primitive_counts[index_b] = count_d;
+            primitive_counts[index_d] = count_b;
+
+            swap_count++;
+
+            post_swap = cost_cb < cost_ad;
         }
 
-        swap_count++;
+        // put node pairs in their cost order
+        array_swap(nodes, index_a, nodes, index_c, 2);
+        array_swap(primitive_counts, index_a, primitive_counts, index_c, 2);
     }
 
     return swap_count;

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAmDA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,GAAG,CAAC,KAAK,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAkF7C,iBAOC;IAED;;;;OAIG;IACH,uBAHW,KAAK,CAAC,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,yBAHW,KAAK,CAAC,QAAQ,GACZ,gBAAgB,CAI5B;IAED;;;;;OAKG;IACH,qBAJW,KAAK,CAAC,cAAc,YACpB,KAAK,CAAC,QAAQ,aACd,IAAI,GAAC,MAAM,EAAE,QAavB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,IAAI,QA0Cd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAsCnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,GACZ,MAAM,CA+CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,QAwHlB;;CACJ;oBAzlB8B,mCAAmC;+BAqBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B;qBAPzC,kCAAkC"}
+{"version":3,"file":"PathTracedScene.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/path_tracer/PathTracedScene.js"],"names":[],"mappings":"AAoDA;IAGI;;;OAGG;IACH,eAFU,GAAG,CAEa;IAG1B;;;OAGG;IACH,QAFU,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAElB;IAEnB;;;OAGG;IACH,UAFU,aAAa,EAAE,CAEX;IAEd;;;OAGG;IACH,WAFU,GAAG,CAAC,KAAK,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAElC;IAmBtB;;;;OAIG;IACH,6BAA6C;IAqF7C,iBAOC;IAED;;;;OAIG;IACH,uBAHW,KAAK,CAAC,cAAc,GACnB,mBAAmB,CAmB9B;IAED;;;OAGG;IACH,gBAFW,aAAa,QAMvB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACZ,OAAO,CAiCnB;IAED;;;;OAIG;IACH,iBAHW,cAAc,GACZ,OAAO,CAgBnB;IAED;;;;OAIG;IACH,yBAHW,KAAK,CAAC,QAAQ,GACZ,gBAAgB,CAI5B;IAED;;;;;OAKG;IACH,qBAJW,KAAK,CAAC,cAAc,YACpB,KAAK,CAAC,QAAQ,aACd,IAAI,GAAC,MAAM,EAAE,QAavB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,EAAE,OACR,MAAM,EAAE,gBACR,IAAI,QA0Cd;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAsCnB;IAED;;;;;OAKG;IACH,WAJW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,IAAI,GACZ,MAAM,CA+CjB;IAED;;;;;;OAMG;IACH,uBALW,MAAM,EAAE,cACR,MAAM,aACN,MAAM,EAAE,oBACR,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,EAAE,cACR,MAAM,OACN,MAAM,EAAE,QAwHlB;;CACJ;oBA7lB8B,mCAAmC;+BAqBnC,qBAAqB;8BAJtB,kDAAkD;oCAC5C,0BAA0B;qBAPzC,kCAAkC"}

package/src/engine/graphics/sh3/path_tracer/PathTracedScene.js

@@ -23,22 +23,23 @@ import { MaterialConverter } from "./material/MaterialConverter.js";
 import { PathTracedMesh } from "./PathTracedMesh.js";
 import { sample_material } from "./texture/sample_material.js";
 
-function light_getDistanceAttenuation( distance, cutoff_distance, decay_exponent){
+function light_getDistanceAttenuation(distance, cutoff_distance, decay_exponent) {
 
-    let distanceFalloff = 1.0 / Math.max( Math.pow( distance, decay_exponent ), 0.01 );
+    let distanceFalloff = 1.0 / Math.max(Math.pow(distance, decay_exponent), 0.01);
 
-    if ( cutoff_distance > 0.0 ) {
+    if (cutoff_distance > 0.0) {
         const b = distance / cutoff_distance;
-        const b2 = b*b;
-        const b4 = b2*b2;
+        const b2 = b * b;
+        const b4 = b2 * b2;
 
-        const c= saturate( 1.0 - b4 );
+        const c = saturate(1.0 - b4);
 
-        distanceFalloff *= c*c;
+        distanceFalloff *= c * c;
     }
 
     return distanceFalloff;
 }
+
 /**
  *
  * @type {number[]|Uint32Array}
@@ -170,7 +171,10 @@ export class PathTracedScene {
             bvh.node_set_height(node, 0);
 
         }
-        ebvh_nodes_sort_sah_local4(bvh, nodes, 0, 2,node_leaf_count);
+        const primitive_counts = new Uint32Array(node_leaf_count);
+        primitive_counts.fill(1);
+
+        ebvh_nodes_sort_sah_local4(bvh, nodes, primitive_counts, 0, 2, node_leaf_count);
 
         // record newly generated nodes as "unprocessed"
         const unprocessed_nodes = new Uint32Array(node_leaf_count);
@@ -589,9 +593,9 @@ export class PathTracedScene {
                     continue;
                 }
 
-                const attenuation = light_getDistanceAttenuation(distance_to_light,radius,2);
+                const attenuation = light_getDistanceAttenuation(distance_to_light, radius, 2);
 
-                const intensity = dotNL * light.intensity.getValue()*attenuation;
+                const intensity = dotNL * light.intensity.getValue() * attenuation;
                 const light_color = light.color;
 
                 out[out_offset] += light_color.r * intensity;