@woosh/meep-engine 2.109.25 → 2.109.26

package/build/meep.module.js

@@ -71547,6 +71547,23 @@ class EntityObserver {
     }
 }
 
+/**
+ * Given an object and a value, find the first property with matching value and returns name of that property
+ * Useful for working with ENUM-like objects
+ * @param {Object<T>} object
+ * @param {T} value
+ * @returns {string|undefined} name of the property, or undefined if property not found
+ */
+function objectKeyByValue(object, value) {
+    for (let i in object) {
+        if (object[i] === value) {
+            return i;
+        }
+    }
+
+    return undefined;
+}
+
 /**
  *
  * @enum {number}
@@ -71663,6 +71680,10 @@ class Edge {
         return [this.first, this.second];
     }
 
+    toString() {
+        return `Edge:{ first=${this.first}, second=${this.second}, direction=${objectKeyByValue(EdgeDirectionType, this.direction)} }`
+    }
+
 }
 
 /**
@@ -78580,23 +78601,6 @@ class ShadedGeometrySystem extends System {
     }
 }
 
-/**
- * Given an object and a value, find the first property with matching value and returns name of that property
- * Useful for working with ENUM-like objects
- * @param {Object<T>} object
- * @param {T} value
- * @returns {string|undefined} name of the property, or undefined if property not found
- */
-function objectKeyByValue(object, value) {
-    for (let i in object) {
-        if (object[i] === value) {
-            return i;
-        }
-    }
-
-    return undefined;
-}
-
 /**
  *
  * @enum {string}
@@ -84592,7 +84596,7 @@ class ViewStack extends View {
  * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
-class FastBinaryHeap {
+class BinaryHeap {
     /**
      * @private
      * @type {T[]}
@@ -84863,7 +84867,7 @@ class FastBinaryHeap {
  * @readonly
  * @type {boolean}
  */
-FastBinaryHeap.prototype.isFastBinaryHeap = true;
+BinaryHeap.prototype.isBinaryHeap = true;
 
 /**
  * Decorator that wraps another map and lets you observe mutations
@@ -86053,7 +86057,7 @@ let Response$1 = class Response {
 };
 
 /**
- * Used by the priority queue, so the priority is inverted as the FastBinaryHeap returns elements in ascending score order (from lowest)
+ * Used by the priority queue, so the priority is inverted as the BinaryHeap returns elements in ascending score order (from lowest)
  * @param {PendingAsset} pending_asset
  * @returns {number}
  */
@@ -86088,7 +86092,7 @@ class AssetManager {
      * @type {BinaryHeap<PendingAsset>}
      * @private
      */
-    #pending_asset_wait_queue = new FastBinaryHeap(get_pending_asset_priority_score);
+    #pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
     /**
      * Assets currently being processed by #loaders
      * @type {Set<PendingAsset>}
@@ -91420,38 +91424,6 @@ class KeyboardDevice {
     }
 }
 
-/**
- * Event names for DOM {@link EventTarget} related to mouse.
- * useful for .addEventListener and .removeEventListener
- * @readonly
- * @enum {string}
- */
-const MouseEvents = {
-    Down: "mousedown",
-    Up: "mouseup",
-    Move: "mousemove",
-    Enter: "mouseenter",
-    Leave: "mouseleave",
-    Out: "mouseout",
-    Over: "mouseover",
-    Wheel: "wheel",
-    Click: "click",
-    DoubleClick: "dblclick"
-};
-
-/**
- * Event names for DOM {@link EventTarget} related to touch.
- * useful for .addEventListener and .removeEventListener
- * @readonly
- * @enum {string}
- */
-const TouchEvents = {
-    Start: "touchstart",
-    End: "touchend",
-    Move: "touchmove",
-    Cancel: "touchcancel",
-};
-
 /**
  *
  * @param {TouchEvent|MouseEvent} event
@@ -91489,6 +91461,38 @@ function eventToSourceIdentifier(event) {
         ;
 }
 
+/**
+ * Event names for DOM {@link EventTarget} related to mouse.
+ * useful for .addEventListener and .removeEventListener
+ * @readonly
+ * @enum {string}
+ */
+const MouseEvents = {
+    Down: "mousedown",
+    Up: "mouseup",
+    Move: "mousemove",
+    Enter: "mouseenter",
+    Leave: "mouseleave",
+    Out: "mouseout",
+    Over: "mouseover",
+    Wheel: "wheel",
+    Click: "click",
+    DoubleClick: "dblclick"
+};
+
+/**
+ * Event names for DOM {@link EventTarget} related to touch.
+ * useful for .addEventListener and .removeEventListener
+ * @readonly
+ * @enum {string}
+ */
+const TouchEvents = {
+    Start: "touchstart",
+    End: "touchend",
+    Move: "touchmove",
+    Cancel: "touchcancel",
+};
+
 class LocationalInteractionMetadata {
     timestamp = performance.now()
     position = new Vector2()
@@ -108162,7 +108166,7 @@ class MaxRectanglesPacker {
             return -Math.min(box.getWidth(), box.getHeight());
         }
 
-        const heap = new FastBinaryHeap(scoreBoxByMinSide);
+        const heap = new BinaryHeap(scoreBoxByMinSide);
 
         for (let i = 0; i < numBoxes; i++) {
             heap.push(i);

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.109.25",
+  "version": "2.109.26",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/heap/{FastBinaryHeap.d.ts → BinaryHeap.d.ts}

@@ -1,10 +1,10 @@
-export default FastBinaryHeap;
+export default BinaryHeap;
 /**
  * Min-Heap implementation with a score function.
  * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
-declare class FastBinaryHeap<T> {
+declare class BinaryHeap<T> {
     /**
      * @template T
      * @param {function(el:T):number} scoreFunction
@@ -93,6 +93,6 @@ declare class FastBinaryHeap<T> {
      * @readonly
      * @type {boolean}
      */
-    readonly isFastBinaryHeap: boolean;
+    readonly isBinaryHeap: boolean;
 }
-//# sourceMappingURL=FastBinaryHeap.d.ts.map
+//# sourceMappingURL=BinaryHeap.d.ts.map

package/src/core/collection/heap/BinaryHeap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.js"],"names":[],"mappings":";AAEA;;;;GAIG;AACH;IAaI;;;;OAIG;IACH,gCAQC;IAzBD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IASP;;;OAGG;IACH,8BAFuB,MAAM,CAEK;IAItC;;;OAGG;IACH,iBA8BC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}

package/src/core/collection/heap/{FastBinaryHeap.js → BinaryHeap.js}

@@ -5,7 +5,7 @@ import { assert } from "../../assert.js";
  * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
-class FastBinaryHeap {
+class BinaryHeap {
     /**
      * @private
      * @type {T[]}
@@ -278,6 +278,6 @@ class FastBinaryHeap {
  * @readonly
  * @type {boolean}
  */
-FastBinaryHeap.prototype.isFastBinaryHeap = true;
+BinaryHeap.prototype.isBinaryHeap = true;
 
-export default FastBinaryHeap;
+export default BinaryHeap;

package/src/core/collection/heap/BinaryHeap.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BinaryHeap.spec.d.ts.map

package/src/core/collection/heap/BinaryHeap.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryHeap.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/BinaryHeap.spec.js"],"names":[],"mappings":""}

package/src/core/collection/heap/{FastBinaryHeap.spec.js → BinaryHeap.spec.js}

@@ -2,20 +2,20 @@ import { passThrough } from "../../function/passThrough.js";
 import { returnZero } from "../../function/returnZero.js";
 import { randomIntegerBetween } from "../../math/random/randomIntegerBetween.js";
 import { seededRandom } from "../../math/random/seededRandom.js";
-import FastBinaryHeap from "./FastBinaryHeap.js";
+import BinaryHeap from "./BinaryHeap.js";
 
 test("constructor doesn't throw", () => {
-    new FastBinaryHeap(returnZero);
+    new BinaryHeap(returnZero);
 });
 
 test("empty heap has size 0", () => {
-    const h = new FastBinaryHeap(returnZero);
+    const h = new BinaryHeap(returnZero);
 
     expect(h.size()).toBe(0);
 });
 
 test('clear empty', () => {
-    const h = new FastBinaryHeap(returnZero);
+    const h = new BinaryHeap(returnZero);
 
     h.clear();
 
@@ -24,7 +24,7 @@ test('clear empty', () => {
 });
 
 test('clear heap with 1 element', () => {
-    const h = new FastBinaryHeap(returnZero);
+    const h = new BinaryHeap(returnZero);
 
     h.push(1);
 
@@ -35,7 +35,7 @@ test('clear heap with 1 element', () => {
 });
 
 test("isEmpty", () => {
-    const h = new FastBinaryHeap(returnZero);
+    const h = new BinaryHeap(returnZero);
 
     expect(h.isEmpty()).toBe(true);
 
@@ -49,7 +49,7 @@ test("isEmpty", () => {
 });
 
 test("push followed by a pop", () => {
-    const h = new FastBinaryHeap(returnZero);
+    const h = new BinaryHeap(returnZero);
 
     h.push(7);
 
@@ -63,7 +63,7 @@ test("push followed by a pop", () => {
 });
 
 test("contains method", () => {
-    const h = new FastBinaryHeap(returnZero);
+    const h = new BinaryHeap(returnZero);
 
     expect(h.contains(7)).toBe(false);
 
@@ -82,7 +82,7 @@ test("contains method", () => {
 });
 
 test("correct sorting of 4 numbers", () => {
-    const h = new FastBinaryHeap(passThrough);
+    const h = new BinaryHeap(passThrough);
 
     const input = [2, 7, 1, 5];
 
@@ -100,7 +100,7 @@ test("correct sorting of 4 numbers", () => {
 });
 
 test.skip("performance 100k random fill -> drain", () => {
-    const h = new FastBinaryHeap(passThrough);
+    const h = new BinaryHeap(passThrough);
 
     const random = seededRandom(42);
 

package/src/core/collection/heap/Uint32Heap.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Uint32Heap.spec.d.ts.map

package/src/core/collection/heap/Uint32Heap.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint32Heap.spec.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/Uint32Heap.spec.js"],"names":[],"mappings":""}

package/src/core/geom/3d/topology/simplify/simplifyTopoMesh.d.ts

@@ -22,4 +22,5 @@ export function collapse_edges(number_faces_to_remove: number, heap: BinaryHeap<
  */
 export function simplifyTopoMesh(mesh: TopoMesh, num_faces_to_remove: number, restricted_vertices?: Set<number>): void;
 import { EdgeCollapseCandidate } from "./EdgeCollapseCandidate.js";
+import BinaryHeap from "../../../../collection/heap/BinaryHeap.js";
 //# sourceMappingURL=simplifyTopoMesh.d.ts.map

package/src/core/geom/3d/topology/simplify/simplifyTopoMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplifyTopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/simplifyTopoMesh.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,wCAFW,qBAAqB,UAI/B;AAGD;;;;;;;GAOG;AACH,uDAPW,MAAM,iFAGN,cAAc,qBAAqB,CAAC,qBACpC,IAAI,MAAM,aAAa,uBACvB,IAAI,MAAM,CAAC,QAyKrB;AAED;;;;;;;GAOG;AACH,sEAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QAwDrB;sCAnQqC,4BAA4B"}
+{"version":3,"file":"simplifyTopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/simplifyTopoMesh.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,wCAFW,qBAAqB,UAI/B;AAGD;;;;;;;GAOG;AACH,uDAPW,MAAM,QACN,WAAW,qBAAqB,CAAC,wCAEjC,cAAc,qBAAqB,CAAC,qBACpC,IAAI,MAAM,aAAa,uBACvB,IAAI,MAAM,CAAC,QAyKrB;AAED;;;;;;;GAOG;AACH,sEAHW,MAAM,wBACN,IAAI,MAAM,CAAC,QAwDrB;sCAhQqC,4BAA4B;uBAJ3C,2CAA2C"}

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

@@ -1,10 +1,10 @@
-import FastBinaryHeap from "../../../../collection/heap/FastBinaryHeap.js";
 import { array_copy_unique } from "../../../../collection/array/array_copy_unique.js";
+import BinaryHeap from "../../../../collection/heap/BinaryHeap.js";
+import { build_edge_collapse_candidates } from "./build_edge_collapse_candidates.js";
+import { collapse_all_degenerate_edges } from "./collapse_all_degenerate_edges.js";
+import { collapse_degenerate_edge } from "./collapse_degenerate_edge.js";
 import { EdgeCollapseCandidate } from "./EdgeCollapseCandidate.js";
 import { build_vertex_quadratics } from "./quadratic/build_vertex_quadratics.js";
-import { collapse_degenerate_edge } from "./collapse_degenerate_edge.js";
-import { collapse_all_degenerate_edges } from "./collapse_all_degenerate_edges.js";
-import { build_edge_collapse_candidates } from "./build_edge_collapse_candidates.js";
 
 
 const scratch_array_1 = [];
@@ -220,7 +220,7 @@ export function simplifyTopoMesh(mesh, num_faces_to_remove, restricted_vertices
      *
      * @type {BinaryHeap<EdgeCollapseCandidate>}
      */
-    const open_set = new FastBinaryHeap(extract_edge_cost);
+    const open_set = new BinaryHeap(extract_edge_cost);
 
     /**
      *

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeTriangleRayIntersectionBarycentricEdge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sEAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACL,OAAO,CAgElB"}
+{"version":3,"file":"computeTriangleRayIntersectionBarycentricEdge.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sEAlBW,MAAM,EAAE,YACR,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,GACL,OAAO,CAsElB"}

package/src/core/geom/3d/triangle/computeTriangleRayIntersectionBarycentricEdge.js

@@ -43,20 +43,27 @@ export function computeTriangleRayIntersectionBarycentricEdge(
     //if determinant is near zero, ray lies in plane of triangle
     const det = v3_dot(edge1_x, edge1_y, edge1_z, pvec_x, pvec_y, pvec_z);
 
+    if(det === 0){
+        // ray is parallel to the plane of the triange, no intersection possible
+        return false;
+    }
+
     if (det <= 0) {
         // back-face culling
-        return false;
+        // return false;
     }
 
+    const inv_det = 1 / det;
+
     // calculate distance from vert0 to ray origin (not really, but okay)
     const tvec_x = origin_x - ax;
     const tvec_y = origin_y - ay;
     const tvec_z = origin_z - az;
 
     // calculate u
-    const u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z);
+    const u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z)*inv_det;
 
-    if (u < 0 || u > det) {
+    if (u < 0 || u > 1) {
         // outside of bounds of the triangle
         return false;
     }
@@ -68,22 +75,21 @@ export function computeTriangleRayIntersectionBarycentricEdge(
     const qvec_z = tvec_x * edge1_y - tvec_y * edge1_x;
 
     // calculate V parameter
-    const v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z);
+    const v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z)*inv_det;
 
-    if (v < 0 || u + v > det) {
+    if (v < 0 || u + v > 1) {
         // out of bounds
         return false;
     }
 
 
-    const inv_det = 1 / det;
 
     // calculate t, scale parameter, ray intersects triangle
     const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
 
     result[0] = t;
-    result[1] = u * inv_det;
-    result[2] = v * inv_det;
+    result[1] = u ;
+    result[2] = v ;
 
     return true;
 }

package/src/core/geom/packing/max-rect/MaxRectanglesPacker.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import FastBinaryHeap from "../../../collection/heap/FastBinaryHeap.js";
+import BinaryHeap from "../../../collection/heap/BinaryHeap.js";
 import AABB2 from "../../2d/aabb/AABB2.js";
 import { QuadTreeDatum } from "../../2d/quad-tree/QuadTreeDatum.js";
 import { QuadTreeNode } from "../../2d/quad-tree/QuadTreeNode.js";
@@ -136,7 +136,7 @@ export class MaxRectanglesPacker {
             return -Math.min(box.getWidth(), box.getHeight());
         }
 
-        const heap = new FastBinaryHeap(scoreBoxByMinSide);
+        const heap = new BinaryHeap(scoreBoxByMinSide);
 
         for (let i = 0; i < numBoxes; i++) {
             heap.push(i);

package/src/core/graph/Edge.d.ts

@@ -75,6 +75,7 @@ export class Edge<N> {
      * @returns {N[]}
      */
     get nodes(): N[];
+    toString(): string;
     /**
      *
      * @type {boolean}

package/src/core/graph/Edge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Edge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/Edge.js"],"names":[],"mappings":"gCAIU,MAAM;;;;;;AAQhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,4BAmBC;IAfG;;;OAGG;IACH,WAAc;IACd;;;OAGG;IACH,YAAe;IAEf;;OAEG;IACH,WAFU,iBAAiB,CAEkB;IAGjD;;;;OAIG;IACH,eAHW,CAAC,GACA,OAAO,CAIlB;IAED;;;;;OAKG;IACH,2BAJW,CAAC,UACD,CAAC,GACC,OAAO,CASnB;IAED;;;;OAIG;IACH,YAHW,CAAC,GACC,CAAC,CAIb;IAED;;;OAGG;IACH,sBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,wBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,iBAEC;IAIL;;;OAGG;IACH,QAFU,OAAO,CAEI;CANpB"}
+{"version":3,"file":"Edge.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/Edge.js"],"names":[],"mappings":"gCAKU,MAAM;;;;;;AAQhB;;GAEG;AACH;IACI;;;;;OAKG;IACH,4BAmBC;IAfG;;;OAGG;IACH,WAAc;IACd;;;OAGG;IACH,YAAe;IAEf;;OAEG;IACH,WAFU,iBAAiB,CAEkB;IAGjD;;;;OAIG;IACH,eAHW,CAAC,GACA,OAAO,CAIlB;IAED;;;;;OAKG;IACH,2BAJW,CAAC,UACD,CAAC,GACC,OAAO,CASnB;IAED;;;;OAIG;IACH,YAHW,CAAC,GACC,CAAC,CAIb;IAED;;;OAGG;IACH,sBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,uBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,wBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,iBAEC;IAED,mBAEC;IAIL;;;OAGG;IACH,QAFU,OAAO,CAEI;CANpB"}

package/src/core/graph/Edge.js

@@ -1,4 +1,5 @@
 import { assert } from "../assert.js";
+import { objectKeyByValue } from "../model/object/objectKeyByValue.js";
 
 /**
  *
@@ -118,6 +119,10 @@ export class Edge {
         return [this.first, this.second];
     }
 
+    toString() {
+        return `Edge:{ first=${this.first}, second=${this.second}, direction=${objectKeyByValue(EdgeDirectionType, this.direction)} }`
+    }
+
 }
 
 /**

package/src/core/graph/graph_compute_distance_matrix.js

@@ -1,6 +1,6 @@
 import { BitSet } from "../binary/BitSet.js";
 import { BinaryDataType } from "../binary/type/BinaryDataType.js";
-import FastBinaryHeap from "../collection/heap/FastBinaryHeap.js";
+import BinaryHeap from "../collection/heap/BinaryHeap.js";
 import { SquareMatrix } from "./SquareMatrix.js";
 
 /**
@@ -40,7 +40,7 @@ export function graph_compute_distance_matrix(graph, node_array, targets, node_i
         // distance to self is always 0
         m_distances.setCellValue(source_node, source_node, 0);
 
-        const heap = new FastBinaryHeap(score);
+        const heap = new BinaryHeap(score);
         heap.push(source_node);
 
         while (!heap.isEmpty()) {

package/src/core/graph/metis/cluster_mesh_metis.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {Uint32Array} result
+ * @param {TopoMesh} mesh
+ * @param {number} patch_size
+ * @returns {number}
+ */
+export function cluster_mesh_metis(result: Uint32Array, mesh: TopoMesh, patch_size: number): number;
+//# sourceMappingURL=cluster_mesh_metis.d.ts.map

package/src/core/graph/metis/cluster_mesh_metis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cluster_mesh_metis.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/metis/cluster_mesh_metis.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,2CALW,WAAW,8BAEX,MAAM,GACJ,MAAM,CAqBlB"}

package/src/core/graph/metis/cluster_mesh_metis.js

@@ -0,0 +1,31 @@
+import { mesh_to_metis_graph } from "./mesh_to_metis_graph.js";
+import { metis_cluster_bs } from "./metis_cluster_bs.js";
+
+/**
+ *
+ * @param {Uint32Array} result
+ * @param {TopoMesh} mesh
+ * @param {number} patch_size
+ * @returns {number}
+ */
+export async function cluster_mesh_metis(result, mesh, patch_size) {
+
+    const face_set = mesh.getFaces();
+    const input_face_count = face_set.size;
+
+    const face_array = Array.from(face_set);
+
+    const metis_graph = mesh_to_metis_graph(face_array);
+
+    const partition_count = await metis_cluster_bs(
+        result,
+        input_face_count,
+        metis_graph.edge_addresses,
+        metis_graph.adjacency,
+        metis_graph.edge_weights,
+        patch_size
+    );
+
+    return partition_count;
+}
+

package/src/core/graph/metis/mesh_to_metis_graph.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {TopoTriangle[]} face_array
+ * @returns {{edge_addresses:Uint32Array, adjacency:Uint32Array, edge_weights:Uint32Array}}
+ */
+export function mesh_to_metis_graph(face_array: TopoTriangle[]): {
+    edge_addresses: Uint32Array;
+    adjacency: Uint32Array;
+    edge_weights: Uint32Array;
+};
+//# sourceMappingURL=mesh_to_metis_graph.d.ts.map

package/src/core/graph/metis/mesh_to_metis_graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_to_metis_graph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/metis/mesh_to_metis_graph.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,gDAHW,cAAc;oBACI,WAAW;eAAY,WAAW;kBAAe,WAAW;EA2DxF"}

package/src/core/graph/metis/mesh_to_metis_graph.js

@@ -0,0 +1,64 @@
+import { assert } from "../../assert.js";
+
+/**
+ * @param {TopoTriangle[]} face_array
+ * @returns {{edge_addresses:Uint32Array, adjacency:Uint32Array, edge_weights:Uint32Array}}
+ */
+export function mesh_to_metis_graph(face_array) {
+    assert.isArray(face_array, 'face_array');
+
+    const input_face_count = face_array.length;
+
+    const edge_addresses = new Uint32Array(input_face_count + 1);
+    const adjacency = [];
+    const edge_weights = [];
+
+    const face_index_map = new Map();
+
+    for (let i = 0; i < input_face_count; i++) {
+        const face = face_array[i];
+        face_index_map.set(face, i);
+    }
+
+    let offset = 0;
+    edge_addresses[0] = 0;
+    for (let i = 0; i < input_face_count; i++) {
+        const face = face_array[i];
+
+        const edges = face.edges;
+
+        const edge_count = edges.length;
+        for (let j = 0; j < edge_count; j++) {
+            const topoEdge = edges[j];
+
+            const edge_faces = topoEdge.faces;
+
+            const edge_face_count = edge_faces.length;
+            for (let k = 0; k < edge_face_count; k++) {
+                const neighbour = edge_faces[k];
+
+                if (neighbour === face) {
+                    //skip self
+                    continue;
+                }
+
+                adjacency[offset] = face_index_map.get(neighbour);
+                edge_weights[offset] = 1;
+
+                offset++;
+            }
+        }
+
+        edge_addresses[i + 1] = offset;
+    }
+
+    const adjecency_uint32 = new Uint32Array(adjacency);
+    const edge_weights_uint32 = new Uint32Array(edge_weights);
+
+
+    return {
+        edge_addresses: edge_addresses,
+        adjacency: adjecency_uint32,
+        edge_weights: edge_weights_uint32
+    };
+}

package/src/core/graph/metis/metis_cluster_bs.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ * @param {Uint32Array} result
+ * @param {number} node_count
+ * @param {Uint32Array} edge_addresses
+ * @param {Uint32Array} adjacency_uint32
+ * @param {Uint32Array} edge_weights_uint32
+ * @param {number} patch_size
+ * @returns {Promise<number>}
+ */
+export function metis_cluster_bs(result: Uint32Array, node_count: number, edge_addresses: Uint32Array, adjacency_uint32: Uint32Array, edge_weights_uint32: Uint32Array, patch_size: number): Promise<number>;
+//# sourceMappingURL=metis_cluster_bs.d.ts.map

package/src/core/graph/metis/metis_cluster_bs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metis_cluster_bs.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/metis/metis_cluster_bs.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,yCARW,WAAW,cACX,MAAM,kBACN,WAAW,oBACX,WAAW,uBACX,WAAW,cACX,MAAM,GACJ,QAAQ,MAAM,CAAC,CA6G3B"}