@woosh/meep-engine 3.55.0 → 3.57.0

package/src/core/geom/2d/hash-grid/shg_query_elements_line.js

@@ -1,4 +1,5 @@
-import { assert } from "../../../assert.js";
+import { assert } from "../../../assert.js";
+import { clamp } from "../../../math/clamp.js";
 import { aabb2_clip_line_cohen_sutherland } from "../aabb/aabb2_clip_line_cohen_sutherland.js";
 import { line2_compute_segment_point_distance_sqr } from "../line/line2_compute_segment_point_distance_sqr.js";
 import {
@@ -46,10 +47,12 @@ export function shg_query_elements_line(
     const grid_x1 = x1 * scale_inverse;
     const grid_y1 = y1 * scale_inverse;
 
-    let igrid_x0 = Math.floor(grid_x0);
-    let igrid_y0 = Math.floor(grid_y0);
-    let igrid_x1 = Math.floor(grid_x1);
-    let igrid_y1 = Math.floor(grid_y1);
+    const max_x = grid.size_x - 1;
+    const max_y = grid.size_y - 1;
+    let igrid_x0 = clamp(Math.floor(grid_x0), 0, max_x);
+    let igrid_y0 = clamp(Math.floor(grid_y0), 0, max_y);
+    let igrid_x1 = clamp(Math.floor(grid_x1), 0, max_x);
+    let igrid_y1 = clamp(Math.floor(grid_y1), 0, max_y);
 
     const step_x = igrid_x0 < igrid_x1 ? 1 : -1;
     const step_y = igrid_y0 < igrid_y1 ? 1 : -1;

package/src/core/geom/2d/polygon/polygon2_rasterize_coverage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Coverage of each cell of a `width x height` image by a set of closed contours filled by the nonzero winding rule:
+ * contours wound the same way fill their union, one wound the other way inside them cuts a hole. Each cell
+ * `[x, x + 1) x [y, y + 1)` receives the share of its area inside, in `[0, 1]`.
+ *
+ * Scanline: every cell row is sampled at `rows_per_cell` evenly spaced heights, and along each the filled spans are
+ * exact in `x`, so the coverage is exact across a row and sampled down it. Cells outside the image are left out.
+ *
+ * @param {Float32Array} out `width * height`, row-major, overwritten
+ * @param {number} width
+ * @param {number} height
+ * @param {ArrayLike<number>} points flat `(x, y)` pairs in cell units
+ * @param {ArrayLike<number>} contours `(first point, point count)` pairs, each contour implicitly closed
+ * @param {number} contour_count
+ * @param {number} rows_per_cell sample heights per cell row, at least 1
+ */
+export function polygon2_rasterize_coverage(out: Float32Array, width: number, height: number, points: ArrayLike<number>, contours: ArrayLike<number>, contour_count: number, rows_per_cell: number): void;
+//# sourceMappingURL=polygon2_rasterize_coverage.d.ts.map

package/src/core/geom/2d/polygon/polygon2_rasterize_coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon2_rasterize_coverage.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/polygon/polygon2_rasterize_coverage.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,iDARW,YAAY,SACZ,MAAM,UACN,MAAM,UACN,UAAU,MAAM,CAAC,YACjB,UAAU,MAAM,CAAC,iBACjB,MAAM,iBACN,MAAM,QA+EhB"}

package/src/core/geom/2d/polygon/polygon2_rasterize_coverage.js

@@ -0,0 +1,97 @@
+let crossing_x = new Float64Array(64);
+let crossing_winding = new Int8Array(64);
+
+/**
+ * Coverage of each cell of a `width x height` image by a set of closed contours filled by the nonzero winding rule:
+ * contours wound the same way fill their union, one wound the other way inside them cuts a hole. Each cell
+ * `[x, x + 1) x [y, y + 1)` receives the share of its area inside, in `[0, 1]`.
+ *
+ * Scanline: every cell row is sampled at `rows_per_cell` evenly spaced heights, and along each the filled spans are
+ * exact in `x`, so the coverage is exact across a row and sampled down it. Cells outside the image are left out.
+ *
+ * @param {Float32Array} out `width * height`, row-major, overwritten
+ * @param {number} width
+ * @param {number} height
+ * @param {ArrayLike<number>} points flat `(x, y)` pairs in cell units
+ * @param {ArrayLike<number>} contours `(first point, point count)` pairs, each contour implicitly closed
+ * @param {number} contour_count
+ * @param {number} rows_per_cell sample heights per cell row, at least 1
+ */
+export function polygon2_rasterize_coverage(out, width, height, points, contours, contour_count, rows_per_cell) {
+    out.fill(0);
+    const S = Math.max(1, rows_per_cell | 0);
+    const weight = 1 / S;
+
+    let min_y = Infinity, max_y = -Infinity;
+    let edge_count = 0;
+    for (let c = 0; c < contour_count; c++) {
+        const first = contours[c * 2];
+        const count = contours[c * 2 + 1];
+        edge_count += count;
+        for (let i = 0; i < count; i++) {
+            const y = points[(first + i) * 2 + 1];
+            if (y < min_y) min_y = y;
+            if (y > max_y) max_y = y;
+        }
+    }
+    if (crossing_x.length < edge_count) {
+        crossing_x = new Float64Array(edge_count * 2);
+        crossing_winding = new Int8Array(edge_count * 2);
+    }
+
+    const row_lo = Math.max(0, Math.floor(min_y * S));
+    const row_hi = Math.min(height * S, Math.ceil(max_y * S));
+    for (let sub = row_lo; sub < row_hi; sub++) {
+        const y = (sub + 0.5) / S;
+        const cell_row = Math.floor(sub / S) * width;
+
+        // where each edge crosses this height, and which way
+        let n = 0;
+        for (let c = 0; c < contour_count; c++) {
+            const first = contours[c * 2];
+            const count = contours[c * 2 + 1];
+            for (let i = 0; i < count; i++) {
+                const a = (first + i) * 2;
+                const b = (first + (i + 1) % count) * 2;
+                const ay = points[a + 1], by = points[b + 1];
+                // half-open in y, so a vertex on the line is crossed once
+                if ((ay <= y) === (by <= y)) continue;
+                const t = (y - ay) / (by - ay);
+                const x = points[a] + (points[b] - points[a]) * t;
+                const w = by > ay ? 1 : -1;
+                // insertion keeps the crossings sorted: a scanline meets few edges
+                let j = n++;
+                while (j > 0 && crossing_x[j - 1] > x) {
+                    crossing_x[j] = crossing_x[j - 1];
+                    crossing_winding[j] = crossing_winding[j - 1];
+                    j--;
+                }
+                crossing_x[j] = x;
+                crossing_winding[j] = w;
+            }
+        }
+
+        // fill where the winding number is not zero
+        let winding = 0;
+        for (let i = 0; i < n - 1; i++) {
+            winding += crossing_winding[i];
+            if (winding === 0) continue;
+            const x0 = Math.max(0, crossing_x[i]);
+            const x1 = Math.min(width, crossing_x[i + 1]);
+            if (x1 <= x0) continue;
+            const c0 = Math.floor(x0);
+            const c1 = Math.min(width - 1, Math.floor(x1));
+            if (c0 === c1) {
+                out[cell_row + c0] += (x1 - x0) * weight;
+                continue;
+            }
+            out[cell_row + c0] += (c0 + 1 - x0) * weight;
+            for (let cx = c0 + 1; cx < c1; cx++) out[cell_row + cx] += weight;
+            out[cell_row + c1] += (x1 - c1) * weight;
+        }
+    }
+
+    for (let i = 0; i < out.length; i++) {
+        if (out[i] > 1) out[i] = 1;
+    }
+}

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

@@ -239,8 +239,8 @@ export class StaticR2Tree {
         const bounds_span_x = bounds[2] - bounds_x0;
         const bounds_span_y = bounds[3] - bounds_y0;
 
-        const bounds_multiplier_x = 4095 / bounds_span_x;
-        const bounds_multiplier_y = 4095 / bounds_span_y;
+        const bounds_multiplier_x = bounds_span_x > 0 ? 4095 / bounds_span_x : 0;
+        const bounds_multiplier_y = bounds_span_y > 0 ? 4095 / bounds_span_y : 0;
 
         while (stackPointer > stack_top) {
             stackPointer -= 2;

package/src/core/geom/2d/triangle/tri2_rasterize_coverage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Exact-coverage rasterization of a 2D triangle: every cell whose unit square overlaps the triangle receives the area
+ * of that overlap, so the areas over a triangle inside the image sum to its area. Either winding. Cells outside
+ * `[0, width) x [0, height)` are skipped. The overlap is the triangle clipped to the cell's square.
+ *
+ * See {@link tri2_rasterize_conservative} for which cells overlap at all.
+ *
+ * @param {{width:number, height:number, add:(x:number, y:number, area:number)=>void}} image
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ */
+export function tri2_rasterize_coverage(image: {
+    width: number;
+    height: number;
+    add: (x: number, y: number, area: number) => void;
+}, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number): void;
+//# sourceMappingURL=tri2_rasterize_coverage.d.ts.map

package/src/core/geom/2d/triangle/tri2_rasterize_coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tri2_rasterize_coverage.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_rasterize_coverage.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH,+CARW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,CAAC,CAAC,EAAC,MAAM,EAAE,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,MAAM,KAAG,IAAI,CAAA;CAAC,MAC1E,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAiChB"}

package/src/core/geom/2d/triangle/tri2_rasterize_coverage.js

@@ -0,0 +1,54 @@
+import { polygon2_clip_axis_halfplane } from "../polygon/polygon2_clip_axis_halfplane.js";
+import { polygon2_signed_area } from "../polygon/polygon2_signed_area.js";
+
+// a triangle clipped to a cell's four sides keeps at most 7 corners
+const SCRATCH_A = new Float64Array(16);
+const SCRATCH_B = new Float64Array(16);
+
+/**
+ * Exact-coverage rasterization of a 2D triangle: every cell whose unit square overlaps the triangle receives the area
+ * of that overlap, so the areas over a triangle inside the image sum to its area. Either winding. Cells outside
+ * `[0, width) x [0, height)` are skipped. The overlap is the triangle clipped to the cell's square.
+ *
+ * See {@link tri2_rasterize_conservative} for which cells overlap at all.
+ *
+ * @param {{width:number, height:number, add:(x:number, y:number, area:number)=>void}} image
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ */
+export function tri2_rasterize_coverage(image, x0, y0, x1, y1, x2, y2) {
+    let min_x = Math.floor(Math.min(x0, x1, x2));
+    let min_y = Math.floor(Math.min(y0, y1, y2));
+    let max_x = Math.ceil(Math.max(x0, x1, x2));
+    let max_y = Math.ceil(Math.max(y0, y1, y2));
+
+    if (min_x < 0) min_x = 0;
+    if (min_y < 0) min_y = 0;
+    if (max_x > image.width) max_x = image.width;
+    if (max_y > image.height) max_y = image.height;
+
+    for (let py = min_y; py < max_y; py++) {
+        for (let px = min_x; px < max_x; px++) {
+            SCRATCH_A[0] = x0;
+            SCRATCH_A[1] = y0;
+            SCRATCH_A[2] = x1;
+            SCRATCH_A[3] = y1;
+            SCRATCH_A[4] = x2;
+            SCRATCH_A[5] = y2;
+            let n = polygon2_clip_axis_halfplane(SCRATCH_A, 3, SCRATCH_B, 0, px, false);
+            n = polygon2_clip_axis_halfplane(SCRATCH_B, n, SCRATCH_A, 0, px + 1, true);
+            n = polygon2_clip_axis_halfplane(SCRATCH_A, n, SCRATCH_B, 1, py, false);
+            n = polygon2_clip_axis_halfplane(SCRATCH_B, n, SCRATCH_A, 1, py + 1, true);
+            if (n < 3) continue;
+
+            const area = Math.abs(polygon2_signed_area(SCRATCH_A, n));
+            if (area > 0) {
+                image.add(px, py, area);
+            }
+        }
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_build_frustum.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_build_frustum.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,4CARW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAuChB;AA/CD;;;;;;;;;GASG;AACH,2CARW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAuChB"}
+{"version":3,"file":"aabb3_build_frustum.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_build_frustum.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,4CARW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAIhB;AAZD;;;;;;;;;GASG;AACH,2CARW,MAAM,EAAE,MACR,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAIhB"}

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

@@ -1,53 +1,20 @@
-/**
- * Build orthographic frustum from an axis-aligned bounding box
- * @param {number[]} result
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-export function aabb3_build_frustum(result, x0, y0, z0, x1, y1, z1) {
-
-    // 0 - left
-    result[0] = 1;
-    result[1] = 0;
-    result[2] = 0;
-    result[3] = -x0;
-
-    // 1 - right
-    result[4] = -1;
-    result[5] = 0;
-    result[6] = 0;
-    result[7] = x1;
-
-    // 2 - bottom
-    result[8] = 0;
-    result[9] = 1;
-    result[10] = 0;
-    result[11] = -y0;
-
-    // 3 - top
-    result[12] = 0;
-    result[13] = -1;
-    result[14] = 0;
-    result[15] = y1;
-
-    // 4 - near
-    result[16] = 0;
-    result[17] = 0;
-    result[18] = 1;
-    result[19] = -z0;
-
-    // 5 - far
-    result[20] = 0;
-    result[21] = 0;
-    result[22] = -1;
-    result[23] = z1;
-}
-
-/**
- * @deprecated Renamed to {@link aabb3_build_frustum} (was missing the dimension digit).
- */
-export const aabb_build_frustum = aabb3_build_frustum;
+import { frustum3_from_aabb } from "../frustum/frustum3_from_aabb.js";
+
+/**
+ * Build orthographic frustum from an axis-aligned bounding box
+ * @param {number[]} result
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ */
+export function aabb3_build_frustum(result, x0, y0, z0, x1, y1, z1) {
+    frustum3_from_aabb(result, 0, x0, y0, z0, x1, y1, z1);
+}
+
+/**
+ * @deprecated Renamed to {@link aabb3_build_frustum} (was missing the dimension digit).
+ */
+export const aabb_build_frustum = aabb3_build_frustum;

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

@@ -1,5 +1,5 @@
 /**
- * Compute surface area for a box contain both inputs
+ * Compute half surface area for a box containing both inputs
  * @param {AABB3} a
  * @param {AABB3} b
  * @returns {number}

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

@@ -1 +1 @@
-{"version":3,"file":"aabb3_score_boxes_SAH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_score_boxes_SAH.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2DAFa,MAAM,CAiClB"}
+{"version":3,"file":"aabb3_score_boxes_SAH.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_score_boxes_SAH.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2DAFa,MAAM,CAIlB"}

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

@@ -1,42 +1,11 @@
-import { aabb3_half_surface_area_extents } from "./aabb3_half_surface_area_extents.js";
-
-/**
- * Compute surface area for a box contain both inputs
- * @param {AABB3} a
- * @param {AABB3} b
- * @returns {number}
- */
-function aabb3_score_boxes_SAH(a, b) {
-    
-    // read out bounds
-
-    const ax0 = a.x0;
-    const ay0 = a.y0;
-    const az0 = a.z0;
-    const ax1 = a.x1;
-    const ay1 = a.y1;
-    const az1 = a.z1;
-
-    const bx0 = b.x0;
-    const by0 = b.y0;
-    const bz0 = b.z0;
-    const bx1 = b.x1;
-    const by1 = b.y1;
-    const bz1 = b.z1;
-
-    // compute combined bounds
-
-    const x0 = ax0 < bx0 ? ax0 : bx0;
-    const y0 = ay0 < by0 ? ay0 : by0;
-    const z0 = az0 < bz0 ? az0 : bz0;
-
-    const x1 = ax1 > bx1 ? ax1 : bx1;
-    const y1 = ay1 > by1 ? ay1 : by1;
-    const z1 = az1 > bz1 ? az1 : bz1;
-
-    //
-
-    return aabb3_half_surface_area_extents(x0, y0, z0, x1, y1, z1);
-}
-
-export {aabb3_score_boxes_SAH};
+import { aabb3_union_half_surface_area } from "./aabb3_union_half_surface_area.js";
+
+/**
+ * Compute half surface area for a box containing both inputs
+ * @param {AABB3} a
+ * @param {AABB3} b
+ * @returns {number}
+ */
+export function aabb3_score_boxes_SAH(a, b) {
+    return aabb3_union_half_surface_area(a, b);
+}

package/src/core/geom/3d/atlas/pack/atlas_pack_charts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atlas_pack_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/pack/atlas_pack_charts.js"],"names":[],"mappings":"AA4XA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,0CAdW,OAAO;IAEU,OAAO,GAAxB,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,aAAa,GAA9B,MAAM;IACW,aAAa,GAA9B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACY,UAAU,GAA5B,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,YAAY,GAA9B,OAAO;IACL;IAAC,KAAK,EAAE,MAAM;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,eAAe,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAA;KAAC,CAAC,CAAC;IACrG,UAAc,EAAC,MAAM,CAAC;IAAC,WAAW,EAAC,MAAM,CAAC;IAAC,YAAY,EAAC,MAAM,CAAC;IAAC,WAAW,EAAC,MAAM,CAAC;IACnF,eAAmB,EAAC,MAAM,CAAC;IAAC,iBAAiB,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,OAAO,CAAA;CAAC,CAuIrE"}
+{"version":3,"file":"atlas_pack_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/pack/atlas_pack_charts.js"],"names":[],"mappings":"AA0XA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,0CAdW,OAAO;IAEU,OAAO,GAAxB,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,aAAa,GAA9B,MAAM;IACW,aAAa,GAA9B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACY,UAAU,GAA5B,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,YAAY,GAA9B,OAAO;IACL;IAAC,KAAK,EAAE,MAAM;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,eAAe,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAA;KAAC,CAAC,CAAC;IACrG,UAAc,EAAC,MAAM,CAAC;IAAC,WAAW,EAAC,MAAM,CAAC;IAAC,YAAY,EAAC,MAAM,CAAC;IAAC,WAAW,EAAC,MAAM,CAAC;IACnF,eAAmB,EAAC,MAAM,CAAC;IAAC,iBAAiB,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,OAAO,CAAA;CAAC,CAuIrE"}

package/src/core/geom/3d/atlas/pack/atlas_pack_charts.js

@@ -131,24 +131,28 @@ function pack_order(packs) {
 /**
  * Pick the bottom-left-most of two candidate placements (rot 0 / rot 1).
  *
- * @param {{x:number, y:number}|null} fit0 unrotated candidate position, or null
- * @param {{x:number, y:number}|null} fit1 90-degree-rotated candidate position, or null
- * @returns {{rot:number, pos:{x:number, y:number}}|null} chosen placement, or null if neither fits
+ * @param {boolean} ok0 whether the unrotated candidate fits
+ * @param {number} x0 unrotated candidate x
+ * @param {number} y0 unrotated candidate y
+ * @param {boolean} ok1 whether the 90-degree-rotated candidate fits
+ * @param {number} x1 rotated candidate x
+ * @param {number} y1 rotated candidate y
+ * @returns {number} chosen rotation (0 or 1), or -1 if neither fits
  */
-function choose_placement(fit0, fit1) {
-    if (fit0 === null && fit1 === null) {
-        return null;
+function choose_placement(ok0, x0, y0, ok1, x1, y1) {
+    if (!ok0 && !ok1) {
+        return -1;
     }
-    if (fit1 === null) {
-        return { rot: 0, pos: fit0 };
+    if (!ok1) {
+        return 0;
     }
-    if (fit0 === null) {
-        return { rot: 1, pos: fit1 };
+    if (!ok0) {
+        return 1;
     }
-    if (fit1.y < fit0.y || (fit1.y === fit0.y && fit1.x < fit0.x)) {
-        return { rot: 1, pos: fit1 };
+    if (y1 < y0 || (y1 === y0 && x1 < x0)) {
+        return 1;
     }
-    return { rot: 0, pos: fit0 };
+    return 0;
 }
 
 // ─── Skyline rectangle packer (default, scalable) ────────────────────────────
@@ -178,22 +182,12 @@ function skyline_try_place(sky, pack, page_index, rotate_charts) {
         y1 = sky.found_y;
     }
 
-    let rot = -1;
-    let px = 0;
-    let py = 0;
-    if (ok0) {
-        rot = 0;
-        px = x0;
-        py = y0;
-    }
-    if (ok1 && (rot === -1 || y1 < py || (y1 === py && x1 < px))) {
-        rot = 1;
-        px = x1;
-        py = y1;
-    }
+    const rot = choose_placement(ok0, x0, y0, ok1, x1, y1);
     if (rot === -1) {
         return false;
     }
+    const px = rot === 1 ? x1 : x0;
+    const py = rot === 1 ? y1 : y0;
 
     pack.page = page_index;
     pack.rot = rot;
@@ -305,15 +299,19 @@ function find_first_fit(page, mask) {
 function bitmap_try_place(page, pack, page_index) {
     const fit0 = find_first_fit(page, pack.mask);
     const fit1 = pack.mask_t !== null ? find_first_fit(page, pack.mask_t) : null;
-    const choice = choose_placement(fit0, fit1);
-    if (choice === null) {
+    const rot = choose_placement(
+        fit0 !== null, fit0 !== null ? fit0.x : 0, fit0 !== null ? fit0.y : 0,
+        fit1 !== null, fit1 !== null ? fit1.x : 0, fit1 !== null ? fit1.y : 0
+    );
+    if (rot === -1) {
         return false;
     }
+    const pos = rot === 1 ? fit1 : fit0;
     pack.page = page_index;
-    pack.rot = choice.rot;
-    pack.x = choice.pos.x;
-    pack.y = choice.pos.y;
-    page.or_blit(choice.rot === 1 ? pack.mask_t : pack.mask, pack.x, pack.y);
+    pack.rot = rot;
+    pack.x = pos.x;
+    pack.y = pos.y;
+    page.or_blit(rot === 1 ? pack.mask_t : pack.mask, pack.x, pack.y);
     return true;
 }
 

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":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qEAJW;IAAC,SAAS,CAAC,EAAC,MAAM,CAAC;IAAC,aAAa,CAAC,EAAC,MAAM,CAAA;CAAC,GACxC,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":"AA+CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qEAJW;IAAC,SAAS,CAAC,EAAC,MAAM,CAAC;IAAC,aAAa,CAAC,EAAC,MAAM,CAAA;CAAC,GACxC,OAAO,CA4LnB"}

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

@@ -44,10 +44,6 @@ 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; writes [len_ab, x_c, y_c] into `out`. */
-function project_triangle(pos, i0, i1, i2, out) {
-    tri3_flatten_isometric_indexed(out, 0, pos, i0, i1, i2);
-}
 
 /**
  * Intrinsic boundary-first flattening (a tractable BFF, Sawhney & Crane 2018).
@@ -232,7 +228,7 @@ export function atlas_chart_parameterize_bff(chart, options = {}) {
     let row = 0;
     for (let t = 0; t < T; t++) {
         const i0 = tri[t * 3], i1 = tri[t * 3 + 1], i2 = tri[t * 3 + 2];
-        project_triangle(pos, i0, i1, i2, local);
+        tri3_flatten_isometric_indexed(local, 0, pos, i0, i1, i2);
         const x2 = local[0], x3 = local[1], y3 = local[2];
         const area = 0.5 * x2 * y3;
         if (area <= 1e-20) { row += 2; continue; }

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":"AAoEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sEAJW;IAAC,SAAS,CAAC,EAAC,MAAM,CAAC;IAAC,aAAa,CAAC,EAAC,MAAM,CAAA;CAAC,GACxC,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":"AAsDA;;;;;;;;;;;;;;;;;GAiBG;AACH,sEAJW;IAAC,SAAS,CAAC,EAAC,MAAM,CAAC;IAAC,aAAa,CAAC,EAAC,MAAM,CAAA;CAAC,GACxC,OAAO,CA6HnB"}

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

@@ -51,20 +51,6 @@ function find_diameter_pins(chart) {
     return [p0, p1];
 }
 
-/**
- * Flatten a triangle into an isometric local 2D frame: vertex 0 at the origin,
- * vertex 1 along +x. Writes [x2, x3, y3] (x1=y1=y2=0) into `out`.
- *
- * @param {Float64Array} pos packed xyz vertex positions (3 floats per vertex)
- * @param {number} i0 local index of the first triangle vertex (origin)
- * @param {number} i1 local index of the second triangle vertex (along +x)
- * @param {number} i2 local index of the third triangle vertex
- * @param {number[]} out destination [x2, x3, y3]
- * @returns {void}
- */
-function project_triangle(pos, i0, i1, i2, out) {
-    tri3_flatten_isometric_indexed(out, 0, pos, i0, i1, i2);
-}
 
 /**
  * Least-Squares Conformal Map parameterization (xatlas
@@ -143,7 +129,7 @@ export function atlas_chart_parameterize_lscm(chart, options = {}) {
         const i1 = chart.tri_local[t * 3 + 1];
         const i2 = chart.tri_local[t * 3 + 2];
 
-        project_triangle(chart.positions, i0, i1, i2, local);
+        tri3_flatten_isometric_indexed(local, 0, chart.positions, i0, i1, i2);
         const x2 = local[0];
         const x3 = local[1];
         const y3 = local[2];

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

@@ -1 +1 @@
-{"version":3,"file":"atlas_merge_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_merge_charts.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qEAPW,UAAU,eACV,MAAM,cACN,YAAY;IAEK,WAAW,GAA5B,MAAM;IACJ;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAqFzD"}
+{"version":3,"file":"atlas_merge_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/segment/atlas_merge_charts.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qEAPW,UAAU,eACV,MAAM,cACN,YAAY;IAEK,WAAW,GAA5B,MAAM;IACJ;IAAC,UAAU,EAAE,UAAU,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAC,CAyEzD"}