@woosh/meep-engine 2.34.43 → 2.34.44

package/core/bvh2/aabb3/deserializeAABB3.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AABB3} box
+ */
+function deserializeAABB3(buffer, box) {
+    const x0 = buffer.readFloat64();
+    const y0 = buffer.readFloat64();
+    const z0 = buffer.readFloat64();
+    const x1 = buffer.readFloat64();
+    const y1 = buffer.readFloat64();
+    const z1 = buffer.readFloat64();
+
+    box.setBounds(x0, y0, z0, x1, y1, z1);
+}
+
+export { deserializeAABB3 };

package/core/bvh2/aabb3/deserializeAABB3Encoded_v0.js

@@ -0,0 +1,73 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AABB3} box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ */
+export function deserializeAABB3Encoded_v0(buffer, box, x0, y0, z0, x1, y1, z1) {
+    const header = buffer.readUint8();
+
+    //compute value ranges
+    const xD = x1 - x0;
+    const yD = y1 - y0;
+    const zD = z1 - z0;
+
+
+    let qx0;
+    let qx1;
+
+    let qy0;
+    let qy1;
+
+    let qz0;
+    let qz1;
+
+    if ((header & 1) === 0) {
+        const _x0 = buffer.readUint16();
+        qx0 = (_x0 / 65535) * xD + x0;
+    } else {
+        qx0 = x0;
+    }
+
+    if ((header & 2) === 0) {
+        const _x1 = buffer.readUint16();
+        qx1 = (_x1 / 65535) * xD + x0;
+    } else {
+        qx1 = x1;
+    }
+
+    if ((header & 4) === 0) {
+        const _y0 = buffer.readUint16();
+        qy0 = (_y0 / 65535) * yD + y0;
+    } else {
+        qy0 = y0;
+    }
+
+    if ((header & 8) === 0) {
+        const _y1 = buffer.readUint16();
+        qy1 = (_y1 / 65535) * yD + y0;
+    } else {
+        qy1 = y1;
+    }
+
+    if ((header & 16) === 0) {
+        const _z0 = buffer.readUint16();
+        qz0 = (_z0 / 65535) * zD + z0;
+    } else {
+        qz0 = z0;
+    }
+
+    if ((header & 32) === 0) {
+        const _z1 = buffer.readUint16();
+        qz1 = (_z1 / 65535) * zD + z0;
+    } else {
+        qz1 = z1;
+    }
+
+    box.setBounds(qx0, qy0, qz0, qx1, qy1, qz1);
+}

package/core/bvh2/aabb3/deserializeAABB3Quantized16Uint.js

@@ -0,0 +1,36 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AABB3} box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ */
+export function deserializeAABB3Quantized16Uint(buffer, box, x0, y0, z0, x1, y1, z1) {
+    //compute value ranges
+    const xD = x1 - x0;
+    const yD = y1 - y0;
+    const zD = z1 - z0;
+
+    //read values
+    const _x0 = buffer.readUint16();
+    const _y0 = buffer.readUint16();
+    const _z0 = buffer.readUint16();
+    const _x1 = buffer.readUint16();
+    const _y1 = buffer.readUint16();
+    const _z1 = buffer.readUint16();
+
+    //quantize all values
+    const qx0 = (_x0 / 65535) * xD + x0;
+    const qy0 = (_y0 / 65535) * yD + y0;
+    const qz0 = (_z0 / 65535) * zD + z0;
+
+    const qx1 = (_x1 / 65535) * xD + x0;
+    const qy1 = (_y1 / 65535) * yD + y0;
+    const qz1 = (_z1 / 65535) * zD + z0;
+
+    box.setBounds(qx0, qy0, qz0, qx1, qy1, qz1);
+}

package/core/bvh2/aabb3/serializeAABB3.js

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AABB3} box
+ */
+export function serializeAABB3(buffer, box) {
+    buffer.writeFloat64(box.x0);
+    buffer.writeFloat64(box.y0);
+    buffer.writeFloat64(box.z0);
+    buffer.writeFloat64(box.x1);
+    buffer.writeFloat64(box.y1);
+    buffer.writeFloat64(box.z1);
+}

package/core/bvh2/aabb3/serializeAABB3Quantized16Uint.js

@@ -0,0 +1,33 @@
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {AABB3} box
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ */
+export function serializeAABB3Quantized16Uint(buffer, box, x0, y0, z0, x1, y1, z1) {
+    //compute value ranges
+    const xD = x1 - x0;
+    const yD = y1 - y0;
+    const zD = z1 - z0;
+
+    //quantize all values
+    const _x0 = (((box.x0 - x0) / xD) * 65535) | 0;
+    const _y0 = (((box.y0 - y0) / yD) * 65535) | 0;
+    const _z0 = (((box.z0 - z0) / zD) * 65535) | 0;
+
+    const _x1 = (((box.x1 - x0) / xD) * 65535) | 0;
+    const _y1 = (((box.y1 - y0) / yD) * 65535) | 0;
+    const _z1 = (((box.z1 - z0) / zD) * 65535) | 0;
+
+    buffer.writeUint16(_x0);
+    buffer.writeUint16(_y0);
+    buffer.writeUint16(_z0);
+    buffer.writeUint16(_x1);
+    buffer.writeUint16(_y1);
+    buffer.writeUint16(_z1);
+}

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

@@ -3,10 +3,10 @@ import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
 import { ceilPowerOfTwo } from "../../../binary/operations/ceilPowerOfTwo.js";
 import { array_swap } from "../../../collection/array/array_swap.js";
-import { _boxSurfaceArea2 } from "../../aabb3/AABB3Math.js";
 import { mortonEncode_magicbits } from "../../../geom/3d/morton/mortonEncode_magicbits.js";
 import { min3 } from "../../../math/min3.js";
 import { max3 } from "../../../math/max3.js";
+import { aabb3_compute_half_surface_area } from "../../aabb3/aabb3_compute_half_surface_area.js";
 
 /**
  * @readonly
@@ -272,7 +272,7 @@ export class BinaryUint32BVH {
             }
 
             this.readBounds(address, box, 0);
-            result += _boxSurfaceArea2(box[0], box[1], box[2], box[3], box[4], box[5]);
+            result += aabb3_compute_half_surface_area(box[0], box[1], box[2], box[3], box[4], box[5]);
         }
 
         return result;
@@ -299,7 +299,7 @@ export class BinaryUint32BVH {
         const y1 = max3(scratch_box_0[4], scratch_box_1[4], scratch_box_2[4]);
         const z1 = max3(scratch_box_0[5], scratch_box_1[5], scratch_box_2[5]);
 
-        return _boxSurfaceArea2(x0, y0, z0, x1, y1, z1);
+        return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
     }
 
     /**

package/core/bvh2/binary/BinaryBVH.js

@@ -3,7 +3,7 @@
  */
 import PrimitiveType from "../../binary/type/PrimitiveTypes.js";
 import BinaryStructure from "../../binary/type/Type.js";
-import { intersectRay } from "../aabb3/AABB3Math.js";
+import { aabb3_intersects_ray } from "../aabb3/aabb3_intersects_ray.js";
 
 const NodeType = {
     LEAF: 0,
@@ -262,7 +262,7 @@ BinaryBVH.prototype.traverseRayLeafIntersections = function (startX, startY, sta
         const y1 = daNode.read_y1(dataView, address);
         const z1 = daNode.read_z1(dataView, address);
 
-        let b = intersectRay(x0, y0, z0, x1, y1, z1, startX, startY, startZ, directionX, directionY, directionZ);
+        let b = aabb3_intersects_ray(x0, y0, z0, x1, y1, z1, startX, startY, startZ, directionX, directionY, directionZ);
 
         if (!b) {
             return false;

package/core/bvh2/binary/RayLeafIntersectionVisitor.js

@@ -1,7 +1,7 @@
 import { noop } from "../../function/Functions.js";
-import { intersectRay } from "../aabb3/AABB3Math.js";
 import { IndexedBinaryBVHVisitor } from "./IndexedBinaryBVHVisitor.js";
 import { NodeType } from "./NodeType.js";
+import { aabb3_intersects_ray } from "../aabb3/aabb3_intersects_ray.js";
 
 export class RayLeafIntersectionVisitor extends IndexedBinaryBVHVisitor {
     constructor() {
@@ -37,7 +37,7 @@ export class RayLeafIntersectionVisitor extends IndexedBinaryBVHVisitor {
         const y1 = data[address + 4];
         const z1 = data[address + 5];
 
-        const intersectionFound = intersectRay(x0, y0, z0, x1, y1, z1,
+        const intersectionFound = aabb3_intersects_ray(x0, y0, z0, x1, y1, z1,
             this.originX, this.originY, this.originZ,
             this.directionX, this.directionY, this.directionZ
         );

package/core/bvh2/serialization/deserializeBinaryNode.js

@@ -1,6 +1,6 @@
-import { deserializeAABB3 } from "../aabb3/AABB3.js";
 import { BinaryNode } from "../BinaryNode.js";
 import { deserializeLeafNode, LeafNode } from "../LeafNode.js";
+import { deserializeAABB3 } from "../aabb3/deserializeAABB3.js";
 
 /**
  *

package/core/bvh2/serialization/deserializeBinaryNodeFromBinaryBuffer.js

@@ -1,6 +1,7 @@
-import { deserializeAABB3, deserializeAABB3Encoded_v0 } from "../aabb3/AABB3.js";
 import { BinaryNode } from "../BinaryNode.js";
 import { LeafNode } from "../LeafNode.js";
+import { deserializeAABB3Encoded_v0 } from "../aabb3/deserializeAABB3Encoded_v0.js";
+import { deserializeAABB3 } from "../aabb3/deserializeAABB3.js";
 
 /**
  *

package/core/bvh2/serialization/serializeBinaryNode.js

@@ -1,5 +1,5 @@
-import { serializeAABB3 } from "../aabb3/AABB3.js";
 import { isLeaf, serializeLeafNode } from "../LeafNode.js";
+import { serializeAABB3 } from "../aabb3/serializeAABB3.js";
 
 /**
  *

package/core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js

@@ -1,4 +1,5 @@
-import { serializeAABB3, serializeAABB3Encoded_v0 } from "../aabb3/AABB3.js";
+import { serializeAABB3Encoded_v0 } from "../aabb3/AABB3.js";
+import { serializeAABB3 } from "../aabb3/serializeAABB3.js";
 
 /**
  *

package/core/bvh2/transform/BottomUpOptimizingRebuilder.js

@@ -1,7 +1,8 @@
-import { boxSurfaceArea2, scoreBoxesSAH } from "../aabb3/AABB3Math.js";
 import { BinaryNode } from "../BinaryNode.js";
 import { isLeaf } from "../LeafNode.js";
 import { surfaceAreaHeuristic } from "../sah/surfaceAreaHeuristic.js";
+import { aabb3_score_boxes_SAH } from "../aabb3/aabb3_score_boxes_SAH.js";
+import { aabb3_box_surface_area_2 } from "../aabb3/aabb3_box_surface_area_2.js";
 
 function BottomUpOptimizingRebuilder() {
     this.root = null;
@@ -9,7 +10,7 @@ function BottomUpOptimizingRebuilder() {
     /**
      * @type {function(left:NodeDescription, right:NodeDescription):number} heuristic Cost function of pairing two nodes, lower value means better pairing
      */
-    this.heuristic = scoreBoxesSAH;
+    this.heuristic = aabb3_score_boxes_SAH;
 }
 
 /**
@@ -128,13 +129,13 @@ function leaves(node) {
 }
 
 function sah(left, right) {
-    const leftArea = boxSurfaceArea2(left);
-    const rightArea = boxSurfaceArea2(right);
+    const leftArea = aabb3_box_surface_area_2(left);
+    const rightArea = aabb3_box_surface_area_2(right);
 
     const leftLeaves = leaves(left);
     const rightLeaves = leaves(right);
 
-    const commonArea = scoreBoxesSAH(left, right);
+    const commonArea = aabb3_score_boxes_SAH(left, right);
 
     return surfaceAreaHeuristic(commonArea, leftArea, rightArea, leftLeaves, rightLeaves);
 }

package/core/bvh2/transform/tryRotateSingleNode.js

@@ -1,6 +1,7 @@
-import { boxSurfaceArea2 as computeArea, scoreBoxesSAH as computeAreaFor2 } from "../aabb3/AABB3Math.js";
 import { surfaceAreaHeuristic as sah } from "../sah/surfaceAreaHeuristic.js";
 import { isLeaf } from "../LeafNode.js";
+import { aabb3_score_boxes_SAH as computeAreaFor2 } from "../aabb3/aabb3_score_boxes_SAH.js";
+import { aabb3_box_surface_area_2 as computeArea } from "../aabb3/aabb3_box_surface_area_2.js";
 
 /**
  *

package/core/geom/3d/frustum/{array_setFromProjectionMatrix.js → frustum_from_projection_matrix_array.js}

@@ -25,7 +25,7 @@ function array_set_plane_normalized(destination, destination_offset, x, y, z, w)
  * @param {number[]|Float32Array} frustum_planes
  * @param {number[]} me
  */
-export function array_setFromProjectionMatrix(frustum_planes, me) {
+export function frustum_from_projection_matrix_array(frustum_planes, me) {
 
     const me0 = me[0];
     const me3 = me[3];

package/core/math/fabsf.js

@@ -0,0 +1,8 @@
+/**
+ * Float ABS, from standard C lib
+ * @param {Number} val
+ * @returns {number}
+ */
+export function fabsf(val) {
+    return val >= 0 ? val : -val;
+}

package/engine/development/performance/MetricCollection.js

@@ -10,6 +10,12 @@ export class MetricCollection {
         this.data = new Map();
     }
 
+    clear() {
+        this.data.forEach((value, key) => {
+            value.clear();
+        });
+    }
+
     /**
      *
      * @returns {string[]}

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -1,12 +1,12 @@
 import { ShadedGeometry } from "./ShadedGeometry.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { System } from "../../../ecs/System.js";
-import { intersectRay } from "../../../../core/bvh2/aabb3/AABB3Math.js";
 import { GeometrySpatialQueryAccelerator } from "../../geometry/buffered/query/GeometrySpatialQueryAccelerator.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
 import { mat4 } from "gl-matrix";
 import { returnTrue } from "../../../../core/function/Functions.js";
+import { aabb3_intersects_ray } from "../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 
 /**
  *
@@ -142,7 +142,7 @@ export class ShadedGeometrySystem extends System {
             const node = traversal_stack[traversal_cursor];
 
             // test node against the ray
-            const intersects = intersectRay(
+            const intersects = aabb3_intersects_ray(
                 node.x0, node.y0, node.z0,
                 node.x1, node.y1, node.z1,
                 origin_x, origin_y, origin_z,

package/engine/graphics/ecs/mesh-v2/sample/prototypeShadedGeometry.js

@@ -26,7 +26,9 @@ async function main(engine) {
         color: 0xFFFFFF
     });
 
-    material.visible = true;
+    material.visible = false;
+
+    window.material = material;
 
     const g = ShadedGeometry.from(new BoxBufferGeometry(), material);
 

package/engine/graphics/geometry/buffered/query/RaycastNearestHitComputingVisitor.js

@@ -1,9 +1,9 @@
 import { SurfacePoint3 } from "../../../../../core/geom/3d/SurfacePoint3.js";
 import { NodeType } from "../../../../../core/bvh2/binary/NodeType.js";
-import { intersectRay } from "../../../../../core/bvh2/aabb3/AABB3Math.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import { computeTriangleRayIntersection } from "../../../../../core/geom/3d/triangle/computeTriangleRayIntersection.js";
 import { GeometrySpatialAcceleratorVisitor } from "./GeometryVisitor.js";
+import { aabb3_intersects_ray } from "../../../../../core/bvh2/aabb3/aabb3_intersects_ray.js";
 
 export class RaycastNearestHitComputingVisitor extends GeometrySpatialAcceleratorVisitor {
     constructor() {
@@ -158,7 +158,7 @@ export class RaycastNearestHitComputingVisitor extends GeometrySpatialAccelerato
             const y1 = data[address + 4];
             const z1 = data[address + 5];
 
-            return intersectRay(
+            return aabb3_intersects_ray(
                 x0, y0, z0,
                 x1, y1, z1,
 

package/engine/graphics/micron/format/MicronGeometryPatchOccurance.js

@@ -1,4 +1,5 @@
 import { squirrel3 } from "../../../../core/math/hash/squirrel3.js";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 
 export class MicronGeometryPatchOccurrence {
     constructor() {
@@ -21,7 +22,7 @@ export class MicronGeometryPatchOccurrence {
         this.patch = null;
         /**
          *
-         * @type {THREE.Matrix4|null}
+         * @type {number[]|Float32Array|null}
          */
         this.transform = null;
     }
@@ -41,7 +42,7 @@ export class MicronGeometryPatchOccurrence {
         return this.geometry_id === other.geometry_id
             && this.instance_id === other.instance_id
             && this.patch.id === other.patch.id
-            && this.transform.equals(other.transform)
+            && isArrayEqualStrict(this.transform, other.transform)
             ;
     }
 

package/engine/graphics/micron/prototypeVirtualGeometry.js

@@ -460,7 +460,7 @@ function init() {
 
     // sample_gltf_sponza();
     // gltf_sample('data/models/RTS_Buildings_Humans/18/Building_R_18_out/Building_R_18.gltf');
-    // sample_lucy();
+    sample_lucy();
     // sample_gltf_hapro_2();
     // sample_gltf_hapro_1();
     // sample_gltf_broken_isiflow();
@@ -478,7 +478,7 @@ function init() {
     // gltf_sample('moicon/03_Jan_22_Demo/4-area_1st_floor/model.gltf');
     // gltf_sample('moicon/03_Jan_22_Demo/8-assets/model.gltf');
     // gltf_sample('moicon/03_Jan_22_Demo/worker_test/model.gltf');
-    gltf_sample('moicon/A4/A4/model.gltf');
+    // gltf_sample('moicon/A4/A4/model.gltf');
 
     document.addEventListener("mousemove", onDocumentMouseMove);
 
@@ -709,6 +709,8 @@ function print_perf_stats() {
     });
 
     console.log(values.join(", "));
+
+    metrics.clear();
 }
 
 setInterval(print_perf_stats, 2000);

package/engine/graphics/micron/render/PatchCacheKey.js

@@ -69,7 +69,7 @@ export class PatchCacheKey {
     fromPatchOccurrence(o) {
         this.patch_id = o.patch.id;
         this.geometry_id = o.geometry_id;
-        this.transform.set(o.transform.elements);
+        this.transform.set(o.transform);
     }
 }
 

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -1,10 +1,10 @@
-import { Frustum, Matrix4 } from "three";
 import { array_copy } from "../../../../core/collection/array/copyArray.js";
 import Vector2 from "../../../../core/geom/Vector2.js";
 import { MicronGeometryPatchOccurrence } from "../format/MicronGeometryPatchOccurance.js";
 import { RefinementSpec } from "./refinement/RefinementSpec.js";
 import { ActivePatchList } from "./refinement/ActivePatchList.js";
 import { ActivePatchFlags } from "./refinement/ActivePatchFlags.js";
+import { mat4 } from "gl-matrix";
 
 /**
  * @readonly
@@ -14,27 +14,27 @@ const refinement_spec = new RefinementSpec();
 
 export class VirtualGeometryBuilder {
     constructor() {
-        this.view_projection_matrix = new Matrix4();
+
+
+        const common_buffer = new ArrayBuffer(192);
+
 
         /**
-         *
+         * Camera's world inverse matrix
          * @type {Float32Array|number[]|mat4}
          */
-        this.matrix_projection = new Float32Array(16);
-
-        this.matrix_projection_inverse = new Matrix4();
-
+        this.matrix_world_inverse = new Float32Array(common_buffer, 0, 16);
         /**
-         *
+         * Camera's projection matrix
          * @type {Float32Array|number[]|mat4}
          */
-        this.matrix_world_inverse = new Float32Array(16);
+        this.matrix_projection = new Float32Array(common_buffer, 64, 16);
 
         /**
          *
-         * @type {Frustum}
+         * @type {Float32Array|number[]|mat4}
          */
-        this.view_frustum = new Frustum();
+        this.view_projection_matrix = new Float32Array(common_buffer, 128, 16);
 
         /**
          * @private
@@ -74,20 +74,6 @@ export class VirtualGeometryBuilder {
          * @type {number}
          */
         this.error_bias = 2;
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__info_enforced_node_splits = 0;
-
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__flags__enforce_dependency_splits = true;
     }
 
     dropCache() {
@@ -111,27 +97,15 @@ export class VirtualGeometryBuilder {
         camera.updateMatrix();
         camera.updateMatrixWorld(true);
 
-        this.view_projection_matrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-
         this.matrix_world_inverse.set(camera.matrixWorldInverse.elements);
         this.matrix_projection.set(camera.projectionMatrix.elements);
 
-        this.matrix_projection_inverse.copy(camera.projectionMatrixInverse);
-
-        this.view_frustum.setFromProjectionMatrix(this.view_projection_matrix);
+        mat4.multiply(this.view_projection_matrix, this.matrix_projection, this.matrix_world_inverse);
 
         //
         refinement_spec.focal_length = camera.fov / 180;
     }
 
-    /**
-     *
-     * @param {THREE.Matrix4} matrix
-     */
-    setProjectionMatrix(matrix) {
-        this.view_projection_matrix.copy(matrix);
-    }
-
     /**
      *
      * @param {THREE.Object3D|ThreeMicronMesh} object
@@ -156,7 +130,7 @@ export class VirtualGeometryBuilder {
                 this.buildForMesh(
                     object.instance_id,
                     micron_geometry,
-                    object.matrixWorld,
+                    object.matrixWorld.elements,
                     acl
                 );
             }
@@ -176,7 +150,7 @@ export class VirtualGeometryBuilder {
      *
      * @param {number} instance_id
      * @param {MicronGeometry} geometry
-     * @param {THREE.Matrix4} transform
+     * @param {number[]} transform world transform matrix of the instance
      * @param {ActivePatchList} apl
      */
     buildForMesh(
@@ -186,7 +160,7 @@ export class VirtualGeometryBuilder {
         apl
     ) {
 
-        refinement_spec.build(transform.elements, this.matrix_world_inverse, this.matrix_projection);
+        refinement_spec.build(transform, this.view_projection_matrix);
 
         const output = this.output;
 

package/engine/graphics/micron/render/instanced/ThreeInstancedAdapter.js

@@ -141,6 +141,10 @@ export class ThreeInstancedAdapter {
         const geo = this.__buffer_geometry;
 
         const patch_transform_attribute = geo.getAttribute(ATTRIBUTE_NAME_TRANSFORM);
+        /**
+         *
+         * @type {Float32Array}
+         */
         const patch_transform_array = patch_transform_attribute.array;
 
         patch_transform_attribute.needsUpdate = true;
@@ -157,7 +161,7 @@ export class ThreeInstancedAdapter {
 
             const i16 = i * 16;
 
-            occurrence.transform.toArray(patch_transform_array, i16);
+            patch_transform_array.set(occurrence.transform, i16);
 
             const patch_slot_id = patch_data.ensure(occurrence.patch);
 

package/engine/graphics/micron/render/refinement/ActivePatchList.js

@@ -2,7 +2,7 @@ import { ActivePatchRecord } from "./ActivePatchRecord.js";
 import { ActivePatchFlags } from "./ActivePatchFlags.js";
 import { aabb3_project_to_2d } from "../../../../../core/geom/3d/aabb/aabb3_compute_projected_area.js";
 import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { aabb3_intersects_frustum } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum.js";
+import { aabb3_intersects_frustum_array } from "../../../../../core/bvh2/aabb3/aabb3_intersects_frustum_array.js";
 
 export class ActivePatchList {
     constructor() {
@@ -201,7 +201,7 @@ export class ActivePatchList {
              check if node is in view frustum
              NOTE: following suggestion in "FastMesh: Efficient View-dependent Meshing" by Renato Pajarola et al, we can do a more coarse frustum test approximating frustum as a cone initially
              */
-            const in_view_frustum = aabb3_intersects_frustum(node.bounding_box, frustum_planes);
+            const in_view_frustum = aabb3_intersects_frustum_array(node.bounding_box, frustum_planes);
 
             if (!in_view_frustum) {
                 // outside of view frustum, cull