@woosh/meep-engine 2.34.43 → 2.34.47

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/bvh2/traversal/bvh_traverse_pre_order_using_stack.js

@@ -0,0 +1,43 @@
+const stack = [];
+let stackPointer = 0;
+
+/**
+ *
+ * @param {BinaryNode} root
+ * @param {function(BinaryNode|LeafNode):*} visitor
+ * @param {*} [thisArg]
+ * @return {number}
+ */
+export function bvh_traverse_pre_order_using_stack(root, visitor, thisArg) {
+    let visitCount = 0;
+
+    const stackOffset = stackPointer;
+
+    stack[stackPointer++] = root;
+
+    let n;
+
+    while (stackPointer-- > stackOffset) {
+
+        visitCount++;
+
+        n = stack[stackPointer];
+
+        visitor.call(thisArg, n);
+
+        if (!n.isLeafNode) {
+            //a binary node
+            if (n.right !== null) {
+                stack[stackPointer++] = n.right;
+            }
+            if (n.left !== null) {
+                stack[stackPointer++] = n.left;
+            }
+        }
+    }
+
+    // drop stack frame
+    stackPointer = stackOffset;
+
+    return visitCount;
+}

package/core/bvh2/visual/convert_bvh_to_dot_format_string.js

@@ -0,0 +1,50 @@
+import { convertGraphToDotString } from "../../graph/convertGraphToDotString.js";
+import { bvh_traverse_pre_order_using_stack } from "../traversal/bvh_traverse_pre_order_using_stack.js";
+import { Graph } from "../../graph/v2/Graph.js";
+import { Edge, EdgeDirectionType } from "../../graph/Edge.js";
+
+/**
+ *
+ * @param {BinaryNode} bvh
+ * @returns {Graph}
+ */
+export function bvh_to_graph(bvh) {
+    //traverse twice, first collect all nodes, second time introduce edges
+    const graph = new Graph();
+
+    bvh_traverse_pre_order_using_stack(bvh, node => {
+        graph.addNode(node);
+    });
+
+    bvh_traverse_pre_order_using_stack(bvh, node => {
+        if (node.isBinaryNode) {
+
+            if (node.left !== null) {
+                const edge = new Edge(node, node.left);
+
+                edge.direction = EdgeDirectionType.Forward;
+
+                graph.addEdge(edge);
+            }
+            if (node.right !== null) {
+                const edge = new Edge(node, node.right);
+
+                edge.direction = EdgeDirectionType.Forward;
+
+                graph.addEdge(edge);
+            }
+        }
+    });
+
+    return graph;
+}
+
+/**
+ * Build a Graphviz DOT representation of the graph
+ * @param {BinaryNode} bvh
+ * @returns {string}
+ */
+export function convert_bvh_to_dot_format_string(bvh) {
+    const graph = bvh_to_graph(bvh);
+    return convertGraphToDotString(graph);
+}

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/geom/3d/topology/TopoMesh.js

@@ -31,14 +31,6 @@ export class TopoMesh {
         this.__faces = new Set();
     }
 
-    get edges() {
-        throw new Error('Deprecated accessor, use getEdges instead');
-    }
-
-    get faces() {
-        throw new Error('Deprecated accessor, use getEdges instead');
-    }
-
     /**
      *
      * @returns {Set<TopoEdge>}

package/core/geom/3d/topology/TopoVertex.js

@@ -241,24 +241,25 @@ export class TopoVertex {
         const faces = victim.faces;
         const face_count = faces.length;
 
-        for (let i = 0; i < face_count; i++) {
+        let i = 0;
+
+        for (; i < face_count; i++) {
             // take over the victim's faces
             const face = faces[i];
 
-            // DEBUG
-            face.computeNormal();
+
+            // face.computeNormal(); // DEBUG
             face.replaceVertex(victim, this);
 
             this.addUniqueFace(face);
 
-            // DEBUG
-            face.computeNormal();
+            // face.computeNormal(); // DEBUG
         }
 
         const edges = victim.edges;
         const edge_count = edges.length;
 
-        for (let i = 0; i < edge_count; i++) {
+        for (i = 0; i < edge_count; i++) {
             // take over the victim's edges
             const edge = edges[i];
 

package/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -1,4 +1,7 @@
 import { v3_dot } from "../../../../v3_dot.js";
+import { fabsf } from "../../../../../math/fabsf.js";
+import { EPSILON } from "../../../../../math/MathUtils.js";
+import { vec3 } from "gl-matrix";
 
 export class Quadratic3 {
     constructor() {
@@ -21,6 +24,74 @@ export class Quadratic3 {
         this.d2 = 0;
     }
 
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} result
+     */
+    toVector3(result) {
+        result[0] = this.ad;
+        result[1] = this.bd;
+        result[2] = this.cd;
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     */
+    toTensorM3(m3) {
+        m3[0] = this.a2;
+        m3[1] = this.ab;
+        m3[2] = this.ac;
+
+        m3[3] = this.ab;
+        m3[4] = this.b2;
+        m3[5] = this.bc;
+
+        m3[6] = this.ac;
+        m3[7] = this.bc;
+        m3[8] = this.c2;
+    }
+
+    /**
+     * Equivalent to taking a tensor followed by matrix inversion
+     * @param {ArrayLike<number>|number[]|Float32Array} m3
+     * @param {number} epsilon
+     * @returns {boolean} whether operation was successful or not
+     */
+    toTensorM3Inverse(m3, epsilon) {
+        const a2 = this.a2;
+        const b2 = this.b2;
+        const c2 = this.c2;
+        const bc = this.bc;
+        const ab = this.ab;
+        const ac = this.ac;
+
+        const det = a2 * (b2 * c2 - bc * bc) -
+            ab * (ab * c2 - ac * bc) +
+            ac * (ab * bc - ac * b2);
+
+        if (fabsf(det) > epsilon) {
+
+            const invdet = 1.0 / det;
+
+            m3[0] = (b2 * c2 - bc * bc) * invdet;
+            m3[3] = (bc * ac - ab * c2) * invdet;
+            m3[6] = (ab * bc - b2 * ac) * invdet;
+
+            m3[1] = (ac * bc - ab * c2) * invdet;
+            m3[4] = (a2 * c2 - ac * ac) * invdet;
+            m3[7] = (ab * ac - a2 * bc) * invdet;
+
+            m3[2] = (ab * bc - ac * b2) * invdet;
+            m3[5] = (ac * ab - a2 * bc) * invdet;
+            m3[8] = (a2 * b2 - ab * ab) * invdet;
+
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * Set from plane expressed as a 4 component vector
      * @param {number} x plane normal
@@ -78,18 +149,35 @@ export class Quadratic3 {
     evaluate(x, y, z) {
         // Evaluate vAv + 2bv + c
 
-        return x * x * this.a2 + 2 * x * y * this.ab + 2 * x * z * this.ac + 2 * x * this.ad
-            + y * y * this.b2 + 2 * y * z * this.bc + 2 * y * this.bd
-            + z * z * this.c2 + 2 * z * this.cd
-            + this.d2;
+        return (x * x * this.a2) + (2 * x * y * this.ab) + (2 * x * z * this.ac) + (2 * x * this.ad)    // A
+            + (y * y * this.b2) + (2 * y * z * this.bc) + (2 * y * this.bd)                             // B
+            + (z * z * this.c2) + (2 * z * this.cd)                                                     // C
+            + this.d2;                                                                                  // D
     }
 
     /**
+     * Find optimal vertex position based on the quadratic
+     *
+     * Based on Bleder's implementation: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
      *
      * @param {number[]} out
+     * @returns {boolean}
      */
     optimize(out) {
-        throw new Error('Not Implemented');
+        const m = new Float32Array(9);
+
+        if (this.toTensorM3Inverse(m, EPSILON)) {
+
+            this.toVector3(out);
+
+            vec3.transformMat3(out, out, m);
+            vec3.negate(out, out);
+
+            return true;
+        }
+
+        return false;
+
     }
 
     /**

package/core/geom/3d/topology/simplify/quadratic/build_vertex_quadratics.js

@@ -31,7 +31,10 @@ export function build_vertex_quadratics(mesh, quadratics) {
     const mesh_vertices = mesh.vertices;
     const mesh_vertex_count = mesh_vertices.length;
 
-    for (let i = 0; i < mesh_vertex_count; i++) {
+
+    let i, face;
+
+    for (i = 0; i < mesh_vertex_count; i++) {
         const mesh_vertex = mesh_vertices[i];
 
         const vertex_quadratic = new Quadratic3();
@@ -44,15 +47,15 @@ export function build_vertex_quadratics(mesh, quadratics) {
 
     const faces = mesh.getFaces();
 
-    for (let face of faces) {
+    for (face of faces) {
 
         q.setFromFace(face);
 
         const face_vertices = face.vertices;
         const face_vertex_count = face_vertices.length;
 
-        for (let j = 0; j < face_vertex_count; j++) {
-            const face_vertex = face_vertices[j];
+        for (i = 0; i < face_vertex_count; i++) {
+            const face_vertex = face_vertices[i];
 
             // accumulate to adjacent vertex
             const face_vertex_quadratic = quadratics.get(face_vertex.index);

package/core/geom/3d/topology/simplify/quadratic/compute_edge_collapse_cost_quadratic.js

@@ -18,5 +18,11 @@ export function compute_edge_collapse_cost_quadratic(
     const q_v0 = q0.evaluate(target.x, target.y, target.z);
     const q_v1 = q1.evaluate(target.x, target.y, target.z);
 
-    return q_v0 + q_v1;
+    /**
+     * 'cost' shouldn't be negative but happens sometimes with small values.
+     * @type {number}
+     */
+    const cost = Math.abs(q_v0 + q_v1);
+
+    return cost;
 }