@woosh/meep-engine 2.168.0 → 2.169.0

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

@@ -0,0 +1,34 @@
+import { bt_mesh_count_edge_faces } from "./bt_mesh_count_edge_faces.js";
+
+/**
+ * True when every edge is used by exactly two faces -- a watertight surface with
+ * no boundary, no wire edges and no non-manifold edges.
+ *
+ * This is what "is this a solid?" means for volume, genus and inside/outside
+ * queries: {@link tri3_mesh_compute_signed_volume} is only meaningful on a closed
+ * mesh, and {@link bt_mesh_close_boundary_holes} exists to make an open one
+ * closed.
+ *
+ * An empty mesh is closed, vacuously -- there is no edge to violate the rule.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {boolean}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_is_closed(mesh) {
+    const edges = mesh.edges;
+
+    for (let e = 0; e < edges.size; e++) {
+        if (!edges.is_allocated(e)) {
+            continue;
+        }
+
+        if (bt_mesh_count_edge_faces(mesh, e) !== 2) {
+            return false;
+        }
+    }
+
+    return true;
+}

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

@@ -0,0 +1,22 @@
+/**
+ * True when no edge is used by more than two faces.
+ *
+ * This is the *edge* half of 2-manifoldness. `BinaryTopology` permits
+ * non-manifold edges by design (it is an authoring structure, like Blender's
+ * BMesh), so this is a question a caller asks -- never an invariant the structure
+ * enforces. Boundary edges (one face) and wire edges (no face) both pass; use
+ * {@link bt_mesh_is_closed} when the surface must also have no boundary.
+ *
+ * Note the *vertex* half -- no pinched (bow-tie) vertices, where two otherwise
+ * separate fans meet at a single vertex -- is not checked here. A pinched vertex
+ * has every edge at two faces and is invisible to this test. manifold splits
+ * those in `SplitPinchedVerts`; meep has no equivalent yet.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {boolean}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_is_manifold(mesh: BinaryTopology): boolean;
+//# sourceMappingURL=bt_mesh_is_manifold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_is_manifold.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_is_manifold.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2DALa,OAAO,CAmBnB"}

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

@@ -0,0 +1,37 @@
+import { bt_mesh_count_edge_faces } from "./bt_mesh_count_edge_faces.js";
+
+/**
+ * True when no edge is used by more than two faces.
+ *
+ * This is the *edge* half of 2-manifoldness. `BinaryTopology` permits
+ * non-manifold edges by design (it is an authoring structure, like Blender's
+ * BMesh), so this is a question a caller asks -- never an invariant the structure
+ * enforces. Boundary edges (one face) and wire edges (no face) both pass; use
+ * {@link bt_mesh_is_closed} when the surface must also have no boundary.
+ *
+ * Note the *vertex* half -- no pinched (bow-tie) vertices, where two otherwise
+ * separate fans meet at a single vertex -- is not checked here. A pinched vertex
+ * has every edge at two faces and is invisible to this test. manifold splits
+ * those in `SplitPinchedVerts`; meep has no equivalent yet.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {boolean}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_is_manifold(mesh) {
+    const edges = mesh.edges;
+
+    for (let e = 0; e < edges.size; e++) {
+        if (!edges.is_allocated(e)) {
+            continue;
+        }
+
+        if (bt_mesh_count_edge_faces(mesh, e) > 2) {
+            return false;
+        }
+    }
+
+    return true;
+}

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

@@ -0,0 +1,87 @@
+/**
+ * Check every structural invariant of a {@link BinaryTopology} and return the
+ * defects found. An empty result means the mesh is internally consistent: every
+ * handle resolves, every disk / radial / face-loop cycle is a closed
+ * doubly-linked ring, every element agrees with the elements that reference it,
+ * and every stored coordinate is finite.
+ *
+ * This is the counterpart to manifold's `IsManifold()` -- the invariant checker
+ * that makes a pile of topology-surgery primitives trustworthy. `BinaryTopology`
+ * has ~40 mutators (`bt_edge_collapse`, `bt_vert_splice`, `bt_radial_loop_remove`,
+ * `bt_face_poke`, ...), each of which can scribble a cycle; without this, nothing
+ * notices until a much later operation reads garbage. Run it in specs after any
+ * mutation, and in prototypes after any pipeline stage.
+ *
+ * What it deliberately does NOT check, because `BinaryTopology` permits all of
+ * them by design: wire edges (no incident face), boundary edges (one face),
+ * non-manifold edges (three or more faces), n-gon faces, disconnected islands.
+ * For those, see {@link bt_mesh_is_manifold} and {@link bt_mesh_is_closed}.
+ *
+ * O(V + E + L + F) except for the repeated-vertex check, which is quadratic in a
+ * single face's corner count (faces are small; a 1000-gon would be the anomaly,
+ * not the cost).
+ *
+ * Cycle walks are bounded by the corresponding pool's size. That bound is the
+ * theoretical maximum of a legal cycle, so hitting it is itself a defect and is
+ * reported as {@link BT_DEFECT.CYCLE_NOT_CLOSED} rather than swallowed.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {{code:number, element_type:number, element:number, detail:string}[]}
+ *     defects found, in discovery order; empty when the mesh is consistent
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_mesh_validate(mesh: BinaryTopology): {
+    code: number;
+    element_type: number;
+    element: number;
+    detail: string;
+}[];
+/**
+ * Which kind of element a defect was found on. Typed constant (no stringly-typed
+ * states), mirroring the four pools of {@link BinaryTopology}.
+ * @readonly
+ */
+export const BT_ELEMENT_TYPE: Readonly<{
+    VERTEX: 0;
+    EDGE: 1;
+    LOOP: 2;
+    FACE: 3;
+}>;
+/**
+ * Structural defects {@link bt_mesh_validate} can report. Each value names a
+ * broken invariant of {@link BinaryTopology}, not a symptom.
+ * @readonly
+ */
+export const BT_DEFECT: Readonly<{
+    /** A handle points at a pool slot that is not allocated (dangling reference). */
+    DANGLING_REFERENCE: 0;
+    /** A cycle (disk / radial / face-loop) does not return to its start within the pool's size. */
+    CYCLE_NOT_CLOSED: 1;
+    /** `prev` is not the inverse of `next` somewhere on a cycle. */
+    CYCLE_LINK_ASYMMETRIC: 2;
+    /** An edge is missing from the disk cycle of one of its vertices. */
+    EDGE_NOT_IN_DISK: 3;
+    /** An edge sits on the disk cycle of a vertex that is not one of its endpoints. */
+    DISK_EDGE_VERTEX_MISMATCH: 4;
+    /** A loop is missing from the radial cycle of the edge it claims. */
+    LOOP_NOT_IN_RADIAL: 5;
+    /** A loop on an edge's radial cycle does not claim that edge. */
+    RADIAL_LOOP_EDGE_MISMATCH: 6;
+    /** A loop on a face's loop cycle does not claim that face. */
+    FACE_LOOP_FACE_MISMATCH: 7;
+    /** A face's loop cycle is shorter than three corners. */
+    FACE_TOO_FEW_CORNERS: 8;
+    /** The same vertex appears twice on one face's loop cycle. */
+    FACE_VERTEX_REPEATED: 9;
+    /** A loop's edge does not connect that loop's vertex to the next loop's vertex. */
+    LOOP_EDGE_ENDPOINT_MISMATCH: 10;
+    /** An allocated loop is not reachable from any allocated face. */
+    LOOP_ORPHANED: 11;
+    /** A vertex with incident edges has a NULL edge pointer, or vice versa. */
+    VERTEX_EDGE_POINTER_INCONSISTENT: 12;
+    /** A coordinate or normal component is not finite. */
+    NON_FINITE_VALUE: 13;
+}>;
+//# sourceMappingURL=bt_mesh_validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_validate.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_validate.js"],"names":[],"mappings":"AA0iBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wDANa;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,YAAY,EAAC,MAAM,CAAC;IAAC,OAAO,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,EAAE,CAgB/E;AAplBD;;;;GAIG;AACH;;;;;GAKG;AAEH;;;;GAIG;AACH;IACI,iFAAiF;;IAEjF,+FAA+F;;IAE/F,gEAAgE;;IAEhE,qEAAqE;;IAErE,mFAAmF;;IAEnF,qEAAqE;;IAErE,iEAAiE;;IAEjE,8DAA8D;;IAE9D,yDAAyD;;IAEzD,8DAA8D;;IAE9D,mFAAmF;;IAEnF,kEAAkE;;IAElE,2EAA2E;;IAE3E,sDAAsD;;GAEvD"}