@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/collision/manifold.js

@@ -0,0 +1,238 @@
+import { transformPointInto } from "../math.js";
+import { GEOMETRY_EPSILON } from "../numeric-policy.js";
+function createPrivateManifold2D(distance, first, firstPose, second, secondPose) {
+  const firstVertices = polygonVertices(
+    first,
+    firstPose,
+    distance.normalX,
+    distance.normalY
+  );
+  const secondVertices = polygonVertices(
+    second,
+    secondPose,
+    distance.normalX,
+    distance.normalY
+  );
+  let points;
+  if (firstVertices !== null && secondVertices !== null) {
+    points = faceContactPoints(distance, firstVertices, secondVertices);
+  } else {
+    points = [
+      {
+        firstX: distance.firstX,
+        firstY: distance.firstY,
+        secondX: distance.secondX,
+        secondY: distance.secondY,
+        separation: distance.separation,
+        firstFeature: distance.firstFeature,
+        secondFeature: distance.secondFeature
+      }
+    ];
+  }
+  return {
+    normalX: distance.normalX,
+    normalY: distance.normalY,
+    firstLeaf: distance.firstLeaf,
+    secondLeaf: distance.secondLeaf,
+    points
+  };
+}
+function publicContactFromManifold2D(manifold) {
+  const normal = freezeVector(manifold.normalX, manifold.normalY);
+  const points = manifold.points.map(
+    (point) => Object.freeze({
+      pointOnFirst: freezeVector(point.firstX, point.firstY),
+      pointOnSecond: freezeVector(point.secondX, point.secondY),
+      separation: cleanZero(point.separation)
+    })
+  );
+  return Object.freeze({ normal, points: Object.freeze(points) });
+}
+function faceContactPoints(distance, firstVertices, secondVertices) {
+  const firstFace = supportingFace(
+    firstVertices,
+    -distance.normalX,
+    -distance.normalY
+  );
+  const secondFace = supportingFace(
+    secondVertices,
+    distance.normalX,
+    distance.normalY
+  );
+  const firstAlignment = -(firstFace.normalX * distance.normalX + firstFace.normalY * distance.normalY);
+  const secondAlignment = secondFace.normalX * distance.normalX + secondFace.normalY * distance.normalY;
+  const firstIsReference = firstAlignment >= secondAlignment - GEOMETRY_EPSILON;
+  const reference = firstIsReference ? firstFace : secondFace;
+  const incident = firstIsReference ? secondFace : firstFace;
+  const referenceTangentX = reference.endX - reference.startX;
+  const referenceTangentY = reference.endY - reference.startY;
+  const referenceLength = Math.hypot(referenceTangentX, referenceTangentY);
+  if (referenceLength <= GEOMETRY_EPSILON) return fallbackPoint(distance);
+  const tangentX = referenceTangentX / referenceLength;
+  const tangentY = referenceTangentY / referenceLength;
+  const minimum = reference.startX * tangentX + reference.startY * tangentY;
+  const maximum = reference.endX * tangentX + reference.endY * tangentY;
+  let clipped = clipSegment(
+    [incident.startX, incident.startY, incident.endX, incident.endY],
+    tangentX,
+    tangentY,
+    Math.min(minimum, maximum),
+    true
+  );
+  if (clipped === null) return fallbackPoint(distance);
+  clipped = clipSegment(
+    clipped,
+    tangentX,
+    tangentY,
+    Math.max(minimum, maximum),
+    false
+  );
+  if (clipped === null) return fallbackPoint(distance);
+  const referenceNormalX = reference.normalX;
+  const referenceNormalY = reference.normalY;
+  const points = [];
+  for (let index = 0; index < 2; index += 1) {
+    const x = clipped[index * 2];
+    const y = clipped[index * 2 + 1];
+    const separation = (x - reference.startX) * referenceNormalX + (y - reference.startY) * referenceNormalY;
+    if (separation > GEOMETRY_EPSILON) continue;
+    const projectedX = x - separation * referenceNormalX;
+    const projectedY = y - separation * referenceNormalY;
+    points.push(
+      firstIsReference ? {
+        firstX: projectedX,
+        firstY: projectedY,
+        secondX: x,
+        secondY: y,
+        separation,
+        firstFeature: reference.index,
+        secondFeature: incident.index * 2 + index
+      } : {
+        firstX: x,
+        firstY: y,
+        secondX: projectedX,
+        secondY: projectedY,
+        separation,
+        firstFeature: incident.index * 2 + index,
+        secondFeature: reference.index
+      }
+    );
+  }
+  if (points.length === 0) return fallbackPoint(distance);
+  const publicTangentX = -distance.normalY;
+  const publicTangentY = distance.normalX;
+  points.sort((first, second) => {
+    const projectionDifference = first.firstX * publicTangentX + first.firstY * publicTangentY - (second.firstX * publicTangentX + second.firstY * publicTangentY);
+    if (Math.abs(projectionDifference) > GEOMETRY_EPSILON)
+      return projectionDifference;
+    return first.firstFeature - second.firstFeature || first.secondFeature - second.secondFeature;
+  });
+  return points.slice(0, 2);
+}
+function supportingFace(vertices, directionX, directionY) {
+  let selected = null;
+  let selectedAlignment = Number.NEGATIVE_INFINITY;
+  const count = vertices.length / 2;
+  for (let index = 0; index < count; index += 1) {
+    const next = (index + 1) % count;
+    const startX = vertices[index * 2];
+    const startY = vertices[index * 2 + 1];
+    const endX = vertices[next * 2];
+    const endY = vertices[next * 2 + 1];
+    const edgeX = endX - startX;
+    const edgeY = endY - startY;
+    const length = Math.hypot(edgeX, edgeY);
+    if (length <= GEOMETRY_EPSILON) continue;
+    const normalX = edgeY / length;
+    const normalY = -edgeX / length;
+    const alignment = normalX * directionX + normalY * directionY;
+    if (alignment > selectedAlignment) {
+      selectedAlignment = alignment;
+      selected = { startX, startY, endX, endY, normalX, normalY, index };
+    }
+  }
+  return selected;
+}
+function clipSegment(segment, normalX, normalY, offset, keepGreater) {
+  const firstDistance = segment[0] * normalX + segment[1] * normalY - offset;
+  const secondDistance = segment[2] * normalX + segment[3] * normalY - offset;
+  const firstInside = keepGreater ? firstDistance >= -GEOMETRY_EPSILON : firstDistance <= GEOMETRY_EPSILON;
+  const secondInside = keepGreater ? secondDistance >= -GEOMETRY_EPSILON : secondDistance <= GEOMETRY_EPSILON;
+  if (firstInside && secondInside) return [...segment];
+  if (!firstInside && !secondInside) return null;
+  const denominator = firstDistance - secondDistance;
+  if (Math.abs(denominator) <= GEOMETRY_EPSILON) return null;
+  const amount = firstDistance / denominator;
+  const x = segment[0] + amount * (segment[2] - segment[0]);
+  const y = segment[1] + amount * (segment[3] - segment[1]);
+  return firstInside ? [segment[0], segment[1], x, y] : [x, y, segment[2], segment[3]];
+}
+function fallbackPoint(distance) {
+  return [
+    {
+      firstX: distance.firstX,
+      firstY: distance.firstY,
+      secondX: distance.secondX,
+      secondY: distance.secondY,
+      separation: distance.separation,
+      firstFeature: distance.firstFeature,
+      secondFeature: distance.secondFeature
+    }
+  ];
+}
+function polygonVertices(leaf, pose, normalX, normalY) {
+  let local;
+  if (leaf.kind === "box") {
+    local = [
+      leaf.center[0] - leaf.halfWidth,
+      leaf.center[1] - leaf.halfHeight,
+      leaf.center[0] + leaf.halfWidth,
+      leaf.center[1] - leaf.halfHeight,
+      leaf.center[0] + leaf.halfWidth,
+      leaf.center[1] + leaf.halfHeight,
+      leaf.center[0] - leaf.halfWidth,
+      leaf.center[1] + leaf.halfHeight
+    ];
+  } else if (leaf.kind === "capsule") {
+    const dx = leaf.end[0] - leaf.start[0], dy = leaf.end[1] - leaf.start[1];
+    const length = Math.hypot(dx, dy);
+    if (length <= GEOMETRY_EPSILON) return null;
+    const cosine = Math.cos(pose.rotationRadians), sine = Math.sin(pose.rotationRadians);
+    const localNormalX = cosine * normalX + sine * normalY;
+    const localNormalY = -sine * normalX + cosine * normalY;
+    if (Math.abs(dx * localNormalX + dy * localNormalY) > length * 0.95)
+      return null;
+    const sign = dx * localNormalY - dy * localNormalX >= 0 ? 1 : -1;
+    const nx = sign * localNormalX * leaf.radius, ny = sign * localNormalY * leaf.radius;
+    local = [
+      leaf.start[0] - nx,
+      leaf.start[1] - ny,
+      leaf.end[0] - nx,
+      leaf.end[1] - ny,
+      leaf.end[0] + nx,
+      leaf.end[1] + ny,
+      leaf.start[0] + nx,
+      leaf.start[1] + ny
+    ];
+  } else if (leaf.kind === "polygon") {
+    local = leaf.vertices;
+  } else {
+    return null;
+  }
+  const result = new Float64Array(local.length);
+  for (let index = 0; index < local.length; index += 2) {
+    transformPointInto(result, index, local[index], local[index + 1], pose);
+  }
+  return result;
+}
+function freezeVector(x, y) {
+  return Object.freeze([cleanZero(x), cleanZero(y)]);
+}
+function cleanZero(value) {
+  return Object.is(value, -0) || Math.abs(value) <= Number.EPSILON ? 0 : value;
+}
+export {
+  createPrivateManifold2D,
+  publicContactFromManifold2D
+};
+//# sourceMappingURL=manifold.js.map

package/dist/features/physics/lib/2d/collision/manifold.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/collision/manifold.ts"],
+  "sourcesContent": ["import type { PibblPhysicsShapeContact2D } from \"../../../2d-geometry.js\";\nimport { transformPointInto, type InternalPose2D } from \"../math.js\";\nimport { GEOMETRY_EPSILON } from \"../numeric-policy.js\";\nimport type { ConvexLeaf2D } from \"../shape-records.js\";\n\nexport interface PrivatePairDistance2D {\n  readonly separation: number;\n  readonly firstX: number;\n  readonly firstY: number;\n  readonly secondX: number;\n  readonly secondY: number;\n  readonly normalX: number;\n  readonly normalY: number;\n  readonly firstFeature: number;\n  readonly secondFeature: number;\n  readonly firstLeaf: number;\n  readonly secondLeaf: number;\n}\n\ninterface PrivateManifoldPoint2D {\n  readonly firstX: number;\n  readonly firstY: number;\n  readonly secondX: number;\n  readonly secondY: number;\n  readonly separation: number;\n  readonly firstFeature: number;\n  readonly secondFeature: number;\n}\n\nexport interface PrivateManifold2D {\n  readonly normalX: number;\n  readonly normalY: number;\n  readonly firstLeaf: number;\n  readonly secondLeaf: number;\n  readonly points: readonly PrivateManifoldPoint2D[];\n}\n\nexport function createPrivateManifold2D(\n  distance: PrivatePairDistance2D,\n  first: ConvexLeaf2D,\n  firstPose: InternalPose2D,\n  second: ConvexLeaf2D,\n  secondPose: InternalPose2D,\n): PrivateManifold2D {\n  const firstVertices = polygonVertices(\n    first,\n    firstPose,\n    distance.normalX,\n    distance.normalY,\n  );\n  const secondVertices = polygonVertices(\n    second,\n    secondPose,\n    distance.normalX,\n    distance.normalY,\n  );\n  let points: readonly PrivateManifoldPoint2D[];\n  if (firstVertices !== null && secondVertices !== null) {\n    points = faceContactPoints(distance, firstVertices, secondVertices);\n  } else {\n    points = [\n      {\n        firstX: distance.firstX,\n        firstY: distance.firstY,\n        secondX: distance.secondX,\n        secondY: distance.secondY,\n        separation: distance.separation,\n        firstFeature: distance.firstFeature,\n        secondFeature: distance.secondFeature,\n      },\n    ];\n  }\n  return {\n    normalX: distance.normalX,\n    normalY: distance.normalY,\n    firstLeaf: distance.firstLeaf,\n    secondLeaf: distance.secondLeaf,\n    points,\n  };\n}\n\nexport function publicContactFromManifold2D(\n  manifold: PrivateManifold2D,\n): PibblPhysicsShapeContact2D {\n  const normal = freezeVector(manifold.normalX, manifold.normalY);\n  const points = manifold.points.map((point) =>\n    Object.freeze({\n      pointOnFirst: freezeVector(point.firstX, point.firstY),\n      pointOnSecond: freezeVector(point.secondX, point.secondY),\n      separation: cleanZero(point.separation),\n    }),\n  );\n  return Object.freeze({ normal, points: Object.freeze(points) });\n}\n\nfunction faceContactPoints(\n  distance: PrivatePairDistance2D,\n  firstVertices: Float64Array,\n  secondVertices: Float64Array,\n): readonly PrivateManifoldPoint2D[] {\n  const firstFace = supportingFace(\n    firstVertices,\n    -distance.normalX,\n    -distance.normalY,\n  );\n  const secondFace = supportingFace(\n    secondVertices,\n    distance.normalX,\n    distance.normalY,\n  );\n  const firstAlignment = -(\n    firstFace.normalX * distance.normalX +\n    firstFace.normalY * distance.normalY\n  );\n  const secondAlignment =\n    secondFace.normalX * distance.normalX +\n    secondFace.normalY * distance.normalY;\n  const firstIsReference = firstAlignment >= secondAlignment - GEOMETRY_EPSILON;\n  const reference = firstIsReference ? firstFace : secondFace;\n  const incident = firstIsReference ? secondFace : firstFace;\n  const referenceTangentX = reference.endX - reference.startX;\n  const referenceTangentY = reference.endY - reference.startY;\n  const referenceLength = Math.hypot(referenceTangentX, referenceTangentY);\n  if (referenceLength <= GEOMETRY_EPSILON) return fallbackPoint(distance);\n  const tangentX = referenceTangentX / referenceLength;\n  const tangentY = referenceTangentY / referenceLength;\n  const minimum = reference.startX * tangentX + reference.startY * tangentY;\n  const maximum = reference.endX * tangentX + reference.endY * tangentY;\n  let clipped = clipSegment(\n    [incident.startX, incident.startY, incident.endX, incident.endY],\n    tangentX,\n    tangentY,\n    Math.min(minimum, maximum),\n    true,\n  );\n  if (clipped === null) return fallbackPoint(distance);\n  clipped = clipSegment(\n    clipped,\n    tangentX,\n    tangentY,\n    Math.max(minimum, maximum),\n    false,\n  );\n  if (clipped === null) return fallbackPoint(distance);\n  const referenceNormalX = reference.normalX;\n  const referenceNormalY = reference.normalY;\n  const points: PrivateManifoldPoint2D[] = [];\n  for (let index = 0; index < 2; index += 1) {\n    const x = clipped[index * 2]!;\n    const y = clipped[index * 2 + 1]!;\n    const separation =\n      (x - reference.startX) * referenceNormalX +\n      (y - reference.startY) * referenceNormalY;\n    if (separation > GEOMETRY_EPSILON) continue;\n    const projectedX = x - separation * referenceNormalX;\n    const projectedY = y - separation * referenceNormalY;\n    points.push(\n      firstIsReference\n        ? {\n            firstX: projectedX,\n            firstY: projectedY,\n            secondX: x,\n            secondY: y,\n            separation,\n            firstFeature: reference.index,\n            secondFeature: incident.index * 2 + index,\n          }\n        : {\n            firstX: x,\n            firstY: y,\n            secondX: projectedX,\n            secondY: projectedY,\n            separation,\n            firstFeature: incident.index * 2 + index,\n            secondFeature: reference.index,\n          },\n    );\n  }\n  if (points.length === 0) return fallbackPoint(distance);\n  const publicTangentX = -distance.normalY;\n  const publicTangentY = distance.normalX;\n  points.sort((first, second) => {\n    const projectionDifference =\n      first.firstX * publicTangentX +\n      first.firstY * publicTangentY -\n      (second.firstX * publicTangentX + second.firstY * publicTangentY);\n    if (Math.abs(projectionDifference) > GEOMETRY_EPSILON)\n      return projectionDifference;\n    return (\n      first.firstFeature - second.firstFeature ||\n      first.secondFeature - second.secondFeature\n    );\n  });\n  return points.slice(0, 2);\n}\n\ninterface Face2D {\n  readonly startX: number;\n  readonly startY: number;\n  readonly endX: number;\n  readonly endY: number;\n  readonly normalX: number;\n  readonly normalY: number;\n  readonly index: number;\n}\n\nfunction supportingFace(\n  vertices: Float64Array,\n  directionX: number,\n  directionY: number,\n): Face2D {\n  let selected: Face2D | null = null;\n  let selectedAlignment = Number.NEGATIVE_INFINITY;\n  const count = vertices.length / 2;\n  for (let index = 0; index < count; index += 1) {\n    const next = (index + 1) % count;\n    const startX = vertices[index * 2]!;\n    const startY = vertices[index * 2 + 1]!;\n    const endX = vertices[next * 2]!;\n    const endY = vertices[next * 2 + 1]!;\n    const edgeX = endX - startX;\n    const edgeY = endY - startY;\n    const length = Math.hypot(edgeX, edgeY);\n    if (length <= GEOMETRY_EPSILON) continue;\n    const normalX = edgeY / length;\n    const normalY = -edgeX / length;\n    const alignment = normalX * directionX + normalY * directionY;\n    if (alignment > selectedAlignment) {\n      selectedAlignment = alignment;\n      selected = { startX, startY, endX, endY, normalX, normalY, index };\n    }\n  }\n  return selected!;\n}\n\nfunction clipSegment(\n  segment: readonly [number, number, number, number],\n  normalX: number,\n  normalY: number,\n  offset: number,\n  keepGreater: boolean,\n): [number, number, number, number] | null {\n  const firstDistance = segment[0] * normalX + segment[1] * normalY - offset;\n  const secondDistance = segment[2] * normalX + segment[3] * normalY - offset;\n  const firstInside = keepGreater\n    ? firstDistance >= -GEOMETRY_EPSILON\n    : firstDistance <= GEOMETRY_EPSILON;\n  const secondInside = keepGreater\n    ? secondDistance >= -GEOMETRY_EPSILON\n    : secondDistance <= GEOMETRY_EPSILON;\n  if (firstInside && secondInside) return [...segment];\n  if (!firstInside && !secondInside) return null;\n  const denominator = firstDistance - secondDistance;\n  if (Math.abs(denominator) <= GEOMETRY_EPSILON) return null;\n  const amount = firstDistance / denominator;\n  const x = segment[0] + amount * (segment[2] - segment[0]);\n  const y = segment[1] + amount * (segment[3] - segment[1]);\n  return firstInside\n    ? [segment[0], segment[1], x, y]\n    : [x, y, segment[2], segment[3]];\n}\n\nfunction fallbackPoint(\n  distance: PrivatePairDistance2D,\n): readonly PrivateManifoldPoint2D[] {\n  return [\n    {\n      firstX: distance.firstX,\n      firstY: distance.firstY,\n      secondX: distance.secondX,\n      secondY: distance.secondY,\n      separation: distance.separation,\n      firstFeature: distance.firstFeature,\n      secondFeature: distance.secondFeature,\n    },\n  ];\n}\n\nfunction polygonVertices(\n  leaf: ConvexLeaf2D,\n  pose: InternalPose2D,\n  normalX: number,\n  normalY: number,\n): Float64Array | null {\n  let local: Float64Array | readonly number[];\n  if (leaf.kind === \"box\") {\n    local = [\n      leaf.center[0]! - leaf.halfWidth,\n      leaf.center[1]! - leaf.halfHeight,\n      leaf.center[0]! + leaf.halfWidth,\n      leaf.center[1]! - leaf.halfHeight,\n      leaf.center[0]! + leaf.halfWidth,\n      leaf.center[1]! + leaf.halfHeight,\n      leaf.center[0]! - leaf.halfWidth,\n      leaf.center[1]! + leaf.halfHeight,\n    ];\n  } else if (leaf.kind === \"capsule\") {\n    const dx = leaf.end[0]! - leaf.start[0]!,\n      dy = leaf.end[1]! - leaf.start[1]!;\n    const length = Math.hypot(dx, dy);\n    if (length <= GEOMETRY_EPSILON) return null;\n    const cosine = Math.cos(pose.rotationRadians),\n      sine = Math.sin(pose.rotationRadians);\n    // Keep the two endpoint supports while a capsule rests across a face.\n    // Near an axial impact the round end retains its single witness.\n    const localNormalX = cosine * normalX + sine * normalY;\n    const localNormalY = -sine * normalX + cosine * normalY;\n    if (Math.abs(dx * localNormalX + dy * localNormalY) > length * 0.95)\n      return null;\n    const sign = dx * localNormalY - dy * localNormalX >= 0 ? 1 : -1;\n    const nx = sign * localNormalX * leaf.radius,\n      ny = sign * localNormalY * leaf.radius;\n    local = [\n      leaf.start[0]! - nx,\n      leaf.start[1]! - ny,\n      leaf.end[0]! - nx,\n      leaf.end[1]! - ny,\n      leaf.end[0]! + nx,\n      leaf.end[1]! + ny,\n      leaf.start[0]! + nx,\n      leaf.start[1]! + ny,\n    ];\n  } else if (leaf.kind === \"polygon\") {\n    local = leaf.vertices;\n  } else {\n    return null;\n  }\n  const result = new Float64Array(local.length);\n  for (let index = 0; index < local.length; index += 2) {\n    transformPointInto(result, index, local[index]!, local[index + 1]!, pose);\n  }\n  return result;\n}\n\nfunction freezeVector(x: number, y: number): readonly [number, number] {\n  return Object.freeze([cleanZero(x), cleanZero(y)] as const);\n}\n\nfunction cleanZero(value: number): number {\n  return Object.is(value, -0) || Math.abs(value) <= Number.EPSILON ? 0 : value;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/physics/lib/2d/collision/pairs.d.ts

@@ -0,0 +1,10 @@
+import type { PibblPhysicsDistance2D, PibblPhysicsPose2D, PibblPhysicsShape2D, PibblPhysicsShapeContact2D, PibblPhysicsVector2 } from '../../../2d-geometry.js';
+import { type InternalPose2D } from '../math.js';
+import { type ShapeRecord2D } from '../shape-records.js';
+import { type PrivateManifold2D } from './manifold.js';
+export declare function containsPointInShape2D(shape: PibblPhysicsShape2D, pose: PibblPhysicsPose2D, point: PibblPhysicsVector2): boolean;
+export declare function distanceBetweenPreparedShapes2D(firstShape: PibblPhysicsShape2D, firstPose: PibblPhysicsPose2D, secondShape: PibblPhysicsShape2D, secondPose: PibblPhysicsPose2D): PibblPhysicsDistance2D;
+export declare function overlapPreparedShapes2D(firstShape: PibblPhysicsShape2D, firstPose: PibblPhysicsPose2D, secondShape: PibblPhysicsShape2D, secondPose: PibblPhysicsPose2D): boolean;
+export declare function contactBetweenPreparedShapes2D(firstShape: PibblPhysicsShape2D, firstPose: PibblPhysicsPose2D, secondShape: PibblPhysicsShape2D, secondPose: PibblPhysicsPose2D): PibblPhysicsShapeContact2D | null;
+/** Package-private world/cache seam. Not exported from a package entry. */
+export declare function manifoldBetweenShapeRecords2D(firstRecord: ShapeRecord2D, firstPose: InternalPose2D, firstOrder: number, secondRecord: ShapeRecord2D, secondPose: InternalPose2D, secondOrder: number): PrivateManifold2D | null;

package/dist/features/physics/lib/2d/collision/pairs.js

@@ -0,0 +1,285 @@
+import { copyFiniteVector2 } from "../../shared/validation.js";
+import { composePose2D, copyPose2D, transformPointInto } from "../math.js";
+import { GEOMETRY_EPSILON } from "../numeric-policy.js";
+import { requireShapeRecord2D } from "../shape-records.js";
+import { distanceCapsuleToCapsule2D, distancePointToSegment2D } from "./analytic.js";
+import { epaConvexLeaves2D } from "./epa.js";
+import { gjkConvexLeaves2D } from "./gjk.js";
+import {
+  createPrivateManifold2D,
+  publicContactFromManifold2D
+} from "./manifold.js";
+import { centerOfLeaf2D } from "./support.js";
+const shapeOrders = /* @__PURE__ */ new WeakMap();
+let nextShapeOrder = 0;
+function containsPointInShape2D(shape, pose, point) {
+  const prepared = prepareShape(shape, pose, "shape", "pose");
+  const copiedPoint = copyFiniteVector2(point, "point");
+  return prepared.record.leaves.some(
+    (leaf) => containsPointInLeaf(leaf, prepared.pose, copiedPoint[0], copiedPoint[1])
+  );
+}
+function distanceBetweenPreparedShapes2D(firstShape, firstPose, secondShape, secondPose) {
+  const result = collidePreparedShapes(firstShape, firstPose, secondShape, secondPose);
+  if (result.status === "failed") {
+    throw new Error("2D collision distance did not converge within its fixed iteration bounds.");
+  }
+  return publicDistance(result.distance);
+}
+function overlapPreparedShapes2D(firstShape, firstPose, secondShape, secondPose) {
+  const result = collidePreparedShapes(firstShape, firstPose, secondShape, secondPose);
+  return result.status === "success" && result.distance.separation <= 0;
+}
+function contactBetweenPreparedShapes2D(firstShape, firstPose, secondShape, secondPose) {
+  const result = collidePreparedShapes(firstShape, firstPose, secondShape, secondPose);
+  if (result.status === "failed" || result.distance.separation > 0) {
+    return null;
+  }
+  return publicContactFromManifold2D(
+    createPrivateManifold2D(result.distance, result.first, result.firstPose, result.second, result.secondPose)
+  );
+}
+function manifoldBetweenShapeRecords2D(firstRecord, firstPose, firstOrder, secondRecord, secondPose, secondOrder) {
+  const result = collideShapeRecords(
+    prepareShapeRecord(firstRecord, firstPose, firstOrder),
+    prepareShapeRecord(secondRecord, secondPose, secondOrder)
+  );
+  if (result.status === "failed" || result.distance.separation > 0) return null;
+  return createPrivateManifold2D(result.distance, result.first, result.firstPose, result.second, result.secondPose);
+}
+function collidePreparedShapes(firstShape, firstPublicPose, secondShape, secondPublicPose) {
+  const first = prepareShape(firstShape, firstPublicPose, "first", "firstPose");
+  const second = prepareShape(secondShape, secondPublicPose, "second", "secondPose");
+  return collideShapeRecords(first, second);
+}
+function collideShapeRecords(first, second) {
+  let selected = null;
+  let failures = 0;
+  for (const firstLeaf of first.record.leaves) {
+    for (const secondLeaf of second.record.leaves) {
+      const distance = distanceBetweenLeaves(firstLeaf, first.pose, secondLeaf, second.pose, first, second);
+      if (distance === null) {
+        failures += 1;
+        continue;
+      }
+      const candidate = {
+        status: "success",
+        distance,
+        first: firstLeaf,
+        firstPose: first.pose,
+        second: secondLeaf,
+        secondPose: second.pose
+      };
+      if (selected === null || comparePairCandidates(candidate, selected, first.order, second.order) < 0) {
+        selected = candidate;
+      }
+    }
+  }
+  if (selected === null || failures > 0 && selected.distance.separation > GEOMETRY_EPSILON) {
+    return { status: "failed" };
+  }
+  return selected;
+}
+function distanceBetweenLeaves(first, firstPose, second, secondPose, firstShape, secondShape) {
+  const fallback = preferredNormal(first, firstPose, second, secondPose, firstShape, secondShape);
+  const firstRound = roundSpine(first, firstPose);
+  const secondRound = roundSpine(second, secondPose);
+  if (firstRound !== null && secondRound !== null) {
+    const result = distanceCapsuleToCapsule2D(
+      firstRound.startX,
+      firstRound.startY,
+      firstRound.endX,
+      firstRound.endY,
+      firstRound.radius,
+      secondRound.startX,
+      secondRound.startY,
+      secondRound.endX,
+      secondRound.endY,
+      secondRound.radius,
+      fallback[0],
+      fallback[1]
+    );
+    return {
+      ...result,
+      firstFeature: 0,
+      secondFeature: 0,
+      firstLeaf: first.canonicalLeafIndex,
+      secondLeaf: second.canonicalLeafIndex
+    };
+  }
+  const gjk = gjkConvexLeaves2D(first, firstPose, second, secondPose, fallback[0], fallback[1]);
+  if (gjk.status === "failed") return null;
+  if (gjk.status === "penetrating") {
+    const epa = epaConvexLeaves2D(first, firstPose, second, secondPose, gjk.simplex);
+    if (epa.status === "failed") return null;
+    return {
+      ...epa,
+      firstLeaf: first.canonicalLeafIndex,
+      secondLeaf: second.canonicalLeafIndex
+    };
+  }
+  const normalLength = Math.hypot(gjk.normalX, gjk.normalY);
+  return {
+    separation: gjk.separation,
+    firstX: gjk.firstX,
+    firstY: gjk.firstY,
+    secondX: gjk.secondX,
+    secondY: gjk.secondY,
+    normalX: normalLength > GEOMETRY_EPSILON ? gjk.normalX : fallback[0],
+    normalY: normalLength > GEOMETRY_EPSILON ? gjk.normalY : fallback[1],
+    firstFeature: gjk.firstFeature,
+    secondFeature: gjk.secondFeature,
+    firstLeaf: first.canonicalLeafIndex,
+    secondLeaf: second.canonicalLeafIndex
+  };
+}
+function prepareShape(shell, publicPose, shapePath, posePath) {
+  const record = requireShapeRecord2D(shell);
+  const pose = composePose2D(copyPose2D(publicPose, posePath), record.localPose);
+  return { record, pose, order: shapeOrder(shell, shapePath) };
+}
+function prepareShapeRecord(record, outerPose, order) {
+  return {
+    record,
+    pose: composePose2D(outerPose, record.localPose),
+    order
+  };
+}
+function shapeOrder(shape, _path) {
+  const object = shape;
+  const existing = shapeOrders.get(object);
+  if (existing !== void 0) return existing;
+  const order = nextShapeOrder;
+  nextShapeOrder += 1;
+  shapeOrders.set(object, order);
+  return order;
+}
+function preferredNormal(first, firstPose, second, secondPose, firstShape, secondShape) {
+  const centers = new Float64Array(4);
+  centerOfLeaf2D(centers, 0, first, firstPose);
+  centerOfLeaf2D(centers, 2, second, secondPose);
+  const dx = centers[0] - centers[2];
+  const dy = centers[1] - centers[3];
+  const length = Math.hypot(dx, dy);
+  if (length > GEOMETRY_EPSILON) return [dx / length, dy / length];
+  return firstShape.order <= secondShape.order ? [1, 0] : [-1, 0];
+}
+function containsPointInLeaf(leaf, pose, pointX, pointY) {
+  const local = inversePoint(pointX, pointY, pose);
+  switch (leaf.kind) {
+    case "circle":
+      return Math.hypot(local[0] - leaf.center[0], local[1] - leaf.center[1]) <= leaf.radius + GEOMETRY_EPSILON;
+    case "ellipse": {
+      const dx = local[0] - leaf.center[0];
+      const dy = local[1] - leaf.center[1];
+      const cosine = Math.cos(leaf.rotationRadians);
+      const sine = Math.sin(leaf.rotationRadians);
+      const x = cosine * dx + sine * dy;
+      const y = -sine * dx + cosine * dy;
+      return (x / leaf.radiusX) ** 2 + (y / leaf.radiusY) ** 2 <= 1 + GEOMETRY_EPSILON;
+    }
+    case "box":
+      return Math.abs(local[0] - leaf.center[0]) <= leaf.halfWidth + GEOMETRY_EPSILON && Math.abs(local[1] - leaf.center[1]) <= leaf.halfHeight + GEOMETRY_EPSILON;
+    case "rounded-box": {
+      const dx = local[0] - leaf.center[0];
+      const dy = local[1] - leaf.center[1];
+      if (Math.abs(dx) > leaf.halfWidth + GEOMETRY_EPSILON || Math.abs(dy) > leaf.halfHeight + GEOMETRY_EPSILON)
+        return false;
+      const feature = dy < 0 ? dx < 0 ? 0 : 1 : dx < 0 ? 3 : 2;
+      const radius = leaf.radii[feature];
+      const cornerDx = Math.max(0, Math.abs(dx) - (leaf.halfWidth - radius));
+      const cornerDy = Math.max(0, Math.abs(dy) - (leaf.halfHeight - radius));
+      return cornerDx * cornerDx + cornerDy * cornerDy <= radius * radius + GEOMETRY_EPSILON;
+    }
+    case "capsule":
+      return distancePointToSegment2D(local[0], local[1], leaf.start[0], leaf.start[1], leaf.end[0], leaf.end[1]).separation <= leaf.radius + GEOMETRY_EPSILON;
+    case "segment":
+      return distancePointToSegment2D(local[0], local[1], leaf.start[0], leaf.start[1], leaf.end[0], leaf.end[1]).separation <= GEOMETRY_EPSILON;
+    case "polygon": {
+      for (let index = 0; index < leaf.vertices.length / 2; index += 1) {
+        const next = (index + 1) % (leaf.vertices.length / 2);
+        const ax = leaf.vertices[index * 2];
+        const ay = leaf.vertices[index * 2 + 1];
+        const bx = leaf.vertices[next * 2];
+        const by = leaf.vertices[next * 2 + 1];
+        if ((bx - ax) * (local[1] - ay) - (by - ay) * (local[0] - ax) < -GEOMETRY_EPSILON) return false;
+      }
+      return true;
+    }
+  }
+}
+function inversePoint(x, y, pose) {
+  const dx = x - pose.x;
+  const dy = y - pose.y;
+  const cosine = Math.cos(pose.rotationRadians);
+  const sine = Math.sin(pose.rotationRadians);
+  return [cosine * dx + sine * dy, -sine * dx + cosine * dy];
+}
+function roundSpine(leaf, pose) {
+  const output = new Float64Array(4);
+  switch (leaf.kind) {
+    case "circle":
+      transformPointInto(output, 0, leaf.center[0], leaf.center[1], pose);
+      return {
+        startX: output[0],
+        startY: output[1],
+        endX: output[0],
+        endY: output[1],
+        radius: leaf.radius
+      };
+    case "capsule":
+      transformPointInto(output, 0, leaf.start[0], leaf.start[1], pose);
+      transformPointInto(output, 2, leaf.end[0], leaf.end[1], pose);
+      return {
+        startX: output[0],
+        startY: output[1],
+        endX: output[2],
+        endY: output[3],
+        radius: leaf.radius
+      };
+    case "segment":
+      transformPointInto(output, 0, leaf.start[0], leaf.start[1], pose);
+      transformPointInto(output, 2, leaf.end[0], leaf.end[1], pose);
+      return {
+        startX: output[0],
+        startY: output[1],
+        endX: output[2],
+        endY: output[3],
+        radius: 0
+      };
+    default:
+      return null;
+  }
+}
+function comparePairCandidates(first, second, firstShapeOrder, secondShapeOrder) {
+  const separationDifference = first.distance.separation - second.distance.separation;
+  if (Math.abs(separationDifference) > GEOMETRY_EPSILON) return separationDifference;
+  const firstKey = canonicalLeafKey(first.distance, firstShapeOrder, secondShapeOrder);
+  const secondKey = canonicalLeafKey(second.distance, firstShapeOrder, secondShapeOrder);
+  return firstKey[0] - secondKey[0] || firstKey[1] - secondKey[1] || first.distance.firstFeature - second.distance.firstFeature || first.distance.secondFeature - second.distance.secondFeature;
+}
+function canonicalLeafKey(distance, firstShapeOrder, secondShapeOrder) {
+  return firstShapeOrder <= secondShapeOrder ? [distance.firstLeaf, distance.secondLeaf] : [distance.secondLeaf, distance.firstLeaf];
+}
+function publicDistance(distance) {
+  return Object.freeze({
+    separation: cleanZero(distance.separation),
+    pointOnFirst: freezeVector(distance.firstX, distance.firstY),
+    pointOnSecond: freezeVector(distance.secondX, distance.secondY),
+    normal: freezeVector(distance.normalX, distance.normalY)
+  });
+}
+function freezeVector(x, y) {
+  return Object.freeze([cleanZero(x), cleanZero(y)]);
+}
+function cleanZero(value) {
+  return Object.is(value, -0) || Math.abs(value) <= Number.EPSILON ? 0 : value;
+}
+export {
+  contactBetweenPreparedShapes2D,
+  containsPointInShape2D,
+  distanceBetweenPreparedShapes2D,
+  manifoldBetweenShapeRecords2D,
+  overlapPreparedShapes2D
+};
+//# sourceMappingURL=pairs.js.map

package/dist/features/physics/lib/2d/collision/pairs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/collision/pairs.ts"],
+  "sourcesContent": ["import type {\n  PibblPhysicsDistance2D,\n  PibblPhysicsPose2D,\n  PibblPhysicsShape2D,\n  PibblPhysicsShapeContact2D,\n  PibblPhysicsVector2,\n} from '../../../2d-geometry.js';\nimport { copyFiniteVector2 } from '../../shared/validation.js';\nimport { composePose2D, copyPose2D, transformPointInto, type InternalPose2D } from '../math.js';\nimport { GEOMETRY_EPSILON } from '../numeric-policy.js';\nimport { requireShapeRecord2D, type ConvexLeaf2D, type ShapeRecord2D } from '../shape-records.js';\nimport { distanceCapsuleToCapsule2D, distancePointToSegment2D } from './analytic.js';\nimport { epaConvexLeaves2D } from './epa.js';\nimport { gjkConvexLeaves2D } from './gjk.js';\nimport {\n  createPrivateManifold2D,\n  publicContactFromManifold2D,\n  type PrivateManifold2D,\n  type PrivatePairDistance2D,\n} from './manifold.js';\nimport { centerOfLeaf2D } from './support.js';\n\ninterface PreparedShape2D {\n  readonly record: ShapeRecord2D;\n  readonly pose: InternalPose2D;\n  readonly order: number;\n}\n\ninterface FailedPair2D {\n  readonly status: 'failed';\n}\n\ninterface SuccessfulPair2D {\n  readonly status: 'success';\n  readonly distance: PrivatePairDistance2D;\n  readonly first: ConvexLeaf2D;\n  readonly firstPose: InternalPose2D;\n  readonly second: ConvexLeaf2D;\n  readonly secondPose: InternalPose2D;\n}\n\ntype PairResult2D = FailedPair2D | SuccessfulPair2D;\n\nconst shapeOrders = new WeakMap<object, number>();\nlet nextShapeOrder = 0;\n\nexport function containsPointInShape2D(\n  shape: PibblPhysicsShape2D,\n  pose: PibblPhysicsPose2D,\n  point: PibblPhysicsVector2,\n): boolean {\n  const prepared = prepareShape(shape, pose, 'shape', 'pose');\n  const copiedPoint = copyFiniteVector2(point, 'point');\n  return prepared.record.leaves.some((leaf) =>\n    containsPointInLeaf(leaf, prepared.pose, copiedPoint[0], copiedPoint[1]),\n  );\n}\n\nexport function distanceBetweenPreparedShapes2D(\n  firstShape: PibblPhysicsShape2D,\n  firstPose: PibblPhysicsPose2D,\n  secondShape: PibblPhysicsShape2D,\n  secondPose: PibblPhysicsPose2D,\n): PibblPhysicsDistance2D {\n  const result = collidePreparedShapes(firstShape, firstPose, secondShape, secondPose);\n  if (result.status === 'failed') {\n    throw new Error('2D collision distance did not converge within its fixed iteration bounds.');\n  }\n  return publicDistance(result.distance);\n}\n\nexport function overlapPreparedShapes2D(\n  firstShape: PibblPhysicsShape2D,\n  firstPose: PibblPhysicsPose2D,\n  secondShape: PibblPhysicsShape2D,\n  secondPose: PibblPhysicsPose2D,\n): boolean {\n  const result = collidePreparedShapes(firstShape, firstPose, secondShape, secondPose);\n  return result.status === 'success' && result.distance.separation <= 0;\n}\n\nexport function contactBetweenPreparedShapes2D(\n  firstShape: PibblPhysicsShape2D,\n  firstPose: PibblPhysicsPose2D,\n  secondShape: PibblPhysicsShape2D,\n  secondPose: PibblPhysicsPose2D,\n): PibblPhysicsShapeContact2D | null {\n  const result = collidePreparedShapes(firstShape, firstPose, secondShape, secondPose);\n  if (result.status === 'failed' || result.distance.separation > 0) {\n    return null;\n  }\n  return publicContactFromManifold2D(\n    createPrivateManifold2D(result.distance, result.first, result.firstPose, result.second, result.secondPose),\n  );\n}\n\n/** Package-private world/cache seam. Not exported from a package entry. */\nexport function manifoldBetweenShapeRecords2D(\n  firstRecord: ShapeRecord2D,\n  firstPose: InternalPose2D,\n  firstOrder: number,\n  secondRecord: ShapeRecord2D,\n  secondPose: InternalPose2D,\n  secondOrder: number,\n): PrivateManifold2D | null {\n  const result = collideShapeRecords(\n    prepareShapeRecord(firstRecord, firstPose, firstOrder),\n    prepareShapeRecord(secondRecord, secondPose, secondOrder),\n  );\n  if (result.status === 'failed' || result.distance.separation > 0) return null;\n  return createPrivateManifold2D(result.distance, result.first, result.firstPose, result.second, result.secondPose);\n}\n\nfunction collidePreparedShapes(\n  firstShape: PibblPhysicsShape2D,\n  firstPublicPose: PibblPhysicsPose2D,\n  secondShape: PibblPhysicsShape2D,\n  secondPublicPose: PibblPhysicsPose2D,\n): PairResult2D {\n  const first = prepareShape(firstShape, firstPublicPose, 'first', 'firstPose');\n  const second = prepareShape(secondShape, secondPublicPose, 'second', 'secondPose');\n  return collideShapeRecords(first, second);\n}\n\nfunction collideShapeRecords(first: PreparedShape2D, second: PreparedShape2D): PairResult2D {\n  let selected: SuccessfulPair2D | null = null;\n  let failures = 0;\n  for (const firstLeaf of first.record.leaves) {\n    for (const secondLeaf of second.record.leaves) {\n      const distance = distanceBetweenLeaves(firstLeaf, first.pose, secondLeaf, second.pose, first, second);\n      if (distance === null) {\n        failures += 1;\n        continue;\n      }\n      const candidate: SuccessfulPair2D = {\n        status: 'success',\n        distance,\n        first: firstLeaf,\n        firstPose: first.pose,\n        second: secondLeaf,\n        secondPose: second.pose,\n      };\n      if (selected === null || comparePairCandidates(candidate, selected, first.order, second.order) < 0) {\n        selected = candidate;\n      }\n    }\n  }\n  if (selected === null || (failures > 0 && selected.distance.separation > GEOMETRY_EPSILON)) {\n    return { status: 'failed' };\n  }\n  return selected;\n}\n\nfunction distanceBetweenLeaves(\n  first: ConvexLeaf2D,\n  firstPose: InternalPose2D,\n  second: ConvexLeaf2D,\n  secondPose: InternalPose2D,\n  firstShape: PreparedShape2D,\n  secondShape: PreparedShape2D,\n): PrivatePairDistance2D | null {\n  const fallback = preferredNormal(first, firstPose, second, secondPose, firstShape, secondShape);\n  const firstRound = roundSpine(first, firstPose);\n  const secondRound = roundSpine(second, secondPose);\n  if (firstRound !== null && secondRound !== null) {\n    const result = distanceCapsuleToCapsule2D(\n      firstRound.startX,\n      firstRound.startY,\n      firstRound.endX,\n      firstRound.endY,\n      firstRound.radius,\n      secondRound.startX,\n      secondRound.startY,\n      secondRound.endX,\n      secondRound.endY,\n      secondRound.radius,\n      fallback[0],\n      fallback[1],\n    );\n    return {\n      ...result,\n      firstFeature: 0,\n      secondFeature: 0,\n      firstLeaf: first.canonicalLeafIndex,\n      secondLeaf: second.canonicalLeafIndex,\n    };\n  }\n\n  const gjk = gjkConvexLeaves2D(first, firstPose, second, secondPose, fallback[0], fallback[1]);\n  if (gjk.status === 'failed') return null;\n  if (gjk.status === 'penetrating') {\n    const epa = epaConvexLeaves2D(first, firstPose, second, secondPose, gjk.simplex);\n    if (epa.status === 'failed') return null;\n    return {\n      ...epa,\n      firstLeaf: first.canonicalLeafIndex,\n      secondLeaf: second.canonicalLeafIndex,\n    };\n  }\n  const normalLength = Math.hypot(gjk.normalX, gjk.normalY);\n  return {\n    separation: gjk.separation,\n    firstX: gjk.firstX,\n    firstY: gjk.firstY,\n    secondX: gjk.secondX,\n    secondY: gjk.secondY,\n    normalX: normalLength > GEOMETRY_EPSILON ? gjk.normalX : fallback[0],\n    normalY: normalLength > GEOMETRY_EPSILON ? gjk.normalY : fallback[1],\n    firstFeature: gjk.firstFeature,\n    secondFeature: gjk.secondFeature,\n    firstLeaf: first.canonicalLeafIndex,\n    secondLeaf: second.canonicalLeafIndex,\n  };\n}\n\nfunction prepareShape(\n  shell: PibblPhysicsShape2D,\n  publicPose: PibblPhysicsPose2D,\n  shapePath: string,\n  posePath: string,\n): PreparedShape2D {\n  const record = requireShapeRecord2D(shell);\n  const pose = composePose2D(copyPose2D(publicPose, posePath), record.localPose);\n  return { record, pose, order: shapeOrder(shell, shapePath) };\n}\n\nfunction prepareShapeRecord(record: ShapeRecord2D, outerPose: InternalPose2D, order: number): PreparedShape2D {\n  return {\n    record,\n    pose: composePose2D(outerPose, record.localPose),\n    order,\n  };\n}\n\nfunction shapeOrder(shape: PibblPhysicsShape2D, _path: string): number {\n  const object = shape as object;\n  const existing = shapeOrders.get(object);\n  if (existing !== undefined) return existing;\n  const order = nextShapeOrder;\n  nextShapeOrder += 1;\n  shapeOrders.set(object, order);\n  return order;\n}\n\nfunction preferredNormal(\n  first: ConvexLeaf2D,\n  firstPose: InternalPose2D,\n  second: ConvexLeaf2D,\n  secondPose: InternalPose2D,\n  firstShape: PreparedShape2D,\n  secondShape: PreparedShape2D,\n): readonly [number, number] {\n  const centers = new Float64Array(4);\n  centerOfLeaf2D(centers, 0, first, firstPose);\n  centerOfLeaf2D(centers, 2, second, secondPose);\n  const dx = centers[0]! - centers[2]!;\n  const dy = centers[1]! - centers[3]!;\n  const length = Math.hypot(dx, dy);\n  if (length > GEOMETRY_EPSILON) return [dx / length, dy / length];\n  return firstShape.order <= secondShape.order ? [1, 0] : [-1, 0];\n}\n\nfunction containsPointInLeaf(leaf: ConvexLeaf2D, pose: InternalPose2D, pointX: number, pointY: number): boolean {\n  const local = inversePoint(pointX, pointY, pose);\n  switch (leaf.kind) {\n    case 'circle':\n      return Math.hypot(local[0] - leaf.center[0]!, local[1] - leaf.center[1]!) <= leaf.radius + GEOMETRY_EPSILON;\n    case 'ellipse': {\n      const dx = local[0] - leaf.center[0]!;\n      const dy = local[1] - leaf.center[1]!;\n      const cosine = Math.cos(leaf.rotationRadians);\n      const sine = Math.sin(leaf.rotationRadians);\n      const x = cosine * dx + sine * dy;\n      const y = -sine * dx + cosine * dy;\n      return (x / leaf.radiusX) ** 2 + (y / leaf.radiusY) ** 2 <= 1 + GEOMETRY_EPSILON;\n    }\n    case 'box':\n      return (\n        Math.abs(local[0] - leaf.center[0]!) <= leaf.halfWidth + GEOMETRY_EPSILON &&\n        Math.abs(local[1] - leaf.center[1]!) <= leaf.halfHeight + GEOMETRY_EPSILON\n      );\n    case 'rounded-box': {\n      const dx = local[0] - leaf.center[0]!;\n      const dy = local[1] - leaf.center[1]!;\n      if (Math.abs(dx) > leaf.halfWidth + GEOMETRY_EPSILON || Math.abs(dy) > leaf.halfHeight + GEOMETRY_EPSILON)\n        return false;\n      const feature = dy < 0 ? (dx < 0 ? 0 : 1) : dx < 0 ? 3 : 2;\n      const radius = leaf.radii[feature]!;\n      const cornerDx = Math.max(0, Math.abs(dx) - (leaf.halfWidth - radius));\n      const cornerDy = Math.max(0, Math.abs(dy) - (leaf.halfHeight - radius));\n      return cornerDx * cornerDx + cornerDy * cornerDy <= radius * radius + GEOMETRY_EPSILON;\n    }\n    case 'capsule':\n      return (\n        distancePointToSegment2D(local[0], local[1], leaf.start[0]!, leaf.start[1]!, leaf.end[0]!, leaf.end[1]!)\n          .separation <=\n        leaf.radius + GEOMETRY_EPSILON\n      );\n    case 'segment':\n      return (\n        distancePointToSegment2D(local[0], local[1], leaf.start[0]!, leaf.start[1]!, leaf.end[0]!, leaf.end[1]!)\n          .separation <= GEOMETRY_EPSILON\n      );\n    case 'polygon': {\n      for (let index = 0; index < leaf.vertices.length / 2; index += 1) {\n        const next = (index + 1) % (leaf.vertices.length / 2);\n        const ax = leaf.vertices[index * 2]!;\n        const ay = leaf.vertices[index * 2 + 1]!;\n        const bx = leaf.vertices[next * 2]!;\n        const by = leaf.vertices[next * 2 + 1]!;\n        if ((bx - ax) * (local[1] - ay) - (by - ay) * (local[0] - ax) < -GEOMETRY_EPSILON) return false;\n      }\n      return true;\n    }\n  }\n}\n\nfunction inversePoint(x: number, y: number, pose: InternalPose2D): readonly [number, number] {\n  const dx = x - pose.x;\n  const dy = y - pose.y;\n  const cosine = Math.cos(pose.rotationRadians);\n  const sine = Math.sin(pose.rotationRadians);\n  return [cosine * dx + sine * dy, -sine * dx + cosine * dy];\n}\n\nfunction roundSpine(\n  leaf: ConvexLeaf2D,\n  pose: InternalPose2D,\n): Readonly<{\n  startX: number;\n  startY: number;\n  endX: number;\n  endY: number;\n  radius: number;\n}> | null {\n  const output = new Float64Array(4);\n  switch (leaf.kind) {\n    case 'circle':\n      transformPointInto(output, 0, leaf.center[0]!, leaf.center[1]!, pose);\n      return {\n        startX: output[0]!,\n        startY: output[1]!,\n        endX: output[0]!,\n        endY: output[1]!,\n        radius: leaf.radius,\n      };\n    case 'capsule':\n      transformPointInto(output, 0, leaf.start[0]!, leaf.start[1]!, pose);\n      transformPointInto(output, 2, leaf.end[0]!, leaf.end[1]!, pose);\n      return {\n        startX: output[0]!,\n        startY: output[1]!,\n        endX: output[2]!,\n        endY: output[3]!,\n        radius: leaf.radius,\n      };\n    case 'segment':\n      transformPointInto(output, 0, leaf.start[0]!, leaf.start[1]!, pose);\n      transformPointInto(output, 2, leaf.end[0]!, leaf.end[1]!, pose);\n      return {\n        startX: output[0]!,\n        startY: output[1]!,\n        endX: output[2]!,\n        endY: output[3]!,\n        radius: 0,\n      };\n    default:\n      return null;\n  }\n}\n\nfunction comparePairCandidates(\n  first: SuccessfulPair2D,\n  second: SuccessfulPair2D,\n  firstShapeOrder: number,\n  secondShapeOrder: number,\n): number {\n  const separationDifference = first.distance.separation - second.distance.separation;\n  if (Math.abs(separationDifference) > GEOMETRY_EPSILON) return separationDifference;\n  const firstKey = canonicalLeafKey(first.distance, firstShapeOrder, secondShapeOrder);\n  const secondKey = canonicalLeafKey(second.distance, firstShapeOrder, secondShapeOrder);\n  return (\n    firstKey[0] - secondKey[0] ||\n    firstKey[1] - secondKey[1] ||\n    first.distance.firstFeature - second.distance.firstFeature ||\n    first.distance.secondFeature - second.distance.secondFeature\n  );\n}\n\nfunction canonicalLeafKey(\n  distance: PrivatePairDistance2D,\n  firstShapeOrder: number,\n  secondShapeOrder: number,\n): readonly [number, number] {\n  return firstShapeOrder <= secondShapeOrder\n    ? [distance.firstLeaf, distance.secondLeaf]\n    : [distance.secondLeaf, distance.firstLeaf];\n}\n\nfunction publicDistance(distance: PrivatePairDistance2D): PibblPhysicsDistance2D {\n  return Object.freeze({\n    separation: cleanZero(distance.separation),\n    pointOnFirst: freezeVector(distance.firstX, distance.firstY),\n    pointOnSecond: freezeVector(distance.secondX, distance.secondY),\n    normal: freezeVector(distance.normalX, distance.normalY),\n  });\n}\n\nfunction freezeVector(x: number, y: number): readonly [number, number] {\n  return Object.freeze([cleanZero(x), cleanZero(y)] as const);\n}\n\nfunction cleanZero(value: number): number {\n  return Object.is(value, -0) || Math.abs(value) <= Number.EPSILON ? 0 : value;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/physics/lib/2d/collision/support.d.ts

@@ -0,0 +1,20 @@
+import { type InternalPose2D } from '../math.js';
+import type { ConvexLeaf2D } from '../shape-records.js';
+export interface SupportPoint2D {
+    readonly x: number;
+    readonly y: number;
+    readonly feature: number;
+}
+export interface MinkowskiVertex2D {
+    readonly x: number;
+    readonly y: number;
+    readonly firstX: number;
+    readonly firstY: number;
+    readonly secondX: number;
+    readonly secondY: number;
+    readonly firstFeature: number;
+    readonly secondFeature: number;
+}
+export declare function supportMinkowski2D(first: ConvexLeaf2D, firstPose: InternalPose2D, second: ConvexLeaf2D, secondPose: InternalPose2D, directionX: number, directionY: number): MinkowskiVertex2D;
+export declare function supportLeaf2D(output: Float64Array, outputOffset: number, leaf: ConvexLeaf2D, pose: InternalPose2D, directionX: number, directionY: number): number;
+export declare function centerOfLeaf2D(output: Float64Array, outputOffset: number, leaf: ConvexLeaf2D, pose: InternalPose2D): void;