@pibbl/core 0.0.1

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/collision/casts.ts"],
+  "sourcesContent": ["import type {\n  PibblPhysicsDistance2D,\n  PibblPhysicsPose2D,\n  PibblPhysicsRay2D,\n  PibblPhysicsShape2D,\n  PibblPhysicsShapeHit2D,\n  PibblPhysicsVector2,\n} from '../../../2d-geometry.js';\nimport {\n  copyFiniteVector2,\n  requireNonnegativeNumber,\n} from '../../shared/validation.js';\nimport {\n  IDENTITY_POSE_2D,\n  composePose2D,\n  copyPose2D,\n  transformPointInto,\n  type InternalPose2D,\n} from '../math.js';\nimport { GEOMETRY_EPSILON } from '../numeric-policy.js';\nimport {\n  createShape2D,\n  requireShapeRecord2D,\n  type CircleLeaf2D,\n  type ConvexLeaf2D,\n  type ShapeRecord2D,\n} from '../shape-records.js';\nimport { distancePointToSegment2D } from './analytic.js';\nimport {\n  containsPointInShape2D,\n  distanceBetweenPreparedShapes2D,\n} from './pairs.js';\n\nconst CAST_MAX_ITERATIONS = 32;\nconst CAST_REFINEMENT_ITERATIONS = 64;\nconst CAST_HIT_TOLERANCE = 1e-7;\nconst CAST_TIME_TOLERANCE = 1e-12;\n\ninterface CastCandidate2D {\n  readonly leafKey: readonly [number, number];\n  readonly pointX: number;\n  readonly pointY: number;\n  readonly normalX: number;\n  readonly normalY: number;\n  readonly distance: number;\n  readonly timeOfImpact: number;\n}\n\ninterface PreparedCastShape2D {\n  readonly record: ShapeRecord2D;\n  readonly pose: InternalPose2D;\n}\n\n/**\n * Casts a ray against one posed shape and returns its first hit or null.\n *\n * @param shape - Shape to intersect. See {@link PibblPhysicsShape2D}.\n * @param publicPose - Target shape pose. See {@link PibblPhysicsPose2D}.\n * @param ray - Ray origin, direction, and travel limit. See {@link PibblPhysicsRay2D}.\n * @param options - Whether initial overlap counts as a hit.\n * @returns The first shape hit, or null when there is no hit. See {@link PibblPhysicsShapeHit2D}.\n *\n * @see {@link PibblPhysicsShape2D}\n * @see {@link PibblPhysicsPose2D}\n * @see {@link PibblPhysicsRay2D}\n * @see {@link PibblPhysicsShapeHit2D}\n */\nexport function raycastShape2D(\n  shape: PibblPhysicsShape2D,\n  publicPose: PibblPhysicsPose2D,\n  ray: PibblPhysicsRay2D,\n  options?: Readonly<{ includeInitialOverlap?: boolean }>,\n): PibblPhysicsShapeHit2D | null {\n  const prepared = prepareShape(shape, publicPose, 'pose');\n  const origin = copyFiniteVector2(ray.origin, 'ray.origin');\n  const sourceDirection = copyFiniteVector2(ray.direction, 'ray.direction');\n  const directionScale = Math.max(\n    Math.abs(sourceDirection[0]),\n    Math.abs(sourceDirection[1]),\n  );\n  if (directionScale === 0) {\n    throw new RangeError('ray.direction must be non-zero.');\n  }\n  const maxDistance = requireNonnegativeNumber(ray.maxDistance, 'ray.maxDistance');\n  const scaledDirectionX = sourceDirection[0] / directionScale;\n  const scaledDirectionY = sourceDirection[1] / directionScale;\n  const scaledDirectionLength = Math.hypot(scaledDirectionX, scaledDirectionY);\n  const directionX = scaledDirectionX / scaledDirectionLength;\n  const directionY = scaledDirectionY / scaledDirectionLength;\n  let selected: CastCandidate2D | null = null;\n\n  for (const leaf of prepared.record.leaves) {\n    const leafShape = shapeForLeaf(leaf);\n    const initiallyOverlapping = containsPointInShape2D(\n      leafShape,\n      internalPoseAsPublic(prepared.pose),\n      origin,\n    );\n    let candidate: CastCandidate2D | null;\n    if (initiallyOverlapping) {\n      candidate = options?.includeInitialOverlap === true\n        ? {\n            leafKey: [0, leaf.canonicalLeafIndex],\n            pointX: origin[0],\n            pointY: origin[1],\n            normalX: -directionX,\n            normalY: -directionY,\n            distance: 0,\n            timeOfImpact: 0,\n          }\n        : null;\n    } else if (maxDistance === 0) {\n      candidate = null;\n    } else {\n      candidate = raycastLeaf(\n        leaf,\n        leafShape,\n        prepared.pose,\n        origin[0],\n        origin[1],\n        directionX,\n        directionY,\n        maxDistance,\n      );\n    }\n    if (candidate !== null && isEarlierCandidate(candidate, selected)) {\n      selected = candidate;\n    }\n  }\n\n  return selected === null ? null : publicHit(selected);\n}\n\n/**\n * Sweeps a posed shape along a translation against another posed shape and returns a hit or null.\n *\n * @param moving - Shape to sweep. See {@link PibblPhysicsShape2D}.\n * @param publicFrom - Initial pose of the moving shape. See {@link PibblPhysicsPose2D}.\n * @param publicTranslation - Translation vector for the sweep. See {@link PibblPhysicsVector2}.\n * @param target - Stationary shape to test against. See {@link PibblPhysicsShape2D}.\n * @param publicTargetPose - Pose of the stationary shape. See {@link PibblPhysicsPose2D}.\n * @param options - Whether initial overlap counts as a hit.\n * @returns The first sweep hit, or null when there is no hit. See {@link PibblPhysicsShapeHit2D}.\n *\n * @see {@link PibblPhysicsShape2D}\n * @see {@link PibblPhysicsPose2D}\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShapeHit2D}\n */\nexport function shapeCastAgainstShape2D(\n  moving: PibblPhysicsShape2D,\n  publicFrom: PibblPhysicsPose2D,\n  publicTranslation: PibblPhysicsVector2,\n  target: PibblPhysicsShape2D,\n  publicTargetPose: PibblPhysicsPose2D,\n  options?: Readonly<{ includeInitialOverlap?: boolean }>,\n): PibblPhysicsShapeHit2D | null {\n  const preparedMoving = prepareShape(moving, publicFrom, 'from');\n  const translation = copyFiniteVector2(publicTranslation, 'translation');\n  const preparedTarget = prepareShape(target, publicTargetPose, 'targetPose');\n  const translationLength = Math.hypot(translation[0], translation[1]);\n  if (!Number.isFinite(translationLength)) {\n    throw new RangeError('translation magnitude must be finite.');\n  }\n  let selected: CastCandidate2D | null = null;\n\n  for (const movingLeaf of preparedMoving.record.leaves) {\n    const movingLeafShape = shapeForLeaf(movingLeaf);\n    for (const targetLeaf of preparedTarget.record.leaves) {\n      const targetLeafShape = shapeForLeaf(targetLeaf);\n      const leafKey = pairLeafKey(movingLeaf, targetLeaf);\n      const candidate = movingLeaf.kind === 'circle' && targetLeaf.kind === 'circle'\n        ? castCircleAgainstCircle(\n            movingLeaf,\n            preparedMoving.pose,\n            translation[0],\n            translation[1],\n            translationLength,\n            targetLeaf,\n            preparedTarget.pose,\n            leafKey,\n            options?.includeInitialOverlap === true,\n          )\n        : conservativelyCastLeafPair(\n            movingLeafShape,\n            preparedMoving.pose,\n            translation[0],\n            translation[1],\n            translationLength,\n            targetLeafShape,\n            preparedTarget.pose,\n            leafKey,\n            options?.includeInitialOverlap === true,\n          );\n      if (candidate !== null && isEarlierCandidate(candidate, selected)) {\n        selected = candidate;\n      }\n    }\n  }\n\n  return selected === null ? null : publicHit(selected);\n}\n\nfunction raycastLeaf(\n  leaf: ConvexLeaf2D,\n  leafShape: PibblPhysicsShape2D,\n  pose: InternalPose2D,\n  originX: number,\n  originY: number,\n  directionX: number,\n  directionY: number,\n  maxDistance: number,\n): CastCandidate2D | null {\n  switch (leaf.kind) {\n    case 'circle':\n      return raycastCircle(\n        leaf,\n        pose,\n        originX,\n        originY,\n        directionX,\n        directionY,\n        maxDistance,\n      );\n    case 'capsule':\n      return raycastCapsule(\n        leaf,\n        pose,\n        originX,\n        originY,\n        directionX,\n        directionY,\n        maxDistance,\n      );\n    case 'segment':\n      return raycastSegment(\n        leaf,\n        pose,\n        originX,\n        originY,\n        directionX,\n        directionY,\n        maxDistance,\n      );\n    default: {\n      const pointShape = shapeForPoint();\n      return conservativelyCastLeafPair(\n        pointShape,\n        { x: originX, y: originY, rotationRadians: 0 },\n        directionX * maxDistance,\n        directionY * maxDistance,\n        maxDistance,\n        leafShape,\n        pose,\n        [0, leaf.canonicalLeafIndex],\n        false,\n      );\n    }\n  }\n}\n\nfunction raycastCircle(\n  leaf: CircleLeaf2D,\n  pose: InternalPose2D,\n  originX: number,\n  originY: number,\n  directionX: number,\n  directionY: number,\n  maxDistance: number,\n): CastCandidate2D | null {\n  const center = new Float64Array(2);\n  transformPointInto(center, 0, leaf.center[0]!, leaf.center[1]!, pose);\n  const hit = rayCircleDistance(\n    originX,\n    originY,\n    directionX,\n    directionY,\n    center[0]!,\n    center[1]!,\n    leaf.radius,\n    maxDistance,\n  );\n  if (hit === null) return null;\n  const pointX = originX + directionX * hit;\n  const pointY = originY + directionY * hit;\n  const normal = unitAgainstMotion(\n    pointX - center[0]!,\n    pointY - center[1]!,\n    directionX,\n    directionY,\n  );\n  return {\n    leafKey: [0, leaf.canonicalLeafIndex],\n    pointX,\n    pointY,\n    normalX: normal[0],\n    normalY: normal[1],\n    distance: hit,\n    timeOfImpact: hit / maxDistance,\n  };\n}\n\nfunction raycastCapsule(\n  leaf: Extract<ConvexLeaf2D, { kind: 'capsule' }>,\n  pose: InternalPose2D,\n  originX: number,\n  originY: number,\n  directionX: number,\n  directionY: number,\n  maxDistance: number,\n): CastCandidate2D | null {\n  const endpoints = new Float64Array(4);\n  transformPointInto(endpoints, 0, leaf.start[0]!, leaf.start[1]!, pose);\n  transformPointInto(endpoints, 2, leaf.end[0]!, leaf.end[1]!, pose);\n  const startX = endpoints[0]!;\n  const startY = endpoints[1]!;\n  const endX = endpoints[2]!;\n  const endY = endpoints[3]!;\n  const segmentX = endX - startX;\n  const segmentY = endY - startY;\n  const segmentLength = Math.hypot(segmentX, segmentY);\n  if (segmentLength <= GEOMETRY_EPSILON) {\n    return raycastCircle(\n      { ...leaf, kind: 'circle', center: new Float64Array([leaf.start[0]!, leaf.start[1]!]) },\n      pose,\n      originX,\n      originY,\n      directionX,\n      directionY,\n      maxDistance,\n    );\n  }\n\n  const tangentX = segmentX / segmentLength;\n  const tangentY = segmentY / segmentLength;\n  const sideNormalX = -tangentY;\n  const sideNormalY = tangentX;\n  const relativeX = originX - startX;\n  const relativeY = originY - startY;\n  const alongOrigin = relativeX * tangentX + relativeY * tangentY;\n  const acrossOrigin = relativeX * sideNormalX + relativeY * sideNormalY;\n  const alongDirection = directionX * tangentX + directionY * tangentY;\n  const acrossDirection = directionX * sideNormalX + directionY * sideNormalY;\n  const distances: number[] = [];\n  if (Math.abs(acrossDirection) > GEOMETRY_EPSILON) {\n    for (const side of [-1, 1] as const) {\n      const distance = (side * leaf.radius - acrossOrigin) / acrossDirection;\n      const along = alongOrigin + distance * alongDirection;\n      if (\n        distance >= -CAST_TIME_TOLERANCE &&\n        distance <= maxDistance + CAST_TIME_TOLERANCE &&\n        along >= -CAST_HIT_TOLERANCE &&\n        along <= segmentLength + CAST_HIT_TOLERANCE\n      ) {\n        distances.push(Math.max(0, distance));\n      }\n    }\n  }\n  for (const [centerX, centerY] of [[startX, startY], [endX, endY]] as const) {\n    const distance = rayCircleDistance(\n      originX,\n      originY,\n      directionX,\n      directionY,\n      centerX,\n      centerY,\n      leaf.radius,\n      maxDistance,\n    );\n    if (distance !== null) distances.push(distance);\n  }\n  distances.sort((first, second) => first - second);\n  for (const distance of distances) {\n    const pointX = originX + directionX * distance;\n    const pointY = originY + directionY * distance;\n    const closest = distancePointToSegment2D(\n      pointX,\n      pointY,\n      startX,\n      startY,\n      endX,\n      endY,\n    );\n    if (Math.abs(closest.separation - leaf.radius) > CAST_HIT_TOLERANCE * 8) continue;\n    const normal = unitAgainstMotion(\n      pointX - closest.secondX,\n      pointY - closest.secondY,\n      directionX,\n      directionY,\n    );\n    if (normal[0] * directionX + normal[1] * directionY > CAST_HIT_TOLERANCE) continue;\n    return {\n      leafKey: [0, leaf.canonicalLeafIndex],\n      pointX,\n      pointY,\n      normalX: normal[0],\n      normalY: normal[1],\n      distance,\n      timeOfImpact: distance / maxDistance,\n    };\n  }\n  return null;\n}\n\nfunction raycastSegment(\n  leaf: Extract<ConvexLeaf2D, { kind: 'segment' }>,\n  pose: InternalPose2D,\n  originX: number,\n  originY: number,\n  directionX: number,\n  directionY: number,\n  maxDistance: number,\n): CastCandidate2D | null {\n  const endpoints = new Float64Array(4);\n  transformPointInto(endpoints, 0, leaf.start[0]!, leaf.start[1]!, pose);\n  transformPointInto(endpoints, 2, leaf.end[0]!, leaf.end[1]!, pose);\n  const startX = endpoints[0]!;\n  const startY = endpoints[1]!;\n  const segmentX = endpoints[2]! - startX;\n  const segmentY = endpoints[3]! - startY;\n  const relativeX = startX - originX;\n  const relativeY = startY - originY;\n  const denominator = cross(directionX, directionY, segmentX, segmentY);\n  let distance: number;\n  if (Math.abs(denominator) > GEOMETRY_EPSILON) {\n    distance = cross(relativeX, relativeY, segmentX, segmentY) / denominator;\n    const segmentTime = cross(relativeX, relativeY, directionX, directionY) / denominator;\n    if (\n      distance < -CAST_TIME_TOLERANCE ||\n      distance > maxDistance + CAST_TIME_TOLERANCE ||\n      segmentTime < -CAST_TIME_TOLERANCE ||\n      segmentTime > 1 + CAST_TIME_TOLERANCE\n    ) {\n      return null;\n    }\n  } else {\n    if (Math.abs(cross(relativeX, relativeY, directionX, directionY)) > GEOMETRY_EPSILON) {\n      return null;\n    }\n    const first = relativeX * directionX + relativeY * directionY;\n    const second = first + segmentX * directionX + segmentY * directionY;\n    distance = Math.min(first, second);\n    if (distance < -CAST_TIME_TOLERANCE) distance = Math.max(first, second);\n    if (distance < -CAST_TIME_TOLERANCE || distance > maxDistance + CAST_TIME_TOLERANCE) {\n      return null;\n    }\n  }\n  distance = Math.max(0, Math.min(maxDistance, distance));\n  const pointX = originX + directionX * distance;\n  const pointY = originY + directionY * distance;\n  const normal = segmentNormalAgainstMotion(segmentX, segmentY, directionX, directionY);\n  return {\n    leafKey: [0, leaf.canonicalLeafIndex],\n    pointX,\n    pointY,\n    normalX: normal[0],\n    normalY: normal[1],\n    distance,\n    timeOfImpact: distance / maxDistance,\n  };\n}\n\nfunction castCircleAgainstCircle(\n  moving: CircleLeaf2D,\n  movingPose: InternalPose2D,\n  translationX: number,\n  translationY: number,\n  translationLength: number,\n  target: CircleLeaf2D,\n  targetPose: InternalPose2D,\n  leafKey: readonly [number, number],\n  includeInitialOverlap: boolean,\n): CastCandidate2D | null {\n  const centers = new Float64Array(4);\n  transformPointInto(centers, 0, moving.center[0]!, moving.center[1]!, movingPose);\n  transformPointInto(centers, 2, target.center[0]!, target.center[1]!, targetPose);\n  const relativeX = centers[0]! - centers[2]!;\n  const relativeY = centers[1]! - centers[3]!;\n  const radius = moving.radius + target.radius;\n  if (relativeX * relativeX + relativeY * relativeY <= radius * radius) {\n    if (!includeInitialOverlap) return null;\n    const normal = unitAgainstMotion(relativeX, relativeY, translationX, translationY);\n    return {\n      leafKey,\n      pointX: centers[2]! + normal[0] * target.radius,\n      pointY: centers[3]! + normal[1] * target.radius,\n      normalX: normal[0],\n      normalY: normal[1],\n      distance: 0,\n      timeOfImpact: 0,\n    };\n  }\n  if (translationLength === 0) return null;\n  const a = translationX * translationX + translationY * translationY;\n  const b = 2 * (relativeX * translationX + relativeY * translationY);\n  const c = relativeX * relativeX + relativeY * relativeY - radius * radius;\n  const discriminant = b * b - 4 * a * c;\n  if (discriminant < -GEOMETRY_EPSILON) return null;\n  const time = (-b - Math.sqrt(Math.max(0, discriminant))) / (2 * a);\n  if (time < -CAST_TIME_TOLERANCE || time > 1 + CAST_TIME_TOLERANCE) return null;\n  const timeOfImpact = Math.max(0, Math.min(1, time));\n  const movingX = centers[0]! + translationX * timeOfImpact;\n  const movingY = centers[1]! + translationY * timeOfImpact;\n  const normal = unitAgainstMotion(\n    movingX - centers[2]!,\n    movingY - centers[3]!,\n    translationX,\n    translationY,\n  );\n  return {\n    leafKey,\n    pointX: centers[2]! + normal[0] * target.radius,\n    pointY: centers[3]! + normal[1] * target.radius,\n    normalX: normal[0],\n    normalY: normal[1],\n    distance: translationLength * timeOfImpact,\n    timeOfImpact,\n  };\n}\n\nfunction conservativelyCastLeafPair(\n  moving: PibblPhysicsShape2D,\n  from: InternalPose2D,\n  translationX: number,\n  translationY: number,\n  translationLength: number,\n  target: PibblPhysicsShape2D,\n  targetPose: InternalPose2D,\n  leafKey: readonly [number, number],\n  includeInitialOverlap: boolean,\n): CastCandidate2D | null {\n  let time = 0;\n  for (let iteration = 0; iteration < CAST_MAX_ITERATIONS; iteration += 1) {\n    const movingPose = {\n      x: from.x + translationX * time,\n      y: from.y + translationY * time,\n      rotationRadians: from.rotationRadians,\n    };\n    const distance = samplePairDistance(moving, movingPose, target, targetPose);\n    if (distance === null) return null;\n    if (distance.separation <= (time === 0 ? 0 : CAST_HIT_TOLERANCE)) {\n      if (time === 0 && !includeInitialOverlap) return null;\n      const normal = unitAgainstMotion(\n        distance.normal[0],\n        distance.normal[1],\n        translationX,\n        translationY,\n      );\n      return {\n        leafKey,\n        pointX: distance.pointOnSecond[0],\n        pointY: distance.pointOnSecond[1],\n        normalX: normal[0],\n        normalY: normal[1],\n        distance: translationLength * time,\n        timeOfImpact: time,\n      };\n    }\n    if (translationLength === 0) return null;\n    const closingSpeed = -(\n      distance.normal[0] * translationX +\n      distance.normal[1] * translationY\n    );\n    if (!Number.isFinite(closingSpeed) || closingSpeed <= 0) break;\n    const step = distance.separation / closingSpeed;\n    if (!Number.isFinite(step) || step <= CAST_TIME_TOLERANCE) break;\n    const nextTime = time + step;\n    if (!Number.isFinite(nextTime)) return null;\n    if (nextTime <= time) break;\n    if (nextTime > 1 + CAST_TIME_TOLERANCE) break;\n    time = Math.min(1, nextTime);\n  }\n  return refineBoundedTangent(\n    moving,\n    from,\n    translationX,\n    translationY,\n    translationLength,\n    target,\n    targetPose,\n    leafKey,\n  );\n}\n\nfunction refineBoundedTangent(\n  moving: PibblPhysicsShape2D,\n  from: InternalPose2D,\n  translationX: number,\n  translationY: number,\n  translationLength: number,\n  target: PibblPhysicsShape2D,\n  targetPose: InternalPose2D,\n  leafKey: readonly [number, number],\n): CastCandidate2D | null {\n  let minimumTime = 0;\n  let maximumTime = 1;\n  let tangentTime = 0;\n  let tangent = sampleTranslatedDistance(\n    moving,\n    from,\n    translationX,\n    translationY,\n    tangentTime,\n    target,\n    targetPose,\n  );\n  if (tangent === null) return null;\n  for (let iteration = 0; iteration < CAST_REFINEMENT_ITERATIONS; iteration += 1) {\n    const middleTime = (minimumTime + maximumTime) / 2;\n    const middle = sampleTranslatedDistance(\n      moving,\n      from,\n      translationX,\n      translationY,\n      middleTime,\n      target,\n      targetPose,\n    );\n    if (middle === null) return null;\n    if (middle.separation < tangent.separation) {\n      tangentTime = middleTime;\n      tangent = middle;\n    }\n    const derivative =\n      middle.normal[0] * translationX + middle.normal[1] * translationY;\n    if (!Number.isFinite(derivative)) return null;\n    if (derivative < 0) {\n      minimumTime = middleTime;\n    } else {\n      maximumTime = middleTime;\n    }\n  }\n  if (tangent.separation > CAST_HIT_TOLERANCE) return null;\n\n  let impactTime = tangentTime;\n  if (tangent.separation < 0) {\n    let separatedTime = 0;\n    for (let iteration = 0; iteration < CAST_REFINEMENT_ITERATIONS; iteration += 1) {\n      const middleTime = (separatedTime + impactTime) / 2;\n      const middle = sampleTranslatedDistance(\n        moving,\n        from,\n        translationX,\n        translationY,\n        middleTime,\n        target,\n        targetPose,\n      );\n      if (middle === null) return null;\n      if (middle.separation <= CAST_HIT_TOLERANCE) {\n        impactTime = middleTime;\n        tangent = middle;\n      } else {\n        separatedTime = middleTime;\n      }\n    }\n  }\n  const normal = unitAgainstMotion(\n    tangent.normal[0],\n    tangent.normal[1],\n    translationX,\n    translationY,\n  );\n  return {\n    leafKey,\n    pointX: tangent.pointOnSecond[0],\n    pointY: tangent.pointOnSecond[1],\n    normalX: normal[0],\n    normalY: normal[1],\n    distance: translationLength * impactTime,\n    timeOfImpact: impactTime,\n  };\n}\n\nfunction sampleTranslatedDistance(\n  moving: PibblPhysicsShape2D,\n  from: InternalPose2D,\n  translationX: number,\n  translationY: number,\n  time: number,\n  target: PibblPhysicsShape2D,\n  targetPose: InternalPose2D,\n): PibblPhysicsDistance2D | null {\n  return samplePairDistance(\n    moving,\n    {\n      x: from.x + translationX * time,\n      y: from.y + translationY * time,\n      rotationRadians: from.rotationRadians,\n    },\n    target,\n    targetPose,\n  );\n}\n\nfunction samplePairDistance(\n  moving: PibblPhysicsShape2D,\n  movingPose: InternalPose2D,\n  target: PibblPhysicsShape2D,\n  targetPose: InternalPose2D,\n): PibblPhysicsDistance2D | null {\n  try {\n    const distance = distanceBetweenPreparedShapes2D(\n      moving,\n      internalPoseAsPublic(movingPose),\n      target,\n      internalPoseAsPublic(targetPose),\n    );\n    return isFiniteDistance(distance) ? distance : null;\n  } catch {\n    return null;\n  }\n}\n\nfunction prepareShape(\n  shape: PibblPhysicsShape2D,\n  publicPose: PibblPhysicsPose2D,\n  posePath: string,\n): PreparedCastShape2D {\n  const record = requireShapeRecord2D(shape);\n  const pose = composePose2D(copyPose2D(publicPose, posePath), record.localPose);\n  return { record, pose };\n}\n\nfunction shapeForLeaf(leaf: ConvexLeaf2D): PibblPhysicsShape2D {\n  return createShape2D({\n    leaves: Object.freeze([leaf]),\n    localPose: IDENTITY_POSE_2D,\n    localBounds: new Float64Array(4),\n    area: 0,\n    centroidX: 0,\n    centroidY: 0,\n    unitInertia: 0,\n  });\n}\n\nfunction shapeForPoint(): PibblPhysicsShape2D {\n  return shapeForLeaf(Object.freeze({\n    kind: 'segment',\n    start: new Float64Array(2),\n    end: new Float64Array(2),\n    canonicalLeafIndex: 0,\n  }));\n}\n\nfunction rayCircleDistance(\n  originX: number,\n  originY: number,\n  directionX: number,\n  directionY: number,\n  centerX: number,\n  centerY: number,\n  radius: number,\n  maxDistance: number,\n): number | null {\n  const relativeX = originX - centerX;\n  const relativeY = originY - centerY;\n  const projection = relativeX * directionX + relativeY * directionY;\n  const discriminant = projection * projection -\n    (relativeX * relativeX + relativeY * relativeY - radius * radius);\n  if (discriminant < -GEOMETRY_EPSILON) return null;\n  const distance = -projection - Math.sqrt(Math.max(0, discriminant));\n  if (distance < -CAST_TIME_TOLERANCE || distance > maxDistance + CAST_TIME_TOLERANCE) {\n    return null;\n  }\n  return Math.max(0, Math.min(maxDistance, distance));\n}\n\nfunction unitAgainstMotion(\n  x: number,\n  y: number,\n  motionX: number,\n  motionY: number,\n): readonly [number, number] {\n  const length = Math.hypot(x, y);\n  if (length > GEOMETRY_EPSILON) {\n    const unitX = x / length;\n    const unitY = y / length;\n    return unitX * motionX + unitY * motionY > 0\n      ? [-unitX, -unitY]\n      : [unitX, unitY];\n  }\n  const motionLength = Math.hypot(motionX, motionY);\n  return motionLength > 0\n    ? [-motionX / motionLength, -motionY / motionLength]\n    : [1, 0];\n}\n\nfunction segmentNormalAgainstMotion(\n  segmentX: number,\n  segmentY: number,\n  motionX: number,\n  motionY: number,\n): readonly [number, number] {\n  const length = Math.hypot(segmentX, segmentY);\n  if (length <= GEOMETRY_EPSILON) {\n    return unitAgainstMotion(0, 0, motionX, motionY);\n  }\n  let normalX = -segmentY / length;\n  let normalY = segmentX / length;\n  if (normalX * motionX + normalY * motionY > 0) {\n    normalX = -normalX;\n    normalY = -normalY;\n  }\n  return [normalX, normalY];\n}\n\nfunction internalPoseAsPublic(pose: InternalPose2D): PibblPhysicsPose2D {\n  return {\n    position: [pose.x, pose.y],\n    rotationDegrees: pose.rotationRadians * 180 / Math.PI,\n  };\n}\n\nfunction pairLeafKey(\n  first: ConvexLeaf2D,\n  second: ConvexLeaf2D,\n): readonly [number, number] {\n  return [first.canonicalLeafIndex, second.canonicalLeafIndex];\n}\n\nfunction isEarlierCandidate(\n  candidate: CastCandidate2D,\n  selected: CastCandidate2D | null,\n): boolean {\n  if (selected === null) return true;\n  const timeDifference = candidate.timeOfImpact - selected.timeOfImpact;\n  return Math.abs(timeDifference) > CAST_TIME_TOLERANCE\n    ? timeDifference < 0\n    : candidate.leafKey[0] < selected.leafKey[0] ||\n        (candidate.leafKey[0] === selected.leafKey[0] &&\n          candidate.leafKey[1] < selected.leafKey[1]);\n}\n\nfunction isFiniteDistance(distance: Readonly<{\n  separation: number;\n  pointOnFirst: PibblPhysicsVector2;\n  pointOnSecond: PibblPhysicsVector2;\n  normal: PibblPhysicsVector2;\n}>): boolean {\n  return Number.isFinite(distance.separation) &&\n    Number.isFinite(distance.pointOnFirst[0]) &&\n    Number.isFinite(distance.pointOnFirst[1]) &&\n    Number.isFinite(distance.pointOnSecond[0]) &&\n    Number.isFinite(distance.pointOnSecond[1]) &&\n    Number.isFinite(distance.normal[0]) &&\n    Number.isFinite(distance.normal[1]);\n}\n\nfunction publicHit(candidate: CastCandidate2D): PibblPhysicsShapeHit2D {\n  return Object.freeze({\n    point: freezeVector(candidate.pointX, candidate.pointY),\n    normal: freezeVector(candidate.normalX, candidate.normalY),\n    distance: cleanZero(candidate.distance),\n    timeOfImpact: cleanZero(candidate.timeOfImpact),\n  });\n}\n\nfunction freezeVector(x: number, y: number): PibblPhysicsVector2 {\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\nfunction cross(ax: number, ay: number, bx: number, by: number): number {\n  return ax * by - ay * bx;\n}\n"],
+  "mappings": "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",
+  "names": ["normal"]
+}

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

@@ -0,0 +1,21 @@
+import type { InternalPose2D } from '../math.js';
+import type { ConvexLeaf2D } from '../shape-records.js';
+import { type MinkowskiVertex2D } from './support.js';
+export interface EpaPenetrationResult2D {
+    readonly status: 'penetrating';
+    readonly separation: number;
+    readonly firstX: number;
+    readonly firstY: number;
+    readonly secondX: number;
+    readonly secondY: number;
+    readonly normalX: number;
+    readonly normalY: number;
+    readonly firstFeature: number;
+    readonly secondFeature: number;
+}
+export interface EpaFailureResult2D {
+    readonly status: 'failed';
+    readonly reason: 'iteration-limit' | 'nonfinite' | 'no-progress' | 'invalid-simplex';
+}
+export type EpaResult2D = EpaPenetrationResult2D | EpaFailureResult2D;
+export declare function epaConvexLeaves2D(first: ConvexLeaf2D, firstPose: InternalPose2D, second: ConvexLeaf2D, secondPose: InternalPose2D, simplex: readonly MinkowskiVertex2D[]): EpaResult2D;

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

@@ -0,0 +1,102 @@
+import { GEOMETRY_EPSILON, MAX_EPA_ITERATIONS } from "../numeric-policy.js";
+import { supportMinkowski2D } from "./support.js";
+const EPA_SUPPORT_GAP_TOLERANCE = Math.sqrt(GEOMETRY_EPSILON);
+function epaConvexLeaves2D(first, firstPose, second, secondPose, simplex) {
+  if (simplex.length !== 3) {
+    return { status: "failed", reason: "invalid-simplex" };
+  }
+  const polytope = [...simplex];
+  if (signedArea(polytope) < 0) {
+    polytope.reverse();
+  }
+  if (Math.abs(signedArea(polytope)) <= GEOMETRY_EPSILON) {
+    return { status: "failed", reason: "invalid-simplex" };
+  }
+  for (let iteration = 0; iteration < MAX_EPA_ITERATIONS; iteration += 1) {
+    const edge = closestEdge(polytope);
+    if (edge === null) {
+      return { status: "failed", reason: "nonfinite" };
+    }
+    const support = supportMinkowski2D(
+      first,
+      firstPose,
+      second,
+      secondPose,
+      edge.normalX,
+      edge.normalY
+    );
+    const projection = support.x * edge.normalX + support.y * edge.normalY;
+    if (!Number.isFinite(projection)) {
+      return { status: "failed", reason: "nonfinite" };
+    }
+    const repeated = polytope.some(
+      (vertex) => Math.abs(vertex.x - support.x) <= GEOMETRY_EPSILON && Math.abs(vertex.y - support.y) <= GEOMETRY_EPSILON
+    );
+    if (repeated || projection - edge.distance <= EPA_SUPPORT_GAP_TOLERANCE * Math.max(1, projection)) {
+      return edgeResult(polytope, edge);
+    }
+    if (projection <= edge.distance || polytope.length >= MAX_EPA_ITERATIONS + 3) {
+      return { status: "failed", reason: "no-progress" };
+    }
+    polytope.splice(edge.index + 1, 0, support);
+  }
+  return { status: "failed", reason: "iteration-limit" };
+}
+function closestEdge(polytope) {
+  let selected = null;
+  for (let index = 0; index < polytope.length; index += 1) {
+    const first = polytope[index];
+    const second = polytope[(index + 1) % polytope.length];
+    const edgeX = second.x - first.x;
+    const edgeY = second.y - first.y;
+    const length = Math.hypot(edgeX, edgeY);
+    if (!Number.isFinite(length) || length <= GEOMETRY_EPSILON) continue;
+    let normalX = edgeY / length;
+    let normalY = -edgeX / length;
+    let distance = first.x * normalX + first.y * normalY;
+    if (distance < 0) {
+      normalX = -normalX;
+      normalY = -normalY;
+      distance = -distance;
+    }
+    if (selected === null || distance < selected.distance - GEOMETRY_EPSILON || Math.abs(distance - selected.distance) <= GEOMETRY_EPSILON && index < selected.index) {
+      selected = { index, normalX, normalY, distance };
+    }
+  }
+  return selected;
+}
+function edgeResult(polytope, edge) {
+  const first = polytope[edge.index];
+  const second = polytope[(edge.index + 1) % polytope.length];
+  const dx = second.x - first.x;
+  const dy = second.y - first.y;
+  const denominator = dx * dx + dy * dy;
+  const amount = denominator <= GEOMETRY_EPSILON * GEOMETRY_EPSILON ? 0 : Math.max(0, Math.min(1, -(first.x * dx + first.y * dy) / denominator));
+  const firstFeature = amount <= 0.5 ? first.firstFeature : second.firstFeature;
+  const secondFeature = amount <= 0.5 ? first.secondFeature : second.secondFeature;
+  return {
+    status: "penetrating",
+    separation: -edge.distance,
+    firstX: first.firstX + amount * (second.firstX - first.firstX),
+    firstY: first.firstY + amount * (second.firstY - first.firstY),
+    secondX: first.secondX + amount * (second.secondX - first.secondX),
+    secondY: first.secondY + amount * (second.secondY - first.secondY),
+    normalX: -edge.normalX,
+    normalY: -edge.normalY,
+    firstFeature,
+    secondFeature
+  };
+}
+function signedArea(vertices) {
+  let twiceArea = 0;
+  for (let index = 0; index < vertices.length; index += 1) {
+    const current = vertices[index];
+    const next = vertices[(index + 1) % vertices.length];
+    twiceArea += current.x * next.y - current.y * next.x;
+  }
+  return twiceArea / 2;
+}
+export {
+  epaConvexLeaves2D
+};
+//# sourceMappingURL=epa.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/collision/epa.ts"],
+  "sourcesContent": ["import type { InternalPose2D } from '../math.js';\nimport { GEOMETRY_EPSILON, MAX_EPA_ITERATIONS } from '../numeric-policy.js';\nimport type { ConvexLeaf2D } from '../shape-records.js';\nimport { supportMinkowski2D, type MinkowskiVertex2D } from './support.js';\n\nexport interface EpaPenetrationResult2D {\n  readonly status: 'penetrating';\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}\n\nexport interface EpaFailureResult2D {\n  readonly status: 'failed';\n  readonly reason: 'iteration-limit' | 'nonfinite' | 'no-progress' | 'invalid-simplex';\n}\n\nexport type EpaResult2D = EpaPenetrationResult2D | EpaFailureResult2D;\n\nconst EPA_SUPPORT_GAP_TOLERANCE = Math.sqrt(GEOMETRY_EPSILON);\n\ninterface ClosestEdge2D {\n  readonly index: number;\n  readonly normalX: number;\n  readonly normalY: number;\n  readonly distance: number;\n}\n\nexport function epaConvexLeaves2D(\n  first: ConvexLeaf2D,\n  firstPose: InternalPose2D,\n  second: ConvexLeaf2D,\n  secondPose: InternalPose2D,\n  simplex: readonly MinkowskiVertex2D[],\n): EpaResult2D {\n  if (simplex.length !== 3) {\n    return { status: 'failed', reason: 'invalid-simplex' };\n  }\n  const polytope = [...simplex];\n  if (signedArea(polytope) < 0) {\n    polytope.reverse();\n  }\n  if (Math.abs(signedArea(polytope)) <= GEOMETRY_EPSILON) {\n    return { status: 'failed', reason: 'invalid-simplex' };\n  }\n\n  for (let iteration = 0; iteration < MAX_EPA_ITERATIONS; iteration += 1) {\n    const edge = closestEdge(polytope);\n    if (edge === null) {\n      return { status: 'failed', reason: 'nonfinite' };\n    }\n    const support = supportMinkowski2D(\n      first,\n      firstPose,\n      second,\n      secondPose,\n      edge.normalX,\n      edge.normalY,\n    );\n    const projection = support.x * edge.normalX + support.y * edge.normalY;\n    if (!Number.isFinite(projection)) {\n      return { status: 'failed', reason: 'nonfinite' };\n    }\n    const repeated = polytope.some((vertex) =>\n      Math.abs(vertex.x - support.x) <= GEOMETRY_EPSILON &&\n      Math.abs(vertex.y - support.y) <= GEOMETRY_EPSILON,\n    );\n    if (repeated || projection - edge.distance <= EPA_SUPPORT_GAP_TOLERANCE * Math.max(1, projection)) {\n      return edgeResult(polytope, edge);\n    }\n    if (projection <= edge.distance || polytope.length >= MAX_EPA_ITERATIONS + 3) {\n      return { status: 'failed', reason: 'no-progress' };\n    }\n    polytope.splice(edge.index + 1, 0, support);\n  }\n  return { status: 'failed', reason: 'iteration-limit' };\n}\n\nfunction closestEdge(polytope: readonly MinkowskiVertex2D[]): ClosestEdge2D | null {\n  let selected: ClosestEdge2D | null = null;\n  for (let index = 0; index < polytope.length; index += 1) {\n    const first = polytope[index]!;\n    const second = polytope[(index + 1) % polytope.length]!;\n    const edgeX = second.x - first.x;\n    const edgeY = second.y - first.y;\n    const length = Math.hypot(edgeX, edgeY);\n    if (!Number.isFinite(length) || length <= GEOMETRY_EPSILON) continue;\n    let normalX = edgeY / length;\n    let normalY = -edgeX / length;\n    let distance = first.x * normalX + first.y * normalY;\n    if (distance < 0) {\n      normalX = -normalX;\n      normalY = -normalY;\n      distance = -distance;\n    }\n    if (\n      selected === null ||\n      distance < selected.distance - GEOMETRY_EPSILON ||\n      (Math.abs(distance - selected.distance) <= GEOMETRY_EPSILON && index < selected.index)\n    ) {\n      selected = { index, normalX, normalY, distance };\n    }\n  }\n  return selected;\n}\n\nfunction edgeResult(\n  polytope: readonly MinkowskiVertex2D[],\n  edge: ClosestEdge2D,\n): EpaPenetrationResult2D {\n  const first = polytope[edge.index]!;\n  const second = polytope[(edge.index + 1) % polytope.length]!;\n  const dx = second.x - first.x;\n  const dy = second.y - first.y;\n  const denominator = dx * dx + dy * dy;\n  const amount = denominator <= GEOMETRY_EPSILON * GEOMETRY_EPSILON\n    ? 0\n    : Math.max(0, Math.min(1, -(first.x * dx + first.y * dy) / denominator));\n  const firstFeature = amount <= 0.5 ? first.firstFeature : second.firstFeature;\n  const secondFeature = amount <= 0.5 ? first.secondFeature : second.secondFeature;\n  return {\n    status: 'penetrating',\n    separation: -edge.distance,\n    firstX: first.firstX + amount * (second.firstX - first.firstX),\n    firstY: first.firstY + amount * (second.firstY - first.firstY),\n    secondX: first.secondX + amount * (second.secondX - first.secondX),\n    secondY: first.secondY + amount * (second.secondY - first.secondY),\n    normalX: -edge.normalX,\n    normalY: -edge.normalY,\n    firstFeature,\n    secondFeature,\n  };\n}\n\nfunction signedArea(vertices: readonly MinkowskiVertex2D[]): number {\n  let twiceArea = 0;\n  for (let index = 0; index < vertices.length; index += 1) {\n    const current = vertices[index]!;\n    const next = vertices[(index + 1) % vertices.length]!;\n    twiceArea += current.x * next.y - current.y * next.x;\n  }\n  return twiceArea / 2;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,28 @@
+import type { InternalPose2D } from '../math.js';
+import type { ConvexLeaf2D } from '../shape-records.js';
+import { type MinkowskiVertex2D } from './support.js';
+export interface ConvexDistanceResult2D {
+    readonly status: 'separated';
+    readonly separation: number;
+    readonly firstX: number;
+    readonly firstY: number;
+    readonly secondX: number;
+    readonly secondY: number;
+    readonly normalX: number;
+    readonly normalY: number;
+    readonly firstFeature: number;
+    readonly secondFeature: number;
+}
+export interface ConvexTouchingResult2D extends Omit<ConvexDistanceResult2D, 'status'> {
+    readonly status: 'touching';
+}
+export interface ConvexPenetratingResult2D {
+    readonly status: 'penetrating';
+    readonly simplex: readonly MinkowskiVertex2D[];
+}
+export interface ConvexFailureResult2D {
+    readonly status: 'failed';
+    readonly reason: 'iteration-limit' | 'nonfinite' | 'no-progress';
+}
+export type GjkResult2D = ConvexDistanceResult2D | ConvexTouchingResult2D | ConvexPenetratingResult2D | ConvexFailureResult2D;
+export declare function gjkConvexLeaves2D(first: ConvexLeaf2D, firstPose: InternalPose2D, second: ConvexLeaf2D, secondPose: InternalPose2D, initialDirectionX: number, initialDirectionY: number): GjkResult2D;

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

@@ -0,0 +1,233 @@
+import { GEOMETRY_EPSILON, MAX_GJK_ITERATIONS } from "../numeric-policy.js";
+import { supportMinkowski2D } from "./support.js";
+function gjkConvexLeaves2D(first, firstPose, second, secondPose, initialDirectionX, initialDirectionY) {
+  let directionX = initialDirectionX;
+  let directionY = initialDirectionY;
+  if (Math.hypot(directionX, directionY) <= GEOMETRY_EPSILON) {
+    directionX = 1;
+    directionY = 0;
+  }
+  let reduced = reduceSimplex([
+    supportMinkowski2D(first, firstPose, second, secondPose, directionX, directionY)
+  ]);
+  for (let iteration = 0; iteration < MAX_GJK_ITERATIONS; iteration += 1) {
+    const distanceSquared = reduced.closestX * reduced.closestX + reduced.closestY * reduced.closestY;
+    if (!Number.isFinite(distanceSquared)) {
+      return { status: "failed", reason: "nonfinite" };
+    }
+    if (reduced.containsOrigin) {
+      return { status: "penetrating", simplex: reduced.vertices };
+    }
+    if (distanceSquared <= GEOMETRY_EPSILON * GEOMETRY_EPSILON) {
+      const expanded = expandZeroSimplex(
+        reduced.vertices,
+        first,
+        firstPose,
+        second,
+        secondPose,
+        initialDirectionX,
+        initialDirectionY
+      );
+      if (expanded !== null) {
+        return { status: "penetrating", simplex: expanded };
+      }
+      return distanceResult("touching", reduced);
+    }
+    directionX = -reduced.closestX;
+    directionY = -reduced.closestY;
+    const support = supportMinkowski2D(
+      first,
+      firstPose,
+      second,
+      secondPose,
+      directionX,
+      directionY
+    );
+    if (!finiteVertex(support)) {
+      return { status: "failed", reason: "nonfinite" };
+    }
+    if (reduced.vertices.some((vertex) => sameVertex(vertex, support))) {
+      return distanceResult("separated", reduced);
+    }
+    const supportProjection = support.x * directionX + support.y * directionY;
+    const closestProjection = reduced.closestX * directionX + reduced.closestY * directionY;
+    const progress = supportProjection - closestProjection;
+    if (!Number.isFinite(progress)) {
+      return { status: "failed", reason: "nonfinite" };
+    }
+    if (progress <= GEOMETRY_EPSILON * Math.max(1, Math.hypot(directionX, directionY))) {
+      return distanceResult("separated", reduced);
+    }
+    const next = reduceSimplex([...reduced.vertices, support]);
+    const nextDistanceSquared = next.closestX * next.closestX + next.closestY * next.closestY;
+    if (!next.containsOrigin && nextDistanceSquared >= distanceSquared - GEOMETRY_EPSILON * GEOMETRY_EPSILON && next.vertices.length === reduced.vertices.length) {
+      return distanceResult("separated", next);
+    }
+    reduced = next;
+  }
+  return { status: "failed", reason: "iteration-limit" };
+}
+function expandZeroSimplex(simplex, first, firstPose, second, secondPose, fallbackX, fallbackY) {
+  let axisX = fallbackX;
+  let axisY = fallbackY;
+  if (simplex.length >= 2) {
+    const edgeX = simplex[1].x - simplex[0].x;
+    const edgeY = simplex[1].y - simplex[0].y;
+    axisX = -edgeY;
+    axisY = edgeX;
+  }
+  if (Math.hypot(axisX, axisY) <= GEOMETRY_EPSILON) {
+    axisX = 0;
+    axisY = 1;
+  }
+  const positive = supportMinkowski2D(first, firstPose, second, secondPose, axisX, axisY);
+  const negative = supportMinkowski2D(first, firstPose, second, secondPose, -axisX, -axisY);
+  const candidates = [...simplex, positive, negative];
+  for (let firstIndex = 0; firstIndex < candidates.length - 2; firstIndex += 1) {
+    for (let secondIndex = firstIndex + 1; secondIndex < candidates.length - 1; secondIndex += 1) {
+      for (let thirdIndex = secondIndex + 1; thirdIndex < candidates.length; thirdIndex += 1) {
+        const reduced = reduceTriangle(
+          candidates[firstIndex],
+          candidates[secondIndex],
+          candidates[thirdIndex]
+        );
+        if (reduced.containsOrigin) {
+          return reduced.vertices;
+        }
+      }
+    }
+  }
+  return null;
+}
+function distanceResult(status, reduced) {
+  let firstX = 0;
+  let firstY = 0;
+  let secondX = 0;
+  let secondY = 0;
+  for (let index = 0; index < reduced.vertices.length; index += 1) {
+    const vertex = reduced.vertices[index];
+    const weight = reduced.weights[index];
+    firstX += weight * vertex.firstX;
+    firstY += weight * vertex.firstY;
+    secondX += weight * vertex.secondX;
+    secondY += weight * vertex.secondY;
+  }
+  const dx = firstX - secondX;
+  const dy = firstY - secondY;
+  const separation = Math.hypot(dx, dy);
+  const normalX = separation > GEOMETRY_EPSILON ? dx / separation : 0;
+  const normalY = separation > GEOMETRY_EPSILON ? dy / separation : 0;
+  let featureIndex = 0;
+  for (let index = 1; index < reduced.weights.length; index += 1) {
+    if (reduced.weights[index] > reduced.weights[featureIndex] + GEOMETRY_EPSILON) {
+      featureIndex = index;
+    }
+  }
+  return {
+    status,
+    separation: status === "touching" ? 0 : separation,
+    firstX,
+    firstY,
+    secondX,
+    secondY,
+    normalX,
+    normalY,
+    firstFeature: reduced.vertices[featureIndex].firstFeature,
+    secondFeature: reduced.vertices[featureIndex].secondFeature
+  };
+}
+function reduceSimplex(vertices) {
+  if (vertices.length === 1) {
+    const vertex = vertices[0];
+    return { vertices: [vertex], weights: [1], closestX: vertex.x, closestY: vertex.y, containsOrigin: false };
+  }
+  if (vertices.length === 2) {
+    return reduceSegment(vertices[0], vertices[1]);
+  }
+  return reduceTriangle(vertices.at(-3), vertices.at(-2), vertices.at(-1));
+}
+function reduceSegment(first, second) {
+  const dx = second.x - first.x;
+  const dy = second.y - first.y;
+  const denominator = dx * dx + dy * dy;
+  const amount = denominator <= GEOMETRY_EPSILON * GEOMETRY_EPSILON ? 0 : Math.max(0, Math.min(1, -(first.x * dx + first.y * dy) / denominator));
+  if (amount <= GEOMETRY_EPSILON) {
+    return { vertices: [first], weights: [1], closestX: first.x, closestY: first.y, containsOrigin: false };
+  }
+  if (amount >= 1 - GEOMETRY_EPSILON) {
+    return { vertices: [second], weights: [1], closestX: second.x, closestY: second.y, containsOrigin: false };
+  }
+  return {
+    vertices: [first, second],
+    weights: [1 - amount, amount],
+    closestX: first.x + amount * dx,
+    closestY: first.y + amount * dy,
+    containsOrigin: false
+  };
+}
+function reduceTriangle(first, second, third) {
+  const abX = second.x - first.x;
+  const abY = second.y - first.y;
+  const acX = third.x - first.x;
+  const acY = third.y - first.y;
+  const apX = -first.x;
+  const apY = -first.y;
+  const d1 = abX * apX + abY * apY;
+  const d2 = acX * apX + acY * apY;
+  if (d1 <= 0 && d2 <= 0) return vertexResult(first);
+  const bpX = -second.x;
+  const bpY = -second.y;
+  const d3 = abX * bpX + abY * bpY;
+  const d4 = acX * bpX + acY * bpY;
+  if (d3 >= 0 && d4 <= d3) return vertexResult(second);
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) return segmentResult(first, second, d1 / (d1 - d3));
+  const cpX = -third.x;
+  const cpY = -third.y;
+  const d5 = abX * cpX + abY * cpY;
+  const d6 = acX * cpX + acY * cpY;
+  if (d6 >= 0 && d5 <= d6) return vertexResult(third);
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) return segmentResult(first, third, d2 / (d2 - d6));
+  const va = d3 * d6 - d5 * d4;
+  const d43 = d4 - d3;
+  const d56 = d5 - d6;
+  if (va <= 0 && d43 >= 0 && d56 >= 0) return segmentResult(second, third, d43 / (d43 + d56));
+  const denominator = va + vb + vc;
+  if (!Number.isFinite(denominator) || Math.abs(denominator) <= GEOMETRY_EPSILON) {
+    return reduceSegment(first, second);
+  }
+  const secondWeight = vb / denominator;
+  const thirdWeight = vc / denominator;
+  const firstWeight = 1 - secondWeight - thirdWeight;
+  const strict = firstWeight > GEOMETRY_EPSILON && secondWeight > GEOMETRY_EPSILON && thirdWeight > GEOMETRY_EPSILON;
+  return {
+    vertices: [first, second, third],
+    weights: [firstWeight, secondWeight, thirdWeight],
+    closestX: 0,
+    closestY: 0,
+    containsOrigin: strict
+  };
+}
+function vertexResult(vertex) {
+  return { vertices: [vertex], weights: [1], closestX: vertex.x, closestY: vertex.y, containsOrigin: false };
+}
+function segmentResult(first, second, secondWeight) {
+  return {
+    vertices: [first, second],
+    weights: [1 - secondWeight, secondWeight],
+    closestX: first.x + secondWeight * (second.x - first.x),
+    closestY: first.y + secondWeight * (second.y - first.y),
+    containsOrigin: false
+  };
+}
+function finiteVertex(vertex) {
+  return Number.isFinite(vertex.x) && Number.isFinite(vertex.y) && Number.isFinite(vertex.firstX) && Number.isFinite(vertex.firstY) && Number.isFinite(vertex.secondX) && Number.isFinite(vertex.secondY);
+}
+function sameVertex(first, second) {
+  return Math.abs(first.x - second.x) <= GEOMETRY_EPSILON && Math.abs(first.y - second.y) <= GEOMETRY_EPSILON;
+}
+export {
+  gjkConvexLeaves2D
+};
+//# sourceMappingURL=gjk.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/collision/gjk.ts"],
+  "sourcesContent": ["import type { InternalPose2D } from '../math.js';\nimport { GEOMETRY_EPSILON, MAX_GJK_ITERATIONS } from '../numeric-policy.js';\nimport type { ConvexLeaf2D } from '../shape-records.js';\nimport { supportMinkowski2D, type MinkowskiVertex2D } from './support.js';\n\nexport interface ConvexDistanceResult2D {\n  readonly status: 'separated';\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}\n\nexport interface ConvexTouchingResult2D extends Omit<ConvexDistanceResult2D, 'status'> {\n  readonly status: 'touching';\n}\n\nexport interface ConvexPenetratingResult2D {\n  readonly status: 'penetrating';\n  readonly simplex: readonly MinkowskiVertex2D[];\n}\n\nexport interface ConvexFailureResult2D {\n  readonly status: 'failed';\n  readonly reason: 'iteration-limit' | 'nonfinite' | 'no-progress';\n}\n\nexport type GjkResult2D =\n  | ConvexDistanceResult2D\n  | ConvexTouchingResult2D\n  | ConvexPenetratingResult2D\n  | ConvexFailureResult2D;\n\ninterface ReducedSimplex2D {\n  readonly vertices: readonly MinkowskiVertex2D[];\n  readonly weights: readonly number[];\n  readonly closestX: number;\n  readonly closestY: number;\n  readonly containsOrigin: boolean;\n}\n\nexport function gjkConvexLeaves2D(\n  first: ConvexLeaf2D,\n  firstPose: InternalPose2D,\n  second: ConvexLeaf2D,\n  secondPose: InternalPose2D,\n  initialDirectionX: number,\n  initialDirectionY: number,\n): GjkResult2D {\n  let directionX = initialDirectionX;\n  let directionY = initialDirectionY;\n  if (Math.hypot(directionX, directionY) <= GEOMETRY_EPSILON) {\n    directionX = 1;\n    directionY = 0;\n  }\n  let reduced = reduceSimplex([\n    supportMinkowski2D(first, firstPose, second, secondPose, directionX, directionY),\n  ]);\n\n  for (let iteration = 0; iteration < MAX_GJK_ITERATIONS; iteration += 1) {\n    const distanceSquared = reduced.closestX * reduced.closestX + reduced.closestY * reduced.closestY;\n    if (!Number.isFinite(distanceSquared)) {\n      return { status: 'failed', reason: 'nonfinite' };\n    }\n    if (reduced.containsOrigin) {\n      return { status: 'penetrating', simplex: reduced.vertices };\n    }\n    if (distanceSquared <= GEOMETRY_EPSILON * GEOMETRY_EPSILON) {\n      const expanded = expandZeroSimplex(\n        reduced.vertices,\n        first,\n        firstPose,\n        second,\n        secondPose,\n        initialDirectionX,\n        initialDirectionY,\n      );\n      if (expanded !== null) {\n        return { status: 'penetrating', simplex: expanded };\n      }\n      return distanceResult('touching', reduced);\n    }\n\n    directionX = -reduced.closestX;\n    directionY = -reduced.closestY;\n    const support = supportMinkowski2D(\n      first,\n      firstPose,\n      second,\n      secondPose,\n      directionX,\n      directionY,\n    );\n    if (!finiteVertex(support)) {\n      return { status: 'failed', reason: 'nonfinite' };\n    }\n    if (reduced.vertices.some((vertex) => sameVertex(vertex, support))) {\n      return distanceResult('separated', reduced);\n    }\n    const supportProjection = support.x * directionX + support.y * directionY;\n    const closestProjection = reduced.closestX * directionX + reduced.closestY * directionY;\n    const progress = supportProjection - closestProjection;\n    if (!Number.isFinite(progress)) {\n      return { status: 'failed', reason: 'nonfinite' };\n    }\n    if (progress <= GEOMETRY_EPSILON * Math.max(1, Math.hypot(directionX, directionY))) {\n      return distanceResult('separated', reduced);\n    }\n    const next = reduceSimplex([...reduced.vertices, support]);\n    const nextDistanceSquared = next.closestX * next.closestX + next.closestY * next.closestY;\n    if (\n      !next.containsOrigin &&\n      nextDistanceSquared >= distanceSquared - GEOMETRY_EPSILON * GEOMETRY_EPSILON &&\n      next.vertices.length === reduced.vertices.length\n    ) {\n      return distanceResult('separated', next);\n    }\n    reduced = next;\n  }\n  return { status: 'failed', reason: 'iteration-limit' };\n}\n\nfunction expandZeroSimplex(\n  simplex: readonly MinkowskiVertex2D[],\n  first: ConvexLeaf2D,\n  firstPose: InternalPose2D,\n  second: ConvexLeaf2D,\n  secondPose: InternalPose2D,\n  fallbackX: number,\n  fallbackY: number,\n): readonly MinkowskiVertex2D[] | null {\n  let axisX = fallbackX;\n  let axisY = fallbackY;\n  if (simplex.length >= 2) {\n    const edgeX = simplex[1]!.x - simplex[0]!.x;\n    const edgeY = simplex[1]!.y - simplex[0]!.y;\n    axisX = -edgeY;\n    axisY = edgeX;\n  }\n  if (Math.hypot(axisX, axisY) <= GEOMETRY_EPSILON) {\n    axisX = 0;\n    axisY = 1;\n  }\n  const positive = supportMinkowski2D(first, firstPose, second, secondPose, axisX, axisY);\n  const negative = supportMinkowski2D(first, firstPose, second, secondPose, -axisX, -axisY);\n  const candidates = [...simplex, positive, negative];\n  for (let firstIndex = 0; firstIndex < candidates.length - 2; firstIndex += 1) {\n    for (let secondIndex = firstIndex + 1; secondIndex < candidates.length - 1; secondIndex += 1) {\n      for (let thirdIndex = secondIndex + 1; thirdIndex < candidates.length; thirdIndex += 1) {\n        const reduced = reduceTriangle(\n          candidates[firstIndex]!,\n          candidates[secondIndex]!,\n          candidates[thirdIndex]!,\n        );\n        if (reduced.containsOrigin) {\n          return reduced.vertices;\n        }\n      }\n    }\n  }\n  return null;\n}\n\nfunction distanceResult(\n  status: 'separated' | 'touching',\n  reduced: ReducedSimplex2D,\n): ConvexDistanceResult2D | ConvexTouchingResult2D {\n  let firstX = 0;\n  let firstY = 0;\n  let secondX = 0;\n  let secondY = 0;\n  for (let index = 0; index < reduced.vertices.length; index += 1) {\n    const vertex = reduced.vertices[index]!;\n    const weight = reduced.weights[index]!;\n    firstX += weight * vertex.firstX;\n    firstY += weight * vertex.firstY;\n    secondX += weight * vertex.secondX;\n    secondY += weight * vertex.secondY;\n  }\n  const dx = firstX - secondX;\n  const dy = firstY - secondY;\n  const separation = Math.hypot(dx, dy);\n  const normalX = separation > GEOMETRY_EPSILON ? dx / separation : 0;\n  const normalY = separation > GEOMETRY_EPSILON ? dy / separation : 0;\n  let featureIndex = 0;\n  for (let index = 1; index < reduced.weights.length; index += 1) {\n    if (reduced.weights[index]! > reduced.weights[featureIndex]! + GEOMETRY_EPSILON) {\n      featureIndex = index;\n    }\n  }\n  return {\n    status,\n    separation: status === 'touching' ? 0 : separation,\n    firstX,\n    firstY,\n    secondX,\n    secondY,\n    normalX,\n    normalY,\n    firstFeature: reduced.vertices[featureIndex]!.firstFeature,\n    secondFeature: reduced.vertices[featureIndex]!.secondFeature,\n  };\n}\n\nfunction reduceSimplex(vertices: readonly MinkowskiVertex2D[]): ReducedSimplex2D {\n  if (vertices.length === 1) {\n    const vertex = vertices[0]!;\n    return { vertices: [vertex], weights: [1], closestX: vertex.x, closestY: vertex.y, containsOrigin: false };\n  }\n  if (vertices.length === 2) {\n    return reduceSegment(vertices[0]!, vertices[1]!);\n  }\n  return reduceTriangle(vertices.at(-3)!, vertices.at(-2)!, vertices.at(-1)!);\n}\n\nfunction reduceSegment(first: MinkowskiVertex2D, second: MinkowskiVertex2D): ReducedSimplex2D {\n  const dx = second.x - first.x;\n  const dy = second.y - first.y;\n  const denominator = dx * dx + dy * dy;\n  const amount = denominator <= GEOMETRY_EPSILON * GEOMETRY_EPSILON\n    ? 0\n    : Math.max(0, Math.min(1, -(first.x * dx + first.y * dy) / denominator));\n  if (amount <= GEOMETRY_EPSILON) {\n    return { vertices: [first], weights: [1], closestX: first.x, closestY: first.y, containsOrigin: false };\n  }\n  if (amount >= 1 - GEOMETRY_EPSILON) {\n    return { vertices: [second], weights: [1], closestX: second.x, closestY: second.y, containsOrigin: false };\n  }\n  return {\n    vertices: [first, second],\n    weights: [1 - amount, amount],\n    closestX: first.x + amount * dx,\n    closestY: first.y + amount * dy,\n    containsOrigin: false,\n  };\n}\n\nfunction reduceTriangle(\n  first: MinkowskiVertex2D,\n  second: MinkowskiVertex2D,\n  third: MinkowskiVertex2D,\n): ReducedSimplex2D {\n  const abX = second.x - first.x;\n  const abY = second.y - first.y;\n  const acX = third.x - first.x;\n  const acY = third.y - first.y;\n  const apX = -first.x;\n  const apY = -first.y;\n  const d1 = abX * apX + abY * apY;\n  const d2 = acX * apX + acY * apY;\n  if (d1 <= 0 && d2 <= 0) return vertexResult(first);\n\n  const bpX = -second.x;\n  const bpY = -second.y;\n  const d3 = abX * bpX + abY * bpY;\n  const d4 = acX * bpX + acY * bpY;\n  if (d3 >= 0 && d4 <= d3) return vertexResult(second);\n\n  const vc = d1 * d4 - d3 * d2;\n  if (vc <= 0 && d1 >= 0 && d3 <= 0) return segmentResult(first, second, d1 / (d1 - d3));\n\n  const cpX = -third.x;\n  const cpY = -third.y;\n  const d5 = abX * cpX + abY * cpY;\n  const d6 = acX * cpX + acY * cpY;\n  if (d6 >= 0 && d5 <= d6) return vertexResult(third);\n\n  const vb = d5 * d2 - d1 * d6;\n  if (vb <= 0 && d2 >= 0 && d6 <= 0) return segmentResult(first, third, d2 / (d2 - d6));\n\n  const va = d3 * d6 - d5 * d4;\n  const d43 = d4 - d3;\n  const d56 = d5 - d6;\n  if (va <= 0 && d43 >= 0 && d56 >= 0) return segmentResult(second, third, d43 / (d43 + d56));\n\n  const denominator = va + vb + vc;\n  if (!Number.isFinite(denominator) || Math.abs(denominator) <= GEOMETRY_EPSILON) {\n    return reduceSegment(first, second);\n  }\n  const secondWeight = vb / denominator;\n  const thirdWeight = vc / denominator;\n  const firstWeight = 1 - secondWeight - thirdWeight;\n  const strict = firstWeight > GEOMETRY_EPSILON && secondWeight > GEOMETRY_EPSILON && thirdWeight > GEOMETRY_EPSILON;\n  return {\n    vertices: [first, second, third],\n    weights: [firstWeight, secondWeight, thirdWeight],\n    closestX: 0,\n    closestY: 0,\n    containsOrigin: strict,\n  };\n}\n\nfunction vertexResult(vertex: MinkowskiVertex2D): ReducedSimplex2D {\n  return { vertices: [vertex], weights: [1], closestX: vertex.x, closestY: vertex.y, containsOrigin: false };\n}\n\nfunction segmentResult(\n  first: MinkowskiVertex2D,\n  second: MinkowskiVertex2D,\n  secondWeight: number,\n): ReducedSimplex2D {\n  return {\n    vertices: [first, second],\n    weights: [1 - secondWeight, secondWeight],\n    closestX: first.x + secondWeight * (second.x - first.x),\n    closestY: first.y + secondWeight * (second.y - first.y),\n    containsOrigin: false,\n  };\n}\n\nfunction finiteVertex(vertex: MinkowskiVertex2D): boolean {\n  return Number.isFinite(vertex.x) && Number.isFinite(vertex.y) &&\n    Number.isFinite(vertex.firstX) && Number.isFinite(vertex.firstY) &&\n    Number.isFinite(vertex.secondX) && Number.isFinite(vertex.secondY);\n}\n\nfunction sameVertex(first: MinkowskiVertex2D, second: MinkowskiVertex2D): boolean {\n  return Math.abs(first.x - second.x) <= GEOMETRY_EPSILON &&\n    Math.abs(first.y - second.y) <= GEOMETRY_EPSILON;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,35 @@
+import type { PibblPhysicsShapeContact2D } from "../../../2d-geometry.js";
+import { type InternalPose2D } from "../math.js";
+import type { ConvexLeaf2D } from "../shape-records.js";
+export interface PrivatePairDistance2D {
+    readonly separation: number;
+    readonly firstX: number;
+    readonly firstY: number;
+    readonly secondX: number;
+    readonly secondY: number;
+    readonly normalX: number;
+    readonly normalY: number;
+    readonly firstFeature: number;
+    readonly secondFeature: number;
+    readonly firstLeaf: number;
+    readonly secondLeaf: number;
+}
+interface PrivateManifoldPoint2D {
+    readonly firstX: number;
+    readonly firstY: number;
+    readonly secondX: number;
+    readonly secondY: number;
+    readonly separation: number;
+    readonly firstFeature: number;
+    readonly secondFeature: number;
+}
+export interface PrivateManifold2D {
+    readonly normalX: number;
+    readonly normalY: number;
+    readonly firstLeaf: number;
+    readonly secondLeaf: number;
+    readonly points: readonly PrivateManifoldPoint2D[];
+}
+export declare function createPrivateManifold2D(distance: PrivatePairDistance2D, first: ConvexLeaf2D, firstPose: InternalPose2D, second: ConvexLeaf2D, secondPose: InternalPose2D): PrivateManifold2D;
+export declare function publicContactFromManifold2D(manifold: PrivateManifold2D): PibblPhysicsShapeContact2D;
+export {};