@woosh/meep-engine 3.56.0 → 3.58.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/line/line2_segment_intersection_fraction_2d.d.ts

@@ -5,7 +5,7 @@
  * real crossing is always in [0,1]), and it is used instead of NaN so callers reject the no-crossing
  * case with a trivial comparison (`t < 0` / `=== -1`) rather than the slower Number.isNaN.
  *
- * Unlike {@link line_segment_compute_line_segment_intersection_array_2d}, the first pair of points
+ * Unlike {@link segment2_segment_compute_intersection_array_2d}, the first pair of points
  * defines an unbounded line (not a segment) and the result is the parametric position on the segment
  * rather than the intersection point.
  *

package/src/core/geom/2d/line/line2_segment_intersection_fraction_2d.js

@@ -7,7 +7,7 @@ import { v2_cross_product } from "../../vec2/v2_cross_product.js";
  * real crossing is always in [0,1]), and it is used instead of NaN so callers reject the no-crossing
  * case with a trivial comparison (`t < 0` / `=== -1`) rather than the slower Number.isNaN.
  *
- * Unlike {@link line_segment_compute_line_segment_intersection_array_2d}, the first pair of points
+ * Unlike {@link segment2_segment_compute_intersection_array_2d}, the first pair of points
  * defines an unbounded line (not a segment) and the result is the parametric position on the segment
  * rather than the intersection point.
  *

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_intersects_aabb2.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Separating-axis overlap test between a 2D triangle and an axis-aligned box.
+ *
+ * @param {number} ax first triangle vertex x
+ * @param {number} ay first triangle vertex y
+ * @param {number} bx second triangle vertex x
+ * @param {number} by second triangle vertex y
+ * @param {number} cx third triangle vertex x
+ * @param {number} cy third triangle vertex y
+ * @param {number} bminx box minimum corner x
+ * @param {number} bminy box minimum corner y
+ * @param {number} bmaxx box maximum corner x
+ * @param {number} bmaxy box maximum corner y
+ * @returns {boolean} true if the triangle and box overlap
+ */
+export function tri2_intersects_aabb2(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, bminx: number, bminy: number, bmaxx: number, bmaxy: number): boolean;
+//# sourceMappingURL=tri2_intersects_aabb2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri2_intersects_aabb2.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_intersects_aabb2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,0CAZW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,GACJ,OAAO,CAanB"}

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

@@ -0,0 +1,64 @@
+/**
+ * Separating-axis overlap test between a 2D triangle and an axis-aligned box.
+ *
+ * @param {number} ax first triangle vertex x
+ * @param {number} ay first triangle vertex y
+ * @param {number} bx second triangle vertex x
+ * @param {number} by second triangle vertex y
+ * @param {number} cx third triangle vertex x
+ * @param {number} cy third triangle vertex y
+ * @param {number} bminx box minimum corner x
+ * @param {number} bminy box minimum corner y
+ * @param {number} bmaxx box maximum corner x
+ * @param {number} bmaxy box maximum corner y
+ * @returns {boolean} true if the triangle and box overlap
+ */
+export function tri2_intersects_aabb2(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy) {
+    // Box axes (x then y).
+    if (Math.max(ax, bx, cx) < bminx || Math.min(ax, bx, cx) > bmaxx) return false;
+    if (Math.max(ay, by, cy) < bminy || Math.min(ay, by, cy) > bmaxy) return false;
+
+    // Triangle edge normals.
+    if (edge_separates(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy)) return false;
+    if (edge_separates(bx, by, cx, cy, ax, ay, bminx, bminy, bmaxx, bmaxy)) return false;
+    if (edge_separates(cx, cy, ax, ay, bx, by, bminx, bminy, bmaxx, bmaxy)) return false;
+
+    return true;
+}
+
+/**
+ * Does the outward normal of edge (p->q) separate the box from the triangle?
+ * `r` is the triangle's third vertex (to orient the normal inward).
+ *
+ * @param {number} px edge start vertex x
+ * @param {number} py edge start vertex y
+ * @param {number} qx edge end vertex x
+ * @param {number} qy edge end vertex y
+ * @param {number} rx triangle's third vertex x
+ * @param {number} ry triangle's third vertex y
+ * @param {number} bminx box minimum corner x
+ * @param {number} bminy box minimum corner y
+ * @param {number} bmaxx box maximum corner x
+ * @param {number} bmaxy box maximum corner y
+ * @returns {boolean} true if this edge's axis separates the box from the triangle
+ */
+function edge_separates(px, py, qx, qy, rx, ry, bminx, bminy, bmaxx, bmaxy) {
+    const nx = -(qy - py);
+    const ny = qx - px;
+
+    // triangle interval along n
+    const dp = nx * px + ny * py;
+    const dr = nx * rx + ny * ry;
+    let tri_min, tri_max;
+    if (dp < dr) { tri_min = dp; tri_max = dr; } else { tri_min = dr; tri_max = dp; }
+
+    // box interval along n (4 corners)
+    const c0 = nx * bminx + ny * bminy;
+    const c1 = nx * bmaxx + ny * bminy;
+    const c2 = nx * bminx + ny * bmaxy;
+    const c3 = nx * bmaxx + ny * bmaxy;
+    const box_min = Math.min(c0, c1, c2, c3);
+    const box_max = Math.max(c0, c1, c2, c3);
+
+    return box_max < tri_min || box_min > tri_max;
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Visits every pixel of a `width` x `height` grid whose centre lies inside triangle `(x0, y0)`, `(x1, y1)`, `(x2, y2)`,
+ * in pixel units: pixel `(col, row)` is the point sample at `(col + 0.5, row + 0.5)`. A centre on an edge belongs to
+ * one of the two triangles sharing that edge (the top-left rule), so a mesh visits each point once. An edge-on
+ * triangle visits nothing.
+ *
+ * `visitor.visit(col, row, l0, l1, l2)` receives the pixel and the centre's barycentric weights of the three vertices,
+ * in the order given.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {{visit: function(number, number, number, number, number): void}} visitor
+ */
+export function tri2_rasterize_barycentric(width: number, height: number, x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, visitor: {
+    visit: (arg0: number, arg1: number, arg2: number, arg3: number, arg4: number) => void;
+}): void;
+//# sourceMappingURL=tri2_rasterize_barycentric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tri2_rasterize_barycentric.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_rasterize_barycentric.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,kDAVW,MAAM,UACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,WACN;IAAC,KAAK,SAAW,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,CAAA;CAAC,QA+DzE"}

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

@@ -0,0 +1,81 @@
+/**
+ * Visits every pixel of a `width` x `height` grid whose centre lies inside triangle `(x0, y0)`, `(x1, y1)`, `(x2, y2)`,
+ * in pixel units: pixel `(col, row)` is the point sample at `(col + 0.5, row + 0.5)`. A centre on an edge belongs to
+ * one of the two triangles sharing that edge (the top-left rule), so a mesh visits each point once. An edge-on
+ * triangle visits nothing.
+ *
+ * `visitor.visit(col, row, l0, l1, l2)` receives the pixel and the centre's barycentric weights of the three vertices,
+ * in the order given.
+ *
+ * @param {number} width
+ * @param {number} height
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} x2
+ * @param {number} y2
+ * @param {{visit: function(number, number, number, number, number): void}} visitor
+ */
+export function tri2_rasterize_barycentric(width, height, x0, y0, x1, y1, x2, y2, visitor) {
+    let area = (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0);
+    if (!(Math.abs(area) > 0)) {
+        return;
+    }
+    // counter-clockwise, so the interior is where all three edge functions are positive
+    const swapped = area < 0;
+    if (swapped) {
+        let s = x1; x1 = x2; x2 = s;
+        s = y1; y1 = y2; y2 = s;
+        area = -area;
+    }
+    const inv_area = 1.0 / area;
+
+    // a point on an edge belongs to the triangle that edge runs up through (or left along) in
+    const own_0 = (y2 - y1) > 0 || ((y2 - y1) === 0 && (x2 - x1) < 0);
+    const own_1 = (y0 - y2) > 0 || ((y0 - y2) === 0 && (x0 - x2) < 0);
+    const own_2 = (y1 - y0) > 0 || ((y1 - y0) === 0 && (x1 - x0) < 0);
+
+    const col_lo = Math.max(0, Math.ceil(Math.min(x0, x1, x2) - 0.5));
+    const col_hi = Math.min(width - 1, Math.floor(Math.max(x0, x1, x2) - 0.5));
+    const row_lo = Math.max(0, Math.ceil(Math.min(y0, y1, y2) - 0.5));
+    const row_hi = Math.min(height - 1, Math.floor(Math.max(y0, y1, y2) - 0.5));
+
+    for (let row = row_lo; row <= row_hi; row++) {
+        const cy = row + 0.5;
+
+        // Each edge function is linear along the row, `e(cx) = a - dy * cx`, and bounds cx on one side: the row's
+        // span, widened by a pixel each way so the exact tests below keep their say on the edges
+        let x_lower = -Infinity;
+        let x_upper = Infinity;
+        let dy = y2 - y1;
+        let a = (x2 - x1) * (cy - y1) + dy * x1;
+        if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
+        dy = y0 - y2;
+        a = (x0 - x2) * (cy - y2) + dy * x2;
+        if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
+        dy = y1 - y0;
+        a = (x1 - x0) * (cy - y0) + dy * x0;
+        if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
+
+        const span_lo = Math.max(col_lo, Math.ceil(x_lower - 0.5) - 1);
+        const span_hi = Math.min(col_hi, Math.floor(x_upper - 0.5) + 1);
+
+        for (let col = span_lo; col <= span_hi; col++) {
+            const cx = col + 0.5;
+
+            const e0 = (x2 - x1) * (cy - y1) - (y2 - y1) * (cx - x1);
+            if (e0 < 0 || (e0 === 0 && !own_0)) continue;
+            const e1 = (x0 - x2) * (cy - y2) - (y0 - y2) * (cx - x2);
+            if (e1 < 0 || (e1 === 0 && !own_1)) continue;
+            const e2 = (x1 - x0) * (cy - y0) - (y1 - y0) * (cx - x0);
+            if (e2 < 0 || (e2 === 0 && !own_2)) continue;
+
+            if (swapped) {
+                visitor.visit(col, row, e0 * inv_area, e2 * inv_area, e1 * inv_area);
+            } else {
+                visitor.visit(col, row, e0 * inv_area, e1 * inv_area, e2 * inv_area);
+            }
+        }
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"tri2_rasterize_conservative.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_rasterize_conservative.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,mDARW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,KAAG,IAAI,CAAA;CAAC,MAC5D,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoBhB"}
+{"version":3,"file":"tri2_rasterize_conservative.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/triangle/tri2_rasterize_conservative.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,mDARW;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,GAAG,EAAC,CAAC,CAAC,EAAC,MAAM,EAAC,CAAC,EAAC,MAAM,KAAG,IAAI,CAAA;CAAC,MAC5D,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAoBhB"}

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

@@ -1,99 +1,36 @@
-/**
- * Conservative rasterization of a 2D triangle into a bit image: every cell
- * whose unit square overlaps the triangle is set (a superset of exact coverage),
- * so the resulting mask never under-covers — required for packing gutters.
- * Overlap is decided by the separating-axis test between the triangle and each
- * candidate cell square.
- *
- * @param {{width:number, height:number, set:(x:number,y: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_conservative(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++) {
-            if (tri_box_overlap(x0, y0, x1, y1, x2, y2, px, py, px + 1, py + 1)) {
-                image.set(px, py);
-            }
-        }
-    }
-}
-
-/**
- * Separating-axis overlap test between a triangle and an axis-aligned box.
- *
- * @param {number} ax first triangle vertex x
- * @param {number} ay first triangle vertex y
- * @param {number} bx second triangle vertex x
- * @param {number} by second triangle vertex y
- * @param {number} cx third triangle vertex x
- * @param {number} cy third triangle vertex y
- * @param {number} bminx box minimum corner x
- * @param {number} bminy box minimum corner y
- * @param {number} bmaxx box maximum corner x
- * @param {number} bmaxy box maximum corner y
- * @returns {boolean} true if the triangle and box overlap
- */
-function tri_box_overlap(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy) {
-    // Box axes (x then y).
-    if (Math.max(ax, bx, cx) < bminx || Math.min(ax, bx, cx) > bmaxx) return false;
-    if (Math.max(ay, by, cy) < bminy || Math.min(ay, by, cy) > bmaxy) return false;
-
-    // Triangle edge normals.
-    if (edge_separates(ax, ay, bx, by, cx, cy, bminx, bminy, bmaxx, bmaxy)) return false;
-    if (edge_separates(bx, by, cx, cy, ax, ay, bminx, bminy, bmaxx, bmaxy)) return false;
-    if (edge_separates(cx, cy, ax, ay, bx, by, bminx, bminy, bmaxx, bmaxy)) return false;
-
-    return true;
-}
-
-/**
- * Does the outward normal of edge (p->q) separate the box from the triangle?
- * `r` is the triangle's third vertex (to orient the normal inward).
- *
- * @param {number} px edge start vertex x
- * @param {number} py edge start vertex y
- * @param {number} qx edge end vertex x
- * @param {number} qy edge end vertex y
- * @param {number} rx triangle's third vertex x
- * @param {number} ry triangle's third vertex y
- * @param {number} bminx box minimum corner x
- * @param {number} bminy box minimum corner y
- * @param {number} bmaxx box maximum corner x
- * @param {number} bmaxy box maximum corner y
- * @returns {boolean} true if this edge's axis separates the box from the triangle
- */
-function edge_separates(px, py, qx, qy, rx, ry, bminx, bminy, bmaxx, bmaxy) {
-    const nx = -(qy - py);
-    const ny = qx - px;
-
-    // triangle interval along n
-    const dp = nx * px + ny * py;
-    const dr = nx * rx + ny * ry;
-    let tri_min, tri_max;
-    if (dp < dr) { tri_min = dp; tri_max = dr; } else { tri_min = dr; tri_max = dp; }
-
-    // box interval along n (4 corners)
-    const c0 = nx * bminx + ny * bminy;
-    const c1 = nx * bmaxx + ny * bminy;
-    const c2 = nx * bminx + ny * bmaxy;
-    const c3 = nx * bmaxx + ny * bmaxy;
-    const box_min = Math.min(c0, c1, c2, c3);
-    const box_max = Math.max(c0, c1, c2, c3);
-
-    return box_max < tri_min || box_min > tri_max;
-}
+import { tri2_intersects_aabb2 } from "./tri2_intersects_aabb2.js";
+
+/**
+ * Conservative rasterization of a 2D triangle into a bit image: every cell
+ * whose unit square overlaps the triangle is set (a superset of exact coverage),
+ * so the resulting mask never under-covers — required for packing gutters.
+ * Overlap is decided by the separating-axis test between the triangle and each
+ * candidate cell square.
+ *
+ * @param {{width:number, height:number, set:(x:number,y: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_conservative(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++) {
+            if (tri2_intersects_aabb2(x0, y0, x1, y1, x2, y2, px, py, px + 1, py + 1)) {
+                image.set(px, py);
+            }
+        }
+    }
+}

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

@@ -9,15 +9,4 @@
  * @param {number} z1
  */
 export function aabb3_build_frustum(result: number[], x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
-/**
- * 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 aabb_build_frustum(result: number[], x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void;
 //# sourceMappingURL=aabb3_build_frustum.d.ts.map

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"}