@woosh/meep-engine 3.56.0 → 3.57.0

package/src/core/geom/3d/atlas/segment/atlas_merge_charts.js

@@ -1,116 +1,105 @@
-import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
-
-/**
- * Default minimum proxy-normal dot for a merge. Conservative (~25°): only
- * near-coplanar adjacent charts merge, so the merged chart stays flat enough to
- * parameterize without new distortion. xatlas uses 0.5 (~60°) but pairs it with
- * a per-merge ortho re-validation we deliberately leave to the downstream
- * parameterization (an over-aggressive merge that can't flatten simply falls back
- * to LSCM/piecewise — and the metrics A/B gate catches any regression).
- */
-const DEFAULT_MERGE_MIN_DOT = 0.9;
-
-/**
- * Greedily merge adjacent charts whose area-weighted proxy normals are nearly
- * aligned (xatlas `mergeCharts`, conservative variant), reducing over-
- * segmentation left by the greedy seed+grow. Union-find over chart ids; proxy
- * accumulators are summed as charts merge, so each test is against the current
- * merged normal. Interior edges are visited in ascending id order, and the
- * smaller chart id is always chosen as the union root, so the relabelling is
- * deterministic. Coverage is preserved (every face keeps a chart; ids densified).
- *
- * This does NOT re-parameterize — the driver re-extracts and parameterizes the
- * merged charts. Zero-area charts (degenerate proxy) are never merged.
- *
- * @param {BinaryTopology} mesh face normals populated
- * @param {Int32Array} face_chart face -> chart id (-1 if none)
- * @param {number} chart_count
- * @param {Float32Array} face_areas
- * @param {object} [options]
- * @param {number} [options.mergeMinDot] min proxy-normal dot to merge (default 0.9)
- * @returns {{face_chart: Int32Array, chart_count: number}}
- */
-export function atlas_merge_charts(mesh, face_chart, chart_count, face_areas, options = {}) {
-    const min_dot = options.mergeMinDot ?? DEFAULT_MERGE_MIN_DOT;
-    const faces = mesh.faces;
-    const face_count = faces.size;
-
-    // per-chart area-weighted (un-normalized) normal accumulator = the proxy
-    const proxy = new Float64Array(chart_count * 3);
-    const fn = new Float32Array(3);
-    for (let f = 0; f < face_count; f++) {
-        if (!faces.is_allocated(f)) continue;
-        const c = face_chart[f];
-        if (c < 0) continue;
-        const a = face_areas[f];
-        mesh.face_read_normal(fn, 0, f);
-        proxy[c * 3] += fn[0] * a;
-        proxy[c * 3 + 1] += fn[1] * a;
-        proxy[c * 3 + 2] += fn[2] * a;
-    }
-
-    const parent = new Int32Array(chart_count);
-    for (let c = 0; c < chart_count; c++) parent[c] = c;
-
-    /**
-     * @param {number} x
-     * @returns {number} root with path compression
-     */
-    function find(x) {
-        while (parent[x] !== x) {
-            parent[x] = parent[parent[x]];
-            x = parent[x];
-        }
-        return x;
-    }
-
-    /** Whether two roots' proxy normals are within the merge cone. */
-    function aligned(a, b) {
-        const ax = proxy[a * 3], ay = proxy[a * 3 + 1], az = proxy[a * 3 + 2];
-        const bx = proxy[b * 3], by = proxy[b * 3 + 1], bz = proxy[b * 3 + 2];
-        const la = Math.sqrt(ax * ax + ay * ay + az * az);
-        const lb = Math.sqrt(bx * bx + by * by + bz * bz);
-        if (la === 0 || lb === 0) return false; // zero-area chart -> never merge
-        return (ax * bx + ay * by + az * bz) / (la * lb) >= min_dot;
-    }
-
-    const edges = mesh.edges;
-    const edge_count = edges.size;
-    for (let e = 0; e < edge_count; e++) {
-        if (!edges.is_allocated(e)) continue;
-        const l1 = mesh.edge_read_loop(e);
-        if (l1 === NULL_POINTER) continue;
-        const l2 = mesh.loop_read_radial_next(l1);
-        if (l2 === l1) continue; // mesh boundary edge
-
-        const c1 = face_chart[mesh.loop_read_face(l1)];
-        const c2 = face_chart[mesh.loop_read_face(l2)];
-        if (c1 < 0 || c2 < 0 || c1 === c2) continue;
-
-        const r1 = find(c1);
-        const r2 = find(c2);
-        if (r1 === r2 || !aligned(r1, r2)) continue;
-
-        const root = r1 < r2 ? r1 : r2;
-        const other = r1 < r2 ? r2 : r1;
-        parent[other] = root;
-        proxy[root * 3] += proxy[other * 3];
-        proxy[root * 3 + 1] += proxy[other * 3 + 1];
-        proxy[root * 3 + 2] += proxy[other * 3 + 2];
-    }
-
-    // densify root ids in ascending order
-    const dense = new Int32Array(chart_count).fill(-1);
-    let new_count = 0;
-    for (let c = 0; c < chart_count; c++) {
-        const r = find(c);
-        if (dense[r] === -1) dense[r] = new_count++;
-    }
-
-    const out = new Int32Array(face_count).fill(-1);
-    for (let f = 0; f < face_count; f++) {
-        const c = face_chart[f];
-        if (c >= 0) out[f] = dense[find(c)];
-    }
-    return { face_chart: out, chart_count: new_count };
-}
+import { uf_find, uf_init } from "../../../../collection/union-find/union_find.js";
+import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
+
+/**
+ * Default minimum proxy-normal dot for a merge. Conservative (~25°): only
+ * near-coplanar adjacent charts merge, so the merged chart stays flat enough to
+ * parameterize without new distortion. xatlas uses 0.5 (~60°) but pairs it with
+ * a per-merge ortho re-validation we deliberately leave to the downstream
+ * parameterization (an over-aggressive merge that can't flatten simply falls back
+ * to LSCM/piecewise — and the metrics A/B gate catches any regression).
+ */
+const DEFAULT_MERGE_MIN_DOT = 0.9;
+
+/**
+ * Greedily merge adjacent charts whose area-weighted proxy normals are nearly
+ * aligned (xatlas `mergeCharts`, conservative variant), reducing over-
+ * segmentation left by the greedy seed+grow. Union-find over chart ids; proxy
+ * accumulators are summed as charts merge, so each test is against the current
+ * merged normal. Interior edges are visited in ascending id order, and the
+ * smaller chart id is always chosen as the union root, so the relabelling is
+ * deterministic. Coverage is preserved (every face keeps a chart; ids densified).
+ *
+ * This does NOT re-parameterize — the driver re-extracts and parameterizes the
+ * merged charts. Zero-area charts (degenerate proxy) are never merged.
+ *
+ * @param {BinaryTopology} mesh face normals populated
+ * @param {Int32Array} face_chart face -> chart id (-1 if none)
+ * @param {number} chart_count
+ * @param {Float32Array} face_areas
+ * @param {object} [options]
+ * @param {number} [options.mergeMinDot] min proxy-normal dot to merge (default 0.9)
+ * @returns {{face_chart: Int32Array, chart_count: number}}
+ */
+export function atlas_merge_charts(mesh, face_chart, chart_count, face_areas, options = {}) {
+    const min_dot = options.mergeMinDot ?? DEFAULT_MERGE_MIN_DOT;
+    const faces = mesh.faces;
+    const face_count = faces.size;
+
+    // per-chart area-weighted (un-normalized) normal accumulator = the proxy
+    const proxy = new Float64Array(chart_count * 3);
+    const fn = new Float32Array(3);
+    for (let f = 0; f < face_count; f++) {
+        if (!faces.is_allocated(f)) continue;
+        const c = face_chart[f];
+        if (c < 0) continue;
+        const a = face_areas[f];
+        mesh.face_read_normal(fn, 0, f);
+        proxy[c * 3] += fn[0] * a;
+        proxy[c * 3 + 1] += fn[1] * a;
+        proxy[c * 3 + 2] += fn[2] * a;
+    }
+
+    const parent = new Int32Array(chart_count);
+    uf_init(parent, chart_count);
+
+    /** Whether two roots' proxy normals are within the merge cone. */
+    function aligned(a, b) {
+        const ax = proxy[a * 3], ay = proxy[a * 3 + 1], az = proxy[a * 3 + 2];
+        const bx = proxy[b * 3], by = proxy[b * 3 + 1], bz = proxy[b * 3 + 2];
+        const la = Math.sqrt(ax * ax + ay * ay + az * az);
+        const lb = Math.sqrt(bx * bx + by * by + bz * bz);
+        if (la === 0 || lb === 0) return false; // zero-area chart -> never merge
+        return (ax * bx + ay * by + az * bz) / (la * lb) >= min_dot;
+    }
+
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+    for (let e = 0; e < edge_count; e++) {
+        if (!edges.is_allocated(e)) continue;
+        const l1 = mesh.edge_read_loop(e);
+        if (l1 === NULL_POINTER) continue;
+        const l2 = mesh.loop_read_radial_next(l1);
+        if (l2 === l1) continue; // mesh boundary edge
+
+        const c1 = face_chart[mesh.loop_read_face(l1)];
+        const c2 = face_chart[mesh.loop_read_face(l2)];
+        if (c1 < 0 || c2 < 0 || c1 === c2) continue;
+
+        const r1 = uf_find(parent, c1);
+        const r2 = uf_find(parent, c2);
+        if (r1 === r2 || !aligned(r1, r2)) continue;
+
+        const root = r1 < r2 ? r1 : r2;
+        const other = r1 < r2 ? r2 : r1;
+        parent[other] = root;
+        proxy[root * 3] += proxy[other * 3];
+        proxy[root * 3 + 1] += proxy[other * 3 + 1];
+        proxy[root * 3 + 2] += proxy[other * 3 + 2];
+    }
+
+    // densify root ids in ascending order
+    const dense = new Int32Array(chart_count).fill(-1);
+    let new_count = 0;
+    for (let c = 0; c < chart_count; c++) {
+        const r = uf_find(parent, c);
+        if (dense[r] === -1) dense[r] = new_count++;
+    }
+
+    const out = new Int32Array(face_count).fill(-1);
+    for (let f = 0; f < face_count; f++) {
+        const c = face_chart[f];
+        if (c >= 0) out[f] = dense[uf_find(parent, c)];
+    }
+    return { face_chart: out, chart_count: new_count };
+}

package/src/core/geom/3d/line/line3_compute_segment_point_distance_sqr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_point_distance_sqr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_sqr.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAsClB"}
+{"version":3,"file":"line3_compute_segment_point_distance_sqr.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_sqr.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,6DAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAqBlB"}

package/src/core/geom/3d/line/line3_compute_segment_point_distance_sqr.js

@@ -1,54 +1,36 @@
-import { clamp01 } from "../../../math/clamp01.js";
-import { v3_distance_sqr } from "../../vec3/v3_distance_sqr.js";
-import { line3_compute_segment_closest_point_t } from "./line3_compute_segment_closest_point_t.js";
-
-/**
- * Computes the shortest distance squared between a line segment defined by 2 points and another point
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number}
- * @see line3_compute_segment_closest_point_t
- */
-export function line3_compute_segment_point_distance_sqr(
-    x0, y0, z0,
-    x1, y1, z1,
-    px, py, pz
-) {
-
-    // get line delta
-    const line_delta_x = x1 - x0;
-    const line_delta_y = y1 - y0;
-    const line_delta_z = z1 - z0;
-
-    // find closest point
-    const sp0_x = px - x0;
-    const sp0_y = py - y0;
-    const sp0_z = pz - z0;
-
-    //
-    const d2 = line_delta_x * line_delta_x + line_delta_y * line_delta_y + line_delta_z * line_delta_z;
-
-    if (d2 === 0) {
-        // line is a point
-        return v3_distance_sqr(px, py, pz, x0, y0, z0);
-    }
-
-    const d3 = line_delta_x * sp0_x + line_delta_y * sp0_y + line_delta_z * sp0_z;
-
-    const t = clamp01(d3 / d2);
-
-    // compute point on the line
-    const lp_x = line_delta_x * t + x0;
-    const lp_y = line_delta_y * t + y0;
-    const lp_z = line_delta_z * t + z0;
-
-    // compute distance from the point in question to the point on the line
-    return v3_distance_sqr(px, py, pz, lp_x, lp_y, lp_z);
-}
+import { v3_distance_sqr } from "../../vec3/v3_distance_sqr.js";
+import { line3_compute_segment_closest_point_t } from "./line3_compute_segment_closest_point_t.js";
+
+/**
+ * Computes the shortest distance squared between a line segment defined by 2 points and another point
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number}
+ * @see line3_compute_segment_closest_point_t
+ */
+export function line3_compute_segment_point_distance_sqr(
+    x0, y0, z0,
+    x1, y1, z1,
+    px, py, pz
+) {
+    const t = line3_compute_segment_closest_point_t(
+        x0, y0, z0,
+        x1, y1, z1,
+        px, py, pz
+    );
+
+    // compute point on the line
+    const lp_x = (x1 - x0) * t + x0;
+    const lp_y = (y1 - y0) * t + y0;
+    const lp_z = (z1 - z0) * t + z0;
+
+    // compute distance from the point in question to the point on the line
+    return v3_distance_sqr(px, py, pz, lp_x, lp_y, lp_z);
+}

package/src/core/geom/3d/plane/plane3_compute_intersection_objects.d.ts

@@ -1,14 +1,9 @@
 /**
-
- Algorithm taken from http://geomalgorithms.com/a05-_intersect-1.html. See the
- section 'Intersection of 2 Planes' and specifically the subsection
- (A) Direct Linear Equation
- TODO consolidate with {@link plane3_intersect_plane} as they seem to do the same thing
- @param {Plane} p1
- @param {Plane} p2
- @param {Vector3} out_point
- @param {Vector3} out_direction
- @returns {boolean}
+ * @param {Plane} p1
+ * @param {Plane} p2
+ * @param {Vector3} out_point
+ * @param {Vector3} out_direction
+ * @returns {boolean}
  */
 export function plane3_compute_intersection_objects(p1: Plane, p2: Plane, out_point: Vector3, out_direction: Vector3): boolean;
 //# sourceMappingURL=plane3_compute_intersection_objects.d.ts.map

package/src/core/geom/3d/plane/plane3_compute_intersection_objects.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plane3_compute_intersection_objects.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/plane3_compute_intersection_objects.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,uHAFW,OAAO,CAqCjB"}
+{"version":3,"file":"plane3_compute_intersection_objects.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/plane3_compute_intersection_objects.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,uHAFa,OAAO,CAYnB"}

package/src/core/geom/3d/plane/plane3_compute_intersection_objects.js

@@ -1,82 +1,20 @@
-/**
-
- Algorithm taken from http://geomalgorithms.com/a05-_intersect-1.html. See the
- section 'Intersection of 2 Planes' and specifically the subsection
- (A) Direct Linear Equation
- TODO consolidate with {@link plane3_intersect_plane} as they seem to do the same thing
- @param {Plane} p1
- @param {Plane} p2
- @param {Vector3} out_point
- @param {Vector3} out_direction
- @returns {boolean}
- */
-export function plane3_compute_intersection_objects(
-    p1, p2,
-    out_point, out_direction
-) {
-
-    // the cross product gives us the direction of the line at the intersection
-    // of the two planes, and gives us an easy way to check if the two planes
-    // are parallel - the cross product will have zero magnitude
-
-    out_direction.crossVectors(p1.normal, p2.normal);
-
-    const magnitude = out_direction.lengthSqr();
-
-    if (magnitude === 0) {
-        return false;
-    }
-
-    // now find a point on the intersection. We use the 'Direct Linear Equation'
-    // method described in the linked page, and we choose which coordinate
-    // to set as zero by seeing which has the largest absolute value in the
-    // directional vector
-
-    const X = Math.abs(out_direction.x);
-    const Y = Math.abs(out_direction.y);
-    const Z = Math.abs(out_direction.z);
-
-    if (Z >= X && Z >= Y) {
-        solveIntersectingPoint('z', 'x', 'y', p1, p2, out_point);
-    } else if (Y >= Z && Y >= X) {
-        solveIntersectingPoint('y', 'z', 'x', p1, p2, out_point);
-    } else {
-        solveIntersectingPoint('x', 'y', 'z', p1, p2, out_point);
-    }
-
-    return true;
-}
-
-/**
-
- This method helps finding a point on the intersection between two planes.
- Depending on the orientation of the planes, the problem could solve for the
- zero point on either the x, y or z axis
- * @param {string} zeroCoord
- * @param {string} A
- * @param {string} B
- * @param {*} p1
- * @param {*} p2
- * @param {Vector3} result
- */
-function solveIntersectingPoint(zeroCoord, A, B, p1, p2, result) {
-    const nP1 = p1.normal;
-
-    const a1 = nP1[A];
-    const b1 = nP1[B];
-    // plane equation is dot(normal, p) + constant = 0, so the linear-system RHS is -constant
-    const d1 = -p1.constant;
-
-    const nP2 = p2.normal;
-
-    const a2 = nP2[A];
-    const b2 = nP2[B];
-    const d2 = -p2.constant;
-
-    const A0 = ((b2 * d1) - (b1 * d2)) / ((a1 * b2 - a2 * b1));
-    const B0 = ((a1 * d2) - (a2 * d1)) / ((a1 * b2 - a2 * b1));
-
-    result[zeroCoord] = 0;
-    result[A] = A0;
-    result[B] = B0;
-}
+import { plane3_compute_intersection } from "./plane3_compute_intersection.js";
+
+/**
+ * @param {Plane} p1
+ * @param {Plane} p2
+ * @param {Vector3} out_point
+ * @param {Vector3} out_direction
+ * @returns {boolean}
+ */
+export function plane3_compute_intersection_objects(
+    p1, p2,
+    out_point, out_direction
+) {
+    return plane3_compute_intersection(
+        out_point,
+        out_direction,
+        p1.normal.x, p1.normal.y, p1.normal.z, p1.constant,
+        p2.normal.x, p2.normal.y, p2.normal.z, p2.constant
+    );
+}

package/src/core/geom/3d/plane/plane3_slerp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plane3_slerp.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/plane3_slerp.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,0CAZW,MAAM,EAAE,sBACR,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,KACN,MAAM,QA2EhB"}
+{"version":3,"file":"plane3_slerp.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/plane/plane3_slerp.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,0CAZW,MAAM,EAAE,sBACR,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,KACN,MAAM,QA4DhB"}