@woosh/meep-engine 2.36.10 → 2.36.13

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -1,24 +1,19 @@
-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;
+
+/**
+ * A non-leaf node have both CHILD_1 and CHILD_2 set, when CHILD_1 is not set - it's a leaf node
+ * So we can utilize space of CHILD_2 to store USER_DATA, hence there is overlap in schema
+ * @readonly
+ * @type {number}
+ */
 const COLUMN_USER_DATA = COLUMN_CHILD_2;
 
 /**
@@ -26,34 +21,61 @@ const COLUMN_USER_DATA = COLUMN_CHILD_2;
  * @type {number}
  */
 export const NULL_NODE = 4294967295;
+
 /**
- *
+ * @readonly
+ * @type {number}
+ */
+const CAPACITY_GROW_MULTIPLIER = 1.2;
+
+/**
+ * @readonly
  * @type {number}
  */
-export const NULL_USER_DATA = NULL_NODE;
+const CAPACITY_GROW_MIN_STEP = 64;
 
 /**
  * @readonly
- * @type {number[]}
+ * @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
-]);
+const ELEMENT_WORD_COUNT = 10;
 
 export class ExplicitBinaryBoundingVolumeHierarchy {
     constructor() {
+        /**
+         *
+         * @type {ArrayBuffer}
+         * @private
+         */
+        this.__data_buffer = new ArrayBuffer(0);
+
+        /**
+         *
+         * @type {Float32Array}
+         * @private
+         */
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+
+        /**
+         *
+         * @type {Uint32Array}
+         * @private
+         */
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+
+        /**
+         *
+         * @type {number}
+         * @private
+         */
+        this.__capacity = 0;
 
         /**
          *
-         * @type {RowFirstTable}
+         * @type {number}
          * @private
          */
-        this.__data = new RowFirstTable(TABLE_SPEC);
+        this.__size = 0;
 
         /**
          *
@@ -70,14 +92,6 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         this.__root = NULL_NODE;
     }
 
-    /**
-     *
-     * @returns {RowFirstTable}
-     */
-    get data() {
-        return this.__data;
-    }
-
     /**
      *
      * @returns {number}
@@ -91,7 +105,28 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      * @returns {number}
      */
     get node_capacity() {
-        return this.__data.capacity;
+        return this.__capacity;
+    }
+
+    __grow_capacity() {
+        const new_capacity = Math.ceil(max2(
+            this.__capacity * CAPACITY_GROW_MULTIPLIER,
+            this.__capacity + CAPACITY_GROW_MIN_STEP
+        ));
+
+        const old_data_uint32 = this.__data_uint32;
+
+        const new_data_buffer = new ArrayBuffer(new_capacity * ELEMENT_WORD_COUNT * 4);
+
+        this.__data_buffer = new_data_buffer;
+
+        this.__data_float32 = new Float32Array(new_data_buffer);
+        this.__data_uint32 = new Uint32Array(new_data_buffer);
+
+        // copy old data into new buffer
+        this.__data_uint32.set(old_data_uint32);
+
+        this.__capacity = new_capacity;
     }
 
     /**
@@ -107,19 +142,39 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             result = free.pop();
         } else {
 
-            const data = this.__data;
-
-            const n = data.length;
+            result = this.__size;
 
-            data.resize(n + 1);
-
-            data.length++;
+            if (result >= this.__capacity) {
+                // grow capacity
+                // console.log(`#GROW`);
+                this.__grow_capacity();
+            }
 
-            result = n;
+            this.__size++;
         }
 
         // initialize node
-        this.__data.setRow(result, DEFAULT_ROW_VALUE);
+
+        const address = ELEMENT_WORD_COUNT * result;
+
+        const float32 = this.__data_float32;
+
+        // write AABB
+        float32[address] = Number.POSITIVE_INFINITY;
+        float32[address + 1] = Number.POSITIVE_INFINITY;
+        float32[address + 2] = Number.POSITIVE_INFINITY;
+        float32[address + 3] = Number.NEGATIVE_INFINITY;
+        float32[address + 4] = Number.NEGATIVE_INFINITY;
+        float32[address + 5] = Number.NEGATIVE_INFINITY;
+
+        const uint32 = this.__data_uint32;
+
+        uint32[address + COLUMN_PARENT] = NULL_NODE; // parent
+        uint32[address + COLUMN_CHILD_1] = NULL_NODE; // child-1
+        uint32[address + COLUMN_CHILD_2] = NULL_NODE; // child-2 / user-data
+        uint32[address + COLUMN_HEIGHT] = 0; // height
+
+        // console.log(`#ALLOCATED: ${result}`);
 
         return result;
     }
@@ -130,8 +185,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      */
     release_node(id) {
         assert.isNonNegativeInteger(id, 'id');
-        // TODO reset node
-
+        // no reset required as that's handled in the allocation method
         this.__free.push(id);
     }
 
@@ -142,7 +196,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      */
     node_is_leaf(id) {
         assert.isNonNegativeInteger(id, 'id');
-        const child_1 = this.__data.readCellValue(id, COLUMN_CHILD_1);
+        const child_1 = this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_CHILD_1];
 
         return child_1 === NULL_NODE;
     }
@@ -154,7 +208,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      */
     node_get_user_data(id) {
         assert.isNonNegativeInteger(id, 'id');
-        return this.__data.readCellValue(id, COLUMN_USER_DATA);
+        return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_USER_DATA];
     }
 
     /**
@@ -165,7 +219,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     node_set_user_data(id, value) {
         assert.isNonNegativeInteger(id, 'id');
 
-        this.__data.writeCellValue(id, COLUMN_USER_DATA, value);
+        this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_USER_DATA] = value;
     }
 
     /**
@@ -175,7 +229,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      */
     node_get_child1(id) {
         assert.isNonNegativeInteger(id, 'id');
-        return this.__data.readCellValue(id, COLUMN_CHILD_1);
+        return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_CHILD_1];
     }
 
     /**
@@ -185,7 +239,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      */
     node_get_child2(id) {
         assert.isNonNegativeInteger(id, 'id');
-        return this.__data.readCellValue(id, COLUMN_CHILD_2);
+        return this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_CHILD_2];
     }
 
 
@@ -197,15 +251,16 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     node_get_aabb(id, result) {
         assert.isNonNegativeInteger(id, 'id');
 
-        const data = this.__data;
+        const address = ELEMENT_WORD_COUNT * id;
+        const float32 = this.__data_float32;
 
-        result[0] = data.readCellValue(id, 0);
-        result[1] = data.readCellValue(id, 1);
-        result[2] = data.readCellValue(id, 2);
+        result[0] = float32[address];
+        result[1] = float32[address + 1];
+        result[2] = float32[address + 2];
 
-        result[3] = data.readCellValue(id, 3);
-        result[4] = data.readCellValue(id, 4);
-        result[5] = data.readCellValue(id, 5);
+        result[3] = float32[address + 3];
+        result[4] = float32[address + 4];
+        result[5] = float32[address + 5];
     }
 
     /**
@@ -216,15 +271,16 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     node_set_aabb(id, aabb) {
         assert.isNonNegativeInteger(id, 'id');
 
-        const data = this.__data;
+        const address = ELEMENT_WORD_COUNT * id;
+        const float32 = this.__data_float32;
 
-        data.writeCellValue(id, 0, aabb[0]);
-        data.writeCellValue(id, 1, aabb[1]);
-        data.writeCellValue(id, 2, aabb[2]);
+        float32[address] = aabb[0];
+        float32[address + 1] = aabb[1];
+        float32[address + 2] = aabb[2];
 
-        data.writeCellValue(id, 3, aabb[3]);
-        data.writeCellValue(id, 4, aabb[4]);
-        data.writeCellValue(id, 5, aabb[5]);
+        float32[address + 3] = aabb[3];
+        float32[address + 4] = aabb[4];
+        float32[address + 5] = aabb[5];
     }
 
     /**
@@ -236,7 +292,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         // 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);
+        const parent = this.__data_uint32[ELEMENT_WORD_COUNT * id + COLUMN_PARENT];
 
         if (parent !== NULL_NODE) {
             this.bubble_up_refit(parent);
@@ -258,18 +314,18 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         x0, y0, z0,
         x1, y1, z1
     ) {
-
         assert.isNonNegativeInteger(id, 'id');
 
-        const data = this.__data;
+        const address = ELEMENT_WORD_COUNT * id;
+        const float32 = this.__data_float32;
 
-        data.writeCellValue(id, 0, x0);
-        data.writeCellValue(id, 1, y0);
-        data.writeCellValue(id, 2, z0);
+        float32[address] = x0;
+        float32[address + 1] = y0;
+        float32[address + 2] = z0;
 
-        data.writeCellValue(id, 3, x1);
-        data.writeCellValue(id, 4, y1);
-        data.writeCellValue(id, 5, z1);
+        float32[address + 3] = x1;
+        float32[address + 4] = y1;
+        float32[address + 5] = z1;
     }
 
     /**
@@ -280,15 +336,16 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     node_get_surface_area(id) {
         assert.isNonNegativeInteger(id, 'id');
 
-        const data = this.__data;
+        const address = ELEMENT_WORD_COUNT * id;
+        const float32 = this.__data_float32;
 
-        const x0 = data.readCellValue(id, 0);
-        const y0 = data.readCellValue(id, 1);
-        const z0 = data.readCellValue(id, 2);
+        const x0 = float32[address];
+        const y0 = float32[address + 1];
+        const z0 = float32[address + 2];
 
-        const x1 = data.readCellValue(id, 3);
-        const y1 = data.readCellValue(id, 4);
-        const z1 = data.readCellValue(id, 5);
+        const x1 = float32[address + 3];
+        const y1 = float32[address + 4];
+        const z1 = float32[address + 5];
 
         return aabb3_compute_surface_area(
             x0, y0, z0,
@@ -303,30 +360,33 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      * @returns {number}
      */
     node_get_combined_surface_area(index_a, index_b) {
-        const data = this.__data;
+        const address_a = ELEMENT_WORD_COUNT * index_a;
+        const address_b = ELEMENT_WORD_COUNT * index_b;
 
-        const a_x0 = data.readCellValue(index_a, 0);
-        const b_x0 = data.readCellValue(index_b, 0);
+        const float32 = this.__data_float32;
+
+        const a_x0 = float32[address_a];
+        const b_x0 = float32[address_b];
         const x0 = min2(a_x0, b_x0);
 
-        const a_y0 = data.readCellValue(index_a, 1);
-        const b_y0 = data.readCellValue(index_b, 1);
+        const a_y0 = float32[address_a + 1];
+        const b_y0 = float32[address_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 a_z0 = float32[address_a + 2];
+        const b_z0 = float32[address_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 a_x1 = float32[address_a + 3];
+        const b_x1 = float32[address_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 a_y1 = float32[address_a + 4];
+        const b_y1 = float32[address_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 a_z1 = float32[address_a + 5];
+        const b_z1 = float32[address_b + 5];
         const z1 = max2(a_z1, b_z1);
 
         return aabb3_compute_surface_area(
@@ -342,40 +402,44 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
      * @param {number} index_b
      */
     node_set_combined_aabb(destination, index_a, index_b) {
+        const address_a = ELEMENT_WORD_COUNT * index_a;
+        const address_b = ELEMENT_WORD_COUNT * index_b;
 
-        const data = this.__data;
+        const float32 = this.__data_float32;
 
-        const a_x0 = data.readCellValue(index_a, 0);
-        const b_x0 = data.readCellValue(index_b, 0);
+        const a_x0 = float32[address_a];
+        const b_x0 = float32[address_b];
         const x0 = min2(a_x0, b_x0);
 
-        const a_y0 = data.readCellValue(index_a, 1);
-        const b_y0 = data.readCellValue(index_b, 1);
+        const a_y0 = float32[address_a + 1];
+        const b_y0 = float32[address_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 a_z0 = float32[address_a + 2];
+        const b_z0 = float32[address_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 a_x1 = float32[address_a + 3];
+        const b_x1 = float32[address_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 a_y1 = float32[address_a + 4];
+        const b_y1 = float32[address_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 a_z1 = float32[address_a + 5];
+        const b_z1 = float32[address_b + 5];
         const z1 = max2(a_z1, b_z1);
 
-        data.writeCellValue(destination, 0, x0);
-        data.writeCellValue(destination, 1, y0);
-        data.writeCellValue(destination, 2, z0);
+        const address_destination = destination * ELEMENT_WORD_COUNT;
+
+        float32[address_destination] = x0;
+        float32[address_destination + 1] = y0;
+        float32[address_destination + 2] = z0;
 
-        data.writeCellValue(destination, 3, x1);
-        data.writeCellValue(destination, 4, y1);
-        data.writeCellValue(destination, 5, z1);
+        float32[address_destination + 3] = x1;
+        float32[address_destination + 4] = y1;
+        float32[address_destination + 5] = z1;
     }
 
     /**
@@ -386,13 +450,13 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     insert_leaf(leaf) {
         assert.isNonNegativeInteger(leaf, 'leaf');
 
-        const data = this.__data;
+        let uint32 = this.__data_uint32;
 
         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);
+            uint32[leaf * ELEMENT_WORD_COUNT + COLUMN_PARENT] = NULL_NODE;
 
             return;
         }
@@ -401,8 +465,8 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         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 child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+            const child2 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
             const area = this.node_get_surface_area(index);
 
@@ -451,22 +515,23 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         const sibling = index;
 
         // Create a new parent.
-        const oldParent = data.readCellValue(sibling, COLUMN_PARENT);
+        const oldParent = uint32[sibling * ELEMENT_WORD_COUNT + COLUMN_PARENT];
         const newParent = this.allocate_node();
 
-        data.writeCellValue(newParent, COLUMN_PARENT, oldParent);
-        data.writeCellValue(newParent, COLUMN_USER_DATA, NULL_USER_DATA);
+        uint32 = this.__data_uint32; // reference can be invalidated after allocation, re-bind
+
+        uint32[newParent * ELEMENT_WORD_COUNT + COLUMN_PARENT] = oldParent;
         this.node_set_combined_aabb(newParent, leaf, sibling);
-        data.writeCellValue(newParent, COLUMN_HEIGHT,
-            data.readCellValue(sibling, COLUMN_HEIGHT) + 1
-        );
+        uint32[newParent * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = uint32[sibling * ELEMENT_WORD_COUNT + 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);
+            if (uint32[oldParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === sibling) {
+                uint32[oldParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = newParent;
             } else {
-                data.writeCellValue(oldParent, COLUMN_CHILD_2, newParent);
+                assert.equal(uint32[oldParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2], sibling);
+
+                uint32[oldParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = newParent;
             }
 
         } else {
@@ -474,15 +539,14 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             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);
+        uint32[newParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = sibling;
+        uint32[newParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = leaf;
 
-        // Walk back up the tree fixing heights and AABBs
-        index = data.readCellValue(leaf, COLUMN_PARENT);
+        uint32[sibling * ELEMENT_WORD_COUNT + COLUMN_PARENT] = newParent;
+        uint32[leaf * ELEMENT_WORD_COUNT + COLUMN_PARENT] = newParent;
 
-        this.bubble_up_update(index);
+        // Walk back up the tree fixing heights and AABBs
+        this.bubble_up_update(newParent);
 
     }
 
@@ -495,20 +559,20 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     bubble_up_refit(parent) {
         let index = parent;
 
-        const data = this.__data;
+        const uint32 = this.__data_uint32;
 
         while (index !== NULL_NODE) {
             index = this.balance(index);
 
-            const child1 = data.readCellValue(index, COLUMN_CHILD_1);
-            const child2 = data.readCellValue(index, COLUMN_CHILD_2);
+            const child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+            const child2 = uint32[index * ELEMENT_WORD_COUNT + 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);
+            index = uint32[index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
         }
     }
 
@@ -520,27 +584,25 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
     bubble_up_update(parent) {
         let index = parent;
 
-        const data = this.__data;
+        const uint32 = this.__data_uint32;
 
         while (index !== NULL_NODE) {
             index = this.balance(index);
 
-            const child1 = data.readCellValue(index, COLUMN_CHILD_1);
-            const child2 = data.readCellValue(index, COLUMN_CHILD_2);
+            const child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+            const child2 = uint32[index * ELEMENT_WORD_COUNT + 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),
-                )
+            uint32[index * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
             );
+
             this.node_set_combined_aabb(index, child1, child2);
 
-            index = data.readCellValue(index, COLUMN_PARENT);
+            index = uint32[index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
         }
     }
 
@@ -557,30 +619,30 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             return;
         }
 
-        const data = this.__data;
+        const uint32 = this.__data_uint32;
 
-        const parent = data.readCellValue(leaf, COLUMN_PARENT);
-        const grandParent = data.readCellValue(parent, COLUMN_PARENT);
+        const parent = uint32[leaf * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+        const grandParent = uint32[parent * ELEMENT_WORD_COUNT + COLUMN_PARENT];
 
         let sibling;
 
-        const parent_child1 = data.readCellValue(parent, COLUMN_CHILD_1);
+        const parent_child1 = uint32[parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
 
         if (parent_child1 === leaf) {
-            sibling = data.readCellValue(parent, COLUMN_CHILD_2);
+            sibling = uint32[parent * ELEMENT_WORD_COUNT + 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);
+            const grand_parent_child1 = uint32[grandParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
             if (grand_parent_child1 === parent) {
-                data.writeCellValue(grandParent, COLUMN_CHILD_1, sibling);
+                uint32[grandParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = sibling;
             } else {
-                data.writeCellValue(grandParent, COLUMN_CHILD_2, sibling);
+                uint32[grandParent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = sibling;
             }
-            data.writeCellValue(sibling, COLUMN_PARENT, grandParent);
+            uint32[sibling * ELEMENT_WORD_COUNT + COLUMN_PARENT] = grandParent;
 
             this.release_node(parent);
 
@@ -589,7 +651,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
         } else {
             this.__root = sibling;
-            data.writeCellValue(sibling, COLUMN_PARENT, NULL_NODE);
+            uint32[sibling * ELEMENT_WORD_COUNT + COLUMN_PARENT] = NULL_NODE;
             this.release_node(parent);
         }
     }
@@ -605,15 +667,14 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         assert.notEqual(iA, NULL_NODE, 'input is a null node');
 
         //b2TreeNode* A = m_nodes + iA;
+        const uint32 = this.__data_uint32;
 
-        const data = this.__data;
-
-        if (this.node_is_leaf(iA) || data.readCellValue(iA, COLUMN_HEIGHT) < 2) {
+        if (this.node_is_leaf(iA) || uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] < 2) {
             return iA;
         }
 
-        const iB = data.readCellValue(iA, COLUMN_CHILD_1);
-        const iC = data.readCellValue(iA, COLUMN_CHILD_2);
+        const iB = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+        const iC = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
         assert.greaterThanOrEqual(iB, 0);
         assert.lessThan(iB, this.node_capacity);
@@ -623,12 +684,12 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         //b2TreeNode* B = m_nodes + iB;
         //b2TreeNode* C = m_nodes + iC;
 
-        const balance = data.readCellValue(iC, COLUMN_HEIGHT) - data.readCellValue(iB, COLUMN_HEIGHT);
+        const balance = uint32[iC * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] - uint32[iB * ELEMENT_WORD_COUNT + COLUMN_HEIGHT];
 
         // Rotate C up
         if (balance > 1) {
-            const iF = data.readCellValue(iC, COLUMN_CHILD_1);
-            const iG = data.readCellValue(iC, COLUMN_CHILD_2);
+            const iF = uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+            const iG = uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
             // b2TreeNode* F = m_nodes + iF;
             // b2TreeNode* G = m_nodes + iG;
@@ -639,69 +700,63 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             assert.lessThan(iG, this.node_capacity);
 
             // Swap A and C
-            data.writeCellValue(iC, COLUMN_CHILD_1, iA);
+            uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iA;
 
-            const a_parent = data.readCellValue(iA, COLUMN_PARENT);
+            const a_parent = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_PARENT];
 
-            data.writeCellValue(iC, COLUMN_PARENT, a_parent);
-            data.writeCellValue(iA, COLUMN_PARENT, iC);
+            uint32[iC * ELEMENT_WORD_COUNT + COLUMN_PARENT] = a_parent;
+            uint32[iA * ELEMENT_WORD_COUNT + 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);
+                if (uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === iA) {
+                    uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iC;
                 } else {
                     //b2Assert(m_nodes[C->parent].child2 == iA);
-                    data.writeCellValue(a_parent, COLUMN_CHILD_2, iC);
+                    uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iC;
                 }
             } else {
                 this.__root = iC;
             }
 
             // Rotate
-            if (data.readCellValue(iF, COLUMN_HEIGHT) > data.readCellValue(iG, COLUMN_HEIGHT)) {
+            if (uint32[iF * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] > uint32[iG * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]) {
 
-                data.writeCellValue(iC, COLUMN_CHILD_2, iF);
-                data.writeCellValue(iA, COLUMN_CHILD_2, iG);
-                data.writeCellValue(iG, COLUMN_PARENT, iA);
+                uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iF;
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iG;
+
+                uint32[iG * ELEMENT_WORD_COUNT + 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)
-                    )
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iB * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iG * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
 
-                data.writeCellValue(iC, COLUMN_HEIGHT,
-                    1 + max2(
-                        data.readCellValue(iA, COLUMN_HEIGHT),
-                        data.readCellValue(iF, COLUMN_HEIGHT)
-                    )
+                uint32[iC * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iF * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
+
             } else {
-                data.writeCellValue(iC, COLUMN_CHILD_2, iG);
-                data.writeCellValue(iA, COLUMN_CHILD_2, iF);
+                uint32[iC * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iG;
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iF;
 
-                data.writeCellValue(iF, COLUMN_PARENT, iA);
+                uint32[iF * ELEMENT_WORD_COUNT + 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)
-                    )
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iB * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iF * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
 
-                data.writeCellValue(iC, COLUMN_HEIGHT,
-                    1 + max2(
-                        data.readCellValue(iA, COLUMN_HEIGHT),
-                        data.readCellValue(iG, COLUMN_HEIGHT)
-                    )
+                uint32[iC * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iG * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
 
             }
@@ -711,8 +766,8 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
         // Rotate B up
         if (balance < -1) {
-            const iD = data.readCellValue(iB, COLUMN_CHILD_1);
-            const iE = data.readCellValue(iB, COLUMN_CHILD_2);
+            const iD = uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
+            const iE = uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
 
             assert.greaterThanOrEqual(iD, 0);
             assert.lessThan(iD, this.node_capacity);
@@ -720,68 +775,64 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             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);
+            uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iA;
+            const a_parent = uint32[iA * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+            uint32[iB * ELEMENT_WORD_COUNT + COLUMN_PARENT] = a_parent;
+            uint32[iA * ELEMENT_WORD_COUNT + 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)
+                if (uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] === iA) {
+                    uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iB;
                 } else {
                     //b2Assert(m_nodes[B->parent].child2 == iA);
-                    data.writeCellValue(a_parent, COLUMN_CHILD_2, iB);
+                    assert.equal(uint32[uint32[iB * ELEMENT_WORD_COUNT + COLUMN_PARENT] * ELEMENT_WORD_COUNT + COLUMN_CHILD_2], iA);
+
+                    uint32[a_parent * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iB;
                 }
             } else {
                 this.__root = iB;
             }
 
             // Rotate
-            if (data.readCellValue(iD, COLUMN_HEIGHT) > data.readCellValue(iE, COLUMN_HEIGHT)) {
+            if (uint32[iD * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] > uint32[iE * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]) {
 
-                data.writeCellValue(iB, COLUMN_CHILD_2, iD);
-                data.writeCellValue(iA, COLUMN_CHILD_1, iE);
-                data.writeCellValue(iE, COLUMN_PARENT, iA);
+                uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iD;
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iE;
+                uint32[iE * ELEMENT_WORD_COUNT + 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)
-                    )
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iC * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iE * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
 
-                data.writeCellValue(iB, COLUMN_HEIGHT,
-                    1 + max2(
-                        data.readCellValue(iA, COLUMN_HEIGHT),
-                        data.readCellValue(iD, COLUMN_HEIGHT)
-                    )
+                uint32[iB * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iD * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
 
             } else {
-                data.writeCellValue(iB, COLUMN_CHILD_2, iE);
-                data.writeCellValue(iA, COLUMN_CHILD_1, iD);
-                data.writeCellValue(iD, COLUMN_PARENT, iA);
+
+                uint32[iB * ELEMENT_WORD_COUNT + COLUMN_CHILD_2] = iE;
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_CHILD_1] = iD;
+                uint32[iD * ELEMENT_WORD_COUNT + 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)
-                    )
+                uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iC * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iD * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
 
-                data.writeCellValue(iB, COLUMN_HEIGHT,
-                    1 + max2(
-                        data.readCellValue(iA, COLUMN_HEIGHT),
-                        data.readCellValue(iE, COLUMN_HEIGHT)
-                    )
+                uint32[iB * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+                    uint32[iA * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
+                    uint32[iE * ELEMENT_WORD_COUNT + COLUMN_HEIGHT]
                 );
+
             }
 
             return iB;
@@ -806,7 +857,7 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
             stack[cursor++] = root;
         }
 
-        const data = this.__data;
+        const uint32 = this.__data_uint32;
 
         while (cursor > 0) {
             cursor--;
@@ -815,15 +866,14 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
 
             callback.call(ctx, node, this);
 
-            const child1 = data.readCellValue(node, COLUMN_CHILD_1);
-            const child2 = data.readCellValue(node, COLUMN_CHILD_2);
+            const node_address = node * ELEMENT_WORD_COUNT;
 
-            if (child1 !== NULL_NODE) {
-                stack[cursor++] = child1;
-            }
+            const child1 = uint32[node_address + COLUMN_CHILD_1];
+            const child2 = uint32[node_address + COLUMN_CHILD_2];
 
-            if (child2 !== NULL_NODE) {
+            if (child1 !== NULL_NODE) {
                 stack[cursor++] = child2;
+                stack[cursor++] = child1;
             }
 
         }