@woosh/meep-engine 2.163.11 → 2.165.0

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

@@ -0,0 +1,51 @@
+/**
+ *
+ * Find intersection point between two line segments if they intersect at all
+ * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
+ * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
+ *
+ * @param {number[]|Float32Array|Float64Array} result resulting intersection point will be stored here if intersection exists
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @return {boolean} True if segments intersect, False otherwise
+ */
+export function segment2_segment_compute_intersection_array_2d(
+    result, result_offset,
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y
+) {
+
+    const s1_x = a1_x - a0_x;
+    const s1_y = a1_y - a0_y;
+    const s2_x = b1_x - b0_x;
+    const s2_y = b1_y - b0_y;
+
+    const dy_02 = a0_y - b0_y;
+    const dx_02 = a0_x - b0_x;
+
+    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
+
+    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
+    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
+
+    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
+        // Collision detected
+
+        const intercept_x = a0_x + (t * s1_x);
+        const intercept_y = a0_y + (t * s1_y);
+
+        result[result_offset] = intercept_x;
+        result[result_offset + 1] = intercept_y;
+
+        return true;
+    }
+
+    return false; // No collision
+}

package/src/core/geom/2d/line/segment2_segment_compute_intersection_to_new_array_2d.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {Vector2} p0
+ * @param {Vector2} p1
+ * @param {Vector2} p2
+ * @param {Vector2} p3
+ * @returns {number[]} 2 elements
+ */
+export function segment2_segment_compute_intersection_to_new_array_2d(p0: Vector2, p1: Vector2, p2: Vector2, p3: Vector2): number[];
+//# sourceMappingURL=segment2_segment_compute_intersection_to_new_array_2d.d.ts.map

package/src/core/geom/2d/line/segment2_segment_compute_intersection_to_new_array_2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment2_segment_compute_intersection_to_new_array_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_compute_intersection_to_new_array_2d.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,2HAFa,MAAM,EAAE,CAoBpB"}

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

@@ -0,0 +1,28 @@
+import { segment2_segment_compute_intersection_array_2d } from "./segment2_segment_compute_intersection_array_2d.js";
+
+/**
+ * @param {Vector2} p0
+ * @param {Vector2} p1
+ * @param {Vector2} p2
+ * @param {Vector2} p3
+ * @returns {number[]} 2 elements
+ */
+export function segment2_segment_compute_intersection_to_new_array_2d(p0, p1, p2, p3) {
+    const p0_x = p0.x;
+    const p0_y = p0.y;
+    const p1_x = p1.x;
+    const p1_y = p1.y;
+    const p2_x = p2.x;
+    const p2_y = p2.y;
+    const p3_x = p3.x;
+    const p3_y = p3.y;
+
+    const result = [];
+
+    if (segment2_segment_compute_intersection_array_2d(result, 0, p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y)) {
+        return result;
+    } else {
+        return null; // No collision
+    }
+
+}

package/src/core/geom/2d/line/segment2_segment_compute_intersection_v2_2d.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function segment2_segment_compute_intersection_v2_2d(a0_x: number, a0_y: number, a1_x: number, a1_y: number, b0_x: number, b0_y: number, b1_x: number, b1_y: number, result: Vector2): boolean;
+//# sourceMappingURL=segment2_segment_compute_intersection_v2_2d.d.ts.map

package/src/core/geom/2d/line/segment2_segment_compute_intersection_v2_2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment2_segment_compute_intersection_v2_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_compute_intersection_v2_2d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;GAWG;AACH,kEAXW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,oBAEJ,OAAO,CAkBnB"}

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

@@ -0,0 +1,33 @@
+import { segment2_segment_compute_intersection_array_2d } from "./segment2_segment_compute_intersection_array_2d.js";
+
+const scratch_array = new Float32Array(2);
+
+/**
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function segment2_segment_compute_intersection_v2_2d(
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y,
+    result
+) {
+    const collision = segment2_segment_compute_intersection_array_2d(
+        scratch_array, 0,
+        a0_x, a0_y, a1_x, a1_y,
+        b0_x, b0_y, b1_x, b1_y,
+    );
+
+    if (collision) {
+        result.fromArray(scratch_array);
+    }
+
+    return collision;
+}

package/src/core/geom/2d/line/segment2_segment_compute_intersection_v2_objects_2d.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {Vector2} a0 start of first segment
+ * @param {Vector2} a1 end of first segment
+ * @param {Vector2} b0 start of second segment
+ * @param {Vector2} b1 end of second segment
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function segment2_segment_compute_intersection_v2_objects_2d(a0: Vector2, a1: Vector2, b0: Vector2, b1: Vector2, result: Vector2): boolean;
+//# sourceMappingURL=segment2_segment_compute_intersection_v2_objects_2d.d.ts.map

package/src/core/geom/2d/line/segment2_segment_compute_intersection_v2_objects_2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment2_segment_compute_intersection_v2_objects_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/line/segment2_segment_compute_intersection_v2_objects_2d.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,0IAFa,OAAO,CAInB"}

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

@@ -0,0 +1,13 @@
+import { segment2_segment_compute_intersection_v2_2d } from "./segment2_segment_compute_intersection_v2_2d.js";
+
+/**
+ * @param {Vector2} a0 start of first segment
+ * @param {Vector2} a1 end of first segment
+ * @param {Vector2} b0 start of second segment
+ * @param {Vector2} b1 end of second segment
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function segment2_segment_compute_intersection_v2_objects_2d(a0, a1, b0, b1, result) {
+    return segment2_segment_compute_intersection_v2_2d(a0.x, a0.y, a1.x, a1.y, b0.x, b0.y, b1.x, b1.y, result);
+}

package/src/core/geom/2d/oriented-box/min_area_rect_2d.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Minimum-area oriented bounding rectangle of a 2D point set, via rotating
+ * calipers over the convex hull. By the standard theorem the min-area rectangle
+ * has one side collinear with a hull edge, so each hull edge is tried as the box
+ * orientation and the tightest is kept.
+ *
+ * The returned `angle` is the direction of that hull edge (the box's local
+ * x-axis); rotating the point set by `-angle` makes its axis-aligned bounding
+ * box equal to this oriented box. `width`/`height` are the box extents along the
+ * edge and its perpendicular.
+ *
+ * @param {number[]|Float32Array|Float64Array} points flat xy
+ * @param {number} point_count
+ * @returns {{angle:number, width:number, height:number, area:number}}
+ */
+export function min_area_rect_2d(points: number[] | Float32Array | Float64Array, point_count: number): {
+    angle: number;
+    width: number;
+    height: number;
+    area: number;
+};
+//# sourceMappingURL=min_area_rect_2d.d.ts.map

package/src/core/geom/2d/oriented-box/min_area_rect_2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"min_area_rect_2d.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/oriented-box/min_area_rect_2d.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,yCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,GACJ;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAA;CAAC,CAqDpE"}

package/src/core/geom/2d/oriented-box/min_area_rect_2d.js

@@ -0,0 +1,69 @@
+import { convex_hull_monotone_2d } from "../convex-hull/convex_hull_monotone_2d.js";
+
+/**
+ * Minimum-area oriented bounding rectangle of a 2D point set, via rotating
+ * calipers over the convex hull. By the standard theorem the min-area rectangle
+ * has one side collinear with a hull edge, so each hull edge is tried as the box
+ * orientation and the tightest is kept.
+ *
+ * The returned `angle` is the direction of that hull edge (the box's local
+ * x-axis); rotating the point set by `-angle` makes its axis-aligned bounding
+ * box equal to this oriented box. `width`/`height` are the box extents along the
+ * edge and its perpendicular.
+ *
+ * @param {number[]|Float32Array|Float64Array} points flat xy
+ * @param {number} point_count
+ * @returns {{angle:number, width:number, height:number, area:number}}
+ */
+export function min_area_rect_2d(points, point_count) {
+    const hull = convex_hull_monotone_2d(points, point_count);
+    const h = hull.length;
+
+    if (h < 2) {
+        return { angle: 0, width: 0, height: 0, area: 0 };
+    }
+
+    let best_area = Infinity;
+    let best_angle = 0;
+    let best_width = 0;
+    let best_height = 0;
+
+    for (let i = 0; i < h; i++) {
+        const a = hull[i];
+        const b = hull[(i + 1) % h];
+
+        let ex = points[b * 2] - points[a * 2];
+        let ey = points[b * 2 + 1] - points[a * 2 + 1];
+        const len = Math.sqrt(ex * ex + ey * ey);
+        if (len < 1e-12) {
+            continue;
+        }
+        ex /= len;
+        ey /= len;
+
+        let min_u = Infinity, max_u = -Infinity, min_v = Infinity, max_v = -Infinity;
+        for (let k = 0; k < h; k++) {
+            const px = points[hull[k] * 2];
+            const py = points[hull[k] * 2 + 1];
+            const u = px * ex + py * ey;
+            const v = -px * ey + py * ex;
+            if (u < min_u) min_u = u;
+            if (u > max_u) max_u = u;
+            if (v < min_v) min_v = v;
+            if (v > max_v) max_v = v;
+        }
+
+        const width = max_u - min_u;
+        const height = max_v - min_v;
+        const area = width * height;
+
+        if (area < best_area) {
+            best_area = area;
+            best_angle = Math.atan2(ey, ex);
+            best_width = width;
+            best_height = height;
+        }
+    }
+
+    return { angle: best_angle, width: best_width, height: best_height, area: best_area };
+}

package/src/core/geom/2d/packing/skyline.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Bottom-left skyline rectangle packer (Jylänki's skyline-BL). The skyline is a
+ * left-to-right sequence of horizontal segments giving the free height at each
+ * column; a rectangle is placed at the lowest-then-leftmost position whose span
+ * fits, raising the skyline over its footprint. O(segments) per placement — the
+ * scalable packer for large atlases where the exact bitmap canBlit scan is too
+ * slow.
+ *
+ * Segments are packed as `(x, y, width)` uint32 triplets in a single typed
+ * array (not an array of objects) for cache locality and zero per-placement
+ * allocation: {@link place} rebuilds into a reused scratch buffer and swaps.
+ * Rectangles never overlap; simple skyline (no waste-map), so a little space is
+ * left under overhangs — fine for texture atlases.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Skyline {
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width: number, height: number);
+    /** Current bounds width. @type {number} */
+    width: number;
+    /** Current bounds height. @type {number} */
+    height: number;
+    /**
+     * x of the most recent successful {@link find} (valid only when `find`
+     * returned true).
+     * @type {number}
+     */
+    found_x: number;
+    /** y of the most recent successful {@link find}. @type {number} */
+    found_y: number;
+    /**
+     * Live segment count.
+     * @type {number}
+     * @private
+     */
+    private __count;
+    /**
+     * Capacity in triplets of {@link __segments} and {@link __scratch}.
+     * @type {number}
+     * @private
+     */
+    private __capacity;
+    /**
+     * Packed `(x, y, width)` triplets, x-ascending. Segment k spans columns
+     * `[x_k, x_k + width_k)` at free height `y_k`.
+     * @type {Uint32Array}
+     * @private
+     */
+    private __segments;
+    /**
+     * Scratch buffer reused by {@link place} to rebuild the segment list, then
+     * swapped with {@link __segments}.
+     * @type {Uint32Array}
+     * @private
+     */
+    private __scratch;
+    /**
+     * Grow the segment and scratch buffers to hold at least `triplets`
+     * segments, preserving the live segments.
+     * @param {number} triplets
+     * @private
+     */
+    private __ensure_capacity;
+    /**
+     * Highest segment `y` across the columns `[segments[i].x, x_right)` — the
+     * floor a rectangle would rest on if its left edge started at segment `i`.
+     * @param {number} i start segment index
+     * @param {number} x_right exclusive right edge of the span
+     * @returns {number}
+     * @private
+     */
+    private __level;
+    /**
+     * Find the lowest-then-leftmost position for a `w x h` rectangle. On success
+     * stores it in {@link found_x}/{@link found_y}. Does not mutate the skyline.
+     * @param {number} w rectangle width
+     * @param {number} h rectangle height
+     * @returns {boolean} true if it fits within the current bounds
+     */
+    find(w: number, h: number): boolean;
+    /**
+     * Append segment `(x, y, width)` to `scratch[n]`, merging into the previous
+     * scratch segment when they are adjacent at the same height.
+     * @param {Uint32Array} scratch
+     * @param {number} n current scratch segment count
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @returns {number} the new scratch segment count
+     * @private
+     */
+    private __emit;
+    /**
+     * Raise the skyline to account for a `w x h` rectangle placed at (x, y).
+     * Rebuilds the (still x-sorted) segment list into the scratch buffer — the
+     * portions of old segments left of x and right of x+w, with the new top
+     * segment between them — then swaps it in. No per-segment allocation.
+     * @param {number} x placement left edge
+     * @param {number} y placement bottom edge
+     * @param {number} w rectangle width
+     * @param {number} h rectangle height
+     */
+    place(x: number, y: number, w: number, h: number): void;
+    /**
+     * Enlarge the bounds, preserving placements. The new width starts at y=0.
+     * @param {number} width new width (>= current)
+     * @param {number} height new height (>= current)
+     */
+    grow(width: number, height: number): void;
+}
+//# sourceMappingURL=skyline.d.ts.map

package/src/core/geom/2d/packing/skyline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skyline.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/packing/skyline.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IA6CI;;;OAGG;IACH,mBAHW,MAAM,UACN,MAAM,EAYhB;IA1DD,2CAA2C;IAC3C,OADiC,MAAM,CAC7B;IACV,4CAA4C;IAC5C,QADkC,MAAM,CAC7B;IAEX;;;;OAIG;IACH,SAFU,MAAM,CAEJ;IACZ,mEAAmE;IACnE,SADyD,MAAM,CACnD;IAEZ;;;;OAIG;IACH,gBAAY;IAEZ;;;;OAIG;IACH,mBAAgB;IAEhB;;;;;OAKG;IACH,mBAAkD;IAElD;;;;;OAKG;IACH,kBAAiD;IAkBjD;;;;;OAKG;IACH,0BAaC;IAED;;;;;;;OAOG;IACH,gBAWC;IAED;;;;;;OAMG;IACH,QAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0BnB;IAED;;;;;;;;;;OAUG;IACH,eAeC;IAED;;;;;;;;;OASG;IACH,SALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAsChB;IAED;;;;OAIG;IACH,YAHW,MAAM,UACN,MAAM,QAsBhB;CACJ"}

package/src/core/geom/2d/packing/skyline.js

@@ -0,0 +1,258 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Bottom-left skyline rectangle packer (Jylänki's skyline-BL). The skyline is a
+ * left-to-right sequence of horizontal segments giving the free height at each
+ * column; a rectangle is placed at the lowest-then-leftmost position whose span
+ * fits, raising the skyline over its footprint. O(segments) per placement — the
+ * scalable packer for large atlases where the exact bitmap canBlit scan is too
+ * slow.
+ *
+ * Segments are packed as `(x, y, width)` uint32 triplets in a single typed
+ * array (not an array of objects) for cache locality and zero per-placement
+ * allocation: {@link place} rebuilds into a reused scratch buffer and swaps.
+ * Rectangles never overlap; simple skyline (no waste-map), so a little space is
+ * left under overhangs — fine for texture atlases.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Skyline {
+    /** Current bounds width. @type {number} */
+    width = 0;
+    /** Current bounds height. @type {number} */
+    height = 0;
+
+    /**
+     * x of the most recent successful {@link find} (valid only when `find`
+     * returned true).
+     * @type {number}
+     */
+    found_x = 0;
+    /** y of the most recent successful {@link find}. @type {number} */
+    found_y = 0;
+
+    /**
+     * Live segment count.
+     * @type {number}
+     * @private
+     */
+    __count = 1;
+
+    /**
+     * Capacity in triplets of {@link __segments} and {@link __scratch}.
+     * @type {number}
+     * @private
+     */
+    __capacity = 16;
+
+    /**
+     * Packed `(x, y, width)` triplets, x-ascending. Segment k spans columns
+     * `[x_k, x_k + width_k)` at free height `y_k`.
+     * @type {Uint32Array}
+     * @private
+     */
+    __segments = new Uint32Array(this.__capacity * 3);
+
+    /**
+     * Scratch buffer reused by {@link place} to rebuild the segment list, then
+     * swapped with {@link __segments}.
+     * @type {Uint32Array}
+     * @private
+     */
+    __scratch = new Uint32Array(this.__capacity * 3);
+
+    /**
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(width, height) {
+        assert.isNonNegativeInteger(width, "width");
+        assert.isNonNegativeInteger(height, "height");
+
+        this.width = width;
+        this.height = height;
+        this.__count = 1;
+        this.__segments[0] = 0;
+        this.__segments[1] = 0;
+        this.__segments[2] = width;
+    }
+
+    /**
+     * Grow the segment and scratch buffers to hold at least `triplets`
+     * segments, preserving the live segments.
+     * @param {number} triplets
+     * @private
+     */
+    __ensure_capacity(triplets) {
+        if (this.__capacity >= triplets) {
+            return;
+        }
+        let cap = this.__capacity;
+        while (cap < triplets) {
+            cap *= 2;
+        }
+        const grown = new Uint32Array(cap * 3);
+        grown.set(this.__segments.subarray(0, this.__count * 3));
+        this.__segments = grown;
+        this.__scratch = new Uint32Array(cap * 3);
+        this.__capacity = cap;
+    }
+
+    /**
+     * Highest segment `y` across the columns `[segments[i].x, x_right)` — the
+     * floor a rectangle would rest on if its left edge started at segment `i`.
+     * @param {number} i start segment index
+     * @param {number} x_right exclusive right edge of the span
+     * @returns {number}
+     * @private
+     */
+    __level(i, x_right) {
+        const seg = this.__segments;
+        const count = this.__count;
+        let max_y = 0;
+        for (let j = i; j < count && seg[j * 3] < x_right; j++) {
+            const y = seg[j * 3 + 1];
+            if (y > max_y) {
+                max_y = y;
+            }
+        }
+        return max_y;
+    }
+
+    /**
+     * Find the lowest-then-leftmost position for a `w x h` rectangle. On success
+     * stores it in {@link found_x}/{@link found_y}. Does not mutate the skyline.
+     * @param {number} w rectangle width
+     * @param {number} h rectangle height
+     * @returns {boolean} true if it fits within the current bounds
+     */
+    find(w, h) {
+        const seg = this.__segments;
+        const count = this.__count;
+        let best_y = Infinity;
+        let best_x = -1;
+
+        for (let i = 0; i < count; i++) {
+            const x = seg[i * 3];
+            if (x + w > this.width) {
+                break; // segments are x-ascending: nothing further right fits
+            }
+            const y = this.__level(i, x + w);
+            if (y + h <= this.height && (y < best_y || (y === best_y && x < best_x))) {
+                best_y = y;
+                best_x = x;
+            }
+        }
+
+        if (best_x === -1) {
+            return false;
+        }
+        this.found_x = best_x;
+        this.found_y = best_y;
+        return true;
+    }
+
+    /**
+     * Append segment `(x, y, width)` to `scratch[n]`, merging into the previous
+     * scratch segment when they are adjacent at the same height.
+     * @param {Uint32Array} scratch
+     * @param {number} n current scratch segment count
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @returns {number} the new scratch segment count
+     * @private
+     */
+    __emit(scratch, n, x, y, width) {
+        if (width <= 0) {
+            return n;
+        }
+        if (n > 0) {
+            const last = (n - 1) * 3;
+            if (scratch[last + 1] === y && scratch[last] + scratch[last + 2] === x) {
+                scratch[last + 2] += width;
+                return n;
+            }
+        }
+        scratch[n * 3] = x;
+        scratch[n * 3 + 1] = y;
+        scratch[n * 3 + 2] = width;
+        return n + 1;
+    }
+
+    /**
+     * Raise the skyline to account for a `w x h` rectangle placed at (x, y).
+     * Rebuilds the (still x-sorted) segment list into the scratch buffer — the
+     * portions of old segments left of x and right of x+w, with the new top
+     * segment between them — then swaps it in. No per-segment allocation.
+     * @param {number} x placement left edge
+     * @param {number} y placement bottom edge
+     * @param {number} w rectangle width
+     * @param {number} h rectangle height
+     */
+    place(x, y, w, h) {
+        // worst case: one segment straddling both edges -> 2 clips + the new top
+        this.__ensure_capacity(this.__count + 2);
+
+        const seg = this.__segments;
+        const scratch = this.__scratch;
+        const count = this.__count;
+        const top = y + h;
+        const xr = x + w;
+        let n = 0;
+
+        // portions of segments left of x (x-ascending -> emitted in order)
+        for (let i = 0; i < count; i++) {
+            const sx = seg[i * 3];
+            if (sx < x) {
+                const right = Math.min(sx + seg[i * 3 + 2], x);
+                n = this.__emit(scratch, n, sx, seg[i * 3 + 1], right - sx);
+            }
+        }
+
+        // the new top segment, in x-order between the left and right portions
+        n = this.__emit(scratch, n, x, top, w);
+
+        // portions of segments right of x+w
+        for (let i = 0; i < count; i++) {
+            const sx = seg[i * 3];
+            const send = sx + seg[i * 3 + 2];
+            if (send > xr) {
+                const left = Math.max(sx, xr);
+                n = this.__emit(scratch, n, left, seg[i * 3 + 1], send - left);
+            }
+        }
+
+        this.__segments = scratch;
+        this.__scratch = seg;
+        this.__count = n;
+    }
+
+    /**
+     * Enlarge the bounds, preserving placements. The new width starts at y=0.
+     * @param {number} width new width (>= current)
+     * @param {number} height new height (>= current)
+     */
+    grow(width, height) {
+        if (width > this.width) {
+            const last = (this.__count - 1) * 3;
+            const seg = this.__segments;
+            if (seg[last + 1] === 0 && seg[last] + seg[last + 2] === this.width) {
+                // extend the trailing floor segment in place
+                seg[last + 2] += width - this.width;
+            } else {
+                this.__ensure_capacity(this.__count + 1);
+                const k = this.__count * 3;
+                this.__segments[k] = this.width;
+                this.__segments[k + 1] = 0;
+                this.__segments[k + 2] = width - this.width;
+                this.__count++;
+            }
+            this.width = width;
+        }
+        if (height > this.height) {
+            this.height = height;
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Sutherland-Hodgman clip of a 2D polygon against one half-plane of a directed edge - the general-edge
+ * analogue of {@link polygon2_clip_axis_halfplane}. The edge passes through (ex, ey) with direction
+ * (dx, dy); `keep_left` keeps the side with `cross(dir, P - e) >= 0`, otherwise the right side.
+ *
+ * @param {Float64Array} points_in input vertices (stride 2)
+ * @param {number} point_count input vertex count
+ * @param {Float64Array} points_out output buffer (stride 2), sized for at least point_count + 1 vertices
+ * @param {number} ex
+ * @param {number} ey a point on the edge
+ * @param {number} dx
+ * @param {number} dy the edge direction
+ * @param {boolean} keep_left keep the left half-plane when true
+ * @returns {number} surviving vertex count
+ */
+export function polygon2_clip_halfplane(points_in: Float64Array, point_count: number, points_out: Float64Array, ex: number, ey: number, dx: number, dy: number, keep_left: boolean): number;
+//# sourceMappingURL=polygon2_clip_halfplane.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polygon2_clip_halfplane.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/polygon/polygon2_clip_halfplane.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,mDAVW,YAAY,eACZ,MAAM,cACN,YAAY,MACZ,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,aACN,OAAO,GACL,MAAM,CAgClB"}