@woosh/meep-engine 2.34.44 → 2.34.48

package/core/binary/BitSet.js

@@ -533,12 +533,14 @@ BitSet.prototype.shift = function (distance, start_index, end_index) {
  * Sets all of the bits in this BitSet to false.
  */
 BitSet.prototype.reset = function () {
-    if (this.__length <= 0) {
+    const current_length = this.__length;
+
+    if (current_length <= 0) {
         // no action required
         return;
     }
 
-    this.__data_uint32.fill(0, 0, Math.ceil(this.__length / 32));
+    this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
     this.__length = 0;
 };
 

package/core/bvh2/BinaryNode.js

@@ -211,44 +211,62 @@ export class BinaryNode extends Node {
      */
     __insertion_findSiblingFor(box) {
 
-        const open_set = [this];
-        let cursor = 1;
+        let node = this;
+        let cost_left = 0;
+        let cost_right = 0;
 
-        let best_cost = Infinity;
-        let best_node = this;
+        while (node.isBinaryNode) {
+            const left = node.left;
+            const right = node.right;
 
-        while (cursor > 0) {
-            const node = open_set[--cursor];
+            const area = aabb3_box_surface_area_2(node);
 
-            const cost = inclusion_surface_area_heuristic(node, box);
+            const combined_area = combined_surface_area(node, box);
 
-            if (cost < best_cost) {
-                best_cost = cost;
-                best_node = node;
-            }
+            //cost of creating a new parent for this node and the new leaf
+            const cost = combined_area;
 
-            if (node.isBinaryNode) {
+            // minimum cost of pushing the leaf further down the tree
+            const inheritance_cost = combined_area - area;
 
-                // consider pushing children into the queue
+            // cost of descending left
+            if (left !== null) {
+                if (left.isLeafNode) {
+                    cost_left = combined_surface_area(left, box) + inheritance_cost;
+                } else {
+                    cost_left = combined_surface_area(left, box) - aabb3_box_surface_area_2(left) + inheritance_cost;
+                }
+            } else {
+                cost_left = Infinity;
+            }
 
-                // compute lower bound for cost
-                const c_low = inclusion_cost_lower_bound(node, box);
+            // cost of descending right
+            if (right !== null) {
 
-                if (c_low < best_cost) {
-                    // worth-while to explore children
-                    if (node.left !== null) {
-                        open_set[cursor++] = node.left;
-                    }
-                    if (node.right !== null) {
-                        open_set[cursor++] = node.right
-                    }
+                if (right.isLeafNode) {
+                    cost_right = combined_surface_area(right, box) + inheritance_cost;
+                } else {
+                    cost_right = combined_surface_area(right, box) - aabb3_box_surface_area_2(right) + inheritance_cost;
                 }
+            } else {
+                cost_right = Infinity;
             }
 
+            if (cost < cost_left && cost < cost_right) {
+                // descending either branch is too expensive
+                break;
+            }
 
+            if (cost_left < cost_right && left !== null) {
+                node = left;
+            } else if (right !== null) {
+                node = right;
+            } else {
+                break;
+            }
         }
 
-        return best_node;
+        return node;
     }
 
     /**
@@ -1134,6 +1152,16 @@ BinaryNode.prototype.isBinaryNode = true;
  * @returns {number}
  */
 function inclusion_surface_area_heuristic(node, addition) {
+    return combined_surface_area(node, addition) - aabb3_box_surface_area_2(node);
+}
+
+/**
+ *
+ * @param {AABB3} node
+ * @param {AABB3} addition
+ * @returns {number}
+ */
+function combined_surface_area(node, addition) {
     const x0 = min2(node.x0, addition.x0);
     const y0 = min2(node.y0, addition.y0);
     const z0 = min2(node.z0, addition.z0);
@@ -1142,7 +1170,7 @@ function inclusion_surface_area_heuristic(node, addition) {
     const y1 = max2(node.y1, addition.y1);
     const z1 = max2(node.z1, addition.z1);
 
-    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1) - aabb3_box_surface_area_2(node);
+    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
 }
 
 /**

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/aabb/aabb3_estimate_projected_area2.js

@@ -16,7 +16,7 @@ export function aabb3_estimate_projected_area2(aabb, matrix) {
     for (let i = 0; i < 2; i++) {
         for (let j = 0; j < 3; j++) {
 
-            const m_a = i * 4 + j;
+            const m_a = i  + j* 4;
             const m_v = matrix[m_a];
 
             const a = m_v * aabb[j];

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;
 }

package/core/geom/3d/topology/simplify/simplifyTopoMesh.js

@@ -23,7 +23,6 @@ export function extract_edge_cost(edge) {
 /**
  * @param {number} number_faces_to_remove minimum number of faces to removed
  * @param {BinaryHeap<EdgeCollapseCandidate>} heap
- * @param {EdgeCollapseCandidate[]} removed_edges
  * @param {TopoMesh} mesh
  * @param {Map<TopoEdge, EdgeCollapseCandidate>} edge_to_collapse_map
  * @param {Map<number, Quadratic3>} vertex_quadratics
@@ -32,7 +31,6 @@ export function extract_edge_cost(edge) {
 export function collapse_edges(
     number_faces_to_remove,
     heap,
-    removed_edges,
     mesh,
     edge_to_collapse_map,
     vertex_quadratics,
@@ -64,8 +62,6 @@ export function collapse_edges(
         //     continue;
         // }
 
-        removed_edges.push(collapse_candidate);
-
         // find edges that need to be updated
         const victim_vertex = collapse_candidate.victim_vertex;
 
@@ -208,21 +204,15 @@ export function collapse_edges(
  * @param {TopoMesh} mesh
  * @param {number} num_faces_to_remove desired number of faces to remove
  * @param {Set<number>} [restricted_vertices] vertices that are not allowed to be removed
- * @returns {EdgeCollapseCandidate[]} collapsed edges
  */
 export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices = new Set()) {
-    /**
-     *
-     * @type {EdgeCollapseCandidate[]}
-     */
-    const removed_edges = [];
 
     const faces = mesh.getFaces();
     const face_count = faces.size;
 
     if (num_faces_to_remove <= 0 || face_count <= 0) {
         // we're already at the target
-        return removed_edges;
+        return ;
     }
 
 
@@ -258,7 +248,6 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
     collapse_edges(
         num_faces_to_remove,
         open_set,
-        removed_edges,
         mesh,
         edge_to_collapse_map,
         vertex_quadratics,
@@ -270,6 +259,4 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
     collapse_all_degenerate_edges(mesh.getEdges(), mesh);
 
     // debugValidateMesh(mesh);
-
-    return removed_edges;
 }

package/core/graph/convertGraphToDotString.js

@@ -2,7 +2,7 @@ import LineBuilder from "../codegen/LineBuilder.js";
 import { EdgeDirectionType } from "./Edge.js";
 
 /**
- * Build a DOT representation of the graph
+ * Build a Graphviz DOT representation of the graph
  * @param {Graph} graph
  * @returns {string}
  */
@@ -13,7 +13,7 @@ export function convertGraphToDotString(graph) {
 
     lb.indent();
 
-    const nodes = graph.nodes;
+    const nodes = Array.from(graph.getNodes());
     const nodeCount = nodes.length;
 
     function nodeId(index) {
@@ -33,9 +33,9 @@ export function convertGraphToDotString(graph) {
 
         const node = nodes[i];
 
-        const attachedEdges = graph.getAttachedEdges(node);
+        const attachedEdges = [];
 
-        const nAttachedEdges = attachedEdges.length;
+        const nAttachedEdges = graph.getAttachedEdges(attachedEdges, node);
 
         for (let j = 0; j < nAttachedEdges; j++) {
             const edge = attachedEdges[j];

package/core/graph/v2/Graph.js

@@ -335,6 +335,10 @@ export class Graph {
      * @returns {number}
      */
     getAttachedEdges(result, node) {
+        assert.defined(result, 'result');
+        assert.isArray(result, 'result');
+        assert.defined(node, 'node');
+
         const context = this.__nodes.get(node);
 
         if (context === undefined) {

package/engine/ecs/foliage/ecs/Foliage2System.js

@@ -111,13 +111,26 @@ export class Foliage2System extends System {
 
         this.renderLayer = graphics.layers.create('instanced-mesh-system');
 
-        graphics.views.elements.forEach(this.__handle_view_added, this);
+        /**
+         *
+         * @type {CameraViewManager}
+         */
+        const views = graphics.views;
+
+        /**
+         *
+         * @type {List<CameraView>}
+         */
+        const view_list = views.elements;
+
+        view_list.forEach(this.__handle_view_added, this);
 
-        graphics.views.elements.on.added.add(this.__handle_view_added, this);
-        graphics.views.elements.on.removed.add(this.__handle_view_removed, this);
+        view_list.on.added.add(this.__handle_view_added, this);
+        view_list.on.removed.add(this.__handle_view_removed, this);
 
-        this.renderLayer.buildVisibleSet = (view, visitObject, thisArg) => {
+        this.renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
             const data = this.data;
+            let additions = 0;
 
             for (let entity in data) {
 
@@ -147,11 +160,15 @@ export class Foliage2System extends System {
                         }
 
                         const mesh = group.mesh;
-                        visitObject.call(thisArg, mesh);
+
+                        destination[additions + destination_offset] = mesh;
+                        additions++;
                     }
 
                 }
             }
+
+            return additions;
         };
 
         readyCallback();

package/engine/graphics/compute_geometry_polycount.js

@@ -0,0 +1,21 @@
+/**
+ *
+ * @param {THREE.BufferGeometry} geometry
+ * @returns {number}
+ */
+export function compute_geometry_polycount(geometry) {
+    const index = geometry.getIndex();
+
+    if (index !== null) {
+        return index.count / 3;
+    }
+
+    const position_attribute = geometry.getAttribute('position');
+
+    if (position_attribute !== undefined) {
+        return position_attribute.count / 3;
+    }
+
+    // no valid way to discern polycount, assume 0
+    return 0;
+}