@woosh/meep-engine 2.37.20 → 2.38.2

package/core/collection/array/array_get_index_in_range.js

@@ -0,0 +1,16 @@
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {T} needle
+ * @param {number} min_index
+ * @param {number} max_index
+ */
+export function array_get_index_in_range(array, needle, min_index, max_index) {
+    for (let i = min_index; i <= max_index; i++) {
+        if (array[i] === needle) {
+            return i;
+        }
+    }
+
+    return -1;
+}

package/{engine/navigation/grid → core/collection/heap}/BinaryHeap.js

@@ -1,3 +1,8 @@
+/**
+ * @deprecated use {@link FastBinaryHeap} instead
+ * @param scoreFunction
+ * @constructor
+ */
 function BinaryHeap(scoreFunction) {
     this.content = [];
     this.hash = [];
@@ -99,7 +104,7 @@ BinaryHeap.prototype = {
             element = content[n],
             elemScore = scoreFunction(element);
 
-        for (;;) {
+        for (; ;) {
             // Compute the indices of the child elements.
             const child2N = (n + 1) << 1,
                 child1N = child2N - 1;

package/{engine/navigation/grid → core/collection/heap}/FastBinaryHeap.js

@@ -1,4 +1,4 @@
-import { assert } from "../../../core/assert.js";
+import { assert } from "../../assert.js";
 
 /**
  * Min-Heap implementation with a score function. The data structure is a binary heap where elements are removed in order defined by scoring function
@@ -6,7 +6,8 @@ import { assert } from "../../../core/assert.js";
  */
 class BinaryHeap {
     /**
-     * @param {(T)=>number} scoreFunction
+     * @template T
+     * @param {function(el:T):number} scoreFunction
      * @constructor
      */
     constructor(scoreFunction) {

package/{engine/navigation/grid → core/collection/heap}/FastBinaryHeap.spec.js

@@ -1,7 +1,7 @@
-import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { seededRandom } from "../../math/random/seededRandom.js";
 import BinaryHeap from "./FastBinaryHeap.js";
-import { passThrough, returnZero } from "../../../core/function/Functions.js";
-import { randomIntegerBetween } from "../../../core/math/random/randomIntegerBetween.js";
+import { passThrough, returnZero } from "../../function/Functions.js";
+import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
 
 test("constructor doesn't throw", () => {
     new BinaryHeap(returnZero);

package/core/collection/heap/Uin32Heap.spec.js

@@ -0,0 +1,59 @@
+import { Uint32Heap } from "./Uint32Heap.js";
+
+test('initial capacity setting via constructor', () => {
+    const heap = new Uint32Heap(3);
+
+    expect(heap.capacity).toBe(3);
+});
+
+test('heap capacity grows as needed', () => {
+    const heap = new Uint32Heap(0);
+
+    heap.insert(1, 1);
+
+    expect(heap.capacity).toBeGreaterThanOrEqual(1);
+});
+
+test('initial heap size is 0', () => {
+    const heap = new Uint32Heap();
+
+    expect(heap.size).toBe(0);
+});
+
+test('insert operation increases size by 1', () => {
+    const heap = new Uint32Heap();
+
+    const s0 = heap.size;
+
+    heap.insert(0, 0);
+
+    expect(heap.size).toBe(s0 + 1);
+});
+
+test('pop operation reduces size by 1', () => {
+    const heap = new Uint32Heap();
+
+    heap.insert(0, 0);
+
+    const s0 = heap.size;
+
+    heap.pop_min();
+
+    expect(heap.size).toBe(s0 - 1);
+});
+
+test('insert 5 out of order, retrieve in order', () => {
+    const heap = new Uint32Heap();
+
+    heap.insert(3, 4);
+    heap.insert(5, 5);
+    heap.insert(7, 2);
+    heap.insert(11, 3);
+    heap.insert(13, 1);
+
+    expect(heap.pop_min()).toBe(13);
+    expect(heap.pop_min()).toBe(7);
+    expect(heap.pop_min()).toBe(11);
+    expect(heap.pop_min()).toBe(3);
+    expect(heap.pop_min()).toBe(5);
+});

package/core/collection/heap/Uint32Heap.js

@@ -0,0 +1,385 @@
+import { assert } from "../../assert.js";
+import { max2 } from "../../math/max2.js";
+
+const UINT32_MAX = 4294967295;
+
+const DEFAULT_CAPACITY = 64;
+const ELEMENT_BYTE_SIZE = 8;
+
+/**
+ * % to increase capacity by when growing
+ * NOTE: Must be greater than 1
+ * @type {number}
+ */
+const RESIZE_GROW_FACTOR = 1.2;
+/**
+ * Minimum number of elements to expand the size by when growing
+ * NOTE: Must be an integer
+ * NOTE: Must be greater than 0
+ * @type {number}
+ */
+const RESIZE_GROW_MIN_COUNT = 16;
+
+/**
+ *
+ * @param {number} i
+ * @returns {number}
+ */
+function HEAP_PARENT(i) {
+    return ((i) - 1) >> 1;
+}
+
+/**
+ *
+ * @param {number} i
+ * @returns {number}
+ */
+function HEAP_LEFT(i) {
+    return ((i) << 1) + 1;
+}
+
+/**
+ *
+ * @param {number} i
+ * @returns {number}
+ */
+function HEAP_RIGHT(i) {
+    return ((i) << 1) + 2;
+}
+
+/**
+ * Binary Heap implementation that stores uin32 ID along with a floating point score value
+ * Inspired by Blender's heap implementation found here: https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/BLI_heap.c
+ */
+export class Uint32Heap {
+    /**
+     *
+     * @param {number} [capacity] Can supply initial capacity, heap will still grow when necessary. This allows to prevent needless re-allocations when max heap size is known in advance
+     */
+    constructor(capacity = DEFAULT_CAPACITY) {
+        assert.isNonNegativeInteger(capacity, 'capacity');
+
+        this.__data_buffer = new ArrayBuffer(capacity * ELEMENT_BYTE_SIZE);
+
+        /**
+         * Used to access stored IDs
+         * @type {Uint32Array}
+         * @private
+         */
+        this.__data_uint32 = new Uint32Array(this.__data_buffer);
+
+        /**
+         * Used to access stored Score values
+         * @type {Float32Array}
+         * @private
+         */
+        this.__data_float32 = new Float32Array(this.__data_buffer);
+
+        this.__capacity = capacity;
+        this.__size = 0;
+    }
+
+    /**
+     *
+     * @private
+     */
+    __capacity_grow() {
+        const old_capacity = this.__capacity;
+
+        const new_capacity = max2(
+            old_capacity * RESIZE_GROW_FACTOR,
+            old_capacity + RESIZE_GROW_MIN_COUNT
+        );
+
+        assert.greaterThan(new_capacity, old_capacity, 'invalid growth');
+
+        const new_buffer = new ArrayBuffer(new_capacity * ELEMENT_BYTE_SIZE);
+        const new_uint32 = new Uint32Array(new_buffer);
+
+        // copy old data into new container
+        new_uint32.set(this.__data_uint32);
+
+        this.__data_buffer = new_buffer;
+        this.__data_uint32 = new_uint32;
+        this.__data_float32 = new Float32Array(new_buffer);
+
+        // update capacity
+        this.__capacity = new_capacity;
+    }
+
+    /**
+     * @private
+     * @param {number} a index of an element
+     * @param {number} b index of an element
+     * @returns {boolean}
+     */
+    compare(a, b) {
+        const float32 = this.__data_float32;
+
+        return float32[a * 2] < float32[b * 2];
+    }
+
+    /**
+     * Swap two elements
+     * @private
+     * @param {number} i element index
+     * @param {number} j element index
+     */
+    swap(i, j) {
+        const i2 = i * 2;
+        const j2 = j * 2;
+
+        const uint32 = this.__data_uint32;
+
+        const mem_0 = uint32[i2];
+        uint32[i2] = uint32[j2];
+        uint32[j2] = mem_0;
+
+        const mem_1 = uint32[i2 + 1];
+        uint32[i2 + 1] = uint32[j2 + 1];
+        uint32[j2 + 1] = mem_1;
+    }
+
+    /**
+     * @private
+     * @param {number} index
+     */
+    heap_down(index) {
+        let i = index;
+
+        // size does not change, cache it for performance
+        const size = this.__size;
+
+        while (true) {
+            const l = ((i) << 1) + 1;
+            const r = l + 1;
+
+            let smallest = i;
+
+            if (l < size && this.compare(l, smallest)) {
+                smallest = l;
+            }
+
+            if (r < size && this.compare(r, smallest)) {
+                smallest = r;
+            }
+
+            if (smallest === i) {
+                break;
+            }
+
+            this.swap(i, smallest);
+
+            i = smallest;
+        }
+
+    }
+
+    /**
+     * Bubble up given element into its correct position
+     * @private
+     * @param {number} index
+     */
+    heap_up(index) {
+        let i = index;
+
+        while (i > 0) {
+            // get parent
+            const p = ((i) - 1) >> 1;
+
+            if (this.compare(p, i)) {
+                break;
+            }
+
+            this.swap(p, i);
+
+            i = p;
+        }
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get size() {
+        return this.__size;
+    }
+
+    /**
+     *
+     * @returns {number}
+     */
+    get capacity() {
+        return this.__capacity;
+    }
+
+    /**
+     * Node with the lowest score
+     * @returns {number}
+     */
+    get top_id() {
+        return this.__data_uint32[1];
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    is_empty() {
+        return this.__size === 0;
+    }
+
+    pop_min() {
+        assert.greaterThan(this.__size, 0, 'heap is empty');
+
+        const result = this.top_id;
+
+        this.__size--;
+
+        if (this.__size > 0) {
+            // move top element to the bottom
+            this.swap(0, this.__size);
+
+            // rebalance
+            this.heap_down(0);
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @returns {number}
+     */
+    find_index_by_id(id) {
+        const n = this.__size
+        const n2 = n * 2;
+
+        const uint32 = this.__data_uint32;
+
+        for (let address = 1; address < n2; address += 2) {
+            const _id = uint32[address];
+
+            if (_id === id) {
+                return (address >>> 1);
+            }
+        }
+
+        // not found
+        return -1;
+    }
+
+
+    /**
+     *
+     * @param {number} id
+     */
+    remove(id) {
+        const i = this.find_index_by_id(id);
+
+        if (i !== -1) {
+            this.__remove_by_index(i);
+        }
+    }
+
+    /**
+     *
+     * @param {number} index
+     */
+    __remove_by_index(index) {
+        assert.greaterThan(this.__size, 0, 'heap is empty');
+
+        let i = index;
+
+        while (i > 0) {
+            const p = HEAP_PARENT(i);
+            this.swap(p, i);
+
+            i = p;
+        }
+
+        this.pop_min();
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} score
+     */
+    update_score(id, score) {
+        const index = this.find_index_by_id(id);
+
+        if (index === -1) {
+            throw new Error('Not found');
+        }
+
+        this.__update_score_by_index(index, score);
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number} score
+     */
+    __update_score_by_index(index, score) {
+
+        const float32 = this.__data_float32;
+        const index2 = index * 2;
+        const existing_score = float32[index2];
+
+        if (score < existing_score) {
+            float32[index2] = score;
+            this.heap_up(index);
+        } else if (score > existing_score) {
+            float32[index2] = score;
+            this.heap_down(index);
+        }
+    }
+
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} score
+     */
+    insert_or_update(id, score) {
+        const i = this.find_index_by_id(id);
+
+        if (i === -1) {
+            this.insert(id, score);
+        } else {
+            this.__update_score_by_index(i, score);
+        }
+    }
+
+    /**
+     *
+     * @param {number} id
+     * @param {number} score
+     */
+    insert(id, score) {
+        assert.isNonNegativeInteger(id, 'value');
+        assert.lessThanOrEqual(id, UINT32_MAX - 1, 'must be less than or equal to (2^32 - 2)');
+
+        if (this.__size >= this.__capacity) {
+            // need to re-allocate
+            this.__capacity_grow();
+        }
+
+        // insert at the end
+        const index = this.__size;
+        const address = index * 2;
+
+        // write data
+        this.__data_float32[address] = score;
+        this.__data_uint32[address + 1] = id;
+
+        // record increased size
+        this.__size++;
+
+        this.heap_up(index);
+    }
+
+
+}

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

@@ -5,11 +5,12 @@ import { mortonEncode_magicbits } from "../morton/mortonEncode_magicbits.js";
  *
  * @param {TopoVertex} a
  * @param {TopoVertex} b
+ * @param {number} tolerance
  */
-function isPositionEquivalent(a, b) {
-    return epsilonEquals(b.x, a.x, EPSILON)
-        && epsilonEquals(b.y, a.y, EPSILON)
-        && epsilonEquals(b.z, a.z, EPSILON)
+function isPositionEquivalent(a, b, tolerance) {
+    return epsilonEquals(b.x, a.x, tolerance)
+        && epsilonEquals(b.y, a.y, tolerance)
+        && epsilonEquals(b.z, a.z, tolerance)
         ;
 }
 
@@ -35,8 +36,10 @@ function recordDuplicate(result, a, b) {
  *
  * @param {TopoMesh} mesh
  * @param {AABB3} aabb
+ * @param {number} tolerance
+ * @returns {Map<TopoVertex, TopoVertex[]>}
  */
-export function computeTopoMeshVertexDuplicates(mesh, aabb) {
+export function computeTopoMeshVertexDuplicates(mesh, aabb, tolerance = EPSILON) {
     const vertices = mesh.vertices;
 
     const n = vertices.length;
@@ -84,7 +87,7 @@ export function computeTopoMeshVertexDuplicates(mesh, aabb) {
                  */
                 const vertex_b = spatial_bucket[j];
 
-                if (isPositionEquivalent(vertex_a, vertex_b)) {
+                if (isPositionEquivalent(vertex_a, vertex_b, tolerance)) {
                     // same coordinates
                     recordDuplicate(result, vertex_a, vertex_b);
                     recordDuplicate(result, vertex_b, vertex_a);

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

@@ -76,16 +76,16 @@ export function expandConnectivityByLocality(mesh, aabb) {
 
     let j;
 
-    for (let topoEdge of edges) {
+    for (let edge of edges) {
 
-        const duplicate_v0s = vertex_duplicates.get(topoEdge.v0);
+        const duplicate_v0s = vertex_duplicates.get(edge.v0);
 
         if (duplicate_v0s === undefined) {
             // no duplicate vertices, edge is unique
             continue;
         }
 
-        const duplicate_v1s = vertex_duplicates.get(topoEdge.v1);
+        const duplicate_v1s = vertex_duplicates.get(edge.v1);
 
         if (duplicate_v1s === undefined) {
             // no duplicate vertices, edge is unique
@@ -95,8 +95,8 @@ export function expandConnectivityByLocality(mesh, aabb) {
         const n = findCommonDuplicateEdges(duplicate_edges, duplicate_v0s, duplicate_v1s);
 
         for (j = 0; j < n; j++) {
-            const dulicateEdge = duplicate_edges[j];
-            connectEdges(topoEdge, dulicateEdge);
+            const duplicate_edge = duplicate_edges[j];
+            connectEdges(edge, duplicate_edge);
         }
     }
 

package/core/geom/3d/topology/query/query_edge_is_boundary.js

@@ -0,0 +1,7 @@
+/**
+ * @param {TopoEdge} edge
+ * @returns {boolean}
+ */
+export function query_edge_is_boundary(edge) {
+    return edge.faces.length === 1;
+}

package/core/geom/3d/topology/query/query_edge_is_manifold.js

@@ -0,0 +1,13 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ * Tests whether this edge is manifold.
+ * A manifold edge has exactly 2 faces attached to it.
+ * @param {TopoEdge} edge
+ * @returns {boolean}
+ */
+export function query_edge_is_manifold(edge) {
+    assert.notNull(edge, 'edge');
+    return edge.faces.length === 2;
+}
+

package/core/geom/3d/topology/query/query_edge_is_manifold_or_boundary.js

@@ -0,0 +1,11 @@
+import { query_edge_is_boundary } from "./query_edge_is_boundary.js";
+import { query_edge_is_manifold } from "./query_edge_is_manifold.js";
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @returns {boolean}
+ */
+export function query_edge_is_manifold_or_boundary(edge) {
+    return query_edge_is_manifold(edge) || query_edge_is_boundary(edge);
+}

package/core/geom/3d/topology/query/query_edge_is_wire.js

@@ -0,0 +1,13 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @returns {boolean}
+ */
+export function query_edge_is_wire(edge) {
+    assert.notNull(edge, 'edge');
+
+    const faces = edge.faces;
+    return faces.length === 0;
+}

package/core/geom/3d/topology/query/query_edge_other_vertex.js

@@ -0,0 +1,20 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ * Given a vertex, returns other vertex on the edge
+ * @param {TopoEdge} edge
+ * @param {TopoVertex} v
+ * @returns {TopoVertex|null}
+ */
+export function query_edge_other_vertex(edge, v) {
+    assert.notNull(edge, 'edge');
+    assert.notNull(v, 'v');
+
+    if (edge.v0 === v) {
+        return edge.v1;
+    } else if (edge.v1 === v) {
+        return edge.v0;
+    }
+
+    return null;
+}

package/core/geom/3d/topology/query/query_edge_share_vert.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {TopoEdge} a
+ * @param {TopoEdge} b
+ * @returns {boolean}
+ */
+export function query_edge_share_vert(a, b) {
+    return a.v0 === b.v0 || a.v0 === b.v1 || a.v1 === b.v0 || a.v1 === b.v1;
+}

package/core/geom/3d/topology/query/query_face_get_other_edges.js

@@ -0,0 +1,39 @@
+import { assert } from "../../../../assert.js";
+
+/**
+ *
+ * @param {TopoEdge[]} result
+ * @param {number} result_offset
+ * @param {TopoTriangle} face
+ * @param {TopoEdge} edge
+ */
+export function query_face_get_other_edges(result, result_offset, face, edge) {
+
+    let a, b;
+
+    const edges = face.edges;
+
+    if (edges.length < 3) {
+        return false;
+    }
+
+    assert.equal(edges.length, 3, `must have 3 edges, instead has ${edges.length}`);
+
+    if (edges[0] === edge) {
+        a = 1;
+        b = 2;
+    } else if (edges[1] === edge) {
+        a = 0;
+        b = 2;
+    } else if (edges[2] === edge) {
+        a = 0;
+        b = 1;
+    } else {
+        throw new Error('Edge not contained in the face');
+    }
+
+    result[result_offset] = edges[a];
+    result[result_offset + 1] = edges[b];
+
+    return true;
+}