@woosh/meep-engine 2.169.1 → 2.169.2

package/src/core/geom/2d/quad-tree/qt_match_data_by_circle.js

@@ -1,70 +1,101 @@
-import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
-
-/**
- *
- * @type {QuadTreeNode[]}
- */
-const node_stack = [];
-
-/**
- * @template T
- * @param {QuadTreeDatum<T>[]} result
- * @param {number} result_offset
- * @param {QuadTreeNode<T>} tree
- * @param {number} x
- * @param {number} y
- * @param {number} radius
- * @param {(data: T) => boolean} [predicate]
- * @param {*} [predicateContext]
- * @returns {number}
- */
-export function qt_match_data_by_circle(
-    result, result_offset,
-    tree,
-    x, y, radius,
-    predicate, predicateContext
-) {
-    let result_cursor = result_offset;
-
-    let stack_pointer = 0;
-
-    const r2 = radius * radius;
-
-    node_stack[stack_pointer] = tree;
-    stack_pointer++;
-
-    while (stack_pointer > 0) {
-
-        --stack_pointer;
-        const node = node_stack[stack_pointer];
-
-        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
-
-        if (d2 > r2) {
-            // not a match
-            continue;
-        }
-
-        const data = node.data;
-        const data_count = data.length;
-
-        for (let i = 0; i < data_count; i++) {
-            const datum = data[i];
-
-            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
-
-            if (d2_to_datum <= r2 && predicate.call(predicateContext, datum.data)) {
-                result[result_cursor++] = datum;
-            }
-        }
-
-        if (node.isSplit()) {
-            node_stack[stack_pointer++] = node.topLeft;
-            node_stack[stack_pointer++] = node.bottomLeft;
-            node_stack[stack_pointer++] = node.topRight;
-            node_stack[stack_pointer++] = node.bottomRight;
-        }
-    }
-
-    return result_cursor - result_offset;
-}
+import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
+
+/**
+ * @type {QuadTreeNode[]}
+ */
+const node_stack = [];
+
+/**
+ * Collect every datum whose bounds lie within `radius` of `(x, y)` AND satisfy `predicate`.
+ *
+ * Also the implementation behind {@link qt_collect_by_circle}, which is this query with an
+ * accept-everything predicate — the traversal was previously written out twice, differing only by the
+ * `predicate.call(...)` conjunct.
+ *
+ * Children are pruned on PUSH (against the circle's bounding square) as well as tested on POP, matching
+ * {@link qt_collect_by_box}. Testing only on pop still returns the right answer but walks and re-tests
+ * quadrants the circle cannot reach.
+ *
+ * @template T
+ * @param {Array<QuadTreeDatum<T>>} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @param {function(T):boolean} predicate
+ * @param {*} [predicateContext] `this` for `predicate`
+ * @returns {number} number of matches written
+ */
+export function qt_match_data_by_circle(
+    result, result_offset,
+    tree,
+    x, y, radius,
+    predicate, predicateContext
+) {
+    let result_cursor = result_offset;
+
+    let stack_pointer = 0;
+
+    const r2 = radius * radius;
+
+    // bounding square of the query circle, used to prune quadrants on push
+    const query_x0 = x - radius;
+    const query_y0 = y - radius;
+    const query_x1 = x + radius;
+    const query_y1 = y + radius;
+
+    node_stack[stack_pointer] = tree;
+    stack_pointer++;
+
+    while (stack_pointer > 0) {
+
+        --stack_pointer;
+        const node = node_stack[stack_pointer];
+
+        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
+
+        if (d2 > r2) {
+            // not a match
+            continue;
+        }
+
+        const data = node.data;
+        const data_count = data.length;
+
+        for (let i = 0; i < data_count; i++) {
+            const datum = data[i];
+
+            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+
+            if (d2_to_datum <= r2 && predicate.call(predicateContext, datum.data)) {
+                result[result_cursor++] = datum;
+            }
+        }
+
+        if (node.isSplit()) {
+            const hx = (node.x0 + node.x1) * 0.5;
+            const hy = (node.y0 + node.y1) * 0.5;
+
+            if (hx >= query_x0) {
+                if (hy >= query_y0) {
+                    node_stack[stack_pointer++] = node.topLeft;
+                }
+                if (hy <= query_y1) {
+                    node_stack[stack_pointer++] = node.bottomLeft;
+                }
+            }
+
+            if (hx <= query_x1) {
+                if (hy >= query_y0) {
+                    node_stack[stack_pointer++] = node.topRight;
+                }
+                if (hy <= query_y1) {
+                    node_stack[stack_pointer++] = node.bottomRight;
+                }
+            }
+        }
+    }
+
+    return result_cursor - result_offset;
+}

package/src/core/geom/2d/r-tree/StaticR2Tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAgFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAuEC;CACJ"}
+{"version":3,"file":"StaticR2Tree.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/r-tree/StaticR2Tree.js"],"names":[],"mappings":"AAoEA;;;GAGG;AACH;IAEI;;;OAGG;IACH,sBAAc;IAEd;;;;OAIG;IACH,+BAAc;IAEd;;;;OAIG;IACH,4BAAwB;IAExB;;;;OAIG;IACH,0BAAsB;IAOtB;;;OAGG;IACH,kBAFW,WAAW,QASrB;IAFG,6BAA0D;IAK9D,6BASC;IAED;;;OAGG;IACH,oBAFW,MAAM,QAchB;IAGD;;;;;;;;OAQG;IACH,mBAPW,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwBhB;IAED;;;OAGG;IACH,uBAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,4BAHW,MAAM,GACJ,MAAM,CAQlB;IAGD;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAoFlB;IAED;;;;;OAKG;IACH,sBAYC;IAED;;OAEG;IACH,cAuEC;CACJ"}

package/src/core/geom/2d/r-tree/StaticR2Tree.js

@@ -219,12 +219,16 @@ export class StaticR2Tree {
         const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
         const stack_top = stack.pointer;
 
-        let stackPointer = stack_top + 2;
+        let stackPointer = stack_top;
         let iL, iR;
 
 
-        stack[0] = 0; // first node
-        stack[1] = this.__node_count_leaf - 1; // last node
+        // seed RELATIVE to stack_top: SCRATCH_UINT32_TRAVERSAL_STACK is shared, so an outer traversal may
+        // already own the low slots. Writing the seed to absolute 0/1 while reading from stack_top made
+        // this read another traversal's frame whenever it ran nested. BinaryUint32BVH, which this was
+        // forked from, always seeded relative.
+        stack[stackPointer++] = 0; // first node
+        stack[stackPointer++] = this.__node_count_leaf - 1; // last node
 
         const data = this.__data_float32;
 

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts

@@ -3,14 +3,13 @@
  * BROADPHASE use: it must never report a false miss for a segment that grazes a face, since callers treat
  * a `false` as "no candidate here" and skip the exact geometry test entirely.
  *
- * Robust at the degenerate "axis-aligned ray with the origin exactly on a face" boundary. When a direction
- * component is `0` its reciprocal is `±Infinity`, so the slab coordinate of the face the origin sits on is
- * `0 · ±Infinity = NaN`. A NaN can ONLY arise that way (it needs a `(face − origin)` term of exactly `0`),
- * and it always means the ray runs parallel to that slab with the origin on one of its planes — i.e. inside
- * the closed slab for every `t`. That axis therefore contributes the fully-open interval `[-Infinity,
- * +Infinity]`, imposing no constraint. Letting the NaN flow through `min2`/`max2` instead collapses the
- * final test to `NaN <= … = false` and drops a box the ray genuinely crosses (a NaN-ignoring min/max alone
- * is NOT enough — it yields `[-Infinity, -Infinity]` / `[+Infinity, +Infinity]`, still a spurious miss).
+ * This is the boolean face of {@link aabb3_ray_segment_entry_distance} and is defined as "that query did
+ * not return its miss sentinel", so the two cannot disagree. The slab arithmetic — including the NaN
+ * handling for an axis-aligned ray whose origin sits exactly on a face — lives there and is documented
+ * there; keeping a second copy here is how the two previously drifted apart.
+ *
+ * PRECONDITION: the direction is non-degenerate (at least one non-zero component). A zero direction makes
+ * every slab coordinate `±Infinity`, for which "entry distance" is not meaningful.
  *
  * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
  * @param {number} x0

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,iDAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,OAAO,CAmDnB"}
+{"version":3,"file":"aabb3_intersects_ray_segment.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,iDAhBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,YACN,MAAM,YACN,MAAM,YACN,MAAM,mBACN,MAAM,mBACN,MAAM,mBACN,MAAM,gBACN,MAAM,gBACN,MAAM,GACJ,OAAO,CAiBnB"}

package/src/core/geom/3d/aabb/aabb3_intersects_ray_segment.js

@@ -1,19 +1,17 @@
-import { max2 } from "../../../math/max2.js";
-import { min2 } from "../../../math/min2.js";
+import { aabb3_ray_segment_entry_distance } from "./aabb3_ray_segment_entry_distance.js";
 
 /**
  * Conservative slab test of an axis-aligned ray SEGMENT against a closed AABB (faces included). Built for
  * BROADPHASE use: it must never report a false miss for a segment that grazes a face, since callers treat
  * a `false` as "no candidate here" and skip the exact geometry test entirely.
  *
- * Robust at the degenerate "axis-aligned ray with the origin exactly on a face" boundary. When a direction
- * component is `0` its reciprocal is `±Infinity`, so the slab coordinate of the face the origin sits on is
- * `0 · ±Infinity = NaN`. A NaN can ONLY arise that way (it needs a `(face − origin)` term of exactly `0`),
- * and it always means the ray runs parallel to that slab with the origin on one of its planes — i.e. inside
- * the closed slab for every `t`. That axis therefore contributes the fully-open interval `[-Infinity,
- * +Infinity]`, imposing no constraint. Letting the NaN flow through `min2`/`max2` instead collapses the
- * final test to `NaN <= … = false` and drops a box the ray genuinely crosses (a NaN-ignoring min/max alone
- * is NOT enough — it yields `[-Infinity, -Infinity]` / `[+Infinity, +Infinity]`, still a spurious miss).
+ * This is the boolean face of {@link aabb3_ray_segment_entry_distance} and is defined as "that query did
+ * not return its miss sentinel", so the two cannot disagree. The slab arithmetic — including the NaN
+ * handling for an axis-aligned ray whose origin sits exactly on a face — lives there and is documented
+ * there; keeping a second copy here is how the two previously drifted apart.
+ *
+ * PRECONDITION: the direction is non-degenerate (at least one non-zero component). A zero direction makes
+ * every slab coordinate `±Infinity`, for which "entry distance" is not meaningful.
  *
  * @see Ray Tracing Gems II, Chapter 2 "RAY AXIS-ALIGNED BOUNDING BOX INTERSECTION"
  * @param {number} x0
@@ -40,46 +38,12 @@ export function aabb3_intersects_ray_segment(
     min_distance, max_distance
 ) {
 
-    // move aabb into ray space
-    const _x0 = x0 - origin_x;
-    const _y0 = y0 - origin_y;
-    const _z0 = z0 - origin_z;
-
-    const _x1 = x1 - origin_x;
-    const _y1 = y1 - origin_y;
-    const _z1 = z1 - origin_z;
-
-
-    // Absolute distances to lower and upper box coordinates
-    const t_lower_x = _x0 * inv_direction_x;
-    const t_lower_y = _y0 * inv_direction_y;
-    const t_lower_z = _z0 * inv_direction_z;
-
-    const t_upper_x = _x1 * inv_direction_x;
-    const t_upper_y = _y1 * inv_direction_y;
-    const t_upper_z = _z1 * inv_direction_z;
-
-    // A NaN slab coordinate (`0 · ±Infinity`) flags an axis-aligned ray whose origin lies exactly on one
-    // of this slab's faces: it is parallel to the slab and, because the closed box owns its faces, stays
-    // inside it for every t. Such an axis contributes the fully-open interval [-Infinity, +Infinity]; see
-    // the function doc for why the raw NaN min/max would instead poison the test into a false miss.
-    const x_parallel_on_face = t_lower_x !== t_lower_x || t_upper_x !== t_upper_x;
-    const y_parallel_on_face = t_lower_y !== t_lower_y || t_upper_y !== t_upper_y;
-    const z_parallel_on_face = t_lower_z !== t_lower_z || t_upper_z !== t_upper_z;
-
-    // The four t-intervals (for x-/y-/z-slabs, and ray p(t))
-    const t_min_x = x_parallel_on_face ? -Infinity : min2(t_lower_x, t_upper_x);
-    const t_min_y = y_parallel_on_face ? -Infinity : min2(t_lower_y, t_upper_y);
-    const t_min_z = z_parallel_on_face ? -Infinity : min2(t_lower_z, t_upper_z);
-
-    const t_max_x = x_parallel_on_face ? Infinity : max2(t_lower_x, t_upper_x);
-    const t_max_y = y_parallel_on_face ? Infinity : max2(t_lower_y, t_upper_y);
-    const t_max_z = z_parallel_on_face ? Infinity : max2(t_lower_z, t_upper_z);
-
-    // Easy to remember: ``max of mins, and min of maxes''
-    const t_box_min = Math.max(t_min_x, t_min_y, t_min_z, min_distance);
-    const t_box_max = Math.min(t_max_x, t_max_y, t_max_z, max_distance);
-
-    return t_box_min <= t_box_max;
+    return aabb3_ray_segment_entry_distance(
+        x0, y0, z0,
+        x1, y1, z1,
+        origin_x, origin_y, origin_z,
+        inv_direction_x, inv_direction_y, inv_direction_z,
+        min_distance, max_distance
+    ) !== Infinity;
 }
 

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_chart_parameterize_bff.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA4LnB"}
+{"version":3,"file":"atlas_chart_parameterize_bff.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA4LnB"}

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_bff.js

@@ -1,3 +1,4 @@
+import { tri3_flatten_isometric_indexed } from "../../triangle/tri3_flatten_isometric.js";
 import { cg_solve } from "../../../../math/linalg/cg/cg_solve.js";
 import { cg_solve_normal_equations } from "../../../../math/linalg/cg/cg_solve_normal_equations.js";
 import { SparseMatrixCSR } from "../../../../math/linalg/sparse/SparseMatrixCSR.js";
@@ -23,7 +24,16 @@ function clamped_cot(pos, o, p, q) {
     return c > COT_MAX ? COT_MAX : c;
 }
 
-/** Interior angle (radians) at vertex i0 in triangle (i0,i1,i2). */
+/**
+ * Interior angle (radians) at vertex i0 in triangle (i0,i1,i2).
+ *
+ * Deliberately NOT `v3_angle`, despite computing the same angle for well-formed triangles. The two
+ * disagree exactly where it matters here: `v3_angle` delegates to `v3_cos_angle`, which returns 0 for a
+ * zero-length edge, so `v3_angle` reports `acos(0) = PI/2`. This returns 0 radians instead, and does so
+ * for any edge under 1e-20 rather than only for exactly-zero ones. Curvature below is accumulated as
+ * `Omega = 2*PI - sum(theta)`, so a degenerate sliver contributing PI/2 instead of 0 would silently
+ * corrupt the curvature of the vertex it touches.
+ */
 function interior_angle(pos, i0, i1, i2) {
     const ux = pos[i1 * 3] - pos[i0 * 3], uy = pos[i1 * 3 + 1] - pos[i0 * 3 + 1], uz = pos[i1 * 3 + 2] - pos[i0 * 3 + 2];
     const vx = pos[i2 * 3] - pos[i0 * 3], vy = pos[i2 * 3 + 1] - pos[i0 * 3 + 1], vz = pos[i2 * 3 + 2] - pos[i0 * 3 + 2];
@@ -34,20 +44,9 @@ function interior_angle(pos, i0, i1, i2) {
     return Math.acos(Math.max(-1, Math.min(1, c)));
 }
 
-/** Flatten a triangle into an isometric local 2D frame (vertex 0 at origin,
- *  vertex 1 on +x): writes [x2, x3, y3] into `out`. (Same as LSCM.) */
+/** Flatten a triangle into an isometric local 2D frame; writes [len_ab, x_c, y_c] into `out`. */
 function project_triangle(pos, i0, i1, i2, out) {
-    const ax = pos[i0 * 3], ay = pos[i0 * 3 + 1], az = pos[i0 * 3 + 2];
-    const e1x = pos[i1 * 3] - ax, e1y = pos[i1 * 3 + 1] - ay, e1z = pos[i1 * 3 + 2] - az;
-    const len1 = Math.sqrt(e1x * e1x + e1y * e1y + e1z * e1z);
-    const inv1 = len1 > 0 ? 1 / len1 : 0;
-    const ux = e1x * inv1, uy = e1y * inv1, uz = e1z * inv1;
-    const e2x = pos[i2 * 3] - ax, e2y = pos[i2 * 3 + 1] - ay, e2z = pos[i2 * 3 + 2] - az;
-    const x3 = e2x * ux + e2y * uy + e2z * uz;
-    const px = e2x - x3 * ux, py = e2y - x3 * uy, pz = e2z - x3 * uz;
-    out[0] = len1;
-    out[1] = x3;
-    out[2] = Math.sqrt(px * px + py * py + pz * pz);
+    tri3_flatten_isometric_indexed(out, 0, pos, i0, i1, i2);
 }
 
 /**

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_chart_parameterize_lscm.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.js"],"names":[],"mappings":"AAmFA;;;;;;;;;;;;;;;;;GAiBG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA6HnB"}
+{"version":3,"file":"atlas_chart_parameterize_lscm.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;;;;;;;;GAiBG;AACH;gBAJuB,MAAM;oBAAiB,MAAM;IACvC,OAAO,CA6HnB"}

package/src/core/geom/3d/atlas/param/atlas_chart_parameterize_lscm.js

@@ -1,3 +1,4 @@
+import { tri3_flatten_isometric_indexed } from "../../triangle/tri3_flatten_isometric.js";
 import { cg_solve_normal_equations } from "../../../../math/linalg/cg/cg_solve_normal_equations.js";
 import { SparseMatrixCSR } from "../../../../math/linalg/sparse/SparseMatrixCSR.js";
 
@@ -62,23 +63,7 @@ function find_diameter_pins(chart) {
  * @returns {void}
  */
 function project_triangle(pos, i0, i1, i2, out) {
-    const ax = pos[i0 * 3], ay = pos[i0 * 3 + 1], az = pos[i0 * 3 + 2];
-    const bx = pos[i1 * 3], by = pos[i1 * 3 + 1], bz = pos[i1 * 3 + 2];
-    const cx = pos[i2 * 3], cy = pos[i2 * 3 + 1], cz = pos[i2 * 3 + 2];
-
-    const e1x = bx - ax, e1y = by - ay, e1z = bz - az;
-    const len1 = Math.sqrt(e1x * e1x + e1y * e1y + e1z * e1z);
-    const inv1 = len1 > 0 ? 1 / len1 : 0;
-    const ux = e1x * inv1, uy = e1y * inv1, uz = e1z * inv1;
-
-    const e2x = cx - ax, e2y = cy - ay, e2z = cz - az;
-    const x3 = e2x * ux + e2y * uy + e2z * uz;
-    const px = e2x - x3 * ux, py = e2y - x3 * uy, pz = e2z - x3 * uz;
-    const y3 = Math.sqrt(px * px + py * py + pz * pz);
-
-    out[0] = len1;
-    out[1] = x3;
-    out[2] = y3;
+    tri3_flatten_isometric_indexed(out, 0, pos, i0, i1, i2);
 }
 
 /**

package/src/core/geom/3d/atlas/segment/atlas_chart_roundness_delta.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Roundness term `R` of the xatlas chart-growth cost: how much worse the chart's
+ * perimeter-to-area ratio gets by absorbing a candidate.
+ *
+ * `R = 1 - old_ratio / new_ratio` with `ratio = boundary^2 / area`. Positive when the candidate makes the
+ * chart less compact, so the greedy segmenter prefers round charts. Returns 0 for the seed step (no chart
+ * yet) and for degenerate zero-area / zero-boundary states, where the ratio is undefined.
+ *
+ * Shared by the face-granular {@link atlas_segment_charts} and the region-atomic
+ * {@link atlas_segment_charts_atomic}, which must agree on the cost function to produce comparable charts.
+ *
+ * @param {number} chart_area area of the chart before absorbing the candidate
+ * @param {number} chart_boundary boundary length before absorbing the candidate
+ * @param {number} new_area area after absorbing
+ * @param {number} new_boundary boundary length after absorbing
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_roundness_delta(chart_area: number, chart_boundary: number, new_area: number, new_boundary: number): number;
+//# sourceMappingURL=atlas_chart_roundness_delta.d.ts.map

package/src/core/geom/3d/atlas/segment/atlas_chart_roundness_delta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_chart_roundness_delta.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_chart_roundness_delta.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wDATW,MAAM,kBACN,MAAM,YACN,MAAM,gBACN,MAAM,GACJ,MAAM,CAclB"}

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

@@ -0,0 +1,30 @@
+/**
+ * Roundness term `R` of the xatlas chart-growth cost: how much worse the chart's
+ * perimeter-to-area ratio gets by absorbing a candidate.
+ *
+ * `R = 1 - old_ratio / new_ratio` with `ratio = boundary^2 / area`. Positive when the candidate makes the
+ * chart less compact, so the greedy segmenter prefers round charts. Returns 0 for the seed step (no chart
+ * yet) and for degenerate zero-area / zero-boundary states, where the ratio is undefined.
+ *
+ * Shared by the face-granular {@link atlas_segment_charts} and the region-atomic
+ * {@link atlas_segment_charts_atomic}, which must agree on the cost function to produce comparable charts.
+ *
+ * @param {number} chart_area area of the chart before absorbing the candidate
+ * @param {number} chart_boundary boundary length before absorbing the candidate
+ * @param {number} new_area area after absorbing
+ * @param {number} new_boundary boundary length after absorbing
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function atlas_chart_roundness_delta(chart_area, chart_boundary, new_area, new_boundary) {
+    if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
+        const old_ratio = (chart_boundary * chart_boundary) / chart_area;
+        const new_ratio = (new_boundary * new_boundary) / new_area;
+
+        return 1 - old_ratio / new_ratio;
+    }
+
+    return 0;
+}

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.d.ts

@@ -33,6 +33,25 @@ export function atlas_segment_charts(mesh: BinaryTopology, face_areas: Float32Ar
     face_chart: Int32Array;
     chart_count: number;
 };
+/**
+ * Cost returned for a face that must not join the chart (hard reject). Never
+ * inserted into the heap.
+ * @type {number}
+ */
+export const REJECT: number;
+/**
+ * Hard reject when the normal-deviation term reaches this — `1 - dot >= 0.707`
+ * is roughly a 73 degree fold away from the chart's running normal. Matches
+ * xatlas's `computeCost` hard cutoff.
+ * @type {number}
+ */
+export const NORMAL_DEVIATION_REJECT: number;
+/**
+ * A heap entry is considered stale (recomputed against a drifted chart normal)
+ * when its fresh cost differs from the stored cost by more than this.
+ * @type {number}
+ */
+export const STALE_EPSILON: number;
 export namespace ATLAS_SEGMENT_DEFAULTS {
     let maxCost: number;
     let normalDeviationWeight: number;

package/src/core/geom/3d/atlas/segment/atlas_segment_charts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_segment_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAPW,YAAY,gBACZ,YAAY,kBACZ,YAAY,YACZ,MAAM;gBACS,UAAU;iBAAe,MAAM;EA+MxD"}
+{"version":3,"file":"atlas_segment_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uEAPW,YAAY,gBACZ,YAAY,kBACZ,YAAY,YACZ,MAAM;gBACS,UAAU;iBAAe,MAAM;EA0MxD;AAzQD;;;;GAIG;AACH,qBAFU,MAAM,CAEe;AAE/B;;;;;GAKG;AACH,sCAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,4BAFU,MAAM,CAEkB"}

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

@@ -1,3 +1,4 @@
+import { atlas_chart_roundness_delta } from "./atlas_chart_roundness_delta.js";
 import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
 import { v3_dot } from "../../../vec3/v3_dot.js";
 import { EDGE_DIHEDRAL_BOUNDARY } from "../data/atlas_build_edge_dihedrals.js";
@@ -7,7 +8,7 @@ import { EDGE_DIHEDRAL_BOUNDARY } from "../data/atlas_build_edge_dihedrals.js";
  * inserted into the heap.
  * @type {number}
  */
-const REJECT = Infinity;
+export const REJECT = Infinity;
 
 /**
  * Hard reject when the normal-deviation term reaches this — `1 - dot >= 0.707`
@@ -15,14 +16,14 @@ const REJECT = Infinity;
  * xatlas's `computeCost` hard cutoff.
  * @type {number}
  */
-const NORMAL_DEVIATION_REJECT = 0.707;
+export const NORMAL_DEVIATION_REJECT = 0.707;
 
 /**
  * A heap entry is considered stale (recomputed against a drifted chart normal)
  * when its fresh cost differs from the stored cost by more than this.
  * @type {number}
  */
-const STALE_EPSILON = 1e-6;
+export const STALE_EPSILON = 1e-6;
 
 /**
  * Default segmentation weights/limits (xatlas `ChartOptions`). The texture-seam
@@ -170,12 +171,7 @@ export function atlas_segment_charts(mesh, face_areas, edge_lengths, edge_dihedr
 
         const NS = shared_len > 0 ? shared_seam / shared_len : 0;
 
-        let R = 0;
-        if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
-            const old_ratio = (chart_boundary * chart_boundary) / chart_area;
-            const new_ratio = (new_boundary * new_boundary) / new_area;
-            R = 1 - old_ratio / new_ratio;
-        }
+        const R = atlas_chart_roundness_delta(chart_area, chart_boundary, new_area, new_boundary);
 
         out_area = new_area;
         out_boundary = new_boundary;

package/src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_segment_charts_atomic.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;GAgBG;AACH,uFAJW,WAAW,YACX,MAAM;gBACS,UAAU;iBAAe,MAAM;EA6KxD"}
+{"version":3,"file":"atlas_segment_charts_atomic.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_segment_charts_atomic.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,uFAJW,WAAW,YACX,MAAM;gBACS,UAAU;iBAAe,MAAM;EAwKxD"}

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

@@ -1,12 +1,9 @@
 import { IndexedFloatMinHeap } from "../../../../collection/heap/IndexedFloatMinHeap.js";
 import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
-import { ATLAS_SEGMENT_DEFAULTS } from "./atlas_segment_charts.js";
+import { ATLAS_SEGMENT_DEFAULTS, NORMAL_DEVIATION_REJECT, REJECT, STALE_EPSILON } from "./atlas_segment_charts.js";
+import { atlas_chart_roundness_delta } from "./atlas_chart_roundness_delta.js";
+
 
-// These mirror atlas_segment_charts (the face-granular twin); kept local so the
-// two segmenters stay monomorphic.
-const REJECT = Infinity;
-const NORMAL_DEVIATION_REJECT = 0.707;
-const STALE_EPSILON = 1e-6;
 
 /**
  * Region-atomic chart segmentation (xatlas grows whole coplanar regions as
@@ -95,12 +92,7 @@ export function atlas_segment_charts_atomic(region_graph, region_of_face, option
 
         const NS = shared > 0 ? seam / shared : 0;
 
-        let R = 0;
-        if (chart_area > 0 && chart_boundary > 0 && new_boundary > 0) {
-            const old_ratio = (chart_boundary * chart_boundary) / chart_area;
-            const new_ratio = (new_boundary * new_boundary) / new_area;
-            R = 1 - old_ratio / new_ratio;
-        }
+        const R = atlas_chart_roundness_delta(chart_area, chart_boundary, new_area, new_boundary);
 
         out_area = new_area;
         out_boundary = new_boundary;

package/src/core/geom/3d/frustum/read_frustum_corner.d.ts

@@ -1,4 +1,9 @@
 /**
+ * Read one corner out of a packed frustum-corner buffer.
+ *
+ * Index-flavoured wrapper over {@link v3_copy_array}: corners are stored as consecutive `(x, y, z)`
+ * triples, so corner `i` starts at element `i * 3`. Overlapping source/destination ranges are safe —
+ * `v3_copy_array` reads all three components before writing any.
  *
  * @param {number[]|Float32Array|Float64Array} source
  * @param {number} source_index

package/src/core/geom/3d/frustum/read_frustum_corner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read_frustum_corner.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/read_frustum_corner.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,4CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,QAQhB"}
+{"version":3,"file":"read_frustum_corner.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/frustum/read_frustum_corner.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,4CALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,gBAClC,MAAM,eACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,QAIhB"}

package/src/core/geom/3d/frustum/read_frustum_corner.js

@@ -1,4 +1,11 @@
+import { v3_copy_array } from "../../vec3/v3_copy_array.js";
+
 /**
+ * Read one corner out of a packed frustum-corner buffer.
+ *
+ * Index-flavoured wrapper over {@link v3_copy_array}: corners are stored as consecutive `(x, y, z)`
+ * triples, so corner `i` starts at element `i * 3`. Overlapping source/destination ranges are safe —
+ * `v3_copy_array` reads all three components before writing any.
  *
  * @param {number[]|Float32Array|Float64Array} source
  * @param {number} source_index
@@ -6,9 +13,5 @@
  * @param {number} destination_offset
  */
 export function read_frustum_corner(source, source_index, destination, destination_offset) {
-    const address = source_index * 3;
-
-    destination[destination_offset] = source[address];
-    destination[destination_offset + 1] = source[address + 1];
-    destination[destination_offset + 2] = source[address + 2];
+    v3_copy_array(destination, destination_offset, source, source_index * 3);
 }