@woosh/meep-engine 3.55.0 → 3.57.0

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

@@ -1,115 +1,31 @@
-import { NULL_POINTER } from "../../BinaryTopology.js";
-
-/**
- *
- * @param {BinaryTopology} mesh
- * @param {number} edge_from
- * @param {number} edge_to
- * @param {number} vertex
- */
-function edge_link_disk_forward(mesh, edge_from, edge_to, vertex) {
-    const from_v1 = mesh.edge_read_vertex1(edge_from);
-
-    let displaced_edge;
-
-    if (from_v1 === vertex) {
-        displaced_edge = mesh.edge_read_v1_disk_next(edge_from);
-
-        mesh.edge_write_v1_disk_next(edge_from, edge_to);
-
-    } else {
-        displaced_edge = mesh.edge_read_v2_disk_next(edge_from);
-
-        mesh.edge_write_v2_disk_next(edge_from, edge_to);
-    }
-
-    return displaced_edge;
-}
-
-function edge_link_disk_back(mesh, edge_from, edge_to, vertex) {
-    const from_v1 = mesh.edge_read_vertex1(edge_from);
-
-    let displaced_edge;
-
-    if (from_v1 === vertex) {
-        displaced_edge = mesh.edge_read_v1_disk_prev(edge_from);
-
-        mesh.edge_write_v1_disk_prev(edge_from, edge_to);
-
-    } else {
-        displaced_edge = mesh.edge_read_v2_disk_prev(edge_from);
-
-        mesh.edge_write_v2_disk_prev(edge_from, edge_to);
-    }
-
-    return displaced_edge;
-}
-
-/**
- *
- * @param {BinaryTopology} mesh
- * @param {number} edge_source anchor edge, new edge is inserted after this one
- * @param {number} edge_new edge that is being introduced
- * @param {number} vertex
- */
-function edge_link_disk(mesh, edge_source, edge_new, vertex) {
-    const forward_link = edge_link_disk_forward(mesh, edge_source, edge_new, vertex);
-    edge_link_disk_forward(mesh, edge_new, forward_link, vertex);
-
-    edge_link_disk_back(mesh, forward_link, edge_new, vertex);
-    edge_link_disk_back(mesh, edge_new, edge_source, vertex);
-}
-
-/**
- *
- * @param {BinaryTopology} mesh
- * @param {number} v0
- * @param {number} v1
- * @return {number} ID of the newly created edge
- */
-export function bt_edge_create(mesh, v0, v1) {
-    const edge_id = mesh.edge_create();
-
-    mesh.edge_write_vertex1(edge_id, v0);
-    mesh.edge_write_vertex2(edge_id, v1);
-
-    // initialize rest of the edge
-    mesh.edge_write_loop(edge_id, NULL_POINTER);
-
-    // process disk links
-    const first_v0_edge = mesh.vertex_read_edge(v0);
-
-    if (first_v0_edge !== NULL_POINTER) {
-        edge_link_disk(mesh, first_v0_edge, edge_id, v0);
-    } else {
-        // no edges attached yet, attach this one as the first
-        mesh.vertex_write_edge(v0, edge_id);
-        // link to self
-        mesh.edge_write_v1_disk_next(edge_id, edge_id);
-        mesh.edge_write_v1_disk_prev(edge_id, edge_id);
-    }
-
-    if (v0 === v1) {
-        // Self-loop: by convention the edge occupies the v1 slot of v's disk
-        // cycle only; the v2 slot is unused. Running the v1 link pass below
-        // would re-enter the same slot a second time, scribbling on its own
-        // disk_next pointer (typically setting it to self), and corrupting v's
-        // cycle. See BinaryTopology.js __edge_pool comment for the convention.
-        return edge_id;
-    }
-
-    const first_v1_edge = mesh.vertex_read_edge(v1);
-
-    if (first_v1_edge !== NULL_POINTER) {
-
-        edge_link_disk(mesh, first_v1_edge, edge_id, v1);
-
-    } else {
-        // no edges attached yet, attach this one as the first
-        mesh.vertex_write_edge(v1, edge_id);
-        // link to self
-        mesh.edge_write_v2_disk_next(edge_id, edge_id);
-        mesh.edge_write_v2_disk_prev(edge_id, edge_id);
-    }
-    return edge_id;
-}
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_disk_edge_add } from "../bt_disk_edge_add.js";
+
+/**
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v0
+ * @param {number} v1
+ * @return {number} ID of the newly created edge
+ */
+export function bt_edge_create(mesh, v0, v1) {
+    const edge_id = mesh.edge_create();
+
+    mesh.edge_write_vertex1(edge_id, v0);
+    mesh.edge_write_vertex2(edge_id, v1);
+
+    // initialize rest of the edge
+    mesh.edge_write_loop(edge_id, NULL_POINTER);
+
+    // process disk links
+    bt_disk_edge_add(mesh, edge_id, v0);
+
+    if (v0 !== v1) {
+        // Self-loop: by convention the edge occupies the v1 slot of v's disk
+        // cycle only; the v2 slot is unused. See BinaryTopology.js __edge_pool
+        // comment for the convention.
+        bt_disk_edge_add(mesh, edge_id, v1);
+    }
+
+    return edge_id;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"bt_vertex_fuse_duplicate_edges.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_fuse_duplicate_edges.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wEAHW,MAAM,GACJ,MAAM,CA2HlB"}
+{"version":3,"file":"bt_vertex_fuse_duplicate_edges.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_fuse_duplicate_edges.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wEAHW,MAAM,GACJ,MAAM,CAmHlB"}

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

@@ -1,150 +1,142 @@
-import { assert } from "../../../../../../../assert.js";
-import { NULL_POINTER } from "../../BinaryTopology.js";
-import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
-import { bt_loop_kill } from "../bt_loop_kill.js";
-import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
-import { bt_radial_loop_remove } from "../bt_radial_loop_remove.js";
-import { bt_kill_only_edge } from "../edge/bt_kill_only_edge.js";
-
-/**
- * Localized counterpart to {@link bt_mesh_fuse_duplicate_edges} that inspects only
- * `v`'s disk cycle. Any two edges in that cycle sharing the same other endpoint
- * are fused: loops move from the victim to the master, the victim is untangled
- * from both endpoint disk cycles, and its memory is released.
- *
- * If transferring a loop would leave the master edge with two loops on the same
- * face (i.e. the face has collapsed to a degenerate two-edge polygon), that face
- * is killed as well.
- *
- * Self-loops on `v` are left alone; the caller should handle them separately.
- *
- * Typical use: after an iterative edit that may have produced link-vertex
- * duplicates around `v`, run this to restore the one-edge-per-vertex-pair
- * invariant without the cost of a whole-mesh pass.
- *
- * @param {BinaryTopology} mesh
- * @param {number} v
- * @returns {number} Number of faces killed as a side effect.
- */
-export function bt_vertex_fuse_duplicate_edges(mesh, v) {
-    assert.defined(mesh, 'mesh');
-    assert.notNull(mesh, 'mesh');
-    assert.isNonNegativeInteger(v, 'v');
-
-    const edge_pool = mesh.edges;
-
-    const start_e = mesh.vertex_read_edge(v);
-
-    if (start_e === NULL_POINTER) {
-        return 0;
-    }
-
-    // Snapshot v's disk cycle up front so that later fusion operations, which
-    // mutate that cycle, don't invalidate our traversal cursor.
-    const edges_in_disk = [];
-    let curr_e = start_e;
-
-    do {
-        edges_in_disk.push(curr_e);
-
-        if (mesh.edge_read_vertex1(curr_e) === v) {
-            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);
-
-    // Group edges by other endpoint to detect duplicates in a single pass.
-    const master_by_other = new Map();
-    const fusion_masters = [];
-    const fusion_victims = [];
-    const fusion_others = [];
-
-    for (let i = 0; i < edges_in_disk.length; i++) {
-        const e = edges_in_disk[i];
-
-        if (!edge_pool.is_allocated(e)) {
-            continue;
-        }
-
-        const v1 = mesh.edge_read_vertex1(e);
-        const v2 = mesh.edge_read_vertex2(e);
-        const other = v1 === v ? v2 : v1;
-
-        if (other === v) {
-            // Self-loop; not our concern here.
-            continue;
-        }
-
-        if (master_by_other.has(other)) {
-            fusion_masters.push(master_by_other.get(other));
-            fusion_victims.push(e);
-            fusion_others.push(other);
-        } else {
-            master_by_other.set(other, e);
-        }
-    }
-
-    const face_pool = mesh.faces;
-
-    let faces_killed = 0;
-
-    for (let i = 0; i < fusion_masters.length; i++) {
-        const master = fusion_masters[i];
-        const victim = fusion_victims[i];
-        const other = fusion_others[i];
-
-        if (!edge_pool.is_allocated(victim) || !edge_pool.is_allocated(master)) {
-            continue;
-        }
-
-        let l = mesh.edge_read_loop(victim);
-
-        while (l !== NULL_POINTER) {
-            bt_radial_loop_remove(mesh, l, victim);
-
-            const face = mesh.loop_read_face(l);
-            let collapse_face = false;
-
-            if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
-                // If master already has a loop on the same face, transferring
-                // this loop would give that face two coincident edges -- a
-                // degenerate polygon that has to die.
-                let mast_l = mesh.edge_read_loop(master);
-                if (mast_l !== NULL_POINTER) {
-                    const mast_start = mast_l;
-                    do {
-                        if (mesh.loop_read_face(mast_l) === face) {
-                            collapse_face = true;
-                            break;
-                        }
-                        mast_l = mesh.loop_read_radial_next(mast_l);
-                    } while (mast_l !== mast_start && mast_l !== NULL_POINTER);
-                }
-            }
-
-            bt_radial_loop_add(mesh, l, master);
-
-            if (collapse_face) {
-                const face_to_kill = face;
-                let fl = mesh.face_read_loop(face_to_kill);
-                while (fl !== NULL_POINTER) {
-                    bt_loop_kill(mesh, fl);
-                    fl = mesh.face_read_loop(face_to_kill);
-                }
-                // through the topology, not the pool - element lifetime is the topology's, and
-                // `face_destroy` is where the attribute block is kept in step
-                mesh.face_destroy(face_to_kill);
-                faces_killed++;
-            }
-
-            l = mesh.edge_read_loop(victim);
-        }
-
-        bt_disk_edge_remove(mesh, victim, v);
-        bt_disk_edge_remove(mesh, victim, other);
-        bt_kill_only_edge(mesh, victim);
-    }
-
-    return faces_killed;
-}
+import { assert } from "../../../../../../../assert.js";
+import { NULL_POINTER } from "../../BinaryTopology.js";
+import { bt_disk_edge_remove } from "../bt_disk_edge_remove.js";
+import { bt_radial_loop_add } from "../bt_radial_loop_add.js";
+import { bt_radial_loop_remove } from "../bt_radial_loop_remove.js";
+import { bt_kill_only_edge } from "../edge/bt_kill_only_edge.js";
+import { bt_face_kill } from "../face/bt_face_kill.js";
+
+/**
+ * Localized counterpart to {@link bt_mesh_fuse_duplicate_edges} that inspects only
+ * `v`'s disk cycle. Any two edges in that cycle sharing the same other endpoint
+ * are fused: loops move from the victim to the master, the victim is untangled
+ * from both endpoint disk cycles, and its memory is released.
+ *
+ * If transferring a loop would leave the master edge with two loops on the same
+ * face (i.e. the face has collapsed to a degenerate two-edge polygon), that face
+ * is killed as well.
+ *
+ * Self-loops on `v` are left alone; the caller should handle them separately.
+ *
+ * Typical use: after an iterative edit that may have produced link-vertex
+ * duplicates around `v`, run this to restore the one-edge-per-vertex-pair
+ * invariant without the cost of a whole-mesh pass.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} v
+ * @returns {number} Number of faces killed as a side effect.
+ */
+export function bt_vertex_fuse_duplicate_edges(mesh, v) {
+    assert.defined(mesh, 'mesh');
+    assert.notNull(mesh, 'mesh');
+    assert.isNonNegativeInteger(v, 'v');
+
+    const edge_pool = mesh.edges;
+
+    const start_e = mesh.vertex_read_edge(v);
+
+    if (start_e === NULL_POINTER) {
+        return 0;
+    }
+
+    // Snapshot v's disk cycle up front so that later fusion operations, which
+    // mutate that cycle, don't invalidate our traversal cursor.
+    const edges_in_disk = [];
+    let curr_e = start_e;
+
+    do {
+        edges_in_disk.push(curr_e);
+
+        if (mesh.edge_read_vertex1(curr_e) === v) {
+            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);
+
+    // Group edges by other endpoint to detect duplicates in a single pass.
+    const master_by_other = new Map();
+    const fusion_masters = [];
+    const fusion_victims = [];
+    const fusion_others = [];
+
+    for (let i = 0; i < edges_in_disk.length; i++) {
+        const e = edges_in_disk[i];
+
+        if (!edge_pool.is_allocated(e)) {
+            continue;
+        }
+
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+        const other = v1 === v ? v2 : v1;
+
+        if (other === v) {
+            // Self-loop; not our concern here.
+            continue;
+        }
+
+        if (master_by_other.has(other)) {
+            fusion_masters.push(master_by_other.get(other));
+            fusion_victims.push(e);
+            fusion_others.push(other);
+        } else {
+            master_by_other.set(other, e);
+        }
+    }
+
+    const face_pool = mesh.faces;
+
+    let faces_killed = 0;
+
+    for (let i = 0; i < fusion_masters.length; i++) {
+        const master = fusion_masters[i];
+        const victim = fusion_victims[i];
+        const other = fusion_others[i];
+
+        if (!edge_pool.is_allocated(victim) || !edge_pool.is_allocated(master)) {
+            continue;
+        }
+
+        let l = mesh.edge_read_loop(victim);
+
+        while (l !== NULL_POINTER) {
+            bt_radial_loop_remove(mesh, l, victim);
+
+            const face = mesh.loop_read_face(l);
+            let collapse_face = false;
+
+            if (face !== NULL_POINTER && face_pool.is_allocated(face)) {
+                // If master already has a loop on the same face, transferring
+                // this loop would give that face two coincident edges -- a
+                // degenerate polygon that has to die.
+                let mast_l = mesh.edge_read_loop(master);
+                if (mast_l !== NULL_POINTER) {
+                    const mast_start = mast_l;
+                    do {
+                        if (mesh.loop_read_face(mast_l) === face) {
+                            collapse_face = true;
+                            break;
+                        }
+                        mast_l = mesh.loop_read_radial_next(mast_l);
+                    } while (mast_l !== mast_start && mast_l !== NULL_POINTER);
+                }
+            }
+
+            bt_radial_loop_add(mesh, l, master);
+
+            if (collapse_face) {
+                bt_face_kill(mesh, face);
+                faces_killed++;
+            }
+
+            l = mesh.edge_read_loop(victim);
+        }
+
+        bt_disk_edge_remove(mesh, victim, v);
+        bt_disk_edge_remove(mesh, victim, other);
+        bt_kill_only_edge(mesh, victim);
+    }
+
+    return faces_killed;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"bt_vertex_replace.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_replace.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,gEAHW,MAAM,eACN,MAAM,QAoKhB"}
+{"version":3,"file":"bt_vertex_replace.d.ts","sourceRoot":"","sources":["../../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/vertex/bt_vertex_replace.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,gEAHW,MAAM,eACN,MAAM,QAyHhB"}