@woosh/meep-engine 2.131.48 → 2.132.0

package/src/core/geom/3d/topology/struct/binary/query/{bt_mesh_edge_other_vertex.d.ts → bt_edge_other_vertex.d.ts}

@@ -7,5 +7,5 @@
  * @param {number} vertex_id
  * @returns {number}
  */
-export function bt_mesh_edge_other_vertex(mesh: BinaryTopology, edge_id: number, vertex_id: number): number;
-//# sourceMappingURL=bt_mesh_edge_other_vertex.d.ts.map
+export function bt_edge_other_vertex(mesh: BinaryTopology, edge_id: number, vertex_id: number): number;
+//# sourceMappingURL=bt_edge_other_vertex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_edge_other_vertex.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_edge_other_vertex.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,oEAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAalB"}

package/src/core/geom/3d/topology/struct/binary/query/{bt_mesh_edge_other_vertex.js → bt_edge_other_vertex.js}

@@ -7,7 +7,7 @@
  * @param {number} vertex_id
  * @returns {number}
  */
-export function bt_mesh_edge_other_vertex(mesh, edge_id, vertex_id) {
+export function bt_edge_other_vertex(mesh, edge_id, vertex_id) {
 
     const v1 = mesh.edge_read_vertex1(edge_id);
     const v2 = mesh.edge_read_vertex2(edge_id);

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

@@ -0,0 +1,12 @@
+/**
+ * Given a face, get a list of its attached faces.
+ * Two faces are attached if they share a vertex.
+ * @param {number[]|Uint32Array} output
+ * @param {number} output_offset
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {number} number of faces written to output
+ * @see bt_face_get_neighbour_faces
+ */
+export function bt_face_get_attached_faces(output: number[] | Uint32Array, output_offset: number, mesh: BinaryTopology, face_id: number): number;
+//# sourceMappingURL=bt_face_get_attached_faces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_face_get_attached_faces.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_get_attached_faces.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,mDAPW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,iCAEN,MAAM,GACJ,MAAM,CAqFlB"}

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

@@ -0,0 +1,96 @@
+import { assert } from "../../../../../../assert.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Given a face, get a list of its attached faces.
+ * Two faces are attached if they share a vertex.
+ * @param {number[]|Uint32Array} output
+ * @param {number} output_offset
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {number} number of faces written to output
+ * @see bt_face_get_neighbour_faces
+ */
+export function bt_face_get_attached_faces(
+    output,
+    output_offset,
+    mesh,
+    face_id
+) {
+
+    assert.isArrayLike(output, "output");
+    assert.isNonNegativeInteger(output_offset, "output_offset");
+    assert.isNonNegativeInteger(face_id, "face_id");
+    assert.defined(mesh, "mesh");
+    assert.notNull(mesh, "mesh");
+    assert.isObject(mesh, "mesh");
+    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
+
+    let count = 0;
+    const first_loop = mesh.face_read_loop(face_id);
+
+    // Safety check for malformed faces
+    if (first_loop === NULL_POINTER) {
+        return 0;
+    }
+
+    let curr_loop = first_loop;
+
+    // 1. Iterate through every loop (vertex) of the given face
+    do {
+        const v = mesh.loop_read_vertex(curr_loop);
+        const first_edge = mesh.vertex_read_edge(v);
+
+        if (first_edge !== NULL_POINTER) {
+            let curr_edge = first_edge;
+
+            // 2. Iterate through the disk cycle (all edges connected to this vertex)
+            do {
+                const first_radial_loop = mesh.edge_read_loop(curr_edge);
+
+                if (first_radial_loop !== NULL_POINTER) {
+                    let curr_radial_loop = first_radial_loop;
+
+                    // 3. Iterate through the radial cycle (all faces sharing this edge)
+                    do {
+                        const adj_face = mesh.loop_read_face(curr_radial_loop);
+
+                        // Ignore the original face and null pointers
+                        if (adj_face !== face_id && adj_face !== NULL_POINTER) {
+
+                            // Check for duplicates (linear scan is fastest for small n)
+                            let is_duplicate = false;
+                            for (let i = 0; i < count; i++) {
+                                if (output[output_offset + i] === adj_face) {
+                                    is_duplicate = true;
+                                    break;
+                                }
+                            }
+
+                            // Write to output if it's uniquely discovered
+                            if (!is_duplicate) {
+                                output[output_offset + count] = adj_face;
+                                count++;
+                            }
+                        }
+
+                        curr_radial_loop = mesh.loop_read_radial_next(curr_radial_loop);
+                    } while (curr_radial_loop !== first_radial_loop && curr_radial_loop !== NULL_POINTER);
+                }
+
+                // Move to the next edge in the vertex's disk cycle
+                if (mesh.edge_read_vertex1(curr_edge) === v) {
+                    curr_edge = mesh.edge_read_v1_disk_next(curr_edge);
+                } else {
+                    curr_edge = mesh.edge_read_v2_disk_next(curr_edge);
+                }
+
+            } while (curr_edge !== first_edge && curr_edge !== NULL_POINTER);
+        }
+
+        // Move to the next loop in the face
+        curr_loop = mesh.loop_read_next(curr_loop);
+    } while (curr_loop !== first_loop && curr_loop !== NULL_POINTER);
+
+    return count;
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Given a face, get the coordinates of its center.
+ * @param {number[]|Float32Array} output 3d vector
+ * @param {number} output_offset where to write
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {boolean} true if centroid computed, false if something went wrong and no result could be produced
+ */
+export function bt_face_get_centroid(output: number[] | Float32Array, output_offset: number, mesh: BinaryTopology, face_id: number): boolean;
+//# sourceMappingURL=bt_face_get_centroid.d.ts.map

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

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

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

@@ -0,0 +1,75 @@
+import { assert } from "../../../../../../assert.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Temporary array to hold the coordinate data read from the vertex
+ */
+const scratch_coord = [0, 0, 0];
+
+/**
+ * Given a face, get the coordinates of its center.
+ * @param {number[]|Float32Array} output 3d vector
+ * @param {number} output_offset where to write
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {boolean} true if centroid computed, false if something went wrong and no result could be produced
+ */
+export function bt_face_get_centroid(
+    output,
+    output_offset,
+    mesh,
+    face_id
+) {
+    assert.isNonNegativeInteger(output_offset, "output_offset");
+    assert.isNonNegativeInteger(face_id, "face_id");
+
+    // 1. Get the starting loop for the face
+    const first_loop_id = mesh.face_read_loop(face_id);
+
+    // Fallback/safety check in case the face is uninitialized or has no loops
+    if (first_loop_id === NULL_POINTER) {
+        return false;
+    }
+
+    let current_loop_id = first_loop_id;
+    let vertex_count = 0;
+
+    let sum_x = 0;
+    let sum_y = 0;
+    let sum_z = 0;
+
+
+    // 2. Circulate through all loops making up the face
+    do {
+        // Read the vertex ID associated with this loop
+        const vertex_id = mesh.loop_read_vertex(current_loop_id);
+
+        // Read the actual 3D coordinates of that vertex into our temp array
+        mesh.vertex_read_coordinate(scratch_coord, 0, vertex_id);
+
+        // Accumulate the positions
+        sum_x += scratch_coord[0];
+        sum_y += scratch_coord[1];
+        sum_z += scratch_coord[2];
+
+        vertex_count++;
+
+        // Step to the next loop around the face boundary
+        current_loop_id = mesh.loop_read_next(current_loop_id);
+
+    } while (current_loop_id !== first_loop_id); // Stop when we complete the cycle
+
+    // 3. Divide by the number of vertices to get the average (centroid)
+    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;
+    } else {
+        // no vertices
+        return false;
+    }
+
+}

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

@@ -0,0 +1,10 @@
+/**
+ * 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: number[] | Float32Array, output_offset: number, mesh: BinaryTopology, face_id: number): boolean;
+//# sourceMappingURL=bt_face_get_incenter.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,85 @@
+import { assert } from "../../../../../../assert.js";
+import { triangle3_incenter } from "../../../../triangle/triangle3_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 triangle3_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_coord, 0, vertex_id);
+
+        sum_x += scratch_coord[0];
+        sum_y += scratch_coord[1];
+        sum_z += scratch_coord[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;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Given a face, get a list of its neighbors.
+ * Two faces are neighbours if they share an edge.
+ * @param {number[]|Uint32Array} output
+ * @param {number} output_offset
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {number} number of faces written to output
+ * @see bt_face_get_attached_faces
+ */
+export function bt_face_get_neighbour_faces(output: number[] | Uint32Array, output_offset: number, mesh: BinaryTopology, face_id: number): number;
+//# sourceMappingURL=bt_face_get_neighbour_faces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_face_get_neighbour_faces.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_get_neighbour_faces.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,oDAPW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,iCAEN,MAAM,GACJ,MAAM,CA+DlB"}

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

@@ -0,0 +1,74 @@
+import { assert } from "../../../../../../assert.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * Given a face, get a list of its neighbors.
+ * Two faces are neighbours if they share an edge.
+ * @param {number[]|Uint32Array} output
+ * @param {number} output_offset
+ * @param {BinaryTopology} mesh
+ * @param {number} face_id
+ * @returns {number} number of faces written to output
+ * @see bt_face_get_attached_faces
+ */
+export function bt_face_get_neighbour_faces(
+    output,
+    output_offset,
+    mesh,
+    face_id
+) {
+    assert.isArrayLike(output, "output");
+    assert.isNonNegativeInteger(output_offset, "output_offset");
+    assert.isNonNegativeInteger(face_id, "face_id");
+    assert.defined(mesh, "mesh");
+    assert.notNull(mesh, "mesh");
+    assert.isObject(mesh, "mesh");
+    assert.equal(mesh.isBinaryTopology, true, "mesh.isBinaryTopology !== true");
+
+    let count = 0;
+    const start_loop = mesh.face_read_loop(face_id);
+
+    // If the face has no loops (e.g., NULL_POINTER: 0xFFFFFFFF), it has no neighbors
+    if (start_loop === NULL_POINTER) {
+        return 0;
+    }
+
+    let current_loop = start_loop;
+
+    do {
+        // Traverse the radial cycle around the edge to find adjacent faces
+        let radial_loop = mesh.loop_read_radial_next(current_loop);
+
+        while (radial_loop !== current_loop) {
+            const neighbor_face = mesh.loop_read_face(radial_loop);
+
+            // Ensure we aren't adding the original face itself
+            if (neighbor_face !== face_id) {
+
+                // Check if we've already added this face (prevents duplicates
+                // if two faces share more than one edge)
+                let is_duplicate = false;
+
+                for (let i = 0; i < count; i++) {
+                    if (output[output_offset + i] === neighbor_face) {
+                        is_duplicate = true;
+                        break;
+                    }
+                }
+
+                if (!is_duplicate) {
+                    output[output_offset + count] = neighbor_face;
+                    count++;
+                }
+            }
+
+            radial_loop = mesh.loop_read_radial_next(radial_loop);
+        }
+
+        // Move to the next boundary loop of the original face
+        current_loop = mesh.loop_read_next(current_loop);
+
+    } while (current_loop !== start_loop);
+
+    return count;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * A degenerate face is one that has zero area.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face
+ * @returns {boolean}
+ */
+export function bt_face_is_degenerate(mesh: BinaryTopology, face: number): boolean;
+//# sourceMappingURL=bt_face_is_degenerate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_face_is_degenerate.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_face_is_degenerate.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,kEAHW,MAAM,GACJ,OAAO,CAmEnB"}

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

@@ -0,0 +1,78 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+const scratch_coord = [0, 0, 0];
+
+
+/**
+ * A degenerate face is one that has zero area.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face
+ * @returns {boolean}
+ */
+export function bt_face_is_degenerate(mesh, face) {
+    const first_loop = mesh.face_read_loop(face);
+
+    // A face with no loops is topologically degenerate
+    if (first_loop === NULL_POINTER) {
+        return true;
+    }
+
+    let current_loop = first_loop;
+    let loop_count = 0;
+
+    // Components for the Newell's method normal vector
+    let nx = 0.0;
+    let ny = 0.0;
+    let nz = 0.0;
+
+    // Read the starting vertex
+    const first_vertex = mesh.loop_read_vertex(current_loop);
+    mesh.vertex_read_coordinate(scratch_coord, 0, first_vertex);
+
+    // to avoid magnitude issue issues in Newell's method, we shift all vertices to a common local reference
+
+    const reference_x = scratch_coord[0];
+    const reference_y = scratch_coord[1];
+    const reference_z = scratch_coord[2];
+
+    let current_x = 0;
+    let current_y = 0;
+    let current_z = 0;
+
+    do {
+        const next_loop = mesh.loop_read_next(current_loop);
+        const next_vertex = mesh.loop_read_vertex(next_loop);
+
+        // Read the next vertex in the cycle
+        mesh.vertex_read_coordinate(scratch_coord, 0, next_vertex);
+
+        const next_x = scratch_coord[0] - reference_x;
+        const next_y = scratch_coord[1] - reference_y;
+        const next_z = scratch_coord[2] - reference_z;
+
+        // Newell's method cross-product accumulations
+        nx += (current_y - next_y) * (current_z + next_z);
+        ny += (current_z - next_z) * (current_x + next_x);
+        nz += (current_x - next_x) * (current_y + next_y);
+
+        // Shift next to current for the next iteration
+        current_x = next_x;
+        current_y = next_y;
+        current_z = next_z;
+
+        current_loop = next_loop;
+        loop_count++;
+    } while (current_loop !== first_loop);
+
+    // A face with fewer than 3 vertices cannot have an area
+    if (loop_count < 3) {
+        return true;
+    }
+
+    // The length of the Newell vector is twice the area of the polygon.
+    // We can just check the squared length against a small epsilon.
+    const area_squared = (nx * nx) + (ny * ny) + (nz * nz);
+
+    return area_squared <= 1e-17;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Build distance field for a given island (group of faces).
+ * Distances are calculated as shortest from the boundary.
+ *
+ * Distances are the shortest distances from the boundary along the mesh.
+ * Only the island vertices are considered.
+ *
+ * Unreachable vertices are marked with Infinity distance.
+ * @param {Map<number, number>} vertex_boundary_distances Mapping from vertex ID to distance from boundary. The result is stored here.
+ * @param {BinaryTopology} mesh
+ * @param {Set<number>} island_vertices
+ * @param {Set<number>} boundary_vertices Subset of island_vertices that are on the boundary.
+ */
+export function bt_mesh_build_boundary_distance_field(vertex_boundary_distances: Map<number, number>, mesh: BinaryTopology, island_vertices: Set<number>, boundary_vertices: Set<number>): void;
+//# sourceMappingURL=bt_mesh_build_boundary_distance_field.d.ts.map

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

@@ -0,0 +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":"AAIA;;;;;;;;;;;;GAYG;AACH,iFALW,IAAI,MAAM,EAAE,MAAM,CAAC,yCAEnB,IAAI,MAAM,CAAC,qBACX,IAAI,MAAM,CAAC,QAuIrB"}