@woosh/meep-engine 3.56.0 → 3.57.0

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

@@ -1,194 +1,151 @@
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_disk_edge_add } from "../bt_disk_edge_add.js";
-import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
-
-/**
- * The victim's incident edges, collected before its disk cycles are mutated.
- *
- * Grown on demand, the way bt_mesh_append grows its corner buffer. It used to be a fixed 1024
- * bounded only by an assert, which the consumer strips: past 1024 the typed-array write is
- * silently dropped while the count keeps rising, so the second loop reads `undefined`,
- * `element_address(undefined)` is NaN, and `DataView.getUint32(NaN)` coerces the offset to 0 —
- * every overflow iteration then reads and rewrites the head of the edge pool and leaves the real
- * edges dangling on a killed vertex. Silent topology corruption in the pass whose output is baked
- * into a shipped .vgeo, and bt_mesh_simplify has no valence cap to keep a greedy collapse in a
- * flat region from funnelling that much valence into one star vertex.
- *
- * @type {Uint32Array}
- */
-let scratch_edges = new Uint32Array(1024);
-
-/**
- * Patch mesh structure to make all loops/edges/faces point to this new replacement vertex instead of the victim.
- * This effectively removes any usage of the victim from the mesh enabling us to safely remove it.
- *
- * Note: both victim and replacement vertices must be part of the mesh.
- * Note: does not actually remove the victim vertex from the mesh, only links that point to it that will now point to `replacement` instead.
- * Note: may create degenerate edges if victim and replacement are a part of the same edge originally.
- * @param {BinaryTopology} mesh
- * @param {number} victim
- * @param {number} replacement
- */
-export function bt_vertex_replace(
-    mesh,
-    victim,
-    replacement
-) {
-
-    if (victim === replacement) {
-        // special case
-        return;
-    }
-
-    // 1. Traverse and collect all edges attached to the victim vertex.
-    // We collect them into an array first because we will be mutating their disk cycles
-    // during the loop, which would break an inline traversal.
-    let edges_to_move_count = 0;
-    let curr_e = mesh.vertex_read_edge(victim);
-
-    if (curr_e !== NULL_POINTER) {
-        let start_e = curr_e;
-        do {
-
-            if (edges_to_move_count === scratch_edges.length) {
-                const grown = new Uint32Array(scratch_edges.length * 2);
-
-                grown.set(scratch_edges);
-
-                scratch_edges = grown;
-            }
-
-            scratch_edges[edges_to_move_count++] = curr_e;
-
-            // Move to the next edge in the victim's disk cycle
-            if (mesh.edge_read_vertex1(curr_e) === victim) {
-                curr_e = mesh.edge_read_v1_disk_next(curr_e);
-            } else {
-                curr_e = mesh.edge_read_v2_disk_next(curr_e);
-            }
-        } while (curr_e !== start_e && curr_e !== NULL_POINTER);
-    }
-
-    // 2. Unlink the victim vertex by clearing its edge pointer.
-    mesh.vertex_write_edge(victim, NULL_POINTER);
-
-    // 3. Process each edge: update loops, update vertices, and insert into replacement's disk cycle.
-    for (let i = 0; i < edges_to_move_count; i++) {
-        const e = scratch_edges[i];
-
-        // --- Update Loops ---
-        // Loops are corner representations; we must check the radial cycle of loops around this edge
-        let curr_l = mesh.edge_read_loop(e);
-        if (curr_l !== NULL_POINTER) {
-            let start_l = curr_l;
-            do {
-                if (mesh.loop_read_vertex(curr_l) === victim) {
-                    mesh.loop_write_vertex(curr_l, replacement);
-                }
-                curr_l = mesh.loop_read_radial_next(curr_l);
-            } while (curr_l !== start_l && curr_l !== NULL_POINTER);
-        }
-
-        // --- Update Edge Vertices ---
-        // Three cases. Per the disk-cycle convention (see BinaryTopology.js
-        // __edge_pool comment), every edge occupies exactly one slot in each of
-        // its endpoints' cycles -- for self-loops that means one slot total, in
-        // the v1 slot of the unique endpoint's cycle.
-        //
-        //   (a) Normal: e was attached to victim only. Move the victim endpoint
-        //       onto replacement and splice e into replacement's cycle.
-        //   (b) Direct parallel: e connects victim and replacement. Becomes a
-        //       self-loop on replacement. e is already in replacement's disk on
-        //       the OTHER side; remove it there, update the vertex, then re-add
-        //       on the v1 side per convention.
-        //   (c) Self-loop on victim: e was a self-loop on victim. Becomes a
-        //       self-loop on replacement. Update BOTH vertex fields (the legacy
-        //       single-write path would have left vertex2 = victim, dangling
-        //       after bt_vert_kill(victim) runs upstream), then add to
-        //       replacement's cycle from scratch.
-        const e_v1 = mesh.edge_read_vertex1(e);
-        const e_v2 = mesh.edge_read_vertex2(e);
-        const is_v1 = e_v1 === victim;
-        const other_endpoint = is_v1 ? e_v2 : e_v1;
-
-        if (other_endpoint === victim) {
-            // case (c): self-loop on victim -> self-loop on replacement
-            mesh.edge_write_vertex1(e, replacement);
-            mesh.edge_write_vertex2(e, replacement);
-            bt_disk_edge_add(mesh, e, replacement);
-            continue;
-        }
-
-        if (other_endpoint === replacement) {
-            // case (b): direct parallel becoming a self-loop on replacement.
-            // e is currently in replacement's disk on the side OPPOSITE the
-            // victim side; remove it there before rewriting the vertex slot.
-            bt_disk_edge_remove(mesh, e, replacement);
-
-            if (is_v1) {
-                mesh.edge_write_vertex1(e, replacement);
-            } else {
-                mesh.edge_write_vertex2(e, replacement);
-            }
-
-            // Now e is a self-loop; bt_disk_edge_add will write the v1 slot
-            // per the convention.
-            bt_disk_edge_add(mesh, e, replacement);
-            continue;
-        }
-
-        // case (a): normal path. Move the victim endpoint onto replacement and
-        // splice e into replacement's cycle.
-        if (is_v1) {
-            mesh.edge_write_vertex1(e, replacement);
-        } else {
-            mesh.edge_write_vertex2(e, replacement);
-        }
-
-        // --- Insert Edge into Replacement's Disk Cycle ---
-        const base_edge = mesh.vertex_read_edge(replacement);
-
-        if (base_edge === NULL_POINTER) {
-            // This is the first edge attached to the replacement vertex
-            mesh.vertex_write_edge(replacement, e);
-            if (is_v1) {
-                mesh.edge_write_v1_disk_next(e, e);
-                mesh.edge_write_v1_disk_prev(e, e);
-            } else {
-                mesh.edge_write_v2_disk_next(e, e);
-                mesh.edge_write_v2_disk_prev(e, e);
-            }
-        } else {
-            // Splice this edge into the existing disk cycle before base_edge
-            const base_is_v1 = mesh.edge_read_vertex1(base_edge) === replacement;
-            const base_prev = base_is_v1
-                ? mesh.edge_read_v1_disk_prev(base_edge)
-                : mesh.edge_read_v2_disk_prev(base_edge);
-
-            const prev_is_v1 = mesh.edge_read_vertex1(base_prev) === replacement;
-
-            // 1. Link base_prev -> e
-            if (prev_is_v1) {
-                mesh.edge_write_v1_disk_next(base_prev, e);
-            } else {
-                mesh.edge_write_v2_disk_next(base_prev, e);
-            }
-
-            // 2. Link e -> base_prev & e -> base_edge
-            if (is_v1) {
-                mesh.edge_write_v1_disk_prev(e, base_prev);
-                mesh.edge_write_v1_disk_next(e, base_edge);
-            } else {
-                mesh.edge_write_v2_disk_prev(e, base_prev);
-                mesh.edge_write_v2_disk_next(e, base_edge);
-            }
-
-            // 3. Link base_edge -> e
-            if (base_is_v1) {
-                mesh.edge_write_v1_disk_prev(base_edge, e);
-            } else {
-                mesh.edge_write_v2_disk_prev(base_edge, e);
-            }
-        }
-    }
-}
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_disk_edge_add } from "../bt_disk_edge_add.js";
+import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
+
+/**
+ * The victim's incident edges, collected before its disk cycles are mutated.
+ *
+ * Grown on demand, the way bt_mesh_append grows its corner buffer. It used to be a fixed 1024
+ * bounded only by an assert, which the consumer strips: past 1024 the typed-array write is
+ * silently dropped while the count keeps rising, so the second loop reads `undefined`,
+ * `element_address(undefined)` is NaN, and `DataView.getUint32(NaN)` coerces the offset to 0 —
+ * every overflow iteration then reads and rewrites the head of the edge pool and leaves the real
+ * edges dangling on a killed vertex. Silent topology corruption in the pass whose output is baked
+ * into a shipped .vgeo, and bt_mesh_simplify has no valence cap to keep a greedy collapse in a
+ * flat region from funnelling that much valence into one star vertex.
+ *
+ * @type {Uint32Array}
+ */
+let scratch_edges = new Uint32Array(1024);
+
+/**
+ * Patch mesh structure to make all loops/edges/faces point to this new replacement vertex instead of the victim.
+ * This effectively removes any usage of the victim from the mesh enabling us to safely remove it.
+ *
+ * Note: both victim and replacement vertices must be part of the mesh.
+ * Note: does not actually remove the victim vertex from the mesh, only links that point to it that will now point to `replacement` instead.
+ * Note: may create degenerate edges if victim and replacement are a part of the same edge originally.
+ * @param {BinaryTopology} mesh
+ * @param {number} victim
+ * @param {number} replacement
+ */
+export function bt_vertex_replace(
+    mesh,
+    victim,
+    replacement
+) {
+
+    if (victim === replacement) {
+        // special case
+        return;
+    }
+
+    // 1. Traverse and collect all edges attached to the victim vertex.
+    // We collect them into an array first because we will be mutating their disk cycles
+    // during the loop, which would break an inline traversal.
+    let edges_to_move_count = 0;
+    let curr_e = mesh.vertex_read_edge(victim);
+
+    if (curr_e !== NULL_POINTER) {
+        let start_e = curr_e;
+        do {
+
+            if (edges_to_move_count === scratch_edges.length) {
+                const grown = new Uint32Array(scratch_edges.length * 2);
+
+                grown.set(scratch_edges);
+
+                scratch_edges = grown;
+            }
+
+            scratch_edges[edges_to_move_count++] = curr_e;
+
+            // Move to the next edge in the victim's disk cycle
+            if (mesh.edge_read_vertex1(curr_e) === victim) {
+                curr_e = mesh.edge_read_v1_disk_next(curr_e);
+            } else {
+                curr_e = mesh.edge_read_v2_disk_next(curr_e);
+            }
+        } while (curr_e !== start_e && curr_e !== NULL_POINTER);
+    }
+
+    // 2. Unlink the victim vertex by clearing its edge pointer.
+    mesh.vertex_write_edge(victim, NULL_POINTER);
+
+    // 3. Process each edge: update loops, update vertices, and insert into replacement's disk cycle.
+    for (let i = 0; i < edges_to_move_count; i++) {
+        const e = scratch_edges[i];
+
+        // --- Update Loops ---
+        // Loops are corner representations; we must check the radial cycle of loops around this edge
+        let curr_l = mesh.edge_read_loop(e);
+        if (curr_l !== NULL_POINTER) {
+            let start_l = curr_l;
+            do {
+                if (mesh.loop_read_vertex(curr_l) === victim) {
+                    mesh.loop_write_vertex(curr_l, replacement);
+                }
+                curr_l = mesh.loop_read_radial_next(curr_l);
+            } while (curr_l !== start_l && curr_l !== NULL_POINTER);
+        }
+
+        // --- Update Edge Vertices ---
+        // Three cases. Per the disk-cycle convention (see BinaryTopology.js
+        // __edge_pool comment), every edge occupies exactly one slot in each of
+        // its endpoints' cycles -- for self-loops that means one slot total, in
+        // the v1 slot of the unique endpoint's cycle.
+        //
+        //   (a) Normal: e was attached to victim only. Move the victim endpoint
+        //       onto replacement and splice e into replacement's cycle.
+        //   (b) Direct parallel: e connects victim and replacement. Becomes a
+        //       self-loop on replacement. e is already in replacement's disk on
+        //       the OTHER side; remove it there, update the vertex, then re-add
+        //       on the v1 side per convention.
+        //   (c) Self-loop on victim: e was a self-loop on victim. Becomes a
+        //       self-loop on replacement. Update BOTH vertex fields (the legacy
+        //       single-write path would have left vertex2 = victim, dangling
+        //       after bt_vert_kill(victim) runs upstream), then add to
+        //       replacement's cycle from scratch.
+        const e_v1 = mesh.edge_read_vertex1(e);
+        const e_v2 = mesh.edge_read_vertex2(e);
+        const is_v1 = e_v1 === victim;
+        const other_endpoint = is_v1 ? e_v2 : e_v1;
+
+        if (other_endpoint === victim) {
+            // case (c): self-loop on victim -> self-loop on replacement
+            mesh.edge_write_vertex1(e, replacement);
+            mesh.edge_write_vertex2(e, replacement);
+            bt_disk_edge_add(mesh, e, replacement);
+            continue;
+        }
+
+        if (other_endpoint === replacement) {
+            // case (b): direct parallel becoming a self-loop on replacement.
+            // e is currently in replacement's disk on the side OPPOSITE the
+            // victim side; remove it there before rewriting the vertex slot.
+            bt_disk_edge_remove(mesh, e, replacement);
+
+            if (is_v1) {
+                mesh.edge_write_vertex1(e, replacement);
+            } else {
+                mesh.edge_write_vertex2(e, replacement);
+            }
+
+            // Now e is a self-loop; bt_disk_edge_add will write the v1 slot
+            // per the convention.
+            bt_disk_edge_add(mesh, e, replacement);
+            continue;
+        }
+
+        // case (a): normal path. Move the victim endpoint onto replacement and
+        // splice e into replacement's cycle.
+        if (is_v1) {
+            mesh.edge_write_vertex1(e, replacement);
+        } else {
+            mesh.edge_write_vertex2(e, replacement);
+        }
+
+        // --- Insert Edge into Replacement's Disk Cycle ---
+        bt_disk_edge_add(mesh, e, replacement);
+    }
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_incenter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_face_get_incenter.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_get_incenter.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,6CANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,iCAEN,MAAM,GACJ,OAAO,CAwEnB"}
+{"version":3,"file":"bt_face_get_incenter.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_get_incenter.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,6CANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,iCAEN,MAAM,GACJ,OAAO,CA8CnB"}

package/src/core/geom/3d/topology/struct/binary/query/bt_face_get_incenter.js

@@ -1,85 +1,60 @@
-import { assert } from "../../../../../../assert.js";
-import { tri3_incenter } from "../../../../triangle/tri3_incenter.js";
-import { NULL_POINTER } from "../BinaryTopology.js";
-
-const scratch_coords = [0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-/**
- * Given a face, gets the coordinates of its incenter (if a triangle) or centroid (if N-gon).
- * @param {number[]|Float32Array} output 3d vector
- * @param {number} output_offset where to write
- * @param {BinaryTopology} mesh
- * @param {number} face_id
- * @returns {boolean} true if computed, false if something went wrong
- */
-export function bt_face_get_incenter(
-    output,
-                                     output_offset,
-                                     mesh,
-                                     face_id
-) {
-    assert.isNonNegativeInteger(output_offset, "output_offset");
-    assert.isNonNegativeInteger(face_id, "face_id");
-
-    const first_loop_id = mesh.face_read_loop(face_id);
-
-    if (first_loop_id === NULL_POINTER) {
-        return false;
-    }
-
-    let current_loop_id = first_loop_id;
-    let vertex_count = 0;
-
-    // 1. Traverse loops, attempting to collect exactly 3 vertices for a triangle
-    do {
-        if (vertex_count < 3) {
-            const vertex_id = mesh.loop_read_vertex(current_loop_id);
-            mesh.vertex_read_coordinate(scratch_coords, vertex_count * 3, vertex_id);
-        }
-        vertex_count++;
-        current_loop_id = mesh.loop_read_next(current_loop_id);
-    } while (current_loop_id !== first_loop_id);
-
-    // 2. Triangle Fast-Path: Compute exact Incenter
-    if (vertex_count === 3) {
-        const v0x = scratch_coords[0], v0y = scratch_coords[1], v0z = scratch_coords[2];
-        const v1x = scratch_coords[3], v1y = scratch_coords[4], v1z = scratch_coords[5];
-        const v2x = scratch_coords[6], v2y = scratch_coords[7], v2z = scratch_coords[8];
-
-        return tri3_incenter(
-            output, output_offset,
-            v0x, v0y, v0z,
-            v1x, v1y, v1z,
-            v2x, v2y, v2z
-        );
-    }
-
-    // 3. Fallback Path: If N-gon (or degenerate), compute standard Centroid
-    let sum_x = 0;
-    let sum_y = 0;
-    let sum_z = 0;
-
-    current_loop_id = first_loop_id;
-    vertex_count = 0;
-
-    do {
-        const vertex_id = mesh.loop_read_vertex(current_loop_id);
-        mesh.vertex_read_coordinate(scratch_coords, 0, vertex_id);
-
-        sum_x += scratch_coords[0];
-        sum_y += scratch_coords[1];
-        sum_z += scratch_coords[2];
-
-        vertex_count++;
-        current_loop_id = mesh.loop_read_next(current_loop_id);
-    } while (current_loop_id !== first_loop_id);
-
-    if (vertex_count > 0) {
-        output[output_offset]     = sum_x / vertex_count;
-        output[output_offset + 1] = sum_y / vertex_count;
-        output[output_offset + 2] = sum_z / vertex_count;
-        return true;
-    }
-
-    return false;
-}
+import { assert } from "../../../../../../assert.js";
+import { tri3_incenter } from "../../../../triangle/tri3_incenter.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_face_get_centroid } from "./bt_face_get_centroid.js";
+
+const scratch_coords = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+
+/**
+ * Given a face, gets the coordinates of its incenter (if a triangle) or centroid (if N-gon).
+ * @param {number[]|Float32Array} output 3d vector
+ * @param {number} output_offset where to write
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {boolean} true if computed, false if something went wrong
+ */
+export function bt_face_get_incenter(
+    output,
+    output_offset,
+    mesh,
+    face_id
+) {
+    assert.isNonNegativeInteger(output_offset, "output_offset");
+    assert.isNonNegativeInteger(face_id, "face_id");
+
+    const first_loop_id = mesh.face_read_loop(face_id);
+
+    if (first_loop_id === NULL_POINTER) {
+        return false;
+    }
+
+    let current_loop_id = first_loop_id;
+    let vertex_count = 0;
+
+    // 1. Traverse loops, attempting to collect exactly 3 vertices for a triangle
+    do {
+        if (vertex_count < 3) {
+            const vertex_id = mesh.loop_read_vertex(current_loop_id);
+            mesh.vertex_read_coordinate(scratch_coords, vertex_count * 3, vertex_id);
+        }
+        vertex_count++;
+        current_loop_id = mesh.loop_read_next(current_loop_id);
+    } while (current_loop_id !== first_loop_id);
+
+    // 2. Triangle Fast-Path: Compute exact Incenter
+    if (vertex_count === 3) {
+        const v0x = scratch_coords[0], v0y = scratch_coords[1], v0z = scratch_coords[2];
+        const v1x = scratch_coords[3], v1y = scratch_coords[4], v1z = scratch_coords[5];
+        const v2x = scratch_coords[6], v2y = scratch_coords[7], v2z = scratch_coords[8];
+
+        return tri3_incenter(
+            output, output_offset,
+            v0x, v0y, v0z,
+            v1x, v1y, v1z,
+            v2x, v2y, v2z
+        );
+    }
+
+    // 3. Fallback Path: If N-gon (or degenerate), compute standard Centroid
+    return bt_face_get_centroid(output, output_offset, mesh, face_id);
+}

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_distance_field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bt_mesh_build_boundary_distance_field.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_distance_field.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;GAYG;AACH,iFALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,IAAI,MAAM,CAAC,qBACX,IAAI,MAAM,CAAC,QAyIrB"}
+{"version":3,"file":"bt_mesh_build_boundary_distance_field.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_build_boundary_distance_field.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;GAYG;AACH,iFALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,IAAI,MAAM,CAAC,qBACX,IAAI,MAAM,CAAC,QAyHrB"}