@woosh/meep-engine 2.35.16 → 2.36.1

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -0,0 +1,848 @@
+import { RowFirstTable } from "../../collection/table/RowFirstTable.js";
+import { RowFirstTableSpec } from "../../collection/table/RowFirstTableSpec.js";
+import { DataType } from "../../collection/table/DataType.js";
+import { aabb3_compute_surface_area } from "../aabb3/aabb3_compute_surface_area.js";
+import { min2 } from "../../math/min2.js";
+import { max2 } from "../../math/max2.js";
+import { assert } from "../../assert.js";
+
+const TABLE_SPEC = RowFirstTableSpec.get([
+    DataType.Float32, DataType.Float32, DataType.Float32, // x0, y0, z0
+    DataType.Float32, DataType.Float32, DataType.Float32, // x1, y1, z1
+    DataType.Uint32, // parent
+    DataType.Uint32, // child-1
+    DataType.Uint32, // child-2 / user-data (dual use)
+    DataType.Uint16 // height + flags
+]);
+
+const COLUMN_PARENT = 6;
+const COLUMN_CHILD_1 = 7;
+const COLUMN_CHILD_2 = 8;
+const COLUMN_HEIGHT = 9;
+const COLUMN_USER_DATA = COLUMN_CHILD_2;
+
+/**
+ *
+ * @type {number}
+ */
+export const NULL_NODE = 4294967295;
+/**
+ *
+ * @type {number}
+ */
+export const NULL_USER_DATA = NULL_NODE;
+
+/**
+ * @readonly
+ * @type {number[]}
+ */
+const DEFAULT_ROW_VALUE = Object.freeze([
+    Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY,
+    Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY,
+    NULL_NODE, // parent
+    NULL_NODE, // child-1
+    NULL_NODE, // child-2 / user-data
+    0 // height
+]);
+
+export class ExplicitBinaryBoundingVolumeHierarchy {
+    constructor() {
+
+        /**
+         *
+         * @type {RowFirstTable}
+         * @private
+         */
+        this.__data = new RowFirstTable(TABLE_SPEC);
+
+        /**
+         *
+         * @type {number[]}
+         * @private
+         */
+        this.__free = [];
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__root = NULL_NODE;
+    }
+
+    /**
+     *
+     * @returns {RowFirstTable}
+     */
+    get data() {
+        return this.__data;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get root() {
+        return this.__root;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get node_capacity() {
+        return this.__data.capacity;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    allocate_node() {
+        const free = this.__free;
+
+        let result;
+        if (free.length > 0) {
+            // nodes in the free pool
+            result = free.pop();
+        } else {
+
+            const data = this.__data;
+
+            const n = data.length;
+
+            data.resize(n + 1);
+
+            data.length++;
+
+            result = n;
+        }
+
+        // initialize node
+        this.__data.setRow(result, DEFAULT_ROW_VALUE);
+
+        return result;
+    }
+
+    /**
+     * Release memory used by the node
+     * @param {number} id
+     */
+    release_node(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        // TODO reset node
+
+        this.__free.push(id);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {boolean}
+     */
+    node_is_leaf(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        const child_1 = this.__data.readCellValue(id, COLUMN_CHILD_1);
+
+        return child_1 === NULL_NODE;
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_user_data(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        return this.__data.readCellValue(id, COLUMN_USER_DATA);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} value
+     */
+    node_set_user_data(id, value) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        this.__data.writeCellValue(id, COLUMN_USER_DATA, value);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_child1(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        return this.__data.readCellValue(id, COLUMN_CHILD_1);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_child2(id) {
+        assert.isNonNegativeInteger(id, 'id');
+        return this.__data.readCellValue(id, COLUMN_CHILD_2);
+    }
+
+
+    /**
+     *
+     * @param {number} id
+     * @param {number[]} result
+     */
+    node_get_aabb(id, result) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        const data = this.__data;
+
+        result[0] = data.readCellValue(id, 0);
+        result[1] = data.readCellValue(id, 1);
+        result[2] = data.readCellValue(id, 2);
+
+        result[3] = data.readCellValue(id, 3);
+        result[4] = data.readCellValue(id, 4);
+        result[5] = data.readCellValue(id, 5);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number[]} aabb
+     */
+    node_set_aabb(id, aabb) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        const data = this.__data;
+
+        data.writeCellValue(id, 0, aabb[0]);
+        data.writeCellValue(id, 1, aabb[1]);
+        data.writeCellValue(id, 2, aabb[2]);
+
+        data.writeCellValue(id, 3, aabb[3]);
+        data.writeCellValue(id, 4, aabb[4]);
+        data.writeCellValue(id, 5, aabb[5]);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number[]} aabb
+     */
+    node_move_aabb(id, aabb) {
+        // TODO only refit for small changes, and re-insert for large changes
+        this.node_set_aabb(id, aabb);
+
+        const parent = this.__data.readCellValue(id, COLUMN_PARENT);
+
+        if (parent !== NULL_NODE) {
+            this.bubble_up_refit(parent);
+        }
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     */
+    node_set_aabb_primitive(
+        id,
+        x0, y0, z0,
+        x1, y1, z1
+    ) {
+
+        assert.isNonNegativeInteger(id, 'id');
+
+        const data = this.__data;
+
+        data.writeCellValue(id, 0, x0);
+        data.writeCellValue(id, 1, y0);
+        data.writeCellValue(id, 2, z0);
+
+        data.writeCellValue(id, 3, x1);
+        data.writeCellValue(id, 4, y1);
+        data.writeCellValue(id, 5, z1);
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    node_get_surface_area(id) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        const data = this.__data;
+
+        const x0 = data.readCellValue(id, 0);
+        const y0 = data.readCellValue(id, 1);
+        const z0 = data.readCellValue(id, 2);
+
+        const x1 = data.readCellValue(id, 3);
+        const y1 = data.readCellValue(id, 4);
+        const z1 = data.readCellValue(id, 5);
+
+        return aabb3_compute_surface_area(
+            x0, y0, z0,
+            x1, y1, z1
+        );
+    }
+
+    /**
+     *
+     * @param {number} index_a
+     * @param {number} index_b
+     * @returns {number}
+     */
+    node_get_combined_surface_area(index_a, index_b) {
+        const data = this.__data;
+
+        const a_x0 = data.readCellValue(index_a, 0);
+        const b_x0 = data.readCellValue(index_b, 0);
+        const x0 = min2(a_x0, b_x0);
+
+        const a_y0 = data.readCellValue(index_a, 1);
+        const b_y0 = data.readCellValue(index_b, 1);
+        const y0 = min2(a_y0, b_y0);
+
+        const a_z0 = data.readCellValue(index_a, 2);
+        const b_z0 = data.readCellValue(index_b, 2);
+        const z0 = min2(a_z0, b_z0);
+
+        const a_x1 = data.readCellValue(index_a, 3);
+        const b_x1 = data.readCellValue(index_b, 3);
+        const x1 = max2(a_x1, b_x1);
+
+        const a_y1 = data.readCellValue(index_a, 4);
+        const b_y1 = data.readCellValue(index_b, 4);
+        const y1 = max2(a_y1, b_y1);
+
+        const a_z1 = data.readCellValue(index_a, 5);
+        const b_z1 = data.readCellValue(index_b, 5);
+        const z1 = max2(a_z1, b_z1);
+
+        return aabb3_compute_surface_area(
+            x0, y0, z0,
+            x1, y1, z1,
+        );
+    }
+
+    /**
+     *
+     * @param {number} destination
+     * @param {number} index_a
+     * @param {number} index_b
+     */
+    node_set_combined_aabb(destination, index_a, index_b) {
+
+        const data = this.__data;
+
+        const a_x0 = data.readCellValue(index_a, 0);
+        const b_x0 = data.readCellValue(index_b, 0);
+        const x0 = min2(a_x0, b_x0);
+
+        const a_y0 = data.readCellValue(index_a, 1);
+        const b_y0 = data.readCellValue(index_b, 1);
+        const y0 = min2(a_y0, b_y0);
+
+        const a_z0 = data.readCellValue(index_a, 2);
+        const b_z0 = data.readCellValue(index_b, 2);
+        const z0 = min2(a_z0, b_z0);
+
+        const a_x1 = data.readCellValue(index_a, 3);
+        const b_x1 = data.readCellValue(index_b, 3);
+        const x1 = max2(a_x1, b_x1);
+
+        const a_y1 = data.readCellValue(index_a, 4);
+        const b_y1 = data.readCellValue(index_b, 4);
+        const y1 = max2(a_y1, b_y1);
+
+        const a_z1 = data.readCellValue(index_a, 5);
+        const b_z1 = data.readCellValue(index_b, 5);
+        const z1 = max2(a_z1, b_z1);
+
+        data.writeCellValue(destination, 0, x0);
+        data.writeCellValue(destination, 1, y0);
+        data.writeCellValue(destination, 2, z0);
+
+        data.writeCellValue(destination, 3, x1);
+        data.writeCellValue(destination, 4, y1);
+        data.writeCellValue(destination, 5, z1);
+    }
+
+    /**
+     *
+     * @param {number} leaf
+     * @returns {void}
+     */
+    insert_leaf(leaf) {
+        assert.isNonNegativeInteger(leaf, 'leaf');
+
+        const data = this.__data;
+
+        if (this.__root === NULL_NODE) {
+            // special case - no root, set this node as a root
+            this.__root = leaf;
+
+            data.writeCellValue(leaf, COLUMN_PARENT, NULL_NODE);
+
+            return;
+        }
+
+        // Find the best sibling for this node
+        let index = this.__root;
+
+        while (this.node_is_leaf(index) === false) {
+            const child1 = data.readCellValue(index, COLUMN_CHILD_1);
+            const child2 = data.readCellValue(index, COLUMN_CHILD_2);
+
+            const area = this.node_get_surface_area(index);
+
+            const combinedArea = this.node_get_combined_surface_area(index, leaf);
+
+            // Cost of creating a new parent for this node and the new leaf
+            const cost = 2.0 * combinedArea;
+
+            // Minimum cost of pushing the leaf further down the tree
+            const inheritanceCost = 2.0 * (combinedArea - area);
+
+            // Cost of descending into child1
+            let cost1;
+            if (this.node_is_leaf(child1)) {
+                cost1 = this.node_get_combined_surface_area(leaf, child1) + inheritanceCost;
+            } else {
+
+                const oldArea = this.node_get_surface_area(child1);
+                const newArea = this.node_get_combined_surface_area(leaf, child1);
+                cost1 = (newArea - oldArea) + inheritanceCost;
+            }
+
+            // Cost of descending into child2
+            let cost2;
+            if (this.node_is_leaf(child2)) {
+                cost2 = this.node_get_combined_surface_area(leaf, child2) + inheritanceCost;
+            } else {
+                const oldArea = this.node_get_surface_area(child2);
+                const newArea = this.node_get_combined_surface_area(leaf, child2);
+                cost2 = newArea - oldArea + inheritanceCost;
+            }
+
+            // Descend according to the minimum cost.
+            if (cost < cost1 && cost < cost2) {
+                break;
+            }
+
+            // Descend
+            if (cost1 < cost2) {
+                index = child1;
+            } else {
+                index = child2;
+            }
+        }
+
+        const sibling = index;
+
+        // Create a new parent.
+        const oldParent = data.readCellValue(sibling, COLUMN_PARENT);
+        const newParent = this.allocate_node();
+
+        data.writeCellValue(newParent, COLUMN_PARENT, oldParent);
+        data.writeCellValue(newParent, COLUMN_USER_DATA, NULL_USER_DATA);
+        this.node_set_combined_aabb(newParent, leaf, sibling);
+        data.writeCellValue(newParent, COLUMN_HEIGHT,
+            data.readCellValue(sibling, COLUMN_HEIGHT) + 1
+        );
+
+        if (oldParent !== NULL_NODE) {
+            // The sibling was not the root.
+            if (data.readCellValue(oldParent, COLUMN_CHILD_1) === sibling) {
+                data.writeCellValue(oldParent, COLUMN_CHILD_1, newParent);
+            } else {
+                data.writeCellValue(oldParent, COLUMN_CHILD_2, newParent);
+            }
+
+        } else {
+            // The sibling was the root.
+            this.__root = newParent;
+        }
+
+        data.writeCellValue(newParent, COLUMN_CHILD_1, sibling);
+        data.writeCellValue(newParent, COLUMN_CHILD_2, leaf);
+        data.writeCellValue(sibling, COLUMN_PARENT, newParent);
+        data.writeCellValue(leaf, COLUMN_PARENT, newParent);
+
+        // Walk back up the tree fixing heights and AABBs
+        index = data.readCellValue(leaf, COLUMN_PARENT);
+
+        this.bubble_up_update(index);
+
+    }
+
+    /**
+     * refit and update nodes up the tree. Only updates bounds
+     * NOTE: Does not update "height"
+     * @param {number} parent
+     * @private
+     */
+    bubble_up_refit(parent) {
+        let index = parent;
+
+        const data = this.__data;
+
+        while (index !== NULL_NODE) {
+            index = this.balance(index);
+
+            const child1 = data.readCellValue(index, COLUMN_CHILD_1);
+            const child2 = data.readCellValue(index, COLUMN_CHILD_2);
+
+            assert.notEqual(child1, NULL_NODE, 'child1 is null');
+            assert.notEqual(child2, NULL_NODE, 'child2 is null');
+
+            this.node_set_combined_aabb(index, child1, child2);
+
+            index = data.readCellValue(index, COLUMN_PARENT);
+        }
+    }
+
+    /**
+     * refit and update nodes up the tree
+     * @param {number} parent
+     * @private
+     */
+    bubble_up_update(parent) {
+        let index = parent;
+
+        const data = this.__data;
+
+        while (index !== NULL_NODE) {
+            index = this.balance(index);
+
+            const child1 = data.readCellValue(index, COLUMN_CHILD_1);
+            const child2 = data.readCellValue(index, COLUMN_CHILD_2);
+
+            assert.notEqual(child1, NULL_NODE, 'child1 is null');
+            assert.notEqual(child2, NULL_NODE, 'child2 is null');
+
+
+            data.writeCellValue(index, COLUMN_HEIGHT,
+                1 + max2(
+                    data.readCellValue(child1, COLUMN_HEIGHT),
+                    data.readCellValue(child2, COLUMN_HEIGHT),
+                )
+            );
+            this.node_set_combined_aabb(index, child1, child2);
+
+            index = data.readCellValue(index, COLUMN_PARENT);
+        }
+    }
+
+    /**
+     * NOTE: Leaf node is not released, make sure to call {@link #release_node} separately when you no longer need the leaf node
+     * @param {number} leaf
+     * @returns {void}
+     */
+    remove_leaf(leaf) {
+        assert.isNonNegativeInteger(leaf, 'leaf');
+
+        if (leaf === this.__root) {
+            this.__root = NULL_NODE;
+            return;
+        }
+
+        const data = this.__data;
+
+        const parent = data.readCellValue(leaf, COLUMN_PARENT);
+        const grandParent = data.readCellValue(parent, COLUMN_PARENT);
+
+        let sibling;
+
+        const parent_child1 = data.readCellValue(parent, COLUMN_CHILD_1);
+
+        if (parent_child1 === leaf) {
+            sibling = data.readCellValue(parent, COLUMN_CHILD_2);
+        } else {
+            sibling = parent_child1;
+        }
+
+        if (grandParent !== NULL_NODE) {
+            // Destroy parent and connect sibling to grandParent.
+            const grand_parent_child1 = data.readCellValue(grandParent, COLUMN_CHILD_1);
+            if (grand_parent_child1 === parent) {
+                data.writeCellValue(grandParent, COLUMN_CHILD_1, sibling);
+            } else {
+                data.writeCellValue(grandParent, COLUMN_CHILD_2, sibling);
+            }
+            data.writeCellValue(sibling, COLUMN_PARENT, grandParent);
+
+            this.release_node(parent);
+
+            // Adjust ancestor bounds.
+            this.bubble_up_update(grandParent);
+
+        } else {
+            this.__root = sibling;
+            data.writeCellValue(sibling, COLUMN_PARENT, NULL_NODE);
+            this.release_node(parent);
+        }
+    }
+
+    /**
+     * Perform a left or right rotation if node A is imbalanced.
+     * Returns the new root index.
+     * @param {number} iA
+     * @returns {number}
+     * @private
+     */
+    balance(iA) {
+        assert.notEqual(iA, NULL_NODE, 'input is a null node');
+
+        //b2TreeNode* A = m_nodes + iA;
+
+        const data = this.__data;
+
+        if (this.node_is_leaf(iA) || data.readCellValue(iA, COLUMN_HEIGHT) < 2) {
+            return iA;
+        }
+
+        const iB = data.readCellValue(iA, COLUMN_CHILD_1);
+        const iC = data.readCellValue(iA, COLUMN_CHILD_2);
+
+        assert.greaterThanOrEqual(iB, 0);
+        assert.lessThan(iB, this.node_capacity);
+        assert.greaterThanOrEqual(iC, 0);
+        assert.lessThan(iC, this.node_capacity);
+
+        //b2TreeNode* B = m_nodes + iB;
+        //b2TreeNode* C = m_nodes + iC;
+
+        const balance = data.readCellValue(iC, COLUMN_HEIGHT) - data.readCellValue(iB, COLUMN_HEIGHT);
+
+        // Rotate C up
+        if (balance > 1) {
+            const iF = data.readCellValue(iC, COLUMN_CHILD_1);
+            const iG = data.readCellValue(iC, COLUMN_CHILD_2);
+
+            // b2TreeNode* F = m_nodes + iF;
+            // b2TreeNode* G = m_nodes + iG;
+
+            assert.greaterThanOrEqual(iF, 0);
+            assert.lessThan(iF, this.node_capacity);
+            assert.greaterThanOrEqual(iG, 0);
+            assert.lessThan(iG, this.node_capacity);
+
+            // Swap A and C
+            data.writeCellValue(iC, COLUMN_CHILD_1, iA);
+
+            const a_parent = data.readCellValue(iA, COLUMN_PARENT);
+
+            data.writeCellValue(iC, COLUMN_PARENT, a_parent);
+            data.writeCellValue(iA, COLUMN_PARENT, iC);
+
+            // A's old parent should point to C
+            if (a_parent !== NULL_NODE) {
+                if (data.readCellValue(a_parent, COLUMN_CHILD_1) === iA) {
+                    data.writeCellValue(a_parent, COLUMN_CHILD_1, iC);
+                } else {
+                    //b2Assert(m_nodes[C->parent].child2 == iA);
+                    data.writeCellValue(a_parent, COLUMN_CHILD_2, iC);
+                }
+            } else {
+                this.__root = iC;
+            }
+
+            // Rotate
+            if (data.readCellValue(iF, COLUMN_HEIGHT) > data.readCellValue(iG, COLUMN_HEIGHT)) {
+
+                data.writeCellValue(iC, COLUMN_CHILD_2, iF);
+                data.writeCellValue(iA, COLUMN_CHILD_2, iG);
+                data.writeCellValue(iG, COLUMN_PARENT, iA);
+
+                this.node_set_combined_aabb(iA, iB, iG);
+                this.node_set_combined_aabb(iC, iA, iF);
+
+                data.writeCellValue(iA, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iB, COLUMN_HEIGHT),
+                        data.readCellValue(iG, COLUMN_HEIGHT)
+                    )
+                );
+
+                data.writeCellValue(iC, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iA, COLUMN_HEIGHT),
+                        data.readCellValue(iF, COLUMN_HEIGHT)
+                    )
+                );
+            } else {
+                data.writeCellValue(iC, COLUMN_CHILD_2, iG);
+                data.writeCellValue(iA, COLUMN_CHILD_2, iF);
+
+                data.writeCellValue(iF, COLUMN_PARENT, iA);
+
+                this.node_set_combined_aabb(iA, iB, iF);
+                this.node_set_combined_aabb(iC, iA, iG);
+
+                data.writeCellValue(iA, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iB, COLUMN_HEIGHT),
+                        data.readCellValue(iF, COLUMN_HEIGHT)
+                    )
+                );
+
+                data.writeCellValue(iC, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iA, COLUMN_HEIGHT),
+                        data.readCellValue(iG, COLUMN_HEIGHT)
+                    )
+                );
+
+            }
+
+            return iC;
+        }
+
+        // Rotate B up
+        if (balance < -1) {
+            const iD = data.readCellValue(iB, COLUMN_CHILD_1);
+            const iE = data.readCellValue(iB, COLUMN_CHILD_2);
+
+            assert.greaterThanOrEqual(iD, 0);
+            assert.lessThan(iD, this.node_capacity);
+            assert.greaterThanOrEqual(iE, 0);
+            assert.lessThan(iE, this.node_capacity);
+
+            // Swap A and B
+            data.writeCellValue(iB, COLUMN_CHILD_1, iA);
+            const a_parent = data.readCellValue(iA, COLUMN_PARENT);
+            data.writeCellValue(iB, COLUMN_PARENT, a_parent);
+            data.writeCellValue(iA, COLUMN_PARENT, iB);
+
+            // A's old parent should point to B
+            if (a_parent !== NULL_NODE) {
+                if (data.readCellValue(a_parent, COLUMN_CHILD_1) === iA) {
+                    data.writeCellValue(a_parent, COLUMN_CHILD_1, iB)
+                } else {
+                    //b2Assert(m_nodes[B->parent].child2 == iA);
+                    data.writeCellValue(a_parent, COLUMN_CHILD_2, iB);
+                }
+            } else {
+                this.__root = iB;
+            }
+
+            // Rotate
+            if (data.readCellValue(iD, COLUMN_HEIGHT) > data.readCellValue(iE, COLUMN_HEIGHT)) {
+
+                data.writeCellValue(iB, COLUMN_CHILD_2, iD);
+                data.writeCellValue(iA, COLUMN_CHILD_1, iE);
+                data.writeCellValue(iE, COLUMN_PARENT, iA);
+
+                this.node_set_combined_aabb(iA, iC, iE);
+                this.node_set_combined_aabb(iB, iA, iD);
+
+                data.writeCellValue(iA, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iC, COLUMN_HEIGHT),
+                        data.readCellValue(iE, COLUMN_HEIGHT)
+                    )
+                );
+
+                data.writeCellValue(iB, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iA, COLUMN_HEIGHT),
+                        data.readCellValue(iD, COLUMN_HEIGHT)
+                    )
+                );
+
+            } else {
+                data.writeCellValue(iB, COLUMN_CHILD_2, iE);
+                data.writeCellValue(iA, COLUMN_CHILD_1, iD);
+                data.writeCellValue(iD, COLUMN_PARENT, iA);
+
+                this.node_set_combined_aabb(iA, iC, iD);
+                this.node_set_combined_aabb(iB, iA, iE);
+
+                data.writeCellValue(iA, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iC, COLUMN_HEIGHT),
+                        data.readCellValue(iD, COLUMN_HEIGHT)
+                    )
+                );
+
+                data.writeCellValue(iB, COLUMN_HEIGHT,
+                    1 + max2(
+                        data.readCellValue(iA, COLUMN_HEIGHT),
+                        data.readCellValue(iE, COLUMN_HEIGHT)
+                    )
+                );
+            }
+
+            return iB;
+        }
+
+        // no rotation
+        return iA;
+    }
+
+    /**
+     *
+     * @param {(node:number, tree:ExplicitBinaryBoundingVolumeHierarchy)=>void} callback
+     * @param {*} [ctx]
+     */
+    traverse(callback, ctx) {
+        let cursor = 0;
+        const stack = [];
+
+        const root = this.__root;
+
+        if (root !== NULL_NODE) {
+            stack[cursor++] = root;
+        }
+
+        const data = this.__data;
+
+        while (cursor > 0) {
+            cursor--;
+
+            const node = stack[cursor];
+
+            callback.call(ctx, node, this);
+
+            const child1 = data.readCellValue(node, COLUMN_CHILD_1);
+            const child2 = data.readCellValue(node, COLUMN_CHILD_2);
+
+            if (child1 !== NULL_NODE) {
+                stack[cursor++] = child1;
+            }
+
+            if (child2 !== NULL_NODE) {
+                stack[cursor++] = child2;
+            }
+
+        }
+    }
+
+    /**
+     *
+     * @param {number[]} destination
+     * @param {number} destination_offset
+     * @returns {number}
+     */
+    collect_nodes_all(destination, destination_offset) {
+
+        let i = destination_offset;
+
+        this.traverse(n => {
+            destination[i++] = n;
+        });
+
+        return i - destination_offset;
+    }
+}