@woosh/meep-engine 2.122.2 → 2.122.4

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.122.2",
+  "version": "2.122.4",
   "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

@@ -1051,20 +1051,36 @@ export class BVH {
      * @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_combined_aabb(parent, child_1, child_2);
+
+        this.node_assign_children_only(parent, child_1, child_2);
+    }
+
+    /**
+     * Utility method for assigning both children at once
+     * Children must be valid nodes (non-null)
+     * Does not update bounds.
+     * @param {number} parent
+     * @param {number} child_1
+     * @param {number} child_2
+     */
+    node_assign_children_only(parent, child_1, child_2) {
+        assert.isNonNegativeInteger(parent, 'parent');
+        assert.isNonNegativeInteger(child_1, 'child_1');
+        assert.isNonNegativeInteger(child_2, 'child_2');
 
         this.node_set_parent(child_1, parent);
         this.node_set_parent(child_2, parent);
 
+        this.node_set_child1(parent, child_1);
+        this.node_set_child2(parent, child_2);
+
         this.node_set_height(parent,
-            Math.max(
+            1 + 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);
     }
 
     /**

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":"AAYA;;;;;;;;;GASG;AACH,oDAPW,GAAG,eACH,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,kBAChC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,WAAW,WACX,KAAK,YACL,MAAM,QAiIhB;sBAlJqB,6BAA6B"}
+{"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;;;;;;;;;GASG;AACH,oDAPW,GAAG,eACH,MAAM,EAAE,GAAC,WAAW,GAAC,WAAW,kBAChC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,WAAW,WACX,KAAK,YACL,MAAM,QAsHhB;sBAtIqB,6BAA6B"}

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

@@ -8,7 +8,6 @@ import { max2 } from "../../math/max2.js";
 import { build_triangle_morton_codes } from "./build_triangle_morton_codes.js";
 import { COLUMN_CHILD_1, COLUMN_HEIGHT, COLUMN_USER_DATA, ELEMENT_WORD_COUNT, NULL_NODE } from "./BVH.js";
 import { ebvh_build_hierarchy } from "./ebvh_build_hierarchy.js";
-import { ebvh_nodes_sort_sah_local4 } from "./ebvh_nodes_sort_sah_local4.js";
 
 /**
  * Build the BVH bottom-up using spatial hash sorting
@@ -131,18 +130,7 @@ export function ebvh_build_for_geometry_morton(
 
     typed_array_copy(nodes, unprocessed_nodes);
 
-    // do long-distance swaps, starting high and coming down
-    for (let power = 5; power > Math.max(5 - quality, 1); power--) {
 
-        ebvh_nodes_sort_sah_local4(
-            bvh,
-            unprocessed_nodes,
-            0,
-            1 << power,
-            tri_count
-        );
-
-    }
 
 
     // assign root

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

@@ -1,5 +1,4 @@
 import { assert } from "../../assert.js";
-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";
 
@@ -40,6 +39,19 @@ export function ebvh_build_hierarchy(
 
         const sah_optimization_cycle_count = Math.floor(sah_optimization_level + sah_optimization_bias * current_construction_depth);
 
+        // do long-distance swaps, starting high and coming down
+        for (let power = 5; power > Math.max(5 - sah_optimization_cycle_count, 1); power--) {
+
+            ebvh_nodes_sort_sah_local4(
+                bvh,
+                unprocessed_nodes,
+                0,
+                1 << power,
+                unprocessed_node_count
+            );
+
+        }
+
         for (let i = 0; i < sah_optimization_cycle_count; i++) {
 
             // Sort intermediate nodes using small locality and SAH metric
@@ -65,20 +77,7 @@ export function ebvh_build_hierarchy(
 
             const parent = node_pool[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)
-                )
-            );
+            bvh.node_assign_children(parent, child_1, child_2);
 
             unprocessed_nodes[added_nodes++] = parent;
         }

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

@@ -0,0 +1,11 @@
+/**
+ * DO NOT USE, currently broken
+ * @param {BVH} bvh
+ * @param {number[]|Uint32Array} leaf_nodes
+ * @param {number[]} sorted_morton_codes
+ * @param {number} leaf_count
+ * @param {number[]} internal_nodes
+ * @returns {number} new root
+ */
+export function ebvh_build_hierarchy_radix(bvh: BVH, leaf_nodes: number[] | Uint32Array, sorted_morton_codes: number[], leaf_count: number, internal_nodes: number[]): number;
+//# sourceMappingURL=ebvh_build_hierarchy_radix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ebvh_build_hierarchy_radix.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy_radix.js"],"names":[],"mappings":"AA4MA;;;;;;;;GAQG;AACH,gDAPW,GAAG,cACH,MAAM,EAAE,GAAC,WAAW,uBACpB,MAAM,EAAE,cACR,MAAM,kBACN,MAAM,EAAE,GACN,MAAM,CAqElB"}

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

@@ -0,0 +1,281 @@
+import { assert } from "../../assert.js";
+import { clz32 } from "../../binary/clz32.js";
+import { clamp } from "../../math/clamp.js";
+import { NULL_NODE } from "./BVH.js";
+import { ebvh_update_hierarchy_bounds } from "./ebvh_update_hierarchy_bounds.js";
+
+/**
+ *
+ * @see "Thinking Parallel, Part III: Tree Construction on the GPU", 2012 by Tero Karras
+ *
+ * @param {number[]|Uint32Array} sortedMortonCodes
+ * @param {number} first
+ * @param {number} last
+ * @return {number}
+ */
+function find_split(
+    sortedMortonCodes,
+    first,
+    last
+) {
+    // Identical Morton codes => split the range in the middle.
+
+    const firstCode = sortedMortonCodes[first];
+    const lastCode = sortedMortonCodes[last];
+
+    if (firstCode === lastCode) {
+        return (first + last) >>> 1;
+    }
+
+    // Calculate the number of highest bits that are the same
+    // for all objects, using the count-leading-zeros intrinsic.
+
+    const commonPrefix = clz32(firstCode ^ lastCode);
+
+    // Use binary search to find where the next bit differs.
+    // Specifically, we are looking for the highest object that
+    // shares more than commonPrefix bits with the first one.
+
+    let split = first; // initial guess
+    let step = last - first;
+
+    do {
+        step = (step + 1) >>> 1; // exponential decrease
+        const newSplit = split + step; // proposed new position
+
+        if (newSplit < last) {
+            const splitCode = sortedMortonCodes[newSplit];
+            const splitPrefix = clz32(firstCode ^ splitCode);
+            if (splitPrefix > commonPrefix) {
+                split = newSplit; // accept proposal
+            }
+        }
+    }
+    while (step > 1);
+
+    return split;
+}
+
+/**
+ *
+ * @param {number} indexA
+ * @param {number} indexB
+ * @param {number} elementCount
+ * @param {number[]} mortonCodes
+ * @return {number}
+ * @see https://github.com/turanszkij/WickedEngine/blob/506749de321c2ab66fd33fbe41efb95afbbb7ff8/WickedEngine/shaders/bvh_hierarchyCS.hlsl#L28C1-L48C2
+ */
+function GetLongestCommonPrefix(indexA, indexB, elementCount, mortonCodes) {
+    assert.isNonNegativeInteger(indexA, 'indexA');
+    assert.isNonNegativeInteger(indexB, 'indexB');
+
+    if (indexA >= elementCount || indexB >= elementCount) {
+        return -1;
+    } else {
+        const mortonCodeA = mortonCodes[indexA];
+        const mortonCodeB = mortonCodes[indexB];
+        if (mortonCodeA !== mortonCodeB) {
+            return clz32(mortonCodeA ^ mortonCodeB);
+        } else {
+            // TODO: Technically this should be primitive ID
+            return clz32(indexA ^ indexB) + 31;
+        }
+    }
+}
+
+/**
+ * @see https://github.com/turanszkij/WickedEngine/blob/506749de321c2ab66fd33fbe41efb95afbbb7ff8/WickedEngine/shaders/bvh_hierarchyCS.hlsl#L28C1-L48C2
+ * @param {number[]|Uint32Array} output
+ * @param {number[]} sortedMortonCodes
+ * @param {number} numTriangles
+ * @param {number} idx
+ */
+function determineRangeW(output, sortedMortonCodes, numTriangles, idx) {
+    if (idx === 0) {
+        // root
+        output[0] = 0;
+        output[1] = numTriangles - 1;
+        return;
+    }
+
+    let d = GetLongestCommonPrefix(idx, idx + 1, numTriangles, sortedMortonCodes) - GetLongestCommonPrefix(idx, idx - 1, numTriangles, sortedMortonCodes);
+    d = clamp(d, -1, 1);
+
+    let minPrefix = GetLongestCommonPrefix(idx, idx - d, numTriangles, sortedMortonCodes);
+
+    // TODO: Consider starting this at a higher number
+    let maxLength = 2;
+    while (GetLongestCommonPrefix(idx, idx + maxLength * d, numTriangles, sortedMortonCodes) > minPrefix) {
+        maxLength <<= 2;
+    }
+
+    let length = 0;
+    for (let t = maxLength >>> 1; t > 0; t >>>= 1) {
+        if (GetLongestCommonPrefix(idx, idx + (length + t) * d, numTriangles, sortedMortonCodes) > minPrefix) {
+            length = length + t;
+        }
+    }
+
+    let j = idx + length * d;
+
+    output[0] = Math.min(idx, j);
+    output[1] = Math.max(idx, j);
+
+}
+
+
+/**
+ * @see https://github.com/mbartling/cuda-bvh/blob/7f2f98d9d29956c3559632e59104ba66f31f80b8/kernels/bvh.cu#L276C1-L352C2
+ * @param {number[]|Uint32Array} output
+ * @param {number[]} sortedMortonCodes
+ * @param {number} numTriangles
+ * @param {number} idx
+ */
+function determineRange(output, sortedMortonCodes, numTriangles, idx) {
+
+    //determine the range of keys covered by each internal node (as well as its children)
+    //direction is found by looking at the neighboring keys ki-1 , ki , ki+1
+    //the index is either the beginning of the range or the end of the range
+    let direction = 0;
+    let common_prefix_with_left = 0;
+    let common_prefix_with_right = 0;
+
+    common_prefix_with_right = clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx + 1]);
+
+    if (idx === 0) {
+        common_prefix_with_left = -1;
+    } else {
+        common_prefix_with_left = clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - 1]);
+
+    }
+
+    direction = ((common_prefix_with_right - common_prefix_with_left) > 0) ? 1 : -1;
+
+    let min_prefix_range = 0;
+
+    if (idx === 0) {
+        min_prefix_range = -1;
+
+    } else {
+        min_prefix_range = clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[idx - direction]);
+    }
+
+    let lmax = 2;
+    let next_key = idx + lmax * direction;
+
+    while ((next_key >= 0) && (next_key < numTriangles) && (clz32(sortedMortonCodes[idx] ^ sortedMortonCodes[next_key]) > min_prefix_range)) {
+        lmax *= 2;
+        next_key = idx + lmax * direction;
+    }
+    //find the other end using binary search
+    let l = 0;
+
+    do {
+        lmax = (lmax + 1) >> 1; // exponential decrease
+        const new_val = idx + (l + lmax) * direction;
+
+        if (new_val >= 0 && new_val < numTriangles) {
+            const Code = sortedMortonCodes[new_val];
+            const Prefix = clz32(sortedMortonCodes[idx] ^ Code);
+            if (Prefix > min_prefix_range) {
+                l = l + lmax;
+            }
+        }
+    } while (lmax > 1);
+
+    const j = idx + l * direction;
+
+    let left = 0;
+    let right = 0;
+
+    if (idx < j) {
+        left = idx;
+        right = j;
+    } else {
+        left = j;
+        right = idx;
+    }
+
+    // printf("idx : (%d) returning range (%d, %d) \n" , idx , left, right);
+
+    output[0] = left
+    output[1] = right;
+}
+
+/**
+ * DO NOT USE, currently broken
+ * @param {BVH} bvh
+ * @param {number[]|Uint32Array} leaf_nodes
+ * @param {number[]} sorted_morton_codes
+ * @param {number} leaf_count
+ * @param {number[]} internal_nodes
+ * @returns {number} new root
+ */
+export function ebvh_build_hierarchy_radix(
+    bvh,
+    leaf_nodes,
+    sorted_morton_codes,
+    leaf_count,
+    internal_nodes,
+) {
+    console.warn("IMPLEMENTATION IS INCOMPLETE, DO NOT USE")
+
+    assert.isNonNegativeInteger(leaf_count, 'leaf_count');
+
+    // Construct leaf nodes.
+    // Note: This step can be avoided by storing
+    // the tree in a slightly different way.
+
+    const range = new Uint32Array(2);
+
+    // Construct internal nodes.
+    const intermediate_node_count = leaf_count - 1;
+    for (let idx = 0; idx < intermediate_node_count; idx++) // in parallel
+    {
+        // Find out which range of objects the node corresponds to.
+        // (This is where the magic happens!)
+
+        determineRange(range, sorted_morton_codes, leaf_count, idx);
+
+        const first = range[0];
+        const last = range[1];
+
+        // Determine where to split the range.
+
+        const split = find_split(sorted_morton_codes, first, last);
+        assert.isNonNegativeInteger(split, 'split');
+
+        // Select childA.
+
+        let childA;
+        if (split === first) {
+            childA = leaf_nodes[split];
+        } else {
+            childA = internal_nodes[split];
+        }
+
+        // Select childB.
+
+        let childB;
+        if (split + 1 === last) {
+            childB = leaf_nodes[split + 1];
+        } else {
+            childB = internal_nodes[split + 1];
+        }
+
+        // Record parent-child relationships.
+        const parent = internal_nodes[idx];
+
+        bvh.node_assign_children_only(parent, childA, childB);
+    }
+
+    // Node 0 is the root.
+    const root = internal_nodes[0];
+
+    bvh.node_set_parent(root, NULL_NODE);
+
+    // update bounds
+    ebvh_update_hierarchy_bounds(bvh, root);
+
+    return root;
+}

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,2CAJW,GAAG,SACH,MAAM,iBACN,MAAM,QA8IhB"}
+{"version":3,"file":"ebvh_optimize_treelet.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_optimize_treelet.js"],"names":[],"mappings":"AAuNA;;;;;;;GAOG;AACH,2CAJW,GAAG,SACH,MAAM,iBACN,MAAM,QA+IhB"}

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

@@ -256,6 +256,7 @@ export function ebvh_optimize_treelet(
 
     const min_height = Math.ceil(Math.log2(treelet_size));
 
+    // do a stackless traversal
     while (true) {
 
 

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

@@ -0,0 +1,8 @@
+/**
+ * Traverses the tree bottom-up, updating bounds as it goes
+ * @param {BVH} bvh
+ * @param {number} root
+ * @returns {void}
+ */
+export function ebvh_update_hierarchy_bounds(bvh: BVH, root?: number): void;
+//# sourceMappingURL=ebvh_update_hierarchy_bounds.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ebvh_update_hierarchy_bounds.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_update_hierarchy_bounds.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,kDAJW,GAAG,SACH,MAAM,GACJ,IAAI,CAuIhB"}

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

@@ -0,0 +1,147 @@
+import { assert } from "../../assert.js";
+import { NULL_NODE } from "./BVH.js";
+
+const CAME_FROM_TYPE_PARENT = 0;
+const CAME_FROM_TYPE_CHILD_1 = 1;
+const CAME_FROM_TYPE_CHILD_2 = 2;
+
+/**
+ * Traverses the tree bottom-up, updating bounds as it goes
+ * @param {BVH} bvh
+ * @param {number} root
+ * @returns {void}
+ */
+export function ebvh_update_hierarchy_bounds(bvh, root = bvh.root) {
+    assert.isNonNegativeInteger(root, 'root');
+
+    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;
+    }
+
+    // do a stackless traversal
+    while (true) {
+
+
+        if (
+            came_from_type === CAME_FROM_TYPE_CHILD_2
+        ) {
+            // moving up last time, lets calculate
+            const child_1 = bvh.node_get_child1(node);
+            const child_2 = bvh.node_get_child2(node);
+
+            bvh.node_set_combined_aabb(node, child_1, child_2);
+        }
+
+        // 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;
+            }
+
+
+        }
+
+    }
+}