dacha 0.17.2 → 0.18.0-alpha.1

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-box/utils.js

@@ -0,0 +1,126 @@
+import { Vector2, VectorOps } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON, projectPolygon } from '../utils';
+export const CONTACT_EPSILON = 1e-4;
+export const MAX_CONTACT_POINTS = 2;
+export const findMinBoxesOverlap = (geometry1, geometry2) => {
+    let minOverlap = Infinity;
+    let bestAxis = geometry1.edges[0].normal;
+    for (const edge of geometry1.edges) {
+        const axis = edge.normal;
+        const projection1 = projectPolygon(geometry1.points, axis);
+        const projection2 = projectPolygon(geometry2.points, axis);
+        const distance1 = projection1.min - projection2.max;
+        const distance2 = projection2.min - projection1.max;
+        if (distance1 > INTERSECTION_EPSILON || distance2 > INTERSECTION_EPSILON) {
+            return false;
+        }
+        const overlap = Math.min(Math.abs(distance1), Math.abs(distance2));
+        if (overlap < minOverlap) {
+            minOverlap = overlap;
+            bestAxis = axis;
+        }
+    }
+    return {
+        axis: bestAxis,
+        overlap: minOverlap,
+    };
+};
+const clipSegmentToLine = (vertices, normal, offset) => {
+    const clipped = [];
+    const distance1 = VectorOps.dotProduct(vertices[0], normal) - offset;
+    const distance2 = VectorOps.dotProduct(vertices[1], normal) - offset;
+    if (distance1 <= CONTACT_EPSILON) {
+        clipped.push(vertices[0]);
+    }
+    if (distance2 <= CONTACT_EPSILON) {
+        clipped.push(vertices[1]);
+    }
+    if (distance1 * distance2 < 0) {
+        const t = distance1 / (distance1 - distance2);
+        const point1 = vertices[0];
+        const point2 = vertices[1];
+        clipped.push({
+            x: point1.x + (point2.x - point1.x) * t,
+            y: point1.y + (point2.y - point1.y) * t,
+        });
+    }
+    return clipped;
+};
+const getMostAntiParallelEdge = (polygon, normal) => {
+    let bestEdge = polygon.edges[0];
+    let minDot = VectorOps.dotProduct(bestEdge.normal, normal);
+    for (const edge of polygon.edges) {
+        const dot = VectorOps.dotProduct(edge.normal, normal);
+        if (dot < minDot) {
+            minDot = dot;
+            bestEdge = edge;
+        }
+    }
+    return bestEdge;
+};
+const getMostParallelEdge = (polygon, normal) => {
+    let bestEdge = polygon.edges[0];
+    let maxDot = VectorOps.dotProduct(bestEdge.normal, normal);
+    for (const edge of polygon.edges) {
+        const dot = VectorOps.dotProduct(edge.normal, normal);
+        if (dot > maxDot) {
+            maxDot = dot;
+            bestEdge = edge;
+        }
+    }
+    return bestEdge;
+};
+const dedupePoints = (points) => {
+    const unique = [];
+    for (const point of points) {
+        if (unique.some((entry) => Math.abs(entry.x - point.x) <= CONTACT_EPSILON &&
+            Math.abs(entry.y - point.y) <= CONTACT_EPSILON)) {
+            continue;
+        }
+        unique.push(point);
+        if (unique.length === MAX_CONTACT_POINTS) {
+            return unique;
+        }
+    }
+    return unique;
+};
+/**
+ * Builds up to two box-vs-box contact points by clipping the incident edge
+ * against the side planes of the reference edge.
+ *
+ * The returned points lie on the reference face plane, which makes them
+ * suitable to use as world-space contact points in a simple impulse solver.
+ */
+export const buildContactPoints = (referencePolygon, referenceNormal, incidentPolygon) => {
+    const referenceEdge = getMostParallelEdge(referencePolygon, referenceNormal);
+    const incidentEdge = getMostAntiParallelEdge(incidentPolygon, referenceNormal);
+    const tangent = new Vector2(referenceEdge.point2.x - referenceEdge.point1.x, referenceEdge.point2.y - referenceEdge.point1.y);
+    tangent.normalize();
+    const minTangentOffset = VectorOps.dotProduct(referenceEdge.point1, tangent);
+    const maxTangentOffset = VectorOps.dotProduct(referenceEdge.point2, tangent);
+    let clippedPoints = [incidentEdge.point1, incidentEdge.point2];
+    clippedPoints = clipSegmentToLine(clippedPoints, tangent, maxTangentOffset);
+    if (clippedPoints.length === 0) {
+        return [];
+    }
+    if (clippedPoints.length === 2) {
+        tangent.multiplyNumber(-1);
+        clippedPoints = clipSegmentToLine(clippedPoints, tangent, -minTangentOffset);
+        if (clippedPoints.length === 0) {
+            return [];
+        }
+    }
+    const frontOffset = VectorOps.dotProduct(referenceEdge.point1, referenceNormal);
+    const contacts = [];
+    clippedPoints.forEach((point) => {
+        const separation = VectorOps.dotProduct(point, referenceNormal) - frontOffset;
+        if (separation > CONTACT_EPSILON) {
+            return;
+        }
+        contacts.push({
+            x: point.x - referenceNormal.x * separation,
+            y: point.y - referenceNormal.y * separation,
+        });
+    });
+    return dedupePoints(contacts);
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-circle/check-box-and-circle-intersection.d.ts

@@ -0,0 +1,9 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks box and circle colliders for intersection.
+ *
+ * The closest point on the box is used as the world-space contact point.
+ * For circles inside the box, the nearest face normal is used as the
+ * collision direction and penetration is measured to that face.
+ */
+export declare const checkBoxAndCircleIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-circle/check-box-and-circle-intersection.js

@@ -0,0 +1,46 @@
+import { MathOps, Vector2, VectorOps, } from '../../../../../../../engine/math-lib';
+import { orientNormal, INTERSECTION_EPSILON } from '../utils';
+const buildNormal = (circle, closestEdge, closestPoint) => {
+    let normal = new Vector2(circle.center.x - closestPoint.x, circle.center.y - closestPoint.y);
+    if (normal.magnitude === 0) {
+        normal = closestEdge.normal.clone();
+    }
+    return normal.normalize();
+};
+/**
+ * Checks box and circle colliders for intersection.
+ *
+ * The closest point on the box is used as the world-space contact point.
+ * For circles inside the box, the nearest face normal is used as the
+ * collision direction and penetration is measured to that face.
+ */
+export const checkBoxAndCircleIntersection = (arg1, arg2) => {
+    const isBoxFirst = 'radius' in arg2.geometry;
+    const box = (isBoxFirst ? arg1.geometry : arg2.geometry);
+    const circle = (isBoxFirst ? arg2.geometry : arg1.geometry);
+    let closestEdge = box.edges[0];
+    let closestPoint = box.points[0];
+    let minDistance = Infinity;
+    box.edges.forEach((edge) => {
+        const candidate = VectorOps.getClosestPointOnEdge(circle.center, edge);
+        const distance = MathOps.getDistanceBetweenTwoPoints(candidate.x, circle.center.x, candidate.y, circle.center.y);
+        if (distance < minDistance) {
+            minDistance = distance;
+            closestEdge = edge;
+            closestPoint = candidate;
+        }
+    });
+    const isCircleInsideBox = VectorOps.isPointInPolygon(circle.center, box.edges);
+    if (!isCircleInsideBox &&
+        minDistance > circle.radius + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const penetration = isCircleInsideBox
+        ? circle.radius + minDistance
+        : Math.max(0, circle.radius - minDistance);
+    return {
+        normal: orientNormal(buildNormal(circle, closestEdge, closestPoint), arg1.geometry.center, arg2.geometry.center),
+        penetration,
+        contactPoints: [closestPoint],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-segment/check-box-and-segment-intersection.d.ts

@@ -0,0 +1,10 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks a box against a segment.
+ *
+ * SAT is used with the box face normals plus the segment normal to determine
+ * whether the finite segment overlaps the convex box. Contact points are then
+ * collected from segment endpoints inside the box, box vertices lying on the
+ * segment, and explicit edge/segment intersections.
+ */
+export declare const checkBoxAndSegmentIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-segment/check-box-and-segment-intersection.js

@@ -0,0 +1,28 @@
+import { buildBoxSegmentContactPoints, findMinBoxSegmentOverlap } from './utils';
+import { orientNormal } from '../utils';
+/**
+ * Checks a box against a segment.
+ *
+ * SAT is used with the box face normals plus the segment normal to determine
+ * whether the finite segment overlaps the convex box. Contact points are then
+ * collected from segment endpoints inside the box, box vertices lying on the
+ * segment, and explicit edge/segment intersections.
+ */
+export const checkBoxAndSegmentIntersection = (arg1, arg2) => {
+    const isBoxFirst = 'edges' in arg1.geometry;
+    const box = (isBoxFirst ? arg1.geometry : arg2.geometry);
+    const segment = (isBoxFirst ? arg2.geometry : arg1.geometry);
+    const overlap = findMinBoxSegmentOverlap(box, segment);
+    if (overlap === false) {
+        return false;
+    }
+    const contactPoints = buildBoxSegmentContactPoints(box, segment);
+    if (contactPoints.length === 0) {
+        return false;
+    }
+    return {
+        normal: orientNormal(overlap.axis.clone(), arg1.geometry.center, arg2.geometry.center),
+        penetration: overlap.overlap,
+        contactPoints,
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-segment/utils.d.ts

@@ -0,0 +1,19 @@
+import { type Vector2 } from '../../../../../../../engine/math-lib';
+import type { BoxGeometry, Point, SegmentGeometry } from '../../types';
+export declare const lerpPoint: (point1: Point, point2: Point, value: number) => Point;
+export declare const findMinBoxSegmentOverlap: (box: BoxGeometry, segment: SegmentGeometry) => {
+    axis: Vector2;
+    overlap: number;
+} | false;
+/**
+ * Clips the segment against each box edge's inward half-space.
+ *
+ * The segment is treated parametrically, with `t = 0` at `point1` and
+ * `t = 1` at `point2`. Each box edge can only shrink that valid `[start, end]`
+ * interval. After all four edges are processed, the surviving interval is:
+ * - empty: no intersection
+ * - a single `t`: one touching point
+ * - a finite interval: the overlapping subsegment inside the box
+ *
+ */
+export declare const buildBoxSegmentContactPoints: (box: BoxGeometry, segment: SegmentGeometry) => Point[];

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/box-segment/utils.js

@@ -0,0 +1,76 @@
+import { MathOps, VectorOps, } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON, projectPolygon } from '../utils';
+const arePointsEqual = (point1, point2) => Math.abs(point1.x - point2.x) <= INTERSECTION_EPSILON &&
+    Math.abs(point1.y - point2.y) <= INTERSECTION_EPSILON;
+export const lerpPoint = (point1, point2, value) => ({
+    x: point1.x + (point2.x - point1.x) * value,
+    y: point1.y + (point2.y - point1.y) * value,
+});
+export const findMinBoxSegmentOverlap = (box, segment) => {
+    const axes = [...box.edges.map((edge) => edge.normal), segment.normal];
+    let minOverlap = Infinity;
+    let bestAxis = axes[0];
+    for (const axis of axes) {
+        const boxProjection = projectPolygon(box.points, axis);
+        const segmentProjection = projectPolygon([segment.point1, segment.point2], axis);
+        const distance1 = segmentProjection.min - boxProjection.max;
+        const distance2 = boxProjection.min - segmentProjection.max;
+        if (distance1 > INTERSECTION_EPSILON || distance2 > INTERSECTION_EPSILON) {
+            return false;
+        }
+        const overlap = Math.min(Math.abs(distance1), Math.abs(distance2));
+        if (overlap < minOverlap) {
+            minOverlap = overlap;
+            bestAxis = axis;
+        }
+    }
+    return {
+        axis: bestAxis,
+        overlap: minOverlap,
+    };
+};
+/**
+ * Clips the segment against each box edge's inward half-space.
+ *
+ * The segment is treated parametrically, with `t = 0` at `point1` and
+ * `t = 1` at `point2`. Each box edge can only shrink that valid `[start, end]`
+ * interval. After all four edges are processed, the surviving interval is:
+ * - empty: no intersection
+ * - a single `t`: one touching point
+ * - a finite interval: the overlapping subsegment inside the box
+ *
+ */
+export const buildBoxSegmentContactPoints = (box, segment) => {
+    let start = 0;
+    let end = 1;
+    for (const edge of box.edges) {
+        const offset = VectorOps.dotProduct(edge.point1, edge.normal);
+        const point1Distance = VectorOps.dotProduct(segment.point1, edge.normal) - offset;
+        const point2Distance = VectorOps.dotProduct(segment.point2, edge.normal) - offset;
+        if (point1Distance > INTERSECTION_EPSILON &&
+            point2Distance > INTERSECTION_EPSILON) {
+            return [];
+        }
+        if (point1Distance <= INTERSECTION_EPSILON &&
+            point2Distance <= INTERSECTION_EPSILON) {
+            continue;
+        }
+        const denominator = point1Distance - point2Distance;
+        const t = denominator === 0 ? 0 : point1Distance / denominator;
+        if (point1Distance > INTERSECTION_EPSILON) {
+            start = Math.max(start, t);
+        }
+        else {
+            end = Math.min(end, t);
+        }
+        if (start > end + INTERSECTION_EPSILON) {
+            return [];
+        }
+    }
+    const contact1 = lerpPoint(segment.point1, segment.point2, MathOps.clamp(start, 0, 1));
+    if (Math.abs(end - start) <= INTERSECTION_EPSILON) {
+        return [contact1];
+    }
+    const contact2 = lerpPoint(segment.point1, segment.point2, MathOps.clamp(end, 0, 1));
+    return arePointsEqual(contact1, contact2) ? [contact1] : [contact1, contact2];
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/circle-circle/check-circles-intersection.d.ts

@@ -0,0 +1,12 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks circles for intersection.
+ *
+ * The manifold is straightforward:
+ * - the normal follows the line between circle centers
+ * - penetration is the overlap of the radii along that line
+ * - the contact point lies on the surface of the first circle
+ *
+ * When both centers are equal, the X axis is used as a deterministic fallback.
+ */
+export declare const checkCirclesIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/circle-circle/check-circles-intersection.js

@@ -0,0 +1,47 @@
+import { Vector2 } from '../../../../../../../engine/math-lib';
+import { INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks circles for intersection.
+ *
+ * The manifold is straightforward:
+ * - the normal follows the line between circle centers
+ * - penetration is the overlap of the radii along that line
+ * - the contact point lies on the surface of the first circle
+ *
+ * When both centers are equal, the X axis is used as a deterministic fallback.
+ */
+export const checkCirclesIntersection = (arg1, arg2) => {
+    const { radius: radius1, center: { x: x1, y: y1 }, } = arg1.geometry;
+    const { radius: radius2, center: { x: x2, y: y2 }, } = arg2.geometry;
+    const offsetX = x2 - x1;
+    const offsetY = y2 - y1;
+    const distance = Math.sqrt(offsetX ** 2 + offsetY ** 2);
+    if (distance > radius1 + radius2 + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const penetration = Math.max(0, radius1 + radius2 - distance);
+    if (distance === 0) {
+        return {
+            normal: new Vector2(1, 0),
+            penetration,
+            contactPoints: [
+                {
+                    x: x1 + radius1,
+                    y: y1,
+                },
+            ],
+        };
+    }
+    const normal = new Vector2(offsetX, offsetY);
+    normal.normalize();
+    return {
+        normal,
+        penetration,
+        contactPoints: [
+            {
+                x: x1 + normal.x * radius1,
+                y: y1 + normal.y * radius1,
+            },
+        ],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/circle-segment/check-circle-and-segment-intersection.d.ts

@@ -0,0 +1,10 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks a circle against a segment.
+ *
+ * The circle center is projected onto the finite segment. When the distance
+ * from that closest point to the center is within the circle radius, the
+ * projected point becomes the contact point and the normal points away from
+ * the segment toward the circle center.
+ */
+export declare const checkCircleAndSegmentIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/circle-segment/check-circle-and-segment-intersection.js

@@ -0,0 +1,33 @@
+import { MathOps, Vector2, VectorOps, } from '../../../../../../../engine/math-lib';
+import { orientNormal, INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks a circle against a segment.
+ *
+ * The circle center is projected onto the finite segment. When the distance
+ * from that closest point to the center is within the circle radius, the
+ * projected point becomes the contact point and the normal points away from
+ * the segment toward the circle center.
+ */
+export const checkCircleAndSegmentIntersection = (arg1, arg2) => {
+    const isSegmentFirst = 'point1' in arg1.geometry;
+    const segment = (isSegmentFirst ? arg1.geometry : arg2.geometry);
+    const circle = (isSegmentFirst ? arg2.geometry : arg1.geometry);
+    const closestPoint = VectorOps.getClosestPointOnEdge(circle.center, segment);
+    const distance = MathOps.getDistanceBetweenTwoPoints(circle.center.x, closestPoint.x, circle.center.y, closestPoint.y);
+    if (distance > circle.radius + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const normal = new Vector2(circle.center.x - closestPoint.x, circle.center.y - closestPoint.y);
+    if (normal.magnitude === 0) {
+        normal.x = segment.normal.x;
+        normal.y = segment.normal.y;
+    }
+    else {
+        normal.normalize();
+    }
+    return {
+        normal: orientNormal(normal, arg1.geometry.center, arg2.geometry.center),
+        penetration: Math.max(0, circle.radius - distance),
+        contactPoints: [closestPoint],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/index.d.ts

@@ -1,3 +1,3 @@
-import type { CollisionEntry, Intersection } from '../types';
-export type CheckIntersectionFn = (arg1: CollisionEntry, arg2: CollisionEntry) => Intersection | false;
+import type { Proxy, Intersection } from '../types';
+export type CheckIntersectionFn = (arg1: Proxy, arg2: Proxy) => Intersection | false;
 export declare const intersectionCheckers: Record<string, Record<string, CheckIntersectionFn>>;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/index.js

@@ -1,13 +1,37 @@
-import { checkBoxAndCircleIntersection } from './check-box-and-circle-intersection';
-import { checkBoxesIntersection } from './check-boxes-intersection';
-import { checkCirclesIntersection } from './check-circles-intersection';
+import { checkBoxAndCircleIntersection } from './box-circle/check-box-and-circle-intersection';
+import { checkBoxAndSegmentIntersection } from './box-segment/check-box-and-segment-intersection';
+import { checkBoxesIntersection } from './box-box/check-boxes-intersection';
+import { checkCirclesIntersection } from './circle-circle/check-circles-intersection';
+import { checkCircleAndSegmentIntersection } from './circle-segment/check-circle-and-segment-intersection';
+import { checkPointAndBoxIntersection } from './point-box/check-point-and-box-intersection';
+import { checkPointAndCircleIntersection } from './point-circle/check-point-and-circle-intersection';
+import { checkPointAndSegmentIntersection } from './point-segment/check-point-and-segment-intersection';
+import { checkRayAndBoxIntersection } from './ray-box/check-ray-and-box-intersection';
+import { checkRayAndCircleIntersection } from './ray-circle/check-ray-and-circle-intersection';
+import { checkRayAndSegmentIntersection } from './ray-segment/check-ray-and-segment-intersection';
 export const intersectionCheckers = {
     box: {
         box: checkBoxesIntersection,
         circle: checkBoxAndCircleIntersection,
+        segment: checkBoxAndSegmentIntersection,
     },
     circle: {
         circle: checkCirclesIntersection,
         box: checkBoxAndCircleIntersection,
+        segment: checkCircleAndSegmentIntersection,
+    },
+    segment: {
+        box: checkBoxAndSegmentIntersection,
+        circle: checkCircleAndSegmentIntersection,
+    },
+    point: {
+        box: checkPointAndBoxIntersection,
+        circle: checkPointAndCircleIntersection,
+        segment: checkPointAndSegmentIntersection,
+    },
+    ray: {
+        box: checkRayAndBoxIntersection,
+        circle: checkRayAndCircleIntersection,
+        segment: checkRayAndSegmentIntersection,
     },
 };

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/point-box/check-point-and-box-intersection.d.ts

@@ -0,0 +1,9 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks point and box colliders for intersection.
+ *
+ * The manifold uses the nearest point on the box boundary as the contact.
+ * For points inside the box, penetration is the distance to the nearest edge.
+ * When the point lies exactly on the boundary, penetration is reported as zero.
+ */
+export declare const checkPointAndBoxIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/point-box/check-point-and-box-intersection.js

@@ -0,0 +1,36 @@
+import { VectorOps } from '../../../../../../../engine/math-lib';
+import { orientNormal, INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks point and box colliders for intersection.
+ *
+ * The manifold uses the nearest point on the box boundary as the contact.
+ * For points inside the box, penetration is the distance to the nearest edge.
+ * When the point lies exactly on the boundary, penetration is reported as zero.
+ */
+export const checkPointAndBoxIntersection = (arg1, arg2) => {
+    const isBoxFirst = 'edges' in arg1.geometry;
+    const box = (isBoxFirst ? arg1.geometry : arg2.geometry);
+    const point = (isBoxFirst ? arg2.geometry : arg1.geometry);
+    let bestEdge = box.edges[0];
+    let bestSignedDistance = -Infinity;
+    for (const edge of box.edges) {
+        const signedDistance = VectorOps.dotProduct({
+            x: point.center.x - edge.point1.x,
+            y: point.center.y - edge.point1.y,
+        }, edge.normal);
+        if (signedDistance > INTERSECTION_EPSILON) {
+            return false;
+        }
+        if (signedDistance > bestSignedDistance) {
+            bestSignedDistance = signedDistance;
+            bestEdge = edge;
+        }
+    }
+    const contactPoint = VectorOps.getClosestPointOnEdge(point.center, bestEdge);
+    const isPointOnBoxBoundary = Math.abs(bestSignedDistance) <= INTERSECTION_EPSILON;
+    return {
+        normal: orientNormal(bestEdge.normal.clone(), arg1.geometry.center, arg2.geometry.center),
+        penetration: isPointOnBoxBoundary ? 0 : -bestSignedDistance,
+        contactPoints: [contactPoint],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/point-circle/check-point-and-circle-intersection.d.ts

@@ -0,0 +1,9 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks point and circle colliders for intersection.
+ *
+ * The manifold uses the nearest point on the circle boundary as the contact.
+ * When the point lies at the circle center, the X axis is used as a
+ * deterministic fallback.
+ */
+export declare const checkPointAndCircleIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/point-circle/check-point-and-circle-intersection.js

@@ -0,0 +1,33 @@
+import { Vector2 } from '../../../../../../../engine/math-lib';
+import { orientNormal, INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks point and circle colliders for intersection.
+ *
+ * The manifold uses the nearest point on the circle boundary as the contact.
+ * When the point lies at the circle center, the X axis is used as a
+ * deterministic fallback.
+ */
+export const checkPointAndCircleIntersection = (arg1, arg2) => {
+    const isCircleFirst = 'radius' in arg1.geometry;
+    const circle = (isCircleFirst ? arg1.geometry : arg2.geometry);
+    const point = (isCircleFirst ? arg2.geometry : arg1.geometry);
+    const offsetX = point.center.x - circle.center.x;
+    const offsetY = point.center.y - circle.center.y;
+    const distance = Math.sqrt(offsetX ** 2 + offsetY ** 2);
+    if (distance > circle.radius + INTERSECTION_EPSILON) {
+        return false;
+    }
+    const normal = distance === 0
+        ? new Vector2(1, 0)
+        : new Vector2(offsetX, offsetY).normalize();
+    return {
+        normal: orientNormal(normal, arg1.geometry.center, arg2.geometry.center),
+        penetration: Math.max(0, circle.radius - distance),
+        contactPoints: [
+            {
+                x: circle.center.x + normal.x * circle.radius,
+                y: circle.center.y + normal.y * circle.radius,
+            },
+        ],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/point-segment/check-point-and-segment-intersection.d.ts

@@ -0,0 +1,9 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks whether a query point lies on a segment.
+ *
+ * The closest point on the finite segment is projected from the point.
+ * If the projected distance is near zero, that projected point becomes
+ * the contact point and the stored segment normal is used for orientation.
+ */
+export declare const checkPointAndSegmentIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/point-segment/check-point-and-segment-intersection.js

@@ -0,0 +1,26 @@
+import { MathOps, Vector2, VectorOps, } from '../../../../../../../engine/math-lib';
+import { orientNormal, INTERSECTION_EPSILON } from '../utils';
+/**
+ * Checks whether a query point lies on a segment.
+ *
+ * The closest point on the finite segment is projected from the point.
+ * If the projected distance is near zero, that projected point becomes
+ * the contact point and the stored segment normal is used for orientation.
+ */
+export const checkPointAndSegmentIntersection = (arg1, arg2) => {
+    const isSegmentFirst = 'point1' in arg1.geometry;
+    const segment = (isSegmentFirst ? arg1.geometry : arg2.geometry);
+    const point = (isSegmentFirst ? arg2.geometry : arg1.geometry);
+    const closestPoint = VectorOps.getClosestPointOnEdge(point.center, segment);
+    const distance = MathOps.getDistanceBetweenTwoPoints(point.center.x, closestPoint.x, point.center.y, closestPoint.y);
+    if (distance > INTERSECTION_EPSILON) {
+        return false;
+    }
+    return {
+        normal: orientNormal(segment.normal.magnitude === 0
+            ? new Vector2(1, 0)
+            : segment.normal.clone(), arg1.geometry.center, arg2.geometry.center),
+        penetration: 0,
+        contactPoints: [closestPoint],
+    };
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/ray-box/check-ray-and-box-intersection.d.ts

@@ -0,0 +1,11 @@
+import type { Proxy, Intersection } from '../../types';
+/**
+ * Checks a ray against a convex box using half-space clipping.
+ *
+ * The intersection interval is clipped against each box face.
+ * - `tEnter` tracks the first point where the ray enters the box
+ * - `tExit` tracks the first point where the ray leaves the box
+ *
+ * When the ray starts inside the box, the first hit is the exit point.
+ */
+export declare const checkRayAndBoxIntersection: (arg1: Proxy, arg2: Proxy) => Intersection | false;