@woosh/meep-engine 2.156.0 → 2.157.0

package/src/core/bvh8/bvh8_get_node_child_bounds.js

@@ -0,0 +1,53 @@
+import { assert } from "../assert.js";
+import { reinterpret_uint32_as_float32 } from "../binary/reinterpret_uint32_as_float32.js";
+import { aabb3_array_set } from "../geom/3d/aabb/aabb3_array_set.js";
+
+const scratch_f32 = new Float32Array(6);
+
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} out_offset
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {number} child
+ */
+export function bvh8_get_node_child_bounds(out, out_offset, bvh, node, child) {
+    assert.isNonNegativeInteger(node, 'node');
+    assert.isNonNegativeInteger(child, 'child');
+
+    bvh.node_get_p(node, scratch_f32);
+
+    const p_x = scratch_f32[0];
+    const p_y = scratch_f32[1];
+    const p_z = scratch_f32[2];
+
+    // read out exponent
+    bvh.node_get_e(node, scratch_f32);
+
+    const e_x = scratch_f32[0];
+    const e_y = scratch_f32[1];
+    const e_z = scratch_f32[2];
+
+    const scale_x = reinterpret_uint32_as_float32(e_x << 23);
+    const scale_y = reinterpret_uint32_as_float32(e_y << 23);
+    const scale_z = reinterpret_uint32_as_float32(e_z << 23);
+
+    bvh.node_get_quantized_min(node, child, scratch_f32);
+
+    const q_low_x = scratch_f32[0];
+    const q_low_y = scratch_f32[1];
+    const q_low_z = scratch_f32[2];
+
+    bvh.node_get_quantized_max(node, child, scratch_f32);
+
+    const q_high_x = scratch_f32[0];
+    const q_high_y = scratch_f32[1];
+    const q_high_z = scratch_f32[2];
+
+    aabb3_array_set(
+        out, out_offset,
+        q_low_x * scale_x + p_x, q_low_y * scale_y + p_y, q_low_z * scale_z + p_z,
+        q_high_x * scale_x + p_x, q_high_y * scale_y + p_y, q_high_z * scale_z + p_z
+    );
+}

package/src/core/bvh8/bvh8_node_child_surface_area.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {number} child
+ * @returns {number}
+ */
+export function bvh8_node_child_surface_area(bvh: BVH8, node: number, child: number): number;
+//# sourceMappingURL=bvh8_node_child_surface_area.d.ts.map

package/src/core/bvh8/bvh8_node_child_surface_area.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_node_child_surface_area.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_node_child_surface_area.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,8DAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAMlB"}

package/src/core/bvh8/bvh8_node_child_surface_area.js

@@ -0,0 +1,18 @@
+import { aabb3_compute_surface_area } from "../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { bvh8_get_node_child_bounds } from "./bvh8_get_node_child_bounds.js";
+
+const scratch_f32 = new Float32Array(6);
+
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @param {number} child
+ * @returns {number}
+ */
+export function bvh8_node_child_surface_area(bvh, node, child) {
+    bvh8_get_node_child_bounds(scratch_f32, 0, bvh, node, child);
+
+    return aabb3_compute_surface_area(...scratch_f32);
+}
+

package/src/core/bvh8/bvh8_node_count_triangles.d.ts

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @returns {number} number of triangles under this node
+ */
+export function bvh8_node_count_triangles(bvh: BVH8, node: number): number;
+//# sourceMappingURL=bvh8_node_count_triangles.d.ts.map

package/src/core/bvh8/bvh8_node_count_triangles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_node_count_triangles.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_node_count_triangles.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,2DAHW,MAAM,GACJ,MAAM,CAqBlB"}

package/src/core/bvh8/bvh8_node_count_triangles.js

@@ -0,0 +1,28 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+
+/**
+ *
+ * @param {BVH8} bvh
+ * @param {number} node
+ * @returns {number} number of triangles under this node
+ */
+export function bvh8_node_count_triangles(bvh, node) {
+    let result = 0;
+
+    const imask = bvh.node_get_imask(node);
+
+    for (let i = 0; i < 8; i++) {
+        if ((imask & (1 << i)) !== 0) {
+            // intermediate node
+            continue;
+        }
+
+        const meta = bvh.node_get_meta(node, i);
+
+        const triangles = bitCount(meta & 0b11100000);
+
+        result += triangles;
+    }
+
+    return result;
+}

package/src/core/bvh8/bvh8_quality.d.ts

@@ -0,0 +1,8 @@
+/**
+ * We compute surface area heuristic (SAH) over the entire (sub-)tree
+ * @param {BVH8} bvh
+ * @param {number} [root]
+ * @returns {number} Lower = better
+ */
+export function bvh8_quality(bvh: BVH8, root?: number): number;
+//# sourceMappingURL=bvh8_quality.d.ts.map

package/src/core/bvh8/bvh8_quality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_quality.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_quality.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,+CAHW,MAAM,GACJ,MAAM,CA+DlB"}

package/src/core/bvh8/bvh8_quality.js

@@ -0,0 +1,73 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+import { aabb3_compute_surface_area } from "../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { bvh8_get_node_bounds } from "./bvh8_get_node_bounds.js";
+import { bvh8_node_child_surface_area } from "./bvh8_node_child_surface_area.js";
+
+/**
+ * We compute surface area heuristic (SAH) over the entire (sub-)tree
+ * @param {BVH8} bvh
+ * @param {number} [root]
+ * @returns {number} Lower = better
+ */
+export function bvh8_quality(bvh, root = 0) {
+    const stack = [root];
+    let node_count = 0;
+
+    // cost of traversing an intermediate node
+    const COST_INTERMEDIATE = 1.2;
+    // cost of traversing a leaf node
+    const COST_LEAF = 0.1;
+    // cost of performing ray/triangle test
+    const COST_TRIANGLE = 1;
+
+    const root_bounds = new Float32Array(6);
+    bvh8_get_node_bounds(root_bounds, 0, bvh, root);
+    const root_area = aabb3_compute_surface_area(...root_bounds);
+
+    if (root_area === 0) {
+        return 1;
+    }
+
+    let sum_area_node = 0;
+    let sum_triangle_cost = 0;
+    let sum_area_leaf = 0;
+
+    while (stack.length > 0) {
+        const node = stack.pop();
+
+        node_count++;
+
+        const imask = bvh.node_get_imask(node);
+
+        const offset = bvh.node_get_base_index_child(node);
+
+        let child_count = 0;
+        for (let i = 0; i < 8; i++) {
+
+            const child_area = bvh8_node_child_surface_area(bvh, node, i);
+
+            if ((imask & (1 << i)) !== 0) {
+                // intermediate
+                sum_area_node += child_area;
+
+                stack.push(offset + child_count);
+                child_count++;
+            } else {
+
+                const meta = bvh.node_get_meta(node, i);
+
+                if (meta === 0) {
+                    // empty
+                    continue;
+                }
+
+                const triangle_count = bitCount(meta & 0b11100000);
+
+                sum_triangle_cost += (child_area * triangle_count)
+                sum_area_leaf += child_area;
+            }
+        }
+    }
+
+    return (COST_INTERMEDIATE * sum_area_node + COST_LEAF * sum_area_leaf + COST_TRIANGLE * sum_triangle_cost) / root_area;
+}

package/src/core/bvh8/bvh8_validate_structure.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Validate structural invariants of a BVH8, independent of any geometry:
+ *
+ * - every internal slot (imask bit set) stores exactly `(24 + slot) | 0b00100000` in its meta
+ * - every leaf slot stores a triangle offset ≤ 23 (≥ 24 would be misread as an internal slot)
+ *   and a unary triangle count mask (0b001, 0b011 or 0b111)
+ * - internal child blocks lie within the node pool
+ * - every allocated node is reachable from the root exactly once
+ *
+ * Throws an Error describing the first violation found.
+ *
+ * @param {BVH8} bvh
+ */
+export function bvh8_validate_structure(bvh: BVH8): void;
+//# sourceMappingURL=bvh8_validate_structure.d.ts.map

package/src/core/bvh8/bvh8_validate_structure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bvh8_validate_structure.d.ts","sourceRoot":"","sources":["../../../../src/core/bvh8/bvh8_validate_structure.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,yDAuEC"}

package/src/core/bvh8/bvh8_validate_structure.js

@@ -0,0 +1,87 @@
+import { bitCount } from "../binary/operations/bitCount.js";
+
+/**
+ * Validate structural invariants of a BVH8, independent of any geometry:
+ *
+ * - every internal slot (imask bit set) stores exactly `(24 + slot) | 0b00100000` in its meta
+ * - every leaf slot stores a triangle offset ≤ 23 (≥ 24 would be misread as an internal slot)
+ *   and a unary triangle count mask (0b001, 0b011 or 0b111)
+ * - internal child blocks lie within the node pool
+ * - every allocated node is reachable from the root exactly once
+ *
+ * Throws an Error describing the first violation found.
+ *
+ * @param {BVH8} bvh
+ */
+export function bvh8_validate_structure(bvh) {
+    const node_count = bvh.nodes.size;
+
+    if (node_count === 0) {
+        // empty tree
+        return;
+    }
+
+    const visited = new Uint8Array(node_count);
+    let visited_count = 0;
+
+    const stack = [0];
+
+    while (stack.length > 0) {
+        const node = stack.pop();
+
+        if (node >= node_count) {
+            throw new Error(`node index ${node} is out of range [0, ${node_count})`);
+        }
+
+        if (visited[node] !== 0) {
+            throw new Error(`node ${node} is reachable more than once`);
+        }
+
+        visited[node] = 1;
+        visited_count++;
+
+        const imask = bvh.node_get_imask(node);
+        const base_index_child = bvh.node_get_base_index_child(node);
+
+        const internal_count = bitCount(imask);
+
+        if (internal_count > 0 && base_index_child + internal_count > node_count) {
+            throw new Error(`node ${node}: child block [${base_index_child}, ${base_index_child + internal_count}) exceeds node pool size ${node_count}`);
+        }
+
+        let intermediate_count = 0;
+
+        for (let i = 0; i < 8; i++) {
+            const meta = bvh.node_get_meta(node, i);
+
+            if ((imask & (1 << i)) !== 0) {
+                // internal slot
+                const expected = (24 + i) | 0b00100000;
+
+                if (meta !== expected) {
+                    throw new Error(`node ${node} slot ${i}: internal slot meta is ${meta}, expected ${expected}`);
+                }
+
+                stack.push(base_index_child + intermediate_count);
+                intermediate_count++;
+
+            } else if (meta !== 0) {
+                // leaf slot
+                const triangle_offset = meta & 0b11111;
+                const unary_count = (meta >> 5) & 0b111;
+
+                if (triangle_offset > 23) {
+                    throw new Error(`node ${node} slot ${i}: leaf triangle offset ${triangle_offset} > 23 collides with the internal slot encoding`);
+                }
+
+                if (unary_count !== 0b001 && unary_count !== 0b011 && unary_count !== 0b111) {
+                    throw new Error(`node ${node} slot ${i}: triangle count mask ${unary_count.toString(2)} is not unary`);
+                }
+            }
+        }
+    }
+
+    if (visited_count !== node_count) {
+        throw new Error(`${node_count - visited_count} allocated node(s) are not reachable from the root`);
+    }
+}

package/src/core/collection/Uint32MinHeap.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Binary min-heap of uint32 values backed by a flat `Uint32Array`.
+ *
+ * Built for deterministic id-recycling free lists: {@link pop} always
+ * returns the SMALLEST stored value, so two pools given the same
+ * allocate/free sequence reuse identical ids regardless of how the calls
+ * interleaved — the property the physics `BodyStorage` / `ManifoldStore`
+ * free lists are built on (each previously carried a byte-identical
+ * private copy of this heap). Values are expected unique (they are slot
+ * ids); duplicates are not rejected but make pop order between the
+ * duplicates unspecified.
+ *
+ * Grows by doubling on push; never shrinks. Not a hot-path structure —
+ * pushes/pops happen at allocate/release time, not per-iteration.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Uint32MinHeap {
+    /**
+     * @param {number} [initial_capacity]
+     */
+    constructor(initial_capacity?: number);
+    /**
+     * @private
+     * @type {Uint32Array}
+     */
+    private __data;
+    /**
+     * @private
+     * @type {number}
+     */
+    private __count;
+    /**
+     * Number of stored values.
+     * @returns {number}
+     */
+    get size(): number;
+    /**
+     * Remove every value. Capacity is retained.
+     */
+    clear(): void;
+    /**
+     * Insert a value.
+     * @param {number} v
+     */
+    push(v: number): void;
+    /**
+     * Remove and return the smallest value. Caller guarantees non-empty
+     * (the free-list usage always checks `size` first); popping an empty
+     * heap returns stale storage.
+     * @returns {number}
+     */
+    pop(): number;
+}
+//# sourceMappingURL=Uint32MinHeap.d.ts.map

package/src/core/collection/Uint32MinHeap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Uint32MinHeap.d.ts","sourceRoot":"","sources":["../../../../src/core/collection/Uint32MinHeap.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAEI;;OAEG;IACH,+BAFW,MAAM,EAchB;IAXG;;;OAGG;IACH,eAA4D;IAE5D;;;OAGG;IACH,gBAAgB;IAGpB;;;OAGG;IACH,mBAEC;IAED;;OAEG;IACH,cAEC;IAED;;;OAGG;IACH,QAFW,MAAM,QAwBhB;IAED;;;;;OAKG;IACH,OAFa,MAAM,CAuBlB;CACJ"}

package/src/core/collection/Uint32MinHeap.js

@@ -0,0 +1,109 @@
+/**
+ * Binary min-heap of uint32 values backed by a flat `Uint32Array`.
+ *
+ * Built for deterministic id-recycling free lists: {@link pop} always
+ * returns the SMALLEST stored value, so two pools given the same
+ * allocate/free sequence reuse identical ids regardless of how the calls
+ * interleaved — the property the physics `BodyStorage` / `ManifoldStore`
+ * free lists are built on (each previously carried a byte-identical
+ * private copy of this heap). Values are expected unique (they are slot
+ * ids); duplicates are not rejected but make pop order between the
+ * duplicates unspecified.
+ *
+ * Grows by doubling on push; never shrinks. Not a hot-path structure —
+ * pushes/pops happen at allocate/release time, not per-iteration.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class Uint32MinHeap {
+
+    /**
+     * @param {number} [initial_capacity]
+     */
+    constructor(initial_capacity = 16) {
+        /**
+         * @private
+         * @type {Uint32Array}
+         */
+        this.__data = new Uint32Array(Math.max(1, initial_capacity));
+
+        /**
+         * @private
+         * @type {number}
+         */
+        this.__count = 0;
+    }
+
+    /**
+     * Number of stored values.
+     * @returns {number}
+     */
+    get size() {
+        return this.__count;
+    }
+
+    /**
+     * Remove every value. Capacity is retained.
+     */
+    clear() {
+        this.__count = 0;
+    }
+
+    /**
+     * Insert a value.
+     * @param {number} v
+     */
+    push(v) {
+        let heap = this.__data;
+        if (this.__count === heap.length) {
+            const next = new Uint32Array(heap.length << 1);
+            next.set(heap);
+            this.__data = next;
+            heap = next;
+        }
+
+        let i = this.__count++;
+        heap[i] = v;
+        while (i > 0) {
+            const parent = (i - 1) >>> 1;
+            if (heap[parent] > heap[i]) {
+                const tmp = heap[parent];
+                heap[parent] = heap[i];
+                heap[i] = tmp;
+                i = parent;
+            } else {
+                break;
+            }
+        }
+    }
+
+    /**
+     * Remove and return the smallest value. Caller guarantees non-empty
+     * (the free-list usage always checks `size` first); popping an empty
+     * heap returns stale storage.
+     * @returns {number}
+     */
+    pop() {
+        const heap = this.__data;
+        const result = heap[0];
+        const new_count = --this.__count;
+        if (new_count > 0) {
+            heap[0] = heap[new_count];
+            let i = 0;
+            for (;;) {
+                const l = (i << 1) + 1;
+                const r = l + 1;
+                let smallest = i;
+                if (l < new_count && heap[l] < heap[smallest]) smallest = l;
+                if (r < new_count && heap[r] < heap[smallest]) smallest = r;
+                if (smallest === i) break;
+                const tmp = heap[i];
+                heap[i] = heap[smallest];
+                heap[smallest] = tmp;
+                i = smallest;
+            }
+        }
+        return result;
+    }
+}

package/src/core/collection/list/FilteredListProjection.js

@@ -1,4 +1,4 @@
-import { frameThrottle } from "../../../engine/graphics/FrameThrottle.js";
+import { frameThrottle } from "../../function/frameThrottle.js";
 import { invokeObjectEquals } from "../../model/object/invokeObjectEquals.js";
 import { array_set_diff } from "../array/array_set_diff.js";
 import List from "./List.js";

package/src/{engine/physics/island → core/collection/union-find}/union_find.d.ts

@@ -4,8 +4,10 @@
  *
  * Design choices:
  *  - **Path halving** rather than full path compression. Halving rewires
- *    `parent[x]` to `parent[parent[x]]` as it walks, which is `O(α(n))`
- *    amortised (same as full compression) but has a simpler control flow and
+ *    `parent[x]` to `parent[parent[x]]` as it walks. WITHOUT union-by-rank
+ *    (deliberately omitted — see below) this is Θ(log n) amortised, not the
+ *    textbook O(α(n)) (that bound needs halving AND rank together); log n of
+ *    a per-island body count is negligible. Halving has simpler control flow and
  *    is deterministic regardless of call order. Full compression's iterative
  *    second pass would observe a different mutation pattern depending on
  *    which subtree was queried first — fine for correctness, awkward for
@@ -18,9 +20,10 @@
  *    union-by-rank but path halving keeps the amortised cost the same in
  *    practice for the body counts we care about (≤ millions).
  *
- * Used by {@link IslandBuilder} to partition awake bodies + contact pairs
- * into connected components (islands) so the solver can iterate each
- * independently and so whole islands can sleep atomically.
+ * Primary consumer: the physics engine's `IslandBuilder`, which partitions
+ * awake bodies + contact pairs into connected components (islands) so the
+ * solver can iterate each independently and so whole islands can sleep
+ * atomically.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/core/collection/union-find/union_find.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union_find.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/union-find/union_find.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH;;;;GAIG;AACH,gCAHW,WAAW,KACX,MAAM,QAIhB;AAED;;;;;;GAMG;AACH,gCAJW,WAAW,KACX,MAAM,GACJ,MAAM,CAYlB;AAED;;;;;;;GAOG;AACH,iCALW,WAAW,KACX,MAAM,KACN,MAAM,GACJ,MAAM,CAalB"}

package/src/{engine/physics/island → core/collection/union-find}/union_find.js

@@ -4,8 +4,10 @@
  *
  * Design choices:
  *  - **Path halving** rather than full path compression. Halving rewires
- *    `parent[x]` to `parent[parent[x]]` as it walks, which is `O(α(n))`
- *    amortised (same as full compression) but has a simpler control flow and
+ *    `parent[x]` to `parent[parent[x]]` as it walks. WITHOUT union-by-rank
+ *    (deliberately omitted — see below) this is Θ(log n) amortised, not the
+ *    textbook O(α(n)) (that bound needs halving AND rank together); log n of
+ *    a per-island body count is negligible. Halving has simpler control flow and
  *    is deterministic regardless of call order. Full compression's iterative
  *    second pass would observe a different mutation pattern depending on
  *    which subtree was queried first — fine for correctness, awkward for
@@ -18,9 +20,10 @@
  *    union-by-rank but path halving keeps the amortised cost the same in
  *    practice for the body counts we care about (≤ millions).
  *
- * Used by {@link IslandBuilder} to partition awake bodies + contact pairs
- * into connected components (islands) so the solver can iterate each
- * independently and so whole islands can sleep atomically.
+ * Primary consumer: the physics engine's `IslandBuilder`, which partitions
+ * awake bodies + contact pairs into connected components (islands) so the
+ * solver can iterate each independently and so whole islands can sleep
+ * atomically.
  *
  * @author Alex Goldring
  * @copyright Company Named Limited (c) 2026

package/src/core/dom/isImageBitmap.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Guards against cases where ImageBitmap doesn't exist
+ * @param {*} image
+ * @return {boolean}
+ */
+export function isImageBitmap(image: any): boolean;
+//# sourceMappingURL=isImageBitmap.d.ts.map

package/src/core/dom/isImageBitmap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isImageBitmap.d.ts","sourceRoot":"","sources":["../../../../src/core/dom/isImageBitmap.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,2CAFY,OAAO,CAQlB"}

package/src/core/dom/isImageBitmap.js

@@ -0,0 +1,12 @@
+/**
+ * Guards against cases where ImageBitmap doesn't exist
+ * @param {*} image
+ * @return {boolean}
+ */
+export function isImageBitmap(image) {
+    /**
+     * check that browser/environment has the class at all to avoid potential exceptions
+     * Required for Safari below version 15.6
+     */
+    return typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap;
+}

package/src/core/function/frameThrottle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Wraps a function in {@link window.requestAnimationFrame}
+ * @param {function} original
+ * @param {*} [thisArg]
+ * @returns {function} proxy which will call the original at most once per frame
+ */
+export function frameThrottle(original: Function, thisArg?: any): Function;
+//# sourceMappingURL=frameThrottle.d.ts.map

package/src/core/function/frameThrottle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frameThrottle.d.ts","sourceRoot":"","sources":["../../../../src/core/function/frameThrottle.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,2EAgBC"}

package/src/core/function/frameThrottle.js

@@ -0,0 +1,23 @@
+/**
+ * Wraps a function in {@link window.requestAnimationFrame}
+ * @param {function} original
+ * @param {*} [thisArg]
+ * @returns {function} proxy which will call the original at most once per frame
+ */
+export function frameThrottle(original, thisArg) {
+    let pending = false;
+
+    function wrap() {
+        pending = false;
+        original.call(thisArg);
+    }
+
+    function proxy() {
+        if (!pending) {
+            pending = true;
+            requestAnimationFrame(wrap);
+        }
+    }
+
+    return proxy;
+}

package/src/{engine/physics/narrowphase/clip_against_axis_uv.d.ts → core/geom/2d/polygon/polygon2_clip_axis_halfplane.d.ts}

@@ -7,10 +7,10 @@
  * @param {Float64Array} points_in
  * @param {number} point_count
  * @param {Float64Array} points_out
- * @param {number} coord_idx 0 = u, 1 = v
+ * @param {number} coord_idx 0 = first coordinate (x/u), 1 = second (y/v)
  * @param {number} bound
  * @param {boolean} keep_below true to keep points with coord ≤ bound
  * @returns {number} surviving vertex count
  */
-export function clip_against_axis_uv(points_in: Float64Array, point_count: number, points_out: Float64Array, coord_idx: number, bound: number, keep_below: boolean): number;
-//# sourceMappingURL=clip_against_axis_uv.d.ts.map
+export function polygon2_clip_axis_halfplane(points_in: Float64Array, point_count: number, points_out: Float64Array, coord_idx: number, bound: number, keep_below: boolean): number;
+//# sourceMappingURL=polygon2_clip_axis_halfplane.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polygon2_clip_axis_halfplane.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/2d/polygon/polygon2_clip_axis_halfplane.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wDARW,YAAY,eACZ,MAAM,cACN,YAAY,aACZ,MAAM,SACN,MAAM,cACN,OAAO,GACL,MAAM,CAuClB"}