math 0.0.0 → 0.1.0

package/dist/shapes/polygon2.js

@@ -0,0 +1,451 @@
+/**
+ * A 2D polygon is represented as a flat array of vertex coordinates laid out as
+ * `[x0, y0, x1, y1, ...]`, together with an explicit vertex count `n`.
+ *
+ * The count is passed separately (rather than derived from `verts.length`) so a
+ * single scratch buffer can be reused across polygons of different sizes: only
+ * the first `n` vertices are read, and any trailing slots are ignored. Vertices
+ * are assumed to be ordered (clockwise or counter-clockwise) around the polygon.
+ */
+/**
+ * Returns the signed area of the polygon using the shoelace formula.
+ * The result is positive when the vertices wind counter-clockwise and negative
+ * when they wind clockwise, so the sign can be used to determine winding order.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns the signed area
+ */
+function signedArea(vertices, n) {
+    let area = 0;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = vertices[i * 2];
+        const yi = vertices[i * 2 + 1];
+        const xj = vertices[j * 2];
+        const yj = vertices[j * 2 + 1];
+        area += xj * yi - xi * yj;
+    }
+    return area / 2;
+}
+/**
+ * Returns the (non-negative) area of the polygon.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns the absolute area
+ */
+function area(vertices, n) {
+    return Math.abs(signedArea(vertices, n));
+}
+/**
+ * Tests whether a point lies inside the polygon. Works for both convex and
+ * concave polygons. Points exactly on an edge or vertex are considered inside.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param point the point to test
+ * @returns true if the point is inside (or on the boundary of) the polygon
+ */
+function containsPoint(vertices, n, point) {
+    let inside = false;
+    const x = point[0];
+    const y = point[1];
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = vertices[i * 2];
+        const yi = vertices[i * 2 + 1];
+        const xj = vertices[j * 2];
+        const yj = vertices[j * 2 + 1];
+        // Signed area of the triangle (j, i, point): zero when the point lies on
+        // the edge, sign tells which side it is on.
+        const where = (yi - yj) * (x - xi) - (xi - xj) * (y - yi);
+        if (yj < yi) {
+            // Upward edge: count a crossing when the point's y is within [yj, yi).
+            if (y >= yj && y < yi) {
+                if (where === 0)
+                    return true; // on edge
+                if (where > 0) {
+                    if (y === yj) {
+                        // Ray passes exactly through vertex j; only toggle when the
+                        // previous vertex is below, to avoid double-counting.
+                        if (y > vertices[(j === 0 ? n - 1 : j - 1) * 2 + 1])
+                            inside = !inside;
+                    }
+                    else {
+                        inside = !inside;
+                    }
+                }
+            }
+        }
+        else if (yi < yj) {
+            // Downward edge: count a crossing when the point's y is within (yi, yj].
+            if (y > yi && y <= yj) {
+                if (where === 0)
+                    return true; // on edge
+                if (where < 0) {
+                    if (y === yj) {
+                        if (y < vertices[(j === 0 ? n - 1 : j - 1) * 2 + 1])
+                            inside = !inside;
+                    }
+                    else {
+                        inside = !inside;
+                    }
+                }
+            }
+        }
+        else if (y === yi && ((x >= xj && x <= xi) || (x >= xi && x <= xj))) {
+            // Point lies on a horizontal edge.
+            return true;
+        }
+    }
+    return inside;
+}
+/**
+ * Computes the area-weighted centroid (center of mass) of the polygon.
+ * For a degenerate (zero-area) polygon this falls back to the average of the
+ * vertices.
+ *
+ * @param out the vector to store the centroid
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns out
+ */
+function centroid(out, vertices, n) {
+    let cx = 0;
+    let cy = 0;
+    let a2 = 0; // twice the signed area
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = vertices[i * 2];
+        const yi = vertices[i * 2 + 1];
+        const xj = vertices[j * 2];
+        const yj = vertices[j * 2 + 1];
+        const cross = xj * yi - xi * yj;
+        a2 += cross;
+        cx += (xj + xi) * cross;
+        cy += (yj + yi) * cross;
+    }
+    if (a2 === 0) {
+        // Degenerate polygon (collinear vertices): use the vertex average.
+        let sx = 0;
+        let sy = 0;
+        for (let i = 0; i < n; i++) {
+            sx += vertices[i * 2];
+            sy += vertices[i * 2 + 1];
+        }
+        out[0] = sx / n;
+        out[1] = sy / n;
+        return out;
+    }
+    const inv = 1 / (3 * a2);
+    out[0] = cx * inv;
+    out[1] = cy * inv;
+    return out;
+}
+/**
+ * Returns the perimeter (sum of edge lengths) of the polygon.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns the perimeter
+ */
+function perimeter(vertices, n) {
+    let total = 0;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const dx = vertices[i * 2] - vertices[j * 2];
+        const dy = vertices[i * 2 + 1] - vertices[j * 2 + 1];
+        total += Math.sqrt(dx * dx + dy * dy);
+    }
+    return total;
+}
+/**
+ * Returns the winding order of the polygon from the sign of its signed area:
+ * `1` for counter-clockwise, `-1` for clockwise, and `0` for a degenerate
+ * (zero-area) polygon.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns 1 (CCW), -1 (CW), or 0 (degenerate)
+ */
+function winding(vertices, n) {
+    const a = signedArea(vertices, n);
+    if (a > 0)
+        return 1;
+    if (a < 0)
+        return -1;
+    return 0;
+}
+/**
+ * Tests whether the polygon is convex. Works for both winding orders. Assumes a
+ * simple (non-self-intersecting) polygon; collinear vertices are allowed.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns true if the polygon is convex
+ */
+function isConvex(vertices, n) {
+    if (n < 3)
+        return false;
+    let sign = 0;
+    for (let i = 0; i < n; i++) {
+        const p = ((i - 1 + n) % n) * 2;
+        const c = i * 2;
+        const q = ((i + 1) % n) * 2;
+        // Cross product of the incoming and outgoing edges at vertex i.
+        const ax = vertices[c] - vertices[p];
+        const ay = vertices[c + 1] - vertices[p + 1];
+        const bx = vertices[q] - vertices[c];
+        const by = vertices[q + 1] - vertices[c + 1];
+        const cross = ax * by - ay * bx;
+        if (cross !== 0) {
+            const s = cross > 0 ? 1 : -1;
+            if (sign === 0)
+                sign = s;
+            else if (s !== sign)
+                return false;
+        }
+    }
+    return true;
+}
+/**
+ * Tests whether vertex `i` is a reflex (concave) vertex of the polygon — the
+ * interior angle at that vertex exceeds 180°. Assumes the polygon is wound
+ * counter-clockwise and that `0 <= i < n`.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param i index of the vertex to test
+ * @returns true if vertex `i` is reflex
+ */
+function isReflexVertex(vertices, n, i) {
+    const p = ((i - 1 + n) % n) * 2;
+    const c = i * 2;
+    const q = ((i + 1) % n) * 2;
+    // Cross product of the incoming and outgoing edges; negative = right turn = reflex (CCW).
+    const ax = vertices[c] - vertices[p];
+    const ay = vertices[c + 1] - vertices[p + 1];
+    const bx = vertices[q] - vertices[c];
+    const by = vertices[q + 1] - vertices[c + 1];
+    return ax * by - ay * bx < 0;
+}
+/**
+ * Reverses the winding order of the polygon, writing the result into `out`.
+ * `out` may be the same array as `vertices` to reverse in place.
+ *
+ * @param out the array to write the reversed polygon into
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns out
+ */
+function reverse(out, vertices, n) {
+    for (let lo = 0, hi = n - 1; lo < hi; lo++, hi--) {
+        const x = vertices[lo * 2];
+        const y = vertices[lo * 2 + 1];
+        out[lo * 2] = vertices[hi * 2];
+        out[lo * 2 + 1] = vertices[hi * 2 + 1];
+        out[hi * 2] = x;
+        out[hi * 2 + 1] = y;
+    }
+    // Copy the untouched middle vertex when writing to a different buffer.
+    if (out !== vertices && n % 2 === 1) {
+        const mid = (n >> 1) * 2;
+        out[mid] = vertices[mid];
+        out[mid + 1] = vertices[mid + 1];
+    }
+    return out;
+}
+/**
+ * Writes the axis-aligned bounding box of the polygon into `out` as a Box2
+ * `[minX, minY, maxX, maxY]`.
+ *
+ * @param out the box to store the result
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @returns out
+ */
+function bounds(out, vertices, n) {
+    let minX = Number.POSITIVE_INFINITY;
+    let minY = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let maxY = Number.NEGATIVE_INFINITY;
+    for (let i = 0; i < n; i++) {
+        const x = vertices[i * 2];
+        const y = vertices[i * 2 + 1];
+        if (x < minX)
+            minX = x;
+        if (x > maxX)
+            maxX = x;
+        if (y < minY)
+            minY = y;
+        if (y > maxY)
+            maxY = y;
+    }
+    out[0] = minX;
+    out[1] = minY;
+    out[2] = maxX;
+    out[3] = maxY;
+    return out;
+}
+/**
+ * Finds the point on the polygon's boundary closest to `point` and writes it to
+ * `out`. `point` may lie inside, outside, or on the polygon; the result is
+ * always on an edge.
+ *
+ * @param out the vector to store the closest point
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param point the query point
+ * @returns out
+ */
+function closestPoint(out, vertices, n, point) {
+    const px = point[0];
+    const py = point[1];
+    let bestDistSq = Number.POSITIVE_INFINITY;
+    let bestX = px;
+    let bestY = py;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const ax = vertices[j * 2];
+        const ay = vertices[j * 2 + 1];
+        const abx = vertices[i * 2] - ax;
+        const aby = vertices[i * 2 + 1] - ay;
+        // Project the point onto edge (a -> b), clamped to the segment.
+        const d = abx * abx + aby * aby;
+        let t = d > 0 ? ((px - ax) * abx + (py - ay) * aby) / d : 0;
+        if (t < 0)
+            t = 0;
+        else if (t > 1)
+            t = 1;
+        const cx = ax + t * abx;
+        const cy = ay + t * aby;
+        const dx = px - cx;
+        const dy = py - cy;
+        const distSq = dx * dx + dy * dy;
+        if (distSq < bestDistSq) {
+            bestDistSq = distSq;
+            bestX = cx;
+            bestY = cy;
+        }
+    }
+    out[0] = bestX;
+    out[1] = bestY;
+    return out;
+}
+/**
+ * Returns the distance from `point` to the polygon's boundary, signed so that
+ * points inside the polygon get a negative distance and points outside get a
+ * positive one.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param point the query point
+ * @returns the signed distance (negative inside, positive outside)
+ */
+function signedDistance(vertices, n, point) {
+    const px = point[0];
+    const py = point[1];
+    let bestDistSq = Number.POSITIVE_INFINITY;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const ax = vertices[j * 2];
+        const ay = vertices[j * 2 + 1];
+        const abx = vertices[i * 2] - ax;
+        const aby = vertices[i * 2 + 1] - ay;
+        const d = abx * abx + aby * aby;
+        let t = d > 0 ? ((px - ax) * abx + (py - ay) * aby) / d : 0;
+        if (t < 0)
+            t = 0;
+        else if (t > 1)
+            t = 1;
+        const dx = px - (ax + t * abx);
+        const dy = py - (ay + t * aby);
+        const distSq = dx * dx + dy * dy;
+        if (distSq < bestDistSq)
+            bestDistSq = distSq;
+    }
+    const dist = Math.sqrt(bestDistSq);
+    return containsPoint(vertices, n, point) ? -dist : dist;
+}
+const _projA = [0, 0];
+const _projB = [0, 0];
+/** Projects a polygon onto the axis (nx, ny), storing [min, max] in `out`. */
+function projectOntoAxis(out, nx, ny, vertices, n) {
+    let min = nx * vertices[0] + ny * vertices[1];
+    let max = min;
+    for (let i = 1; i < n; i++) {
+        const d = nx * vertices[i * 2] + ny * vertices[i * 2 + 1];
+        if (d < min)
+            min = d;
+        else if (d > max)
+            max = d;
+    }
+    out[0] = min;
+    out[1] = max;
+}
+/** Returns true if the two polygons are separated along any edge normal of A. */
+function separatedByEdgesOf(verticesA, numA, verticesB, numB) {
+    for (let i = 0, j = numA - 1; i < numA; j = i++) {
+        // Normal of edge (a -> b); orientation does not matter for separation.
+        const nx = verticesA[i * 2 + 1] - verticesA[j * 2 + 1];
+        const ny = -(verticesA[i * 2] - verticesA[j * 2]);
+        projectOntoAxis(_projA, nx, ny, verticesA, numA);
+        projectOntoAxis(_projB, nx, ny, verticesB, numB);
+        if (_projA[0] > _projB[1] || _projB[0] > _projA[1])
+            return true;
+    }
+    return false;
+}
+/**
+ * Tests whether two convex polygons overlap, using the separating axis theorem.
+ * Both polygons must be convex; results are undefined for concave input.
+ * Polygons that touch along an edge or vertex are considered overlapping.
+ *
+ * @param verticesA vertices of the first polygon `[x0, y0, x1, y1, ...]`
+ * @param numA number of vertices in the first polygon
+ * @param verticesB vertices of the second polygon `[x0, y0, x1, y1, ...]`
+ * @param numB number of vertices in the second polygon
+ * @returns true if the polygons overlap
+ */
+function overlapConvex(verticesA, numA, verticesB, numB) {
+    if (separatedByEdgesOf(verticesA, numA, verticesB, numB))
+        return false;
+    if (separatedByEdgesOf(verticesB, numB, verticesA, numA))
+        return false;
+    return true;
+}
+/**
+ * Tests whether the segment `a`-`b` intersects the polygon, i.e. it has an
+ * endpoint inside the polygon or crosses one of its edges. Works for convex and
+ * concave polygons.
+ *
+ * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`
+ * @param n number of vertices to read from `vertices`
+ * @param a start of the segment
+ * @param b end of the segment
+ * @returns true if the segment intersects the polygon
+ */
+function intersectsSegment(vertices, n, a, b) {
+    if (containsPoint(vertices, n, a) || containsPoint(vertices, n, b))
+        return true;
+    const ax = a[0];
+    const ay = a[1];
+    const abx = b[0] - ax;
+    const aby = b[1] - ay;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const cx = vertices[j * 2];
+        const cy = vertices[j * 2 + 1];
+        const dx = vertices[i * 2];
+        const dy = vertices[i * 2 + 1];
+        // Proper segment intersection via perp products (sign-of-area test).
+        const a1 = abx * (dy - ay) - aby * (dx - ax); // (b-a) x (d-a)
+        const a2 = abx * (cy - ay) - aby * (cx - ax); // (b-a) x (c-a)
+        if (a1 * a2 < 0) {
+            const cdx = dx - cx;
+            const cdy = dy - cy;
+            const a3 = cdx * (ay - cy) - cdy * (ax - cx); // (d-c) x (a-c)
+            const a4 = a3 + a2 - a1;
+            if (a3 * a4 < 0)
+                return true;
+        }
+    }
+    return false;
+}
+
+export { area, bounds, centroid, closestPoint, containsPoint, intersectsSegment, isConvex, isReflexVertex, overlapConvex, perimeter, reverse, signedArea, signedDistance, winding };
+//# sourceMappingURL=polygon2.js.map

package/dist/shapes/polygon2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon2.js","sources":["../../src/shapes/polygon2.ts"],"sourcesContent":["import type { Vec2 } from '../core/vec2';\nimport type { Box2 } from './box2';\n\n/**\n * A 2D polygon is represented as a flat array of vertex coordinates laid out as\n * `[x0, y0, x1, y1, ...]`, together with an explicit vertex count `n`.\n *\n * The count is passed separately (rather than derived from `verts.length`) so a\n * single scratch buffer can be reused across polygons of different sizes: only\n * the first `n` vertices are read, and any trailing slots are ignored. Vertices\n * are assumed to be ordered (clockwise or counter-clockwise) around the polygon.\n */\n\n/**\n * Returns the signed area of the polygon using the shoelace formula.\n * The result is positive when the vertices wind counter-clockwise and negative\n * when they wind clockwise, so the sign can be used to determine winding order.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns the signed area\n */\nexport function signedArea(vertices: number[], n: number): number {\n    let area = 0;\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n        const xi = vertices[i * 2];\n        const yi = vertices[i * 2 + 1];\n        const xj = vertices[j * 2];\n        const yj = vertices[j * 2 + 1];\n        area += xj * yi - xi * yj;\n    }\n    return area / 2;\n}\n\n/**\n * Returns the (non-negative) area of the polygon.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns the absolute area\n */\nexport function area(vertices: number[], n: number): number {\n    return Math.abs(signedArea(vertices, n));\n}\n\n/**\n * Tests whether a point lies inside the polygon. Works for both convex and\n * concave polygons. Points exactly on an edge or vertex are considered inside.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @param point the point to test\n * @returns true if the point is inside (or on the boundary of) the polygon\n */\nexport function containsPoint(vertices: number[], n: number, point: Vec2): boolean {\n    let inside = false;\n    const x = point[0];\n    const y = point[1];\n\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n        const xi = vertices[i * 2];\n        const yi = vertices[i * 2 + 1];\n        const xj = vertices[j * 2];\n        const yj = vertices[j * 2 + 1];\n\n        // Signed area of the triangle (j, i, point): zero when the point lies on\n        // the edge, sign tells which side it is on.\n        const where = (yi - yj) * (x - xi) - (xi - xj) * (y - yi);\n\n        if (yj < yi) {\n            // Upward edge: count a crossing when the point's y is within [yj, yi).\n            if (y >= yj && y < yi) {\n                if (where === 0) return true; // on edge\n                if (where > 0) {\n                    if (y === yj) {\n                        // Ray passes exactly through vertex j; only toggle when the\n                        // previous vertex is below, to avoid double-counting.\n                        if (y > vertices[(j === 0 ? n - 1 : j - 1) * 2 + 1]) inside = !inside;\n                    } else {\n                        inside = !inside;\n                    }\n                }\n            }\n        } else if (yi < yj) {\n            // Downward edge: count a crossing when the point's y is within (yi, yj].\n            if (y > yi && y <= yj) {\n                if (where === 0) return true; // on edge\n                if (where < 0) {\n                    if (y === yj) {\n                        if (y < vertices[(j === 0 ? n - 1 : j - 1) * 2 + 1]) inside = !inside;\n                    } else {\n                        inside = !inside;\n                    }\n                }\n            }\n        } else if (y === yi && ((x >= xj && x <= xi) || (x >= xi && x <= xj))) {\n            // Point lies on a horizontal edge.\n            return true;\n        }\n    }\n\n    return inside;\n}\n\n/**\n * Computes the area-weighted centroid (center of mass) of the polygon.\n * For a degenerate (zero-area) polygon this falls back to the average of the\n * vertices.\n *\n * @param out the vector to store the centroid\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns out\n */\nexport function centroid(out: Vec2, vertices: number[], n: number): Vec2 {\n    let cx = 0;\n    let cy = 0;\n    let a2 = 0; // twice the signed area\n\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n        const xi = vertices[i * 2];\n        const yi = vertices[i * 2 + 1];\n        const xj = vertices[j * 2];\n        const yj = vertices[j * 2 + 1];\n        const cross = xj * yi - xi * yj;\n        a2 += cross;\n        cx += (xj + xi) * cross;\n        cy += (yj + yi) * cross;\n    }\n\n    if (a2 === 0) {\n        // Degenerate polygon (collinear vertices): use the vertex average.\n        let sx = 0;\n        let sy = 0;\n        for (let i = 0; i < n; i++) {\n            sx += vertices[i * 2];\n            sy += vertices[i * 2 + 1];\n        }\n        out[0] = sx / n;\n        out[1] = sy / n;\n        return out;\n    }\n\n    const inv = 1 / (3 * a2);\n    out[0] = cx * inv;\n    out[1] = cy * inv;\n    return out;\n}\n\n/**\n * Returns the perimeter (sum of edge lengths) of the polygon.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns the perimeter\n */\nexport function perimeter(vertices: number[], n: number): number {\n    let total = 0;\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n        const dx = vertices[i * 2] - vertices[j * 2];\n        const dy = vertices[i * 2 + 1] - vertices[j * 2 + 1];\n        total += Math.sqrt(dx * dx + dy * dy);\n    }\n    return total;\n}\n\n/**\n * Returns the winding order of the polygon from the sign of its signed area:\n * `1` for counter-clockwise, `-1` for clockwise, and `0` for a degenerate\n * (zero-area) polygon.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns 1 (CCW), -1 (CW), or 0 (degenerate)\n */\nexport function winding(vertices: number[], n: number): number {\n    const a = signedArea(vertices, n);\n    if (a > 0) return 1;\n    if (a < 0) return -1;\n    return 0;\n}\n\n/**\n * Tests whether the polygon is convex. Works for both winding orders. Assumes a\n * simple (non-self-intersecting) polygon; collinear vertices are allowed.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns true if the polygon is convex\n */\nexport function isConvex(vertices: number[], n: number): boolean {\n    if (n < 3) return false;\n\n    let sign = 0;\n    for (let i = 0; i < n; i++) {\n        const p = ((i - 1 + n) % n) * 2;\n        const c = i * 2;\n        const q = ((i + 1) % n) * 2;\n\n        // Cross product of the incoming and outgoing edges at vertex i.\n        const ax = vertices[c] - vertices[p];\n        const ay = vertices[c + 1] - vertices[p + 1];\n        const bx = vertices[q] - vertices[c];\n        const by = vertices[q + 1] - vertices[c + 1];\n        const cross = ax * by - ay * bx;\n\n        if (cross !== 0) {\n            const s = cross > 0 ? 1 : -1;\n            if (sign === 0) sign = s;\n            else if (s !== sign) return false;\n        }\n    }\n\n    return true;\n}\n\n/**\n * Tests whether vertex `i` is a reflex (concave) vertex of the polygon — the\n * interior angle at that vertex exceeds 180°. Assumes the polygon is wound\n * counter-clockwise and that `0 <= i < n`.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @param i index of the vertex to test\n * @returns true if vertex `i` is reflex\n */\nexport function isReflexVertex(vertices: number[], n: number, i: number): boolean {\n    const p = ((i - 1 + n) % n) * 2;\n    const c = i * 2;\n    const q = ((i + 1) % n) * 2;\n\n    // Cross product of the incoming and outgoing edges; negative = right turn = reflex (CCW).\n    const ax = vertices[c] - vertices[p];\n    const ay = vertices[c + 1] - vertices[p + 1];\n    const bx = vertices[q] - vertices[c];\n    const by = vertices[q + 1] - vertices[c + 1];\n    return ax * by - ay * bx < 0;\n}\n\n/**\n * Reverses the winding order of the polygon, writing the result into `out`.\n * `out` may be the same array as `vertices` to reverse in place.\n *\n * @param out the array to write the reversed polygon into\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns out\n */\nexport function reverse(out: number[], vertices: number[], n: number): number[] {\n    for (let lo = 0, hi = n - 1; lo < hi; lo++, hi--) {\n        const x = vertices[lo * 2];\n        const y = vertices[lo * 2 + 1];\n        out[lo * 2] = vertices[hi * 2];\n        out[lo * 2 + 1] = vertices[hi * 2 + 1];\n        out[hi * 2] = x;\n        out[hi * 2 + 1] = y;\n    }\n    // Copy the untouched middle vertex when writing to a different buffer.\n    if (out !== vertices && n % 2 === 1) {\n        const mid = (n >> 1) * 2;\n        out[mid] = vertices[mid];\n        out[mid + 1] = vertices[mid + 1];\n    }\n    return out;\n}\n\n/**\n * Writes the axis-aligned bounding box of the polygon into `out` as a Box2\n * `[minX, minY, maxX, maxY]`.\n *\n * @param out the box to store the result\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @returns out\n */\nexport function bounds(out: Box2, vertices: number[], n: number): Box2 {\n    let minX = Number.POSITIVE_INFINITY;\n    let minY = Number.POSITIVE_INFINITY;\n    let maxX = Number.NEGATIVE_INFINITY;\n    let maxY = Number.NEGATIVE_INFINITY;\n\n    for (let i = 0; i < n; i++) {\n        const x = vertices[i * 2];\n        const y = vertices[i * 2 + 1];\n        if (x < minX) minX = x;\n        if (x > maxX) maxX = x;\n        if (y < minY) minY = y;\n        if (y > maxY) maxY = y;\n    }\n\n    out[0] = minX;\n    out[1] = minY;\n    out[2] = maxX;\n    out[3] = maxY;\n    return out;\n}\n\n/**\n * Finds the point on the polygon's boundary closest to `point` and writes it to\n * `out`. `point` may lie inside, outside, or on the polygon; the result is\n * always on an edge.\n *\n * @param out the vector to store the closest point\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @param point the query point\n * @returns out\n */\nexport function closestPoint(out: Vec2, vertices: number[], n: number, point: Vec2): Vec2 {\n    const px = point[0];\n    const py = point[1];\n    let bestDistSq = Number.POSITIVE_INFINITY;\n    let bestX = px;\n    let bestY = py;\n\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n        const ax = vertices[j * 2];\n        const ay = vertices[j * 2 + 1];\n        const abx = vertices[i * 2] - ax;\n        const aby = vertices[i * 2 + 1] - ay;\n\n        // Project the point onto edge (a -> b), clamped to the segment.\n        const d = abx * abx + aby * aby;\n        let t = d > 0 ? ((px - ax) * abx + (py - ay) * aby) / d : 0;\n        if (t < 0) t = 0;\n        else if (t > 1) t = 1;\n\n        const cx = ax + t * abx;\n        const cy = ay + t * aby;\n        const dx = px - cx;\n        const dy = py - cy;\n        const distSq = dx * dx + dy * dy;\n        if (distSq < bestDistSq) {\n            bestDistSq = distSq;\n            bestX = cx;\n            bestY = cy;\n        }\n    }\n\n    out[0] = bestX;\n    out[1] = bestY;\n    return out;\n}\n\n/**\n * Returns the distance from `point` to the polygon's boundary, signed so that\n * points inside the polygon get a negative distance and points outside get a\n * positive one.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @param point the query point\n * @returns the signed distance (negative inside, positive outside)\n */\nexport function signedDistance(vertices: number[], n: number, point: Vec2): number {\n    const px = point[0];\n    const py = point[1];\n    let bestDistSq = Number.POSITIVE_INFINITY;\n\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n        const ax = vertices[j * 2];\n        const ay = vertices[j * 2 + 1];\n        const abx = vertices[i * 2] - ax;\n        const aby = vertices[i * 2 + 1] - ay;\n\n        const d = abx * abx + aby * aby;\n        let t = d > 0 ? ((px - ax) * abx + (py - ay) * aby) / d : 0;\n        if (t < 0) t = 0;\n        else if (t > 1) t = 1;\n\n        const dx = px - (ax + t * abx);\n        const dy = py - (ay + t * aby);\n        const distSq = dx * dx + dy * dy;\n        if (distSq < bestDistSq) bestDistSq = distSq;\n    }\n\n    const dist = Math.sqrt(bestDistSq);\n    return containsPoint(vertices, n, point) ? -dist : dist;\n}\n\nconst _projA: [number, number] = [0, 0];\nconst _projB: [number, number] = [0, 0];\n\n/** Projects a polygon onto the axis (nx, ny), storing [min, max] in `out`. */\nfunction projectOntoAxis(out: [number, number], nx: number, ny: number, vertices: number[], n: number): void {\n    let min = nx * vertices[0] + ny * vertices[1];\n    let max = min;\n    for (let i = 1; i < n; i++) {\n        const d = nx * vertices[i * 2] + ny * vertices[i * 2 + 1];\n        if (d < min) min = d;\n        else if (d > max) max = d;\n    }\n    out[0] = min;\n    out[1] = max;\n}\n\n/** Returns true if the two polygons are separated along any edge normal of A. */\nfunction separatedByEdgesOf(verticesA: number[], numA: number, verticesB: number[], numB: number): boolean {\n    for (let i = 0, j = numA - 1; i < numA; j = i++) {\n        // Normal of edge (a -> b); orientation does not matter for separation.\n        const nx = verticesA[i * 2 + 1] - verticesA[j * 2 + 1];\n        const ny = -(verticesA[i * 2] - verticesA[j * 2]);\n\n        projectOntoAxis(_projA, nx, ny, verticesA, numA);\n        projectOntoAxis(_projB, nx, ny, verticesB, numB);\n\n        if (_projA[0] > _projB[1] || _projB[0] > _projA[1]) return true;\n    }\n    return false;\n}\n\n/**\n * Tests whether two convex polygons overlap, using the separating axis theorem.\n * Both polygons must be convex; results are undefined for concave input.\n * Polygons that touch along an edge or vertex are considered overlapping.\n *\n * @param verticesA vertices of the first polygon `[x0, y0, x1, y1, ...]`\n * @param numA number of vertices in the first polygon\n * @param verticesB vertices of the second polygon `[x0, y0, x1, y1, ...]`\n * @param numB number of vertices in the second polygon\n * @returns true if the polygons overlap\n */\nexport function overlapConvex(verticesA: number[], numA: number, verticesB: number[], numB: number): boolean {\n    if (separatedByEdgesOf(verticesA, numA, verticesB, numB)) return false;\n    if (separatedByEdgesOf(verticesB, numB, verticesA, numA)) return false;\n    return true;\n}\n\n/**\n * Tests whether the segment `a`-`b` intersects the polygon, i.e. it has an\n * endpoint inside the polygon or crosses one of its edges. Works for convex and\n * concave polygons.\n *\n * @param vertices polygon vertices as a flat array `[x0, y0, x1, y1, ...]`\n * @param n number of vertices to read from `vertices`\n * @param a start of the segment\n * @param b end of the segment\n * @returns true if the segment intersects the polygon\n */\nexport function intersectsSegment(vertices: number[], n: number, a: Vec2, b: Vec2): boolean {\n    if (containsPoint(vertices, n, a) || containsPoint(vertices, n, b)) return true;\n\n    const ax = a[0];\n    const ay = a[1];\n    const abx = b[0] - ax;\n    const aby = b[1] - ay;\n\n    for (let i = 0, j = n - 1; i < n; j = i++) {\n        const cx = vertices[j * 2];\n        const cy = vertices[j * 2 + 1];\n        const dx = vertices[i * 2];\n        const dy = vertices[i * 2 + 1];\n\n        // Proper segment intersection via perp products (sign-of-area test).\n        const a1 = abx * (dy - ay) - aby * (dx - ax); // (b-a) x (d-a)\n        const a2 = abx * (cy - ay) - aby * (cx - ax); // (b-a) x (c-a)\n        if (a1 * a2 < 0) {\n            const cdx = dx - cx;\n            const cdy = dy - cy;\n            const a3 = cdx * (ay - cy) - cdy * (ax - cx); // (d-c) x (a-c)\n            const a4 = a3 + a2 - a1;\n            if (a3 * a4 < 0) return true;\n        }\n    }\n\n    return false;\n}\n"],"names":[],"mappings":"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"}

package/dist/shapes/raycast3.js

@@ -0,0 +1,164 @@
+/**
+ * Creates a new IntersectsTriangleResult with default values.
+ * @returns A new IntersectsTriangleResult.
+ */
+function createIntersectsTriangleResult() {
+    return {
+        fraction: 0,
+        hit: false,
+        frontFacing: false,
+    };
+}
+/**
+ * Ray-triangle intersection test.
+ * Based on https://github.com/pmjoniak/GeometricTools/blob/master/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
+ *
+ * @param out output object to store result (hit boolean, fraction, frontFacing)
+ * @param origin ray origin
+ * @param direction ray direction
+ * @param length ray length
+ * @param a first vertex of triangle
+ * @param b second vertex of triangle
+ * @param c third vertex of triangle
+ * @param backfaceCulling if true, backfaces will not be considered hits
+ */
+function intersectsTriangle(out, origin, direction, length, a, b, c, backfaceCulling) {
+    // compute edge1 = b - a
+    const e1x = b[0] - a[0];
+    const e1y = b[1] - a[1];
+    const e1z = b[2] - a[2];
+    // compute edge2 = c - a
+    const e2x = c[0] - a[0];
+    const e2y = c[1] - a[1];
+    const e2z = c[2] - a[2];
+    // compute normal = edge1 × edge2
+    const nx = e1y * e2z - e1z * e2y;
+    const ny = e1z * e2x - e1x * e2z;
+    const nz = e1x * e2y - e1y * e2x;
+    // determine front vs back facing
+    const dx = direction[0];
+    const dy = direction[1];
+    const dz = direction[2];
+    let DdN = dx * nx + dy * ny + dz * nz;
+    let sign;
+    if (DdN > 0) {
+        // backface
+        if (backfaceCulling) {
+            out.hit = false;
+            out.fraction = 0;
+            out.frontFacing = false;
+            return;
+        }
+        sign = 1;
+    }
+    else if (DdN < 0) {
+        // frontface
+        sign = -1;
+        DdN = -DdN;
+    }
+    else {
+        // ray is parallel to triangle
+        out.hit = false;
+        out.fraction = 0;
+        out.frontFacing = false;
+        return;
+    }
+    // compute diff = origin - a
+    const diffx = origin[0] - a[0];
+    const diffy = origin[1] - a[1];
+    const diffz = origin[2] - a[2];
+    // compute barycentric coordinate b1
+    // DdQxE2 = sign * D · (diff × edge2)
+    const diffCrossE2x = diffy * e2z - diffz * e2y;
+    const diffCrossE2y = diffz * e2x - diffx * e2z;
+    const diffCrossE2z = diffx * e2y - diffy * e2x;
+    const DdQxE2 = sign * (dx * diffCrossE2x + dy * diffCrossE2y + dz * diffCrossE2z);
+    if (DdQxE2 < 0) {
+        out.hit = false;
+        out.fraction = 0;
+        out.frontFacing = false;
+        return;
+    }
+    // compute barycentric coordinate b2
+    // DdE1xQ = sign * D · (edge1 × diff)
+    const e1CrossDiffx = e1y * diffz - e1z * diffy;
+    const e1CrossDiffy = e1z * diffx - e1x * diffz;
+    const e1CrossDiffz = e1x * diffy - e1y * diffx;
+    const DdE1xQ = sign * (dx * e1CrossDiffx + dy * e1CrossDiffy + dz * e1CrossDiffz);
+    if (DdE1xQ < 0) {
+        out.hit = false;
+        out.fraction = 0;
+        out.frontFacing = false;
+        return;
+    }
+    // check if b1 + b2 > 1
+    if (DdQxE2 + DdE1xQ > DdN) {
+        out.hit = false;
+        out.fraction = 0;
+        out.frontFacing = false;
+        return;
+    }
+    // compute intersection distance
+    const QdN = -sign * (diffx * nx + diffy * ny + diffz * nz);
+    if (QdN < 0) {
+        out.hit = false;
+        out.fraction = 0;
+        out.frontFacing = false;
+        return;
+    }
+    const t = QdN / DdN;
+    // check if intersection is within ray length
+    if (t <= length) {
+        out.hit = true;
+        out.fraction = t / length;
+        out.frontFacing = sign < 0;
+    }
+    else {
+        out.hit = false;
+        out.fraction = 0;
+        out.frontFacing = false;
+    }
+}
+/**
+ * Test if a ray intersects an axis-aligned bounding box.
+ * Uses slab-based algorithm that handles parallel rays correctly.
+ *
+ * @param origin ray origin
+ * @param direction ray direction
+ * @param length ray length
+ * @param aabb AABB to test against
+ * @returns true if ray intersects the AABB, false otherwise
+ */
+function intersectsBox3(origin, direction, length, aabb) {
+    let tmin = 0;
+    let tmax = length;
+    for (let i = 0; i < 3; i++) {
+        const d = direction[i];
+        if (Math.abs(d) < 1e-10) {
+            // ray is parallel to slab: check if origin is within slab
+            if (origin[i] < aabb[i] || origin[i] > aabb[i + 3]) {
+                return false;
+            }
+        }
+        else {
+            // compute intersection times with slab
+            const invD = 1 / d;
+            let t0 = (aabb[i] - origin[i]) * invD;
+            let t1 = (aabb[i + 3] - origin[i]) * invD;
+            if (invD < 0) {
+                const temp = t0;
+                t0 = t1;
+                t1 = temp;
+            }
+            tmin = Math.max(tmin, t0);
+            tmax = Math.min(tmax, t1);
+            if (tmax < tmin) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+export { createIntersectsTriangleResult, intersectsBox3, intersectsTriangle };
+//# sourceMappingURL=raycast3.js.map