@woosh/meep-engine 2.68.0 → 2.70.0

package/package.json

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

package/src/core/__module.js

@@ -9,3 +9,4 @@ export * from "./geom/Vector1.js";
 export * from "./events/signal/Signal.js";
 export * from "./events/signal/SignalBinding.js";
 export * from "./geom/Quaternion.js";
+export { quat3_createFromAxisAngle } from "./geom/3d/quaternion/quat3_createFromAxisAngle.js";

package/src/core/binary/BinaryBuffer.js

@@ -4,6 +4,7 @@
  */
 import { assert } from "../assert.js";
 import { array_copy } from "../collection/array/array_copy.js";
+import { typed_array_copy } from "../collection/array/typed/typed_array_copy.js";
 
 /**
  *
@@ -142,8 +143,7 @@ export class BinaryBuffer {
         const newData = new Uint8Array(capacity);
 
         //copy old data
-        const copyLength = Math.min(newData.length, oldData.length);
-        newData.set(oldData.subarray(0, copyLength), 0);
+        typed_array_copy(oldData, newData);
 
         this.data = newData.buffer;
         this.__data_uint8 = newData;
@@ -152,15 +152,24 @@ export class BinaryBuffer {
         this.capacity = capacity;
     }
 
-    ensureCapacity(minCapacity) {
-        if (this.capacity < minCapacity) {
-            const newCapacity = Math.ceil(Math.max(
-                minCapacity,
-                this.capacity * this.__growFactor,
-                this.capacity + MIN_GROWTH_STEP
-            ));
-            this.setCapacity(newCapacity);
+    /**
+     *
+     * @param {number} min_capacity
+     */
+    ensureCapacity(min_capacity) {
+        const existing_capacity = this.capacity;
+
+        if (existing_capacity >= min_capacity) {
+            return;
         }
+
+        const new_capacity = Math.ceil(Math.max(
+            min_capacity,
+            existing_capacity * this.__growFactor,
+            existing_capacity + MIN_GROWTH_STEP
+        ));
+
+        this.setCapacity(new_capacity);
     }
 
     readFloat32() {
@@ -825,16 +834,14 @@ export class BinaryBuffer {
         //mark non-NULL
         this.writeUint32(len);
 
-        const startPosition = this.position;
-
-        let at = startPosition;  // output position
-
-        let tlen = Math.max(32, len + (len >> 1) + 7);  // 1.5x size
+        let cursor = this.position;  // output position
 
-        this.ensureCapacity(tlen + at);
+        const expected_byte_size = Math.max(32, len + (len >> 1) + 7);  // 1.5x size
 
-        let target = this.__data_uint8;  // ... but at 8 byte offset
+        this.ensureCapacity(expected_byte_size + cursor);
 
+        let target = this.__data_uint8;
+        let capacity = this.capacity;
 
         while (pos < len) {
             let value = string.charCodeAt(pos++);
@@ -853,37 +860,36 @@ export class BinaryBuffer {
             }
 
             // expand the buffer if we couldn't write 4 bytes
-            if (at + 4 > this.capacity) {
-                tlen += 8;  // minimum extra
-                tlen *= (1.0 + (pos / len) * 2);  // take 2x the remaining
-                tlen = (tlen >> 3) << 3;  // 8 byte offset
+            if (cursor + 4 > capacity) {
 
-                this.ensureCapacity(tlen + startPosition);
+                this.ensureCapacity(cursor + 4);
 
+                // rebind variables
+                capacity = this.capacity;
                 target = this.__data_uint8;
             }
 
             if ((value & 0xffffff80) === 0) {  // 1-byte
-                target[at++] = value;  // ASCII
+                target[cursor++] = value;  // ASCII
                 continue;
             } else if ((value & 0xfffff800) === 0) {  // 2-byte
-                target[at++] = ((value >> 6) & 0x1f) | 0xc0;
+                target[cursor++] = ((value >> 6) & 0x1f) | 0xc0;
             } else if ((value & 0xffff0000) === 0) {  // 3-byte
-                target[at++] = ((value >> 12) & 0x0f) | 0xe0;
-                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+                target[cursor++] = ((value >> 12) & 0x0f) | 0xe0;
+                target[cursor++] = ((value >> 6) & 0x3f) | 0x80;
             } else if ((value & 0xffe00000) === 0) {  // 4-byte
-                target[at++] = ((value >> 18) & 0x07) | 0xf0;
-                target[at++] = ((value >> 12) & 0x3f) | 0x80;
-                target[at++] = ((value >> 6) & 0x3f) | 0x80;
+                target[cursor++] = ((value >> 18) & 0x07) | 0xf0;
+                target[cursor++] = ((value >> 12) & 0x3f) | 0x80;
+                target[cursor++] = ((value >> 6) & 0x3f) | 0x80;
             } else {
                 // FIXME: do we care
                 continue;
             }
 
-            target[at++] = (value & 0x3f) | 0x80;
+            target[cursor++] = (value & 0x3f) | 0x80;
         }
 
-        this.position = at;
+        this.position = cursor;
     }
 
     /**

package/src/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -2,10 +2,11 @@ import { assert } from "../../../assert.js";
 import { ceilPowerOfTwo } from "../../../binary/operations/ceilPowerOfTwo.js";
 import { array_copy } from "../../../collection/array/array_copy.js";
 import { array_swap } from "../../../collection/array/array_swap.js";
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { aabb3_array_combine } from "../../../geom/3d/aabb/aabb3_array_combine.js";
 import { aabb3_array_set } from "../../../geom/3d/aabb/aabb3_array_set.js";
 import { aabb3_compute_half_surface_area } from "../../../geom/3d/aabb/aabb3_compute_half_surface_area.js";
-import { mortonEncode_magicbits } from "../../../geom/3d/morton/mortonEncode_magicbits.js";
+import { v3_morton_encode_bounded } from "../../../geom/3d/morton/v3_morton_encode_bounded.js";
 import { max2 } from "../../../math/max2.js";
 import { max3 } from "../../../math/max3.js";
 import { min2 } from "../../../math/min2.js";
@@ -54,10 +55,10 @@ function copy_box_zero_size(data, destination, source) {
  * Assumes data will be normalized to 0...1 value range
  * @param {Float32Array} data
  * @param {number} address
- * @param {number[]} matrix
+ * @param {number[]} bounds
  * @returns {number}
  */
-function build_morton(data, address, matrix) {
+function build_morton(data, address, bounds) {
 
     const x0 = data[address];
     const y0 = data[address + 1];
@@ -66,17 +67,15 @@ function build_morton(data, address, matrix) {
     const y1 = data[address + 4];
     const z1 = data[address + 5];
 
-    const cx = (x0 + x1) / 2;
-    const cy = (y0 + y1) / 2;
-    const cz = (z0 + z1) / 2;
+    const cx = (x0 + x1) * 0.5;
+    const cy = (y0 + y1) * 0.5;
+    const cz = (z0 + z1) * 0.5;
 
-    return mortonEncode_magicbits(cx, cy, cz);
-    // return v3_morton_encode_transformed(cx, cy, cz, matrix);
+    return v3_morton_encode_bounded(cx, cy, cz, bounds);
 
 }
 
-const scratch_box_0 = new Float32Array(18);
-const stack = [];
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 export class BinaryUint32BVH {
     /**
@@ -100,34 +99,41 @@ export class BinaryUint32BVH {
      */
     __data_uint32;
 
-    constructor() {
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node_count_binary = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_binary = 0;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node_count_leaf = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_leaf = 0;
 
+    constructor() {
         this.data = new ArrayBuffer(320);
     }
 
+    /**
+     * In bytes
+     * @returns {number}
+     */
+    estimateByteSize() {
+        return this.data.byteLength + 248;
+    }
+
     getTotalBoxCount() {
         return this.__node_count_binary + this.__node_count_leaf;
     }
 
-    getBinaryNodeCount() {
+    get binary_node_count() {
         return this.__node_count_binary;
     }
 
-    getLeafNodeCount() {
+    get leaf_node_count() {
         return this.__node_count_leaf;
     }
 
@@ -149,10 +155,12 @@ export class BinaryUint32BVH {
 
     /**
      *
-     * @param {ArrayBuffer} v
+     * @param {ArrayBuffer} buffer
      */
-    set data(v) {
-        this.__data_buffer = v;
+    set data(buffer) {
+        assert.defined(buffer, 'buffer');
+
+        this.__data_buffer = buffer;
 
         this.__data_float32 = new Float32Array(this.__data_buffer);
         this.__data_uint32 = new Uint32Array(this.__data_buffer);
@@ -162,6 +170,24 @@ export class BinaryUint32BVH {
         return this.__data_buffer;
     }
 
+    /**
+     * Resolve index of the node to address where the node data starts, this is required to know where AABB is stored in memory
+     * @param {number} node_index
+     * @returns {number}
+     */
+    getNodeAddress(node_index) {
+        const binary_node_count = this.__node_count_binary;
+        const leaf_node_index = node_index - binary_node_count;
+
+        if (leaf_node_index < 0) {
+            // binary node
+            return node_index * BVH_BINARY_NODE_SIZE;
+        } else {
+            // leaf node
+            return binary_node_count * BVH_BINARY_NODE_SIZE + leaf_node_index * BVH_LEAF_NODE_SIZE;
+        }
+    }
+
     initialize_structure() {
         // compute memory requirements
         const word_count = this.__node_count_binary * BVH_BINARY_NODE_SIZE + this.__node_count_leaf * BVH_LEAF_NODE_SIZE;
@@ -280,17 +306,15 @@ export class BinaryUint32BVH {
      * @private
      */
     __compute_bounds_area_of_3_boxes(a, b, c) {
-        this.readBounds(a, scratch_box_0, 0);
-        this.readBounds(b, scratch_box_0, 6);
-        this.readBounds(c, scratch_box_0, 12);
+        const float32 = this.__data_float32;
 
-        const x0 = min3(scratch_box_0[0], scratch_box_0[6], scratch_box_0[12]);
-        const y0 = min3(scratch_box_0[1], scratch_box_0[7], scratch_box_0[13]);
-        const z0 = min3(scratch_box_0[2], scratch_box_0[8], scratch_box_0[14]);
+        const x0 = min3(float32[a + 0], float32[b + 0], float32[c + 0]);
+        const y0 = min3(float32[a + 1], float32[b + 1], float32[c + 1]);
+        const z0 = min3(float32[a + 2], float32[b + 2], float32[c + 2]);
 
-        const x1 = max3(scratch_box_0[3], scratch_box_0[9], scratch_box_0[15]);
-        const y1 = max3(scratch_box_0[4], scratch_box_0[10], scratch_box_0[16]);
-        const z1 = max3(scratch_box_0[5], scratch_box_0[11], scratch_box_0[17]);
+        const x1 = max3(float32[a + 3], float32[b + 3], float32[c + 3]);
+        const y1 = max3(float32[a + 4], float32[b + 4], float32[c + 4]);
+        const z1 = max3(float32[a + 5], float32[b + 5], float32[c + 5]);
 
         return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
     }
@@ -342,9 +366,9 @@ export class BinaryUint32BVH {
 
     /**
      * Sort leaf nodes according to their morton codes
-     * @param {number[]} projection
+     * @param {number[]} bounds
      */
-    sort_morton(projection) {
+    sort_morton(bounds) {
 
         const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
 
@@ -374,15 +398,15 @@ export class BinaryUint32BVH {
 
             const pivot_address = pivotIndex * BVH_LEAF_NODE_SIZE + leaf_block_address;
 
-            const pivot = build_morton(data, pivot_address, projection);
+            const pivot = build_morton(data, pivot_address, bounds);
 
             /* partition */
             while (i <= j) {
-                while (build_morton(data, i * BVH_LEAF_NODE_SIZE + leaf_block_address, projection) < pivot) {
+                while (build_morton(data, i * BVH_LEAF_NODE_SIZE + leaf_block_address, bounds) < pivot) {
                     i++;
                 }
 
-                while (build_morton(data, j * BVH_LEAF_NODE_SIZE + leaf_block_address, projection) > pivot) {
+                while (build_morton(data, j * BVH_LEAF_NODE_SIZE + leaf_block_address, bounds) > pivot) {
                     j--;
                 }
 
@@ -452,22 +476,22 @@ export class BinaryUint32BVH {
 
         // build bottom-most level, just above the leaves
         for (i = 0; i < level_node_count; i++) {
-            const leafIndex0 = i * 2;
-            const leafIndex1 = leafIndex0 + 1;
+            const leaf_index_0 = i * 2;
+            const leaf_index_1 = leaf_index_0 + 1;
 
-            const leafOffset0 = leaf_node_block_address + leafIndex0 * BVH_LEAF_NODE_SIZE;
-            const leafOffset1 = leaf_node_block_address + leafIndex1 * BVH_LEAF_NODE_SIZE;
+            const leaf_offset_0 = leaf_node_block_address + leaf_index_0 * BVH_LEAF_NODE_SIZE;
+            const leaf_offset_1 = leaf_node_block_address + leaf_index_1 * BVH_LEAF_NODE_SIZE;
 
-            if (leafIndex1 < node_count_leaf) {
+            if (leaf_index_1 < node_count_leaf) {
                 // both children nodes are valid
                 aabb3_array_combine(
                     float32, offset,
-                    float32, leafOffset0,
-                    float32, leafOffset1
+                    float32, leaf_offset_0,
+                    float32, leaf_offset_1
                 );
-            } else if (leafIndex0 < node_count_leaf) {
+            } else if (leaf_index_0 < node_count_leaf) {
                 // only left child node is valid
-                array_copy(float32, leafOffset0, float32, offset, 6);
+                array_copy(float32, leaf_offset_0, float32, offset, 6);
             } else {
                 //initialize to 0-size box same position as previous node
                 copy_box_zero_size(this.__data_float32, offset, (offset - BVH_BINARY_NODE_SIZE));

package/src/core/bvh2/binary/2/BinaryUint32BVH.spec.js

@@ -19,7 +19,7 @@ test('0 leaf tree must have a no binary nodes', () => {
     bvh.initialize_structure();
     bvh.build();
 
-    expect(bvh.getBinaryNodeCount()).toBe(0);
+    expect(bvh.binary_node_count).toBe(0);
 });
 
 test('1 leaf tree must have a single binary node', () => {
@@ -29,7 +29,7 @@ test('1 leaf tree must have a single binary node', () => {
     bvh.initialize_structure();
     bvh.build();
 
-    expect(bvh.getBinaryNodeCount()).toBe(1);
+    expect(bvh.binary_node_count).toBe(1);
 });
 
 test('4 leaf tree must have a 3 binary nodes', () => {
@@ -39,7 +39,7 @@ test('4 leaf tree must have a 3 binary nodes', () => {
     bvh.initialize_structure();
     bvh.build();
 
-    expect(bvh.getBinaryNodeCount()).toBe(3);
+    expect(bvh.binary_node_count).toBe(3);
 });
 
 test('read/write 1 leaf', () => {
@@ -129,10 +129,8 @@ test('4 node sorted build', () => {
     bvh.setLeafData(3, 13, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6);
 
     bvh.sort_morton([
-        1, 0, 0, 0,
-        0, 1, 0, 0,
-        0, 0, 1, 0,
-        0, 0, 0, 1
+        0, 0, 0,
+        1, 1, 1
     ]);
     bvh.build();
 });

package/src/core/bvh2/binary/2/bvh32_query_user_data_overlaps_clipping_volume.js

@@ -0,0 +1,94 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import {
+    aabb3_array_intersects_clipping_volume_array
+} from "../../../geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
+ * @param {Float32Array|number[]} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @returns {number}
+ */
+export function bvh32_query_user_data_overlaps_clipping_volume(
+    result, result_offset,
+    bvh,
+    planes, planes_offset, plane_count
+) {
+    let hit_count = 0;
+
+    const binary_node_count = bvh.binary_node_count;
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack.pointer++;
+
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack[stack_top] = 0;
+
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
+
+    do {
+        stack.pointer--;
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack[stack.pointer];
+
+        const node_address = bvh.getNodeAddress(node_index);
+
+        if (!aabb3_array_intersects_clipping_volume_array(
+            float32, node_address,
+            planes, planes_offset, plane_count
+        )) {
+            continue;
+        }
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
+            // is intermediate node
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            // left node ends up on top of the stack, which aligns with the desired access sequence
+            if (right_index < last_valid_index) {
+                stack[stack.pointer++] = right_index;
+                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
+                stack[stack.pointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack[stack.pointer++] = left_index;
+            }
+
+
+        } else {
+            // leaf node
+
+            // write to output
+            result[result_offset + hit_count] = uint32[node_address + 6];
+
+            hit_count++;
+        }
+
+    } while (stack.pointer > stack_top)
+
+    return hit_count;
+}

package/src/core/bvh2/binary/2/bvh32_query_user_data_ray.js

@@ -1,14 +1,13 @@
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
 import { aabb3_array_intersects_ray } from "../../../geom/3d/aabb/aabb3_array_intersects_ray.js";
-import { BVH_BINARY_NODE_SIZE, BVH_LEAF_NODE_SIZE } from "./BinaryUint32BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
- * @param {BinaryUint32BVH} bvh
  * @param {number[]} result
  * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
  * @param {number} origin_x
  * @param {number} origin_y
  * @param {number} origin_z
@@ -18,14 +17,14 @@ const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
  * @returns {number}
  */
 export function bvh32_query_user_data_ray(
-    bvh,
     result, result_offset,
+    bvh,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z
 ) {
     let hit_count = 0;
 
-    const binary_node_count = bvh.getBinaryNodeCount();
+    const binary_node_count = bvh.binary_node_count;
 
     if (binary_node_count <= 0) {
         // this should not happen
@@ -44,7 +43,7 @@ export function bvh32_query_user_data_ray(
      */
     stack[stack_top] = 0;
 
-    const last_valid_index = binary_node_count + bvh.getLeafNodeCount();
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
 
     const float32 = bvh.float32;
     const uint32 = bvh.uint32;
@@ -55,17 +54,20 @@ export function bvh32_query_user_data_ray(
         // query_bvh_frustum_from_objects.iteration_count++;
         const node_index = stack[stack.pointer];
 
-        if (node_index < binary_node_count) {
+        const node_address = bvh.getNodeAddress(node_index);
+
+        if (!aabb3_array_intersects_ray(
+            float32, node_address,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        )) {
+            continue;
+        }
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
             // is intermediate node
-            const node_address = node_index * BVH_BINARY_NODE_SIZE;
-
-            if (!aabb3_array_intersects_ray(
-                float32, node_address,
-                origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z
-            )) {
-                continue;
-            }
 
             const left_index = (node_index << 1) + 1;
             const right_index = left_index + 1;
@@ -82,9 +84,6 @@ export function bvh32_query_user_data_ray(
 
         } else {
             // leaf node
-            const leaf_index = node_index - binary_node_count;
-
-            const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
 
             // write to output
             result[result_offset + hit_count] = uint32[node_address + 6];

package/src/core/bvh2/bvh3/query/BVHQueryIntersectsFrustum.js

@@ -1,4 +1,6 @@
-import { aabb3_array_intersects_frustum_array } from "../../../geom/3d/aabb/aabb3_array_intersects_frustum_array.js";
+import {
+    aabb3_array_intersects_clipping_volume_array
+} from "../../../geom/3d/aabb/aabb3_array_intersects_clipping_volume_array.js";
 import { BVHQuery } from "./BVHQuery.js";
 
 const scratch_aabb = [];
@@ -29,6 +31,6 @@ export class BVHQueryIntersectsFrustum extends BVHQuery {
 
         tree.node_get_aabb(node, scratch_aabb);
 
-        return aabb3_array_intersects_frustum_array(scratch_aabb, this.frustum);
+        return aabb3_array_intersects_clipping_volume_array(scratch_aabb, 0, this.frustum, 0, 6);
     }
 }

package/src/core/geom/3d/aabb/AABB3.js

@@ -3,20 +3,20 @@
  */
 
 
-import {assert} from "../../../assert.js";
+import { assert } from "../../../assert.js";
 import computeMortonCode from "../morton/Morton.js";
-import {aabb3_array_intersects_point} from "./aabb3_array_intersects_point.js";
-import {aabb3_build_corners} from "./aabb3_build_corners.js";
-import {aabb3_compute_distance_above_plane_max} from "./aabb3_compute_distance_above_plane_max.js";
-import {aabb3_compute_plane_side} from "./aabb3_compute_plane_side.js";
-import {aabb3_compute_surface_area} from "./aabb3_compute_surface_area.js";
-import {aabb3_intersects_frustum_array} from "./aabb3_intersects_frustum_array.js";
-import {aabb3_intersects_frustum_degree} from "./aabb3_intersects_frustum_degree.js";
-import {aabb3_intersects_line_segment} from "./aabb3_intersects_line_segment.js";
-import {aabb3_intersects_ray} from "./aabb3_intersects_ray.js";
-import {aabb3_matrix4_project} from "./aabb3_matrix4_project.js";
-import {aabb3_signed_distance_sqr_to_point} from "./aabb3_signed_distance_sqr_to_point.js";
-import {aabb3_signed_distance_to_aabb3} from "./aabb3_signed_distance_to_aabb3.js";
+import { aabb3_array_intersects_point } from "./aabb3_array_intersects_point.js";
+import { aabb3_build_corners } from "./aabb3_build_corners.js";
+import { aabb3_compute_distance_above_plane_max } from "./aabb3_compute_distance_above_plane_max.js";
+import { aabb3_compute_plane_side } from "./aabb3_compute_plane_side.js";
+import { aabb3_compute_surface_area } from "./aabb3_compute_surface_area.js";
+import { aabb3_intersects_clipping_volume_array } from "./aabb3_intersects_clipping_volume_array.js";
+import { aabb3_intersects_frustum_degree } from "./aabb3_intersects_frustum_degree.js";
+import { aabb3_intersects_line_segment } from "./aabb3_intersects_line_segment.js";
+import { aabb3_intersects_ray } from "./aabb3_intersects_ray.js";
+import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+import { aabb3_signed_distance_sqr_to_point } from "./aabb3_signed_distance_sqr_to_point.js";
+import { aabb3_signed_distance_to_aabb3 } from "./aabb3_signed_distance_to_aabb3.js";
 
 /**
  * Axis-Aligned bounding box in 3D
@@ -850,7 +850,7 @@ export class AABB3 {
         const y1 = this.y1;
         const z1 = this.z1;
 
-        return aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum);
+        return aabb3_intersects_clipping_volume_array(x0, y0, z0, x1, y1, z1, frustum, 0, 6);
     }
 
     /**