@woosh/meep-engine 3.55.0 → 3.57.0

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_resolve_t_junctions.js

@@ -1,238 +1,227 @@
-import { BVH } from "../../../../../../bvh2/bvh3/BVH.js";
-import {
-    bvh_query_user_data_intersects_capsule
-} from "../../../../../../bvh2/bvh3/query/bvh_query_user_data_intersects_capsule.js";
-import { NULL_POINTER } from "../BinaryTopology.js";
-import { bt_edge_split } from "./edge/bt_edge_split.js";
-import { bt_vertex_replace } from "./vertex/bt_vertex_replace.js";
-
-const _a = new Float32Array(3);
-const _b = new Float32Array(3);
-const _p = new Float32Array(3);
-const _capsule = new Float32Array(7);
-
-/**
- * How many faces already use an edge joining `a` and `b`, counting 0 when nothing joins them.
- *
- * Sums across EVERY edge between the two, not just the first: a split makes edges that duplicate ones
- * the mesh already has, and they stay side by side until the caller's fuse pass merges them. Stopping
- * at the first would undercount exactly the pairs that are about to be over-filled.
- *
- * @param {BinaryTopology} mesh
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-function edge_face_count(mesh, a, b) {
-    const first_edge = mesh.vertex_read_edge(a);
-
-    if (first_edge === NULL_POINTER) {
-        return 0;
-    }
-
-    let count = 0;
-    let edge = first_edge;
-
-    do {
-        const edge_v1 = mesh.edge_read_vertex1(edge);
-        const edge_v2 = mesh.edge_read_vertex2(edge);
-
-        if (edge_v1 === b || edge_v2 === b) {
-            const first_loop = mesh.edge_read_loop(edge);
-
-            if (first_loop !== NULL_POINTER) {
-                let loop = first_loop;
-
-                do {
-                    count++;
-                    loop = mesh.loop_read_radial_next(loop);
-                } while (loop !== first_loop);
-            }
-        }
-
-        edge = (edge_v1 === a)
-            ? mesh.edge_read_v1_disk_next(edge)
-            : mesh.edge_read_v2_disk_next(edge);
-    } while (edge !== first_edge);
-
-    return count;
-}
-
-/**
- * Resolve T-junctions: where a vertex lies on the interior of a boundary edge (rather than at one of
- * its endpoints), split that edge at the vertex so the two pieces can later be welded/fused into a
- * shared edge.
- *
- * This is required for meshes assembled from independently-authored faces of differing sizes - e.g. an
- * L-shaped or ring floor built from rectangles, where one rectangle's corner falls in the middle of a
- * neighbour's edge. Without it those faces touch only at a single vertex, so edge-based neighbour
- * queries (island detection, erosion, path-finding) treat them as DISCONNECTED.
- *
- * Call AFTER an initial vertex-merge/edge-fuse, then FUSE again: each split lands directly on the
- * T-junction vertex, so nothing is left to weld, but the halves it cuts duplicate the edges the other
- * side already owns and fusing those is what finally joins the faces. (Splitting does leave the spare
- * vertex bt_edge_split mints unlinked, for a cleanup/compact pass to reclaim, exactly as a weld does.)
- * The mesh must be triangulated - {@link bt_edge_split}, which does the cutting, splits a triangle in
- * two.
- *
- * A vertex on an edge is NOT split when doing so would leave the mesh non-manifold - see the rules at
- * the candidate scan. That is a deliberate limit rather than a missed case: those vertices are already
- * as connected as the split could make them, and the alternative is an edge with three or more faces,
- * which nothing downstream can walk or repair. Near-degenerate slivers out of a clipper hit this.
- *
- * A BVH over the vertices replaces the naive all-vertices-per-edge scan: for each boundary edge we
- * query only the vertices within the tolerance of the edge segment (a capsule), which IS the on-edge
- * region, so no separate per-candidate distance test is needed. The BVH is built ONCE -- splitting only
- * ever cuts an edge at a vertex that is already in it, so no position is ever missing from the original
- * leaf set and the tree never needs rebuilding as edges split.
- *
- * @param {BinaryTopology} mesh
- * @param {number} [tolerance] max distance from a vertex to an edge for it to count as "on" the edge
- * @returns {number} number of splits performed
- */
-export function bt_mesh_resolve_t_junctions(mesh, tolerance = 1e-4) {
-    const tol_sq = tolerance * tolerance;
-
-    // --- Build a vertex BVH over the original vertices (point leaves; user data = vertex id) ---
-    const vertices = mesh.vertices;
-    const vertex_count = vertices.size;
-
-    const bvh = new BVH();
-
-    let leaf_count = 0;
-    for (let v = 0; v < vertex_count; v++) {
-        if (!vertices.is_allocated(v)) continue;
-
-        // Skip vertices that no edge uses. bt_merge_vertices_by_distance - which callers run right
-        // before this - leaves every vertex it merged away allocated but unlinked, sitting EXACTLY on
-        // top of the survivor it was merged into, for a later cleanup/compact pass to reclaim. Such a
-        // vertex joins no face, so it can never be a T-junction. It is also indistinguishable by
-        // POSITION from the real vertex underneath it while carrying a different id, so as a candidate
-        // it slips past every identity-based exclusion below (this edge's own endpoints, its face's own
-        // corners) and splits the edge at a point one of those already occupies.
-        if (mesh.vertex_read_edge(v) === NULL_POINTER) continue;
-
-        mesh.vertex_read_coordinate(_p, 0, v);
-
-        const node = bvh.allocate_node();
-        bvh.node_set_user_data(node, v);
-        bvh.node_set_aabb_primitive(node, _p[0], _p[1], _p[2], _p[0], _p[1], _p[2]);
-        bvh.insert_leaf(node);
-
-        leaf_count++;
-    }
-
-    if (leaf_count === 0) {
-        return 0;
-    }
-
-    // The query writes one vertex id per overlapping leaf; it can never exceed the leaf count.
-    const candidates = new Uint32Array(leaf_count);
-
-    let total = 0;
-    let rounds = 0;
-    let changed = true;
-
-    while (changed && rounds < 256) {
-        changed = false;
-        rounds++;
-
-        const edge_count = mesh.edges.size;
-
-        for (let e = 0; e < edge_count; e++) {
-            if (!mesh.edges.is_allocated(e)) continue;
-
-            // only boundary edges (a single radial loop) can carry a T-junction
-            const l = mesh.edge_read_loop(e);
-            if (l === NULL_POINTER) continue;
-            if (mesh.loop_read_radial_next(l) !== l) continue;
-
-            const v1 = mesh.edge_read_vertex1(e);
-            const v2 = mesh.edge_read_vertex2(e);
-
-            mesh.vertex_read_coordinate(_a, 0, v1);
-            mesh.vertex_read_coordinate(_b, 0, v2);
-
-            const abx = _b[0] - _a[0], aby = _b[1] - _a[1], abz = _b[2] - _a[2];
-            const ab_sq = abx * abx + aby * aby + abz * abz;
-            if (ab_sq <= tol_sq) continue;
-
-            const t_margin = tolerance / Math.sqrt(ab_sq);
-
-            // candidate vertices: those within `tolerance` of the edge segment (a capsule)
-            _capsule[0] = _a[0]; _capsule[1] = _a[1]; _capsule[2] = _a[2];
-            _capsule[3] = _b[0]; _capsule[4] = _b[1]; _capsule[5] = _b[2];
-            _capsule[6] = tolerance;
-
-            const candidate_count = bvh_query_user_data_intersects_capsule(candidates, 0, bvh, _capsule);
-
-            // the corner of this edge's single face that lies opposite the edge
-            let opposite_vertex = NULL_POINTER;
-            {
-                let face_loop = l;
-                do {
-                    const face_vertex = mesh.loop_read_vertex(face_loop);
-
-                    if (face_vertex !== v1 && face_vertex !== v2) {
-                        opposite_vertex = face_vertex;
-                    }
-
-                    face_loop = mesh.loop_read_next(face_loop);
-                } while (face_loop !== l);
-            }
-
-            let split_t = -1;
-            let split_v = -1;
-
-            for (let i = 0; i < candidate_count; i++) {
-                const v = candidates[i];
-
-                // Candidates are original vertices, which are never removed during resolution (splits
-                // only add), so they are always allocated -- no is_allocated check needed.
-                mesh.vertex_read_coordinate(_p, 0, v);
-
-                // the capsule query already guarantees distance-to-segment <= tolerance; all that is
-                // left is to exclude the segment's endpoints (its hemispherical end caps)
-                const t = ((_p[0] - _a[0]) * abx + (_p[1] - _a[1]) * aby + (_p[2] - _a[2]) * abz) / ab_sq;
-                if (t <= t_margin || t >= 1 - t_margin) continue;
-
-                // Splitting replaces the face with (v1, v, opposite) and (v, v2, opposite), so it puts
-                // one new face on each of (v1, v) and (v, v2), and two on the cross edge (v, opposite).
-                // The caller then fuses each of those onto any existing edge with the same endpoints,
-                // which is the whole point for the first two - the T-junction's other side already owns
-                // them as boundary edges, and fusing is what finally joins the faces. It only works
-                // while the result stays 2-manifold: an edge that already carries as many faces as the
-                // split would push it past ends up with three or four, a pinch whose boundary no longer
-                // walks as a cycle and which no later pass repairs.
-                //
-                // Clipping produces the geometry that trips each case: slivers whose apex sits within
-                // `tolerance` of their own base edge (v is then a corner of this very face, so the
-                // "halves" land on edges it already has), and slivers spanning the same two corners as
-                // the face being split (the cross edge duplicates one of theirs).
-                if (edge_face_count(mesh, v, opposite_vertex) > 0) continue;
-                if (edge_face_count(mesh, v1, v) > 1) continue;
-                if (edge_face_count(mesh, v, v2) > 1) continue;
-
-                split_t = t;
-                split_v = v;
-                break;
-            }
-
-            if (split_t >= 0) {
-                // Cut the edge, then fold the vertex that made onto the T-junction vertex it was cut
-                // for. bt_edge_split has to mint one; leaving it in place until the caller's weld
-                // reunites the two would put a SECOND id on that exact position for the rest of this
-                // pass. The manifold rules above reason about vertex ids, so they would read the
-                // topology around the newcomer as empty and keep splitting onto a position already
-                // fully occupied - which is how an edge ends up with four faces. Folding it in at once
-                // keeps one id per position, so what those rules see is what the weld will produce.
-                bt_vertex_replace(mesh, bt_edge_split(mesh, e, split_t), split_v);
-
-                total++;
-                changed = true;
-            }
-        }
-    }
-
-    return total;
-}
+import { BVH } from "../../../../../../bvh2/bvh3/BVH.js";
+import {
+    bvh_query_user_data_intersects_capsule
+} from "../../../../../../bvh2/bvh3/query/bvh_query_user_data_intersects_capsule.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_face_third_vertex } from "../query/bt_face_third_vertex.js";
+import { bt_edge_split } from "./edge/bt_edge_split.js";
+import { bt_vertex_replace } from "./vertex/bt_vertex_replace.js";
+
+const _a = new Float32Array(3);
+const _b = new Float32Array(3);
+const _p = new Float32Array(3);
+const _capsule = new Float32Array(7);
+
+/**
+ * How many faces already use an edge joining `a` and `b`, counting 0 when nothing joins them.
+ *
+ * Sums across EVERY edge between the two, not just the first: a split makes edges that duplicate ones
+ * the mesh already has, and they stay side by side until the caller's fuse pass merges them. Stopping
+ * at the first would undercount exactly the pairs that are about to be over-filled.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function edge_face_count(mesh, a, b) {
+    const first_edge = mesh.vertex_read_edge(a);
+
+    if (first_edge === NULL_POINTER) {
+        return 0;
+    }
+
+    let count = 0;
+    let edge = first_edge;
+
+    do {
+        const edge_v1 = mesh.edge_read_vertex1(edge);
+        const edge_v2 = mesh.edge_read_vertex2(edge);
+
+        if (edge_v1 === b || edge_v2 === b) {
+            const first_loop = mesh.edge_read_loop(edge);
+
+            if (first_loop !== NULL_POINTER) {
+                let loop = first_loop;
+
+                do {
+                    count++;
+                    loop = mesh.loop_read_radial_next(loop);
+                } while (loop !== first_loop);
+            }
+        }
+
+        edge = (edge_v1 === a)
+            ? mesh.edge_read_v1_disk_next(edge)
+            : mesh.edge_read_v2_disk_next(edge);
+    } while (edge !== first_edge);
+
+    return count;
+}
+
+/**
+ * Resolve T-junctions: where a vertex lies on the interior of a boundary edge (rather than at one of
+ * its endpoints), split that edge at the vertex so the two pieces can later be welded/fused into a
+ * shared edge.
+ *
+ * This is required for meshes assembled from independently-authored faces of differing sizes - e.g. an
+ * L-shaped or ring floor built from rectangles, where one rectangle's corner falls in the middle of a
+ * neighbour's edge. Without it those faces touch only at a single vertex, so edge-based neighbour
+ * queries (island detection, erosion, path-finding) treat them as DISCONNECTED.
+ *
+ * Call AFTER an initial vertex-merge/edge-fuse, then FUSE again: each split lands directly on the
+ * T-junction vertex, so nothing is left to weld, but the halves it cuts duplicate the edges the other
+ * side already owns and fusing those is what finally joins the faces. (Splitting does leave the spare
+ * vertex bt_edge_split mints unlinked, for a cleanup/compact pass to reclaim, exactly as a weld does.)
+ * The mesh must be triangulated - {@link bt_edge_split}, which does the cutting, splits a triangle in
+ * two.
+ *
+ * A vertex on an edge is NOT split when doing so would leave the mesh non-manifold - see the rules at
+ * the candidate scan. That is a deliberate limit rather than a missed case: those vertices are already
+ * as connected as the split could make them, and the alternative is an edge with three or more faces,
+ * which nothing downstream can walk or repair. Near-degenerate slivers out of a clipper hit this.
+ *
+ * A BVH over the vertices replaces the naive all-vertices-per-edge scan: for each boundary edge we
+ * query only the vertices within the tolerance of the edge segment (a capsule), which IS the on-edge
+ * region, so no separate per-candidate distance test is needed. The BVH is built ONCE -- splitting only
+ * ever cuts an edge at a vertex that is already in it, so no position is ever missing from the original
+ * leaf set and the tree never needs rebuilding as edges split.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} [tolerance] max distance from a vertex to an edge for it to count as "on" the edge
+ * @returns {number} number of splits performed
+ */
+export function bt_mesh_resolve_t_junctions(mesh, tolerance = 1e-4) {
+    const tol_sq = tolerance * tolerance;
+
+    // --- Build a vertex BVH over the original vertices (point leaves; user data = vertex id) ---
+    const vertices = mesh.vertices;
+    const vertex_count = vertices.size;
+
+    const bvh = new BVH();
+
+    let leaf_count = 0;
+    for (let v = 0; v < vertex_count; v++) {
+        if (!vertices.is_allocated(v)) continue;
+
+        // Skip vertices that no edge uses. bt_merge_vertices_by_distance - which callers run right
+        // before this - leaves every vertex it merged away allocated but unlinked, sitting EXACTLY on
+        // top of the survivor it was merged into, for a later cleanup/compact pass to reclaim. Such a
+        // vertex joins no face, so it can never be a T-junction. It is also indistinguishable by
+        // POSITION from the real vertex underneath it while carrying a different id, so as a candidate
+        // it slips past every identity-based exclusion below (this edge's own endpoints, its face's own
+        // corners) and splits the edge at a point one of those already occupies.
+        if (mesh.vertex_read_edge(v) === NULL_POINTER) continue;
+
+        mesh.vertex_read_coordinate(_p, 0, v);
+
+        const node = bvh.allocate_node();
+        bvh.node_set_user_data(node, v);
+        bvh.node_set_aabb_primitive(node, _p[0], _p[1], _p[2], _p[0], _p[1], _p[2]);
+        bvh.insert_leaf(node);
+
+        leaf_count++;
+    }
+
+    if (leaf_count === 0) {
+        return 0;
+    }
+
+    // The query writes one vertex id per overlapping leaf; it can never exceed the leaf count.
+    const candidates = new Uint32Array(leaf_count);
+
+    let total = 0;
+    let rounds = 0;
+    let changed = true;
+
+    while (changed && rounds < 256) {
+        changed = false;
+        rounds++;
+
+        const edge_count = mesh.edges.size;
+
+        for (let e = 0; e < edge_count; e++) {
+            if (!mesh.edges.is_allocated(e)) continue;
+
+            // only boundary edges (a single radial loop) can carry a T-junction
+            const l = mesh.edge_read_loop(e);
+            if (l === NULL_POINTER) continue;
+            if (mesh.loop_read_radial_next(l) !== l) continue;
+
+            const v1 = mesh.edge_read_vertex1(e);
+            const v2 = mesh.edge_read_vertex2(e);
+
+            mesh.vertex_read_coordinate(_a, 0, v1);
+            mesh.vertex_read_coordinate(_b, 0, v2);
+
+            const abx = _b[0] - _a[0], aby = _b[1] - _a[1], abz = _b[2] - _a[2];
+            const ab_sq = abx * abx + aby * aby + abz * abz;
+            if (ab_sq <= tol_sq) continue;
+
+            const t_margin = tolerance / Math.sqrt(ab_sq);
+
+            // candidate vertices: those within `tolerance` of the edge segment (a capsule)
+            _capsule[0] = _a[0]; _capsule[1] = _a[1]; _capsule[2] = _a[2];
+            _capsule[3] = _b[0]; _capsule[4] = _b[1]; _capsule[5] = _b[2];
+            _capsule[6] = tolerance;
+
+            const candidate_count = bvh_query_user_data_intersects_capsule(candidates, 0, bvh, _capsule);
+
+            // the corner of this edge's single face that lies opposite the edge
+            const opposite_vertex = bt_face_third_vertex(mesh, mesh.loop_read_face(l), e);
+
+            let split_t = -1;
+            let split_v = -1;
+
+            for (let i = 0; i < candidate_count; i++) {
+                const v = candidates[i];
+
+                // Candidates are original vertices, which are never removed during resolution (splits
+                // only add), so they are always allocated -- no is_allocated check needed.
+                mesh.vertex_read_coordinate(_p, 0, v);
+
+                // the capsule query already guarantees distance-to-segment <= tolerance; all that is
+                // left is to exclude the segment's endpoints (its hemispherical end caps)
+                const t = ((_p[0] - _a[0]) * abx + (_p[1] - _a[1]) * aby + (_p[2] - _a[2]) * abz) / ab_sq;
+                if (t <= t_margin || t >= 1 - t_margin) continue;
+
+                // Splitting replaces the face with (v1, v, opposite) and (v, v2, opposite), so it puts
+                // one new face on each of (v1, v) and (v, v2), and two on the cross edge (v, opposite).
+                // The caller then fuses each of those onto any existing edge with the same endpoints,
+                // which is the whole point for the first two - the T-junction's other side already owns
+                // them as boundary edges, and fusing is what finally joins the faces. It only works
+                // while the result stays 2-manifold: an edge that already carries as many faces as the
+                // split would push it past ends up with three or four, a pinch whose boundary no longer
+                // walks as a cycle and which no later pass repairs.
+                //
+                // Clipping produces the geometry that trips each case: slivers whose apex sits within
+                // `tolerance` of their own base edge (v is then a corner of this very face, so the
+                // "halves" land on edges it already has), and slivers spanning the same two corners as
+                // the face being split (the cross edge duplicates one of theirs).
+                if (edge_face_count(mesh, v, opposite_vertex) > 0) continue;
+                if (edge_face_count(mesh, v1, v) > 1) continue;
+                if (edge_face_count(mesh, v, v2) > 1) continue;
+
+                split_t = t;
+                split_v = v;
+                break;
+            }
+
+            if (split_t >= 0) {
+                // Cut the edge, then fold the vertex that made onto the T-junction vertex it was cut
+                // for. bt_edge_split has to mint one; leaving it in place until the caller's weld
+                // reunites the two would put a SECOND id on that exact position for the rest of this
+                // pass. The manifold rules above reason about vertex ids, so they would read the
+                // topology around the newcomer as empty and keep splitting onto a position already
+                // fully occupied - which is how an edge ends up with four faces. Folding it in at once
+                // keeps one id per position, so what those rules see is what the weld will produce.
+                bt_vertex_replace(mesh, bt_edge_split(mesh, e, split_t), split_v);
+
+                total++;
+                changed = true;
+            }
+        }
+    }
+
+    return total;
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AAikCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,0EANW,MAAM,wBACN,IAAI,MAAM,CAAC,oBACX,IAAI,MAAM,CAAC,GACT,MAAM,CAyBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wFArDW,MAAM,uBACN,IAAI,MAAM,CAAC,mBACX,IAAI,MAAM,CAAC,cA4BX,QAAQ,EAAE,eACV;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAC,GAAC,IAAI,WAS9F,aAAW,IAAI,WAKf,YAAY,GAKV,MAAM,CAgPlB;yBA1+CwB,iCAAiC"}
+{"version":3,"file":"bt_mesh_simplify.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js"],"names":[],"mappings":"AAwjCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmGG;AACH,0EANW,MAAM,wBACN,IAAI,MAAM,CAAC,oBACX,IAAI,MAAM,CAAC,GACT,MAAM,CAyBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkEG;AACH,wFArDW,MAAM,uBACN,IAAI,MAAM,CAAC,mBACX,IAAI,MAAM,CAAC,cA4BX,QAAQ,EAAE,eACV;IAAC,MAAM,EAAE,YAAY,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAC,GAAC,IAAI,WAS9F,aAAW,IAAI,WAKf,YAAY,GAKV,MAAM,CAgPlB;yBAh+CwB,iCAAiC"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_simplify.js

@@ -1,4 +1,5 @@
 import { bt_edge_count_faces } from "../query/bt_edge_count_faces.js";
+import { bt_face_read_triangle_coordinates } from "../query/bt_face_read_triangle.js";
 import { assert } from "../../../../../../assert.js";
 import { IndexedFloatMinHeap } from "../../../../../../collection/heap/IndexedFloatMinHeap.js";
 import { Quadric3 } from "../../../../quadric/Quadric3.js";
@@ -32,9 +33,7 @@ const scratch_candidate = new Float32Array(3);
 const scratch_placement = new Float32Array(3);
 const scratch_old_survivor = new Float32Array(3);
 const scratch_old_victim = new Float32Array(3);
-const scratch_fan_a = new Float32Array(3);
-const scratch_fan_b = new Float32Array(3);
-const scratch_fan_c = new Float32Array(3);
+const scratch_fan = new Float32Array(9);
 const scratch_closest = new Float64Array(3);
 
 /**
@@ -161,34 +160,26 @@ function distance_to_vertex_fan(mesh, vertex, point) {
             const face = mesh.loop_read_face(loop);
 
             if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
-                const la = mesh.face_read_loop(face);
-                const lb = mesh.loop_read_next(la);
-                const lc = mesh.loop_read_next(lb);
-
-                if (mesh.loop_read_next(lc) === la) {
-                    mesh.vertex_read_coordinate(scratch_fan_a, 0, mesh.loop_read_vertex(la));
-                    mesh.vertex_read_coordinate(scratch_fan_b, 0, mesh.loop_read_vertex(lb));
-                    mesh.vertex_read_coordinate(scratch_fan_c, 0, mesh.loop_read_vertex(lc));
-
+                if (bt_face_read_triangle_coordinates(scratch_fan, 0, mesh, face)) {
                     scale_sqr = Math.max(
                         scale_sqr,
-                        scratch_fan_a[0] * scratch_fan_a[0]
-                            + scratch_fan_a[1] * scratch_fan_a[1]
-                            + scratch_fan_a[2] * scratch_fan_a[2],
-                        scratch_fan_b[0] * scratch_fan_b[0]
-                            + scratch_fan_b[1] * scratch_fan_b[1]
-                            + scratch_fan_b[2] * scratch_fan_b[2],
-                        scratch_fan_c[0] * scratch_fan_c[0]
-                            + scratch_fan_c[1] * scratch_fan_c[1]
-                            + scratch_fan_c[2] * scratch_fan_c[2]
+                        scratch_fan[0] * scratch_fan[0]
+                            + scratch_fan[1] * scratch_fan[1]
+                            + scratch_fan[2] * scratch_fan[2],
+                        scratch_fan[3] * scratch_fan[3]
+                            + scratch_fan[4] * scratch_fan[4]
+                            + scratch_fan[5] * scratch_fan[5],
+                        scratch_fan[6] * scratch_fan[6]
+                            + scratch_fan[7] * scratch_fan[7]
+                            + scratch_fan[8] * scratch_fan[8]
                     );
 
                     nearest_sqr = Math.min(nearest_sqr, tri3_closest_point(
                         scratch_closest, 0,
                         point[0], point[1], point[2],
-                        scratch_fan_a[0], scratch_fan_a[1], scratch_fan_a[2],
-                        scratch_fan_b[0], scratch_fan_b[1], scratch_fan_b[2],
-                        scratch_fan_c[0], scratch_fan_c[1], scratch_fan_c[2]
+                        scratch_fan[0], scratch_fan[1], scratch_fan[2],
+                        scratch_fan[3], scratch_fan[4], scratch_fan[5],
+                        scratch_fan[6], scratch_fan[7], scratch_fan[8]
                     ));
                 }
             }

package/src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_edge_create.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_create.js"],"names":[],"mappings":"AA8DA;;;;;;GAMG;AACH,yDAJW,MAAM,MACN,MAAM,GACL,MAAM,CA+CjB"}
+{"version":3,"file":"bt_edge_create.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/edge/bt_edge_create.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,yDAJW,MAAM,MACN,MAAM,GACL,MAAM,CAsBjB"}