@woosh/meep-engine 2.34.45 → 2.34.49

package/core/binary/BitSet.js

@@ -59,7 +59,6 @@ const SHRINK_FACTOR = 0.5;
  */
 const RESIZE_COUNT_THRESHOLD = 128;
 
-
 /**
  * Dynamically sized bit field
  * @constructor
@@ -389,6 +388,7 @@ BitSet.prototype.set = function (bitIndex, value) {
         const bitIndexInc = bitIndex + 1;
 
         if (bitIndexInc > this.__length) {
+            // ensure capacity
             this.__setLength(bitIndexInc);
         }
 
@@ -401,6 +401,7 @@ BitSet.prototype.set = function (bitIndex, value) {
         this.__data_uint32[word_offset] &= ~word_mask;
 
         if (bitIndex === this.__length - 1) {
+            // trim down set size potentially
             const newLastSetBit = this.previousSetBit(bitIndex);
 
             this.__setLength(newLastSetBit + 1);
@@ -533,12 +534,18 @@ 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;
+    } else if (current_length <= 32) {
+        // one word, set first word to 0 manually
+        this.__data_uint32[0] = 0;
+    } else {
+        this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
     }
 
-    this.__data_uint32.fill(0, 0, Math.ceil(this.__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/frustum/frustum_from_projection_matrix_array.js

@@ -7,53 +7,56 @@
  * @param {number} z
  * @param {number} w
  */
-function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+function array_set_plane_normalized(
+    destination, destination_offset,
+    x, y, z, w
+) {
     // compute vector length
     const length = Math.hypot(x, y, z);
 
-    const inverseNormalLength = 1.0 / length;
+    const inverse_length = 1.0 / length;
 
     // apply normalization
-    destination[destination_offset] = x * inverseNormalLength;
-    destination[destination_offset + 1] = y * inverseNormalLength;
-    destination[destination_offset + 2] = z * inverseNormalLength;
-    destination[destination_offset + 3] = w * inverseNormalLength;
+    destination[destination_offset] = x * inverse_length;
+    destination[destination_offset + 1] = y * inverse_length;
+    destination[destination_offset + 2] = z * inverse_length;
+    destination[destination_offset + 3] = w * inverse_length;
 }
 
 /**
  * Set frustum from projection matrix
  * @param {number[]|Float32Array} frustum_planes
- * @param {number[]} me
+ * @param {number[]} m4
  */
-export function frustum_from_projection_matrix_array(frustum_planes, me) {
+export function frustum_from_projection_matrix_array(frustum_planes, m4) {
 
-    const me0 = me[0];
-    const me3 = me[3];
+    const me0 = m4[0];
+    const me3 = m4[3];
 
-    const me4 = me[4];
-    const me7 = me[7];
+    const me4 = m4[4];
+    const me7 = m4[7];
 
-    const me8 = me[8];
-    const me11 = me[11];
+    const me8 = m4[8];
+    const me11 = m4[11];
 
-    const me12 = me[12];
-    const me15 = me[15];
+    const me12 = m4[12];
+    const me15 = m4[15];
 
     array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
     array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
 
-    const me1 = me[1];
-    const me5 = me[5];
-    const me9 = me[9];
-    const me13 = me[13];
+    const me1 = m4[1];
+    const me5 = m4[5];
+    const me9 = m4[9];
+    const me13 = m4[13];
 
     array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
     array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
 
-    const me2 = me[2];
-    const me6 = me[6];
-    const me10 = me[10];
-    const me14 = me[14];
+    const me2 = m4[2];
+    const me6 = m4[6];
+    const me10 = m4[10];
+    const me14 = m4[14];
 
     array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
     array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);

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/asset/loaders/geometry/geometry/computeGeometryEquality.js

@@ -1,4 +1,5 @@
 import { isArrayEqualStrict } from "../../../../../core/collection/array/isArrayEqualStrict.js";
+import { is_typed_array_equals } from "../../../../../core/collection/array/typed/is_typed_array_equals.js";
 
 
 /**
@@ -46,7 +47,7 @@ export function computeGeometryEquality(a, b) {
         const a_attribute = a.attributes[key];
         const b_attribute = b.attributes[key];
 
-        if (!isArrayEqualStrict(a_attribute.array, b_attribute.array)) {
+        if (!is_typed_array_equals(a_attribute.array, b_attribute.array)) {
             return false;
         }
     }

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

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

@@ -4,6 +4,15 @@ import EntityBuilder from "../../../../ecs/EntityBuilder.js";
 import { Transform } from "../../../../ecs/transform/Transform.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";
 import { BoxBufferGeometry, MeshBasicMaterial } from "three";
+import { randomFloatBetween } from "../../../../../core/math/random/randomFloatBetween.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
+import ViewportPosition from "../../../../ecs/gui/position/ViewportPosition.js";
+import GUIElement from "../../../../ecs/gui/GUIElement.js";
+import ButtonView from "../../../../../view/elements/button/ButtonView.js";
+import { downloadAsFile } from "../../../../../core/binary/ByteArrayTools.js";
+import { convert_bvh_to_dot_format_string } from "../../../../../core/bvh2/visual/convert_bvh_to_dot_format_string.js";
+import ViewportPositionSystem from "../../../../ecs/gui/position/ViewportPositionSystem.js";
+import GUIElementSystem from "../../../../ecs/gui/GUIElementSystem.js";
 
 const eh = new EngineHarness();
 
@@ -26,22 +35,68 @@ async function main(engine) {
         color: 0xFFFFFF
     });
 
-    material.visible = false;
+    // material.visible = false;
 
     window.material = material;
 
-    const g = ShadedGeometry.from(new BoxBufferGeometry(), material);
+    const geometry = new BoxBufferGeometry();
 
+    const random = seededRandom(0);
+
+    for (let i = 0; i < 100000; i++) {
+
+        new EntityBuilder()
+            .add(Transform.fromJSON({
+                position: {
+                    x: randomFloatBetween(random, -50, 50),
+                    y: randomFloatBetween(random, 0, 10),
+                    z: randomFloatBetween(random, -50, 50)
+                },
+                scale: 0.01
+            }))
+            .add(ShadedGeometry.from(geometry, material))
+            .build(ecd);
+    }
+
+    debug_button(engine, () => {
+        const dot = convert_bvh_to_dot_format_string(engine.graphics.layers.getLayerByName('shaded-geometry').bvh);
+        downloadAsFile(dot, 'bvh.dot', 'text');
+
+    }, 'save dot file');
+
+}
+
+
+const entityManager = engine.entityManager;
+
+/**
+ *
+ * @param {Engine} engine
+ * @param {function} action
+ * @param {string} [name]
+ * @param {EntityComponentDataset} ecd
+ */
+function debug_button(engine, action, name = "Button", ecd = entityManager.dataset) {
+    if (entityManager.getSystem(ViewportPositionSystem) === null) {
+        entityManager.addSystem(new ViewportPositionSystem(engine.graphics.viewport.size));
+    }
+
+    if (entityManager.getSystem(GUIElementSystem) === null) {
+        entityManager.addSystem(new GUIElementSystem(engine.gui.view, engine));
+    }
 
     new EntityBuilder()
-        .add(Transform.fromJSON({
-            position: {
-                x: 10,
-                y: 1,
-                z: 10
+        .add(ViewportPosition.fromJSON({}))
+        .add(GUIElement.fromView(new ButtonView({
+            action,
+            name,
+            css: {
+                background: 'rgba(255,255,255,0.8)',
+                border: '1px solid black',
+                borderRadius: '4px',
+                padding: '2px',
             }
-        }))
-        .add(g)
+        })))
         .build(ecd);
 }
 

package/engine/graphics/micron/convert_three_object_to_micron.js

@@ -76,8 +76,6 @@ export async function convert_three_object_to_micron(object, micron_cache = defa
 
         await micron_cache.set(g, micron_geometry);
 
-        // console.log(micron_geometry);
-
         return micron_geometry;
     }
 

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

@@ -226,11 +226,9 @@ export class MicronGeometry {
                     }
 
                     // push to stack
-                    stack[stack_cursor] = child;
+                    stack[stack_cursor++] = child;
 
                     included_set.set(child.id, true);
-
-                    stack_cursor++;
                 }
             }
         }