@woosh/meep-engine 2.138.20 → 2.140.0

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

@@ -0,0 +1,227 @@
+import { assert } from "../../../../../../assert.js";
+import { BVH, NULL_NODE } from "../../../../../../bvh2/bvh3/BVH.js";
+import { bvh_query_user_data_ray } from "../../../../../../bvh2/bvh3/query/bvh_query_user_data_ray.js";
+import { seededRandom } from "../../../../../../math/random/seededRandom.js";
+import { SurfacePoint3 } from "../../../../SurfacePoint3.js";
+import { computeTriangleRayIntersection } from "../../../../triangle/computeTriangleRayIntersection.js";
+
+// Three irrational, mutually unrelated ray directions for parity ray-cast
+// majority vote. Same scheme as tetrahedral_mesh_carve_outside_surface — a
+// single ray is fragile at grazing edges, three independent rays settle the
+// vote correctly except in vanishingly improbable configurations.
+const RAY_DIRECTIONS = [
+    0.97123,  0.18927,  0.14431,
+    0.34219,  0.91283, -0.22971,
+   -0.51237,  0.27894,  0.81235,
+];
+const RAY_COUNT = RAY_DIRECTIONS.length / 3;
+
+// Stratification offset cap (as a fraction of a cell). 0 = perfect grid
+// (worst case for Delaunay sliver count), 0.5 = candidates can sit anywhere
+// in the cell. 0.35 is the usual sweet spot: enough jitter to break all
+// face/edge alignments without losing the locality benefits of the grid.
+const JITTER = 0.35;
+
+/**
+ * Build a BVH whose leaves are the surface's triangle faces. User data on
+ * each leaf is the source face ID.
+ */
+function build_surface_bvh(bvh, mesh) {
+    bvh.release_all();
+
+    const face_count = mesh.faces.size;
+    const v = [0, 0, 0];
+
+    for (let f = 0; f < face_count; f++) {
+        if (!mesh.faces.is_allocated(f)) continue;
+
+        const l0 = mesh.face_read_loop(f);
+        const l1 = mesh.loop_read_next(l0);
+        const l2 = mesh.loop_read_next(l1);
+
+        const v0 = mesh.loop_read_vertex(l0);
+        const v1 = mesh.loop_read_vertex(l1);
+        const v2 = mesh.loop_read_vertex(l2);
+
+        mesh.vertex_read_coordinate(v, 0, v0);
+        let minx = v[0], miny = v[1], minz = v[2];
+        let maxx = v[0], maxy = v[1], maxz = v[2];
+
+        mesh.vertex_read_coordinate(v, 0, v1);
+        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
+        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
+        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
+
+        mesh.vertex_read_coordinate(v, 0, v2);
+        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
+        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
+        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
+
+        const node = bvh.allocate_node();
+        bvh.node_set_user_data(node, f);
+        bvh.node_set_aabb_primitive(node, minx, miny, minz, maxx, maxy, maxz);
+        bvh.insert_leaf(node);
+    }
+}
+
+const ray_hit = new SurfacePoint3();
+const ray_candidates = [];
+const va = [0, 0, 0];
+const vb = [0, 0, 0];
+const vc = [0, 0, 0];
+
+/**
+ * Parity ray-cast across `RAY_COUNT` directions; majority decides
+ * inside/outside. Returns true if (strict majority of) rays cross the
+ * surface an odd number of times.
+ */
+function point_is_inside(mesh, bvh, ox, oy, oz) {
+    const root = bvh.root;
+    if (root === NULL_NODE) return false;
+
+    let inside_votes = 0;
+
+    for (let r = 0; r < RAY_COUNT; r++) {
+        const dx = RAY_DIRECTIONS[r * 3];
+        const dy = RAY_DIRECTIONS[r * 3 + 1];
+        const dz = RAY_DIRECTIONS[r * 3 + 2];
+
+        const candidate_count = bvh_query_user_data_ray(
+            bvh, root,
+            ray_candidates, 0,
+            ox, oy, oz,
+            dx, dy, dz
+        );
+
+        let hits = 0;
+        for (let i = 0; i < candidate_count; i++) {
+            const f = ray_candidates[i];
+            const l0 = mesh.face_read_loop(f);
+            const l1 = mesh.loop_read_next(l0);
+            const l2 = mesh.loop_read_next(l1);
+
+            mesh.vertex_read_coordinate(va, 0, mesh.loop_read_vertex(l0));
+            mesh.vertex_read_coordinate(vb, 0, mesh.loop_read_vertex(l1));
+            mesh.vertex_read_coordinate(vc, 0, mesh.loop_read_vertex(l2));
+
+            const hit = computeTriangleRayIntersection(
+                ray_hit,
+                ox, oy, oz,
+                dx, dy, dz,
+                va[0], va[1], va[2],
+                vb[0], vb[1], vb[2],
+                vc[0], vc[1], vc[2]
+            );
+
+            if (hit) hits++;
+        }
+
+        if ((hits & 1) === 1) inside_votes++;
+    }
+
+    return inside_votes * 2 > RAY_COUNT;
+}
+
+/**
+ * Sample interior Steiner points for the volume enclosed by a closed
+ * triangle surface, on a jittered axis-aligned grid sized by
+ * `cells_per_dim`. Points outside the surface are discarded; what remains
+ * is a Float32Array of (x, y, z) tuples that lies strictly inside the
+ * surface (modulo classification noise on near-surface samples).
+ *
+ * Intended as input to `compute_delaunay_tetrahedral_mesh` alongside the
+ * surface vertices, so the Delaunay tet mesh has interior detail rather
+ * than being made entirely of surface-bound tets. Without these Steiner
+ * points, every tet of a non-trivial volume straddles or touches the
+ * surface, blowing up centroid-classification discretization error in
+ * the carving step.
+ *
+ * Grid cells are scaled so the longest bounding-box axis gets
+ * `cells_per_dim` cells; other axes get a proportional share rounded to
+ * the nearest integer (minimum 1). Each cell contributes one candidate
+ * point at its center, perturbed by a deterministic seeded jitter of up
+ * to ±0.35 cell widths — enough to break Delaunay-pathological
+ * alignments without losing the grid's spatial uniformity.
+ *
+ * @param {BinaryTopology} mesh closed surface
+ * @param {number} cells_per_dim grid resolution along the longest bbox axis
+ * @param {number} [seed] seed for the jitter RNG; same seed → same points
+ * @returns {Float32Array} flat (x, y, z) interior point positions
+ */
+export function bt_mesh_sample_interior_grid_points(mesh, cells_per_dim, seed = 0) {
+    assert.defined(mesh, 'mesh');
+    assert.equal(mesh.isBinaryTopology, true, 'mesh.isBinaryTopology !== true');
+    assert.isPositiveInteger(cells_per_dim, 'cells_per_dim');
+
+    // Compute bounding box from vertex pool.
+    const vertices = mesh.vertices;
+    const vertex_count = vertices.size;
+    const coord = [0, 0, 0];
+
+    let min_x = Infinity, min_y = Infinity, min_z = Infinity;
+    let max_x = -Infinity, max_y = -Infinity, max_z = -Infinity;
+
+    for (let v = 0; v < vertex_count; v++) {
+        if (!vertices.is_allocated(v)) continue;
+        mesh.vertex_read_coordinate(coord, 0, v);
+        if (coord[0] < min_x) min_x = coord[0]; if (coord[0] > max_x) max_x = coord[0];
+        if (coord[1] < min_y) min_y = coord[1]; if (coord[1] > max_y) max_y = coord[1];
+        if (coord[2] < min_z) min_z = coord[2]; if (coord[2] > max_z) max_z = coord[2];
+    }
+
+    if (!isFinite(min_x)) {
+        // Empty mesh.
+        return new Float32Array(0);
+    }
+
+    const dx = max_x - min_x;
+    const dy = max_y - min_y;
+    const dz = max_z - min_z;
+    const longest = Math.max(dx, dy, dz);
+
+    if (longest === 0) {
+        // Degenerate: all vertices coincide. No interior to sample.
+        return new Float32Array(0);
+    }
+
+    // Per-axis cell count, rounded so cells are roughly cubical.
+    const cells_x = Math.max(1, Math.round((cells_per_dim * dx) / longest));
+    const cells_y = Math.max(1, Math.round((cells_per_dim * dy) / longest));
+    const cells_z = Math.max(1, Math.round((cells_per_dim * dz) / longest));
+
+    const cell_w = dx / cells_x;
+    const cell_h = dy / cells_y;
+    const cell_d = dz / cells_z;
+
+    // Build BVH over surface triangles for the inside-test.
+    const bvh = new BVH();
+    build_surface_bvh(bvh, mesh);
+
+    const rng = seededRandom(seed);
+    const out = []; // grow dynamically; copy to Float32Array at the end
+
+    for (let iz = 0; iz < cells_z; iz++) {
+        const cz0 = min_z + (iz + 0.5) * cell_d;
+        for (let iy = 0; iy < cells_y; iy++) {
+            const cy0 = min_y + (iy + 0.5) * cell_h;
+            for (let ix = 0; ix < cells_x; ix++) {
+                const cx0 = min_x + (ix + 0.5) * cell_w;
+
+                // Jitter each axis independently within ±JITTER cells.
+                const jx = (rng() * 2 - 1) * JITTER * cell_w;
+                const jy = (rng() * 2 - 1) * JITTER * cell_h;
+                const jz = (rng() * 2 - 1) * JITTER * cell_d;
+
+                const px = cx0 + jx;
+                const py = cy0 + jy;
+                const pz = cz0 + jz;
+
+                if (point_is_inside(mesh, bvh, px, py, pz)) {
+                    out.push(px, py, pz);
+                }
+            }
+        }
+    }
+
+    return new Float32Array(out);
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Enumerate the boundary edge cycles of a BinaryTopology mesh as ordered
+ * sequences of edge IDs. Each cycle traces a single hole in the surface, in
+ * the order the edges appear along the boundary.
+ *
+ * Throws if any boundary vertex has more than two boundary edges (figure-8 /
+ * bridged loops are not supported in this pass — repair the mesh first).
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number[][]} array of cycles; each cycle is an array of boundary edge IDs
+ */
+export function bt_mesh_walk_boundary_loops(mesh: BinaryTopology): number[][];
+//# sourceMappingURL=bt_mesh_walk_boundary_loops.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_walk_boundary_loops.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_mesh_walk_boundary_loops.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;GAUG;AACH,mEAFa,MAAM,EAAE,EAAE,CA0CtB"}

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

@@ -0,0 +1,108 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_query_edge_is_boundary } from "./bt_query_edge_is_boundary.js";
+
+/**
+ * Step one position around the disk cycle of `vertex`, starting from `edge`.
+ * @param {BinaryTopology} mesh
+ * @param {number} edge
+ * @param {number} vertex
+ * @returns {number} next edge in the disk cycle around `vertex`
+ */
+function disk_next(mesh, edge, vertex) {
+    if (mesh.edge_read_vertex1(edge) === vertex) {
+        return mesh.edge_read_v1_disk_next(edge);
+    }
+    return mesh.edge_read_v2_disk_next(edge);
+}
+
+/**
+ * Find the unique boundary edge incident to `vertex` other than `from_edge`.
+ * Throws if the vertex does not have exactly 2 boundary edges (a 2-manifold
+ * boundary vertex must have exactly 2; fewer or more means the boundary is
+ * not a simple cycle — e.g., a figure-8 / bridged pinch).
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} vertex
+ * @param {number} from_edge
+ * @returns {number}
+ */
+function next_boundary_edge_at_vertex(mesh, vertex, from_edge) {
+    const first_edge = mesh.vertex_read_edge(vertex);
+
+    let found = NULL_POINTER;
+    let extras = 0;
+
+    let edge = first_edge;
+    do {
+        if (edge !== from_edge && bt_query_edge_is_boundary(mesh, edge)) {
+            if (found === NULL_POINTER) {
+                found = edge;
+            } else {
+                extras++;
+            }
+        }
+        edge = disk_next(mesh, edge, vertex);
+    } while (edge !== first_edge);
+
+    if (found === NULL_POINTER) {
+        throw new Error(`boundary at vertex ${vertex} is malformed: only one boundary edge attached (dead-end)`);
+    }
+    if (extras > 0) {
+        throw new Error(`boundary at vertex ${vertex} is malformed: ${extras + 2} boundary edges attached (pinch / figure-8 loops are not supported)`);
+    }
+
+    return found;
+}
+
+/**
+ * Enumerate the boundary edge cycles of a BinaryTopology mesh as ordered
+ * sequences of edge IDs. Each cycle traces a single hole in the surface, in
+ * the order the edges appear along the boundary.
+ *
+ * Throws if any boundary vertex has more than two boundary edges (figure-8 /
+ * bridged loops are not supported in this pass — repair the mesh first).
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {number[][]} array of cycles; each cycle is an array of boundary edge IDs
+ */
+export function bt_mesh_walk_boundary_loops(mesh) {
+    const cycles = [];
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+
+    const visited = new Uint8Array(edge_count);
+
+    for (let seed = 0; seed < edge_count; seed++) {
+        if (visited[seed]) {
+            continue;
+        }
+        if (!edges.is_allocated(seed)) {
+            continue;
+        }
+        if (!bt_query_edge_is_boundary(mesh, seed)) {
+            continue;
+        }
+
+        const cycle = [];
+        let edge = seed;
+        let from_vertex = mesh.edge_read_vertex1(edge);
+
+        do {
+            visited[edge] = 1;
+            cycle.push(edge);
+
+            const v1 = mesh.edge_read_vertex1(edge);
+            const v2 = mesh.edge_read_vertex2(edge);
+            const next_vertex = (v1 === from_vertex) ? v2 : v1;
+
+            const next_edge = next_boundary_edge_at_vertex(mesh, next_vertex, edge);
+
+            edge = next_edge;
+            from_vertex = next_vertex;
+        } while (edge !== seed);
+
+        cycles.push(cycle);
+    }
+
+    return cycles;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * An edge is a boundary edge when exactly one face uses it — i.e., its radial
+ * cycle contains a single loop. Wire edges (no loops on the radial cycle) and
+ * manifold edges (two loops) return false.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @returns {boolean}
+ */
+export function bt_query_edge_is_boundary(mesh: BinaryTopology, edge_id: number): boolean;
+//# sourceMappingURL=bt_query_edge_is_boundary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bt_query_edge_is_boundary.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/query/bt_query_edge_is_boundary.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,yEAHW,MAAM,GACJ,OAAO,CAUnB"}

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

@@ -0,0 +1,20 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+
+/**
+ * An edge is a boundary edge when exactly one face uses it — i.e., its radial
+ * cycle contains a single loop. Wire edges (no loops on the radial cycle) and
+ * manifold edges (two loops) return false.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} edge_id
+ * @returns {boolean}
+ */
+export function bt_query_edge_is_boundary(mesh, edge_id) {
+    const loop = mesh.edge_read_loop(edge_id);
+
+    if (loop === NULL_POINTER) {
+        return false;
+    }
+
+    return mesh.loop_read_radial_next(loop) === loop;
+}

package/src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Compute the signed volume enclosed by a triangle surface mesh given as
+ * flat positions + indices, via the divergence theorem.
+ *
+ * For every triangle (a, b, c) this sums the signed volume of the
+ * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
+ * wound (CCW from outside → positive volume), the per-triangle contributions
+ * cancel everywhere except inside the surface, leaving the enclosed volume.
+ *
+ * Useful as a ground truth for validating volumetric mesh generation: the
+ * tetrahedralized version of the same closed surface should have a total tet
+ * volume close to this value (small discretization gap aside).
+ *
+ * @param {ArrayLike<number>} positions flat (x,y,z,…) array
+ * @param {ArrayLike<number>} indices   3 entries per triangle
+ * @returns {number} signed volume — positive for CCW-from-outside winding,
+ *                   negative if flipped, zero for an open or self-cancelling mesh
+ */
+export function triangle_mesh_compute_signed_volume(positions: ArrayLike<number>, indices: ArrayLike<number>): number;
+//# sourceMappingURL=triangle_mesh_compute_signed_volume.d.ts.map

package/src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangle_mesh_compute_signed_volume.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,+DALW,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,GACf,MAAM,CAoBlB"}

package/src/core/geom/3d/triangle/triangle_mesh_compute_signed_volume.js

@@ -0,0 +1,38 @@
+import { triangle_compute_signed_volume } from "./triangle_compute_signed_volume.js";
+
+/**
+ * Compute the signed volume enclosed by a triangle surface mesh given as
+ * flat positions + indices, via the divergence theorem.
+ *
+ * For every triangle (a, b, c) this sums the signed volume of the
+ * tetrahedron (origin, a, b, c); when the mesh is closed and consistently
+ * wound (CCW from outside → positive volume), the per-triangle contributions
+ * cancel everywhere except inside the surface, leaving the enclosed volume.
+ *
+ * Useful as a ground truth for validating volumetric mesh generation: the
+ * tetrahedralized version of the same closed surface should have a total tet
+ * volume close to this value (small discretization gap aside).
+ *
+ * @param {ArrayLike<number>} positions flat (x,y,z,…) array
+ * @param {ArrayLike<number>} indices   3 entries per triangle
+ * @returns {number} signed volume — positive for CCW-from-outside winding,
+ *                   negative if flipped, zero for an open or self-cancelling mesh
+ */
+export function triangle_mesh_compute_signed_volume(positions, indices) {
+    let total = 0;
+
+    const n = indices.length;
+    for (let i = 0; i < n; i += 3) {
+        const a3 = indices[i] * 3;
+        const b3 = indices[i + 1] * 3;
+        const c3 = indices[i + 2] * 3;
+
+        total += triangle_compute_signed_volume(
+            positions[a3],     positions[a3 + 1], positions[a3 + 2],
+            positions[b3],     positions[b3 + 1], positions[b3 + 2],
+            positions[c3],     positions[c3 + 1], positions[c3 + 2],
+        );
+    }
+
+    return total;
+}

package/src/core/geom/3d/triangle/v3_compute_triangle_normal.d.ts

@@ -1,6 +1,6 @@
 /**
  * Compute face normal for a triangle
- * @param {number[]|Float32Array} result X,Y,Z normalized vector is written here
+ * @param {number[]|Float32Array|Float64Array} result X,Y,Z normalized vector is written here
  * @param {number} result_offset offset into result array where to start writing
  * @param {number} a_x
  * @param {number} a_y
@@ -12,5 +12,5 @@
  * @param {number} c_y
  * @param {number} c_z
  */
-export function v3_compute_triangle_normal(result: number[] | Float32Array, result_offset: number, a_x: number, a_y: number, a_z: number, b_x: number, b_y: number, b_z: number, c_x: number, c_y: number, c_z: number): void;
+export function v3_compute_triangle_normal(result: number[] | Float32Array | Float64Array, result_offset: number, a_x: number, a_y: number, a_z: number, b_x: number, b_y: number, b_z: number, c_x: number, c_y: number, c_z: number): void;
 //# sourceMappingURL=v3_compute_triangle_normal.d.ts.map

package/src/core/geom/3d/triangle/v3_compute_triangle_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_compute_triangle_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/v3_compute_triangle_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,mDAZW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA0ChB"}
+{"version":3,"file":"v3_compute_triangle_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/v3_compute_triangle_normal.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,mDAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QA0ChB"}

package/src/core/geom/3d/triangle/v3_compute_triangle_normal.js

@@ -2,7 +2,7 @@ import { v3_length_sqr } from "../../vec3/v3_length_sqr.js";
 
 /**
  * Compute face normal for a triangle
- * @param {number[]|Float32Array} result X,Y,Z normalized vector is written here
+ * @param {number[]|Float32Array|Float64Array} result X,Y,Z normalized vector is written here
  * @param {number} result_offset offset into result array where to start writing
  * @param {number} a_x
  * @param {number} a_y

package/src/core/geom/vec3/v3_dot_array_array.d.ts

@@ -1,10 +1,10 @@
 /**
  *
- * @param {number[]|Float32Array} a
+ * @param {number[]|Float32Array|Float64Array} a
  * @param {number} a_offset
- * @param {number[]|Float32Array} b
+ * @param {number[]|Float32Array|Float64Array} b
  * @param {number} b_offset
  * @returns {number}
  */
-export function v3_dot_array_array(a: number[] | Float32Array, a_offset: number, b: number[] | Float32Array, b_offset: number): number;
+export function v3_dot_array_array(a: number[] | Float32Array | Float64Array, a_offset: number, b: number[] | Float32Array | Float64Array, b_offset: number): number;
 //# sourceMappingURL=v3_dot_array_array.d.ts.map

package/src/core/geom/vec3/v3_dot_array_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_dot_array_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_dot_array_array.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,YACrB,MAAM,GACJ,MAAM,CAgBlB"}
+{"version":3,"file":"v3_dot_array_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_dot_array_array.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,YAClC,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/geom/vec3/v3_dot_array_array.js

@@ -1,8 +1,8 @@
 /**
  *
- * @param {number[]|Float32Array} a
+ * @param {number[]|Float32Array|Float64Array} a
  * @param {number} a_offset
- * @param {number[]|Float32Array} b
+ * @param {number[]|Float32Array|Float64Array} b
  * @param {number} b_offset
  * @returns {number}
  */

package/src/core/geom/vec3/v3_negate_array.d.ts

@@ -1,9 +1,9 @@
 /**
  *
- * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
- * @param {number[]|Float32Array} input
+ * @param {number[]|Float32Array|Float64Array} input
  * @param {number} input_offset
  */
-export function v3_negate_array(result: number[] | Float32Array, result_offset: number, input: number[] | Float32Array, input_offset: number): void;
+export function v3_negate_array(result: number[] | Float32Array | Float64Array, result_offset: number, input: number[] | Float32Array | Float64Array, input_offset: number): void;
 //# sourceMappingURL=v3_negate_array.d.ts.map

package/src/core/geom/vec3/v3_negate_array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_negate_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_negate_array.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wCALW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,gBACrB,MAAM,QAUhB"}
+{"version":3,"file":"v3_negate_array.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_negate_array.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wCALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,SACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,QAUhB"}

package/src/core/geom/vec3/v3_negate_array.js

@@ -1,8 +1,8 @@
 /**
  *
- * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array|Float64Array} result
  * @param {number} result_offset
- * @param {number[]|Float32Array} input
+ * @param {number[]|Float32Array|Float64Array} input
  * @param {number} input_offset
  */
 export function v3_negate_array(result, result_offset, input, input_offset) {

package/src/core/geom/vec3/v3_quat3_apply.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Rotate a 3-D vector by a unit quaternion: `result = q · v · q*`.
+ *
+ * The closed-form expansion below is the standard "two Hamilton
+ * products with a pure-quaternion v" derivation. We compute the
+ * intermediate `t = q · v` (treating v as a quaternion with `w = 0`),
+ * then `result = t · q*` (where `q* = (-qx, -qy, -qz, qw)`). Inline
+ * the sign of the conjugate so the final multiplies avoid temporary
+ * negations.
+ *
+ * Sign convention: `(qx, qy, qz, qw)` — `w` last, matching the
+ * project's existing {@link Quaternion} class and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Companion to {@link v3_quat3_apply_inverse} (rotates by the
+ * conjugate, i.e. inverse rotation).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quat3_apply(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+//# sourceMappingURL=v3_quat3_apply.d.ts.map

package/src/core/geom/vec3/v3_quat3_apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_quat3_apply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAahB"}

package/src/core/geom/vec3/v3_quat3_apply.js

@@ -0,0 +1,39 @@
+/**
+ * Rotate a 3-D vector by a unit quaternion: `result = q · v · q*`.
+ *
+ * The closed-form expansion below is the standard "two Hamilton
+ * products with a pure-quaternion v" derivation. We compute the
+ * intermediate `t = q · v` (treating v as a quaternion with `w = 0`),
+ * then `result = t · q*` (where `q* = (-qx, -qy, -qz, qw)`). Inline
+ * the sign of the conjugate so the final multiplies avoid temporary
+ * negations.
+ *
+ * Sign convention: `(qx, qy, qz, qw)` — `w` last, matching the
+ * project's existing {@link Quaternion} class and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Companion to {@link v3_quat3_apply_inverse} (rotates by the
+ * conjugate, i.e. inverse rotation).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quat3_apply(out, out_offset, vx, vy, vz, qx, qy, qz, qw) {
+    // t = q · v   (Hamilton product, v as pure quaternion w=0)
+    const tx =  qw * vx + qy * vz - qz * vy;
+    const ty =  qw * vy + qz * vx - qx * vz;
+    const tz =  qw * vz + qx * vy - qy * vx;
+    const tw = -qx * vx - qy * vy - qz * vz;
+
+    // result = t · q*   (q* = -qx, -qy, -qz, qw)
+    out[out_offset]     = tx * qw - tw * qx - ty * qz + tz * qy;
+    out[out_offset + 1] = ty * qw - tw * qy - tz * qx + tx * qz;
+    out[out_offset + 2] = tz * qw - tw * qz - tx * qy + ty * qx;
+}

package/src/core/geom/vec3/v3_quat3_apply_inverse.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Inverse-rotate a 3-D vector by a unit quaternion: `result = q* · v · q`,
+ * where `q* = (-qx, -qy, -qz, qw)` is the conjugate.
+ *
+ * Geometrically: if {@link v3_quat3_apply} rotates a body-local vector
+ * into world space (`v_world = q · v_local · q*`), this is the inverse —
+ * it takes a world-space vector and writes it in body-local coordinates.
+ * For unit quaternions the conjugate IS the inverse, so the two
+ * functions are exact inverses of each other.
+ *
+ * Implementation: the conjugate's `xyz` are negated relative to `q`.
+ * Expanding `c · v · c*` with `(cx, cy, cz, cw) = (-qx, -qy, -qz, qw)`
+ * and simplifying produces the closed form below — different sign
+ * pattern than {@link v3_quat3_apply}, NOT just a call with negated
+ * components (the optimisation matters for hot-path callers such as
+ * `PosedShape.support` and the per-triangle concave dispatch in
+ * `narrowphase_step`).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quat3_apply_inverse(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+//# sourceMappingURL=v3_quat3_apply_inverse.d.ts.map

package/src/core/geom/vec3/v3_quat3_apply_inverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_quat3_apply_inverse.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply_inverse.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB"}