@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/shapes.js

@@ -0,0 +1,543 @@
+import {
+  copyFiniteVector2,
+  requireFiniteNumber,
+  requireNonnegativeNumber,
+  requirePositiveNumber
+} from "../shared/validation.js";
+import {
+  CURVE_FLATTENING_MAX_DEPTH,
+  CURVE_FLATTENING_TOLERANCE,
+  IDENTITY_POSE_2D,
+  canonicalizeContour2D,
+  cleanZero,
+  composePose2D,
+  copyPose2D,
+  freezeBounds2D,
+  polygonMassData2D,
+  transformPointInto,
+  triangulateContour2D
+} from "./math.js";
+import { DEGREES_TO_RADIANS, GEOMETRY_EPSILON } from "./numeric-policy.js";
+import {
+  createShape2D,
+  requireShapeRecord2D
+} from "./shape-records.js";
+const FULL_TURN_RADIANS = Math.PI * 2;
+function circleShape2D(input) {
+  const radius = requirePositiveNumber(input.radius, "circle.radius");
+  const center = ownedVector(input.center ?? [0, 0], "circle.center");
+  const area = Math.PI * radius * radius;
+  return createShapeFromLeaves(
+    [Object.freeze({ kind: "circle", center, radius, canonicalLeafIndex: 0 })],
+    area,
+    center[0],
+    center[1],
+    area * radius * radius / 2
+  );
+}
+function ellipseShape2D(input) {
+  const radiusX = requirePositiveNumber(input.radiusX, "ellipse.radiusX");
+  const radiusY = requirePositiveNumber(input.radiusY, "ellipse.radiusY");
+  const center = ownedVector(input.center ?? [0, 0], "ellipse.center");
+  const rotationRadians = requireFiniteNumber(input.rotationDegrees ?? 0, "ellipse.rotationDegrees") * DEGREES_TO_RADIANS;
+  const area = Math.PI * radiusX * radiusY;
+  return createShapeFromLeaves(
+    [Object.freeze({ kind: "ellipse", center, radiusX, radiusY, rotationRadians, canonicalLeafIndex: 0 })],
+    area,
+    center[0],
+    center[1],
+    area * (radiusX * radiusX + radiusY * radiusY) / 4
+  );
+}
+function boxShape2D(input) {
+  const width = requirePositiveNumber(input.width, "box.width");
+  const height = requirePositiveNumber(input.height, "box.height");
+  const center = ownedVector(input.center ?? [0, 0], "box.center");
+  const area = width * height;
+  return createShapeFromLeaves(
+    [Object.freeze({ kind: "box", center, halfWidth: width / 2, halfHeight: height / 2, canonicalLeafIndex: 0 })],
+    area,
+    center[0],
+    center[1],
+    area * (width * width + height * height) / 12
+  );
+}
+function roundedBoxShape2D(input) {
+  const width = requirePositiveNumber(input.width, "roundedBox.width");
+  const height = requirePositiveNumber(input.height, "roundedBox.height");
+  const center = ownedVector(input.center ?? [0, 0], "roundedBox.center");
+  const sourceRadii = typeof input.radius === "number" ? [input.radius, input.radius, input.radius, input.radius] : input.radius;
+  const radii = new Float64Array(4);
+  const maximum = Math.min(width, height) / 2;
+  for (let index = 0; index < radii.length; index += 1) {
+    const radius = requireNonnegativeNumber(
+      sourceRadii[index],
+      `roundedBox.radius[${index}]`
+    );
+    if (radius > maximum) {
+      throw new RangeError(
+        `roundedBox.radius[${index}] must not exceed ${String(maximum)}; received ${String(radius)}.`
+      );
+    }
+    radii[index] = radius;
+  }
+  const contour = roundedBoxContour(width / 2, height / 2, radii, center);
+  const mass = polygonMassData2D(contour);
+  return createShapeFromLeaves(
+    [Object.freeze({
+      kind: "rounded-box",
+      center,
+      halfWidth: width / 2,
+      halfHeight: height / 2,
+      radii,
+      canonicalLeafIndex: 0
+    })],
+    mass.area,
+    mass.centroidX,
+    mass.centroidY,
+    mass.unitInertia
+  );
+}
+function capsuleShape2D(input) {
+  const start = ownedVector(input.start, "capsule.start");
+  const end = ownedVector(input.end, "capsule.end");
+  const radius = requirePositiveNumber(input.radius, "capsule.radius");
+  const leaf = Object.freeze({
+    kind: "capsule",
+    start,
+    end,
+    radius,
+    canonicalLeafIndex: 0
+  });
+  const mass = capsuleMassData(start, end, radius);
+  return createShapeFromLeaves(
+    [leaf],
+    mass.area,
+    mass.centroidX,
+    mass.centroidY,
+    mass.unitInertia
+  );
+}
+function arcShape2D(input) {
+  const center = ownedVector(input.center ?? [0, 0], "arc.center");
+  const radius = requirePositiveNumber(input.radius, "arc.radius");
+  const startAngle = requireFiniteNumber(input.startAngleRadians, "arc.startAngleRadians");
+  const endAngle = requireFiniteNumber(input.endAngleRadians, "arc.endAngleRadians");
+  const thickness = requirePositiveNumber(input.thickness, "arc.thickness");
+  const points = flattenCircularSweep(
+    center[0],
+    center[1],
+    radius,
+    startAngle,
+    endAngle,
+    input.counterclockwise === true
+  );
+  return chainFromOwnedPoints(points, false, thickness / 2);
+}
+function wedgeShape2D(input) {
+  const center = ownedVector(input.center ?? [0, 0], "wedge.center");
+  const radius = requirePositiveNumber(input.radius, "wedge.radius");
+  const startAngle = requireFiniteNumber(input.startAngleRadians, "wedge.startAngleRadians");
+  const endAngle = requireFiniteNumber(input.endAngleRadians, "wedge.endAngleRadians");
+  const points = flattenCircularSweep(
+    center[0],
+    center[1],
+    radius,
+    startAngle,
+    endAngle,
+    input.counterclockwise === true
+  );
+  const sweep = directedSweep(startAngle, endAngle, input.counterclockwise === true);
+  if (Math.abs(sweep) <= GEOMETRY_EPSILON) {
+    throw new RangeError("wedge angles must describe a nonzero sweep.");
+  }
+  const contourSource = Math.abs(sweep) >= FULL_TURN_RADIANS ? points.slice(0, -1).map(asReadonlyVector) : [asReadonlyVector(center), ...points.map(asReadonlyVector)];
+  const contour = canonicalizeContour2D(contourSource, {
+    strictlyConvex: false,
+    path: "wedge.contour"
+  });
+  const triangles = triangulateContour2D(contour);
+  const leaves = triangles.map(
+    (vertices, canonicalLeafIndex) => Object.freeze({ kind: "polygon", vertices, canonicalLeafIndex })
+  );
+  const mass = aggregateLeafMass(leaves);
+  return createShapeFromLeaves(
+    leaves,
+    mass.area,
+    mass.centroidX,
+    mass.centroidY,
+    mass.unitInertia
+  );
+}
+function segmentShape2D(input) {
+  const start = ownedVector(input.start, "segment.start");
+  const end = ownedVector(input.end, "segment.end");
+  return createShapeFromLeaves(
+    [Object.freeze({ kind: "segment", start, end, canonicalLeafIndex: 0 })],
+    0,
+    (start[0] + end[0]) / 2,
+    (start[1] + end[1]) / 2,
+    0
+  );
+}
+function chainShape2D(input) {
+  if (input.points.length < 2) {
+    throw new RangeError("chain.points must contain at least two points.");
+  }
+  const points = input.points.map(
+    (point, index) => ownedVector(point, `chain.points[${index}]`)
+  );
+  const radius = requireNonnegativeNumber(input.radius ?? 0, "chain.radius");
+  return chainFromOwnedPoints(points, input.closed === true, radius);
+}
+function polygonShape2D(input) {
+  const vertices = canonicalizeContour2D(input.points, {
+    strictlyConvex: true,
+    path: "polygon.points"
+  });
+  const mass = polygonMassData2D(vertices);
+  return createShapeFromLeaves(
+    [Object.freeze({ kind: "polygon", vertices, canonicalLeafIndex: 0 })],
+    mass.area,
+    mass.centroidX,
+    mass.centroidY,
+    mass.unitInertia
+  );
+}
+function boundsOfShape2D(shape, pose) {
+  const record = requireShapeRecord2D(shape);
+  const outerPose = copyPose2D(pose, "pose");
+  return boundsForLeaves(record.leaves, composePose2D(outerPose, record.localPose));
+}
+function massProperties2D(shape, options) {
+  const record = requireShapeRecord2D(shape);
+  const density = requirePositiveNumber(options?.density ?? 1, "options.density");
+  const transformedCentroid = new Float64Array(2);
+  transformPointInto(
+    transformedCentroid,
+    0,
+    record.centroidX,
+    record.centroidY,
+    record.localPose
+  );
+  return Object.freeze({
+    area: cleanZero(record.area),
+    centroid: Object.freeze([
+      cleanZero(transformedCentroid[0]),
+      cleanZero(transformedCentroid[1])
+    ]),
+    mass: cleanZero(record.area * density),
+    rotationalInertia: cleanZero(record.unitInertia * density)
+  });
+}
+function transformShape2D(shape, transform) {
+  const source = requireShapeRecord2D(shape);
+  const localPose = composePose2D(copyPose2D(transform, "transform"), source.localPose);
+  const localBounds = mutableBoundsForLeaves(source.leaves, localPose);
+  return createShape2D({
+    leaves: source.leaves,
+    localPose,
+    localBounds,
+    area: source.area,
+    centroidX: source.centroidX,
+    centroidY: source.centroidY,
+    unitInertia: source.unitInertia
+  });
+}
+function createShapeFromLeaves(leaves, area, centroidX, centroidY, unitInertia) {
+  return createShape2D({
+    leaves,
+    localBounds: mutableBoundsForLeaves(leaves, IDENTITY_POSE_2D),
+    area,
+    centroidX,
+    centroidY,
+    unitInertia: Math.max(0, unitInertia)
+  });
+}
+function chainFromOwnedPoints(points, closed, radius) {
+  const segmentCount = points.length === 1 ? 0 : points.length - 1 + (closed ? 1 : 0);
+  const leaves = [];
+  for (let index = 0; index < segmentCount; index += 1) {
+    const start = points[index];
+    const end = points[(index + 1) % points.length];
+    leaves.push(Object.freeze(radius === 0 ? { kind: "segment", start, end, canonicalLeafIndex: index } : { kind: "capsule", start, end, radius, canonicalLeafIndex: index }));
+  }
+  if (leaves.length === 0) {
+    const point = points[0];
+    const area = Math.PI * radius * radius;
+    leaves.push(Object.freeze({
+      kind: "circle",
+      center: point,
+      radius,
+      canonicalLeafIndex: 0
+    }));
+    return createShapeFromLeaves(
+      leaves,
+      area,
+      point[0],
+      point[1],
+      area * radius * radius / 2
+    );
+  }
+  if (radius > 0) {
+    const mass = aggregateLeafMass(leaves);
+    return createShapeFromLeaves(
+      leaves,
+      mass.area,
+      mass.centroidX,
+      mass.centroidY,
+      mass.unitInertia
+    );
+  }
+  const centroid = lineCentroid(points, closed);
+  return createShapeFromLeaves(leaves, 0, centroid[0], centroid[1], 0);
+}
+function boundsForLeaves(leaves, pose) {
+  const bounds = mutableBoundsForLeaves(leaves, pose);
+  return freezeBounds2D(bounds[0], bounds[1], bounds[2], bounds[3]);
+}
+function mutableBoundsForLeaves(leaves, pose) {
+  const result = new Float64Array([
+    Number.POSITIVE_INFINITY,
+    Number.POSITIVE_INFINITY,
+    Number.NEGATIVE_INFINITY,
+    Number.NEGATIVE_INFINITY
+  ]);
+  const point = new Float64Array(2);
+  const include = (x, y, radius = 0) => {
+    transformPointInto(point, 0, x, y, pose);
+    result[0] = Math.min(result[0], point[0] - radius);
+    result[1] = Math.min(result[1], point[1] - radius);
+    result[2] = Math.max(result[2], point[0] + radius);
+    result[3] = Math.max(result[3], point[1] + radius);
+  };
+  for (const leaf of leaves) {
+    switch (leaf.kind) {
+      case "circle":
+        include(leaf.center[0], leaf.center[1], leaf.radius);
+        break;
+      case "ellipse": {
+        transformPointInto(point, 0, leaf.center[0], leaf.center[1], pose);
+        const angle = pose.rotationRadians + leaf.rotationRadians;
+        const cosine = Math.cos(angle);
+        const sine = Math.sin(angle);
+        const extentX = Math.hypot(leaf.radiusX * cosine, leaf.radiusY * sine);
+        const extentY = Math.hypot(leaf.radiusX * sine, leaf.radiusY * cosine);
+        result[0] = Math.min(result[0], point[0] - extentX);
+        result[1] = Math.min(result[1], point[1] - extentY);
+        result[2] = Math.max(result[2], point[0] + extentX);
+        result[3] = Math.max(result[3], point[1] + extentY);
+        break;
+      }
+      case "box":
+        includeBoxCorners(leaf.center, leaf.halfWidth, leaf.halfHeight, pose, result, point);
+        break;
+      case "rounded-box":
+        includeRoundedBoxBounds(leaf, pose, result, point);
+        break;
+      case "capsule":
+        include(leaf.start[0], leaf.start[1], leaf.radius);
+        include(leaf.end[0], leaf.end[1], leaf.radius);
+        break;
+      case "segment":
+        include(leaf.start[0], leaf.start[1]);
+        include(leaf.end[0], leaf.end[1]);
+        break;
+      case "polygon":
+        for (let offset = 0; offset < leaf.vertices.length; offset += 2) {
+          include(leaf.vertices[offset], leaf.vertices[offset + 1]);
+        }
+        break;
+    }
+  }
+  return result;
+}
+function includeBoxCorners(center, halfWidth, halfHeight, pose, bounds, point) {
+  for (const xSign of [-1, 1]) {
+    for (const ySign of [-1, 1]) {
+      transformPointInto(
+        point,
+        0,
+        center[0] + xSign * halfWidth,
+        center[1] + ySign * halfHeight,
+        pose
+      );
+      bounds[0] = Math.min(bounds[0], point[0]);
+      bounds[1] = Math.min(bounds[1], point[1]);
+      bounds[2] = Math.max(bounds[2], point[0]);
+      bounds[3] = Math.max(bounds[3], point[1]);
+    }
+  }
+}
+function includeRoundedBoxBounds(leaf, pose, bounds, point) {
+  const xSigns = [-1, 1, 1, -1];
+  const ySigns = [-1, -1, 1, 1];
+  for (let index = 0; index < 4; index += 1) {
+    const radius = leaf.radii[index];
+    transformPointInto(
+      point,
+      0,
+      leaf.center[0] + xSigns[index] * (leaf.halfWidth - radius),
+      leaf.center[1] + ySigns[index] * (leaf.halfHeight - radius),
+      pose
+    );
+    bounds[0] = Math.min(bounds[0], point[0] - radius);
+    bounds[1] = Math.min(bounds[1], point[1] - radius);
+    bounds[2] = Math.max(bounds[2], point[0] + radius);
+    bounds[3] = Math.max(bounds[3], point[1] + radius);
+  }
+}
+function aggregateLeafMass(leaves) {
+  const entries = leaves.map(leafMassData);
+  const area = entries.reduce((sum, entry) => sum + entry.area, 0);
+  if (area === 0) {
+    return Object.freeze({ area: 0, centroidX: 0, centroidY: 0, unitInertia: 0 });
+  }
+  const centroidX = entries.reduce((sum, entry) => sum + entry.area * entry.centroidX, 0) / area;
+  const centroidY = entries.reduce((sum, entry) => sum + entry.area * entry.centroidY, 0) / area;
+  const unitInertia = entries.reduce((sum, entry) => {
+    const dx = entry.centroidX - centroidX;
+    const dy = entry.centroidY - centroidY;
+    return sum + entry.unitInertia + entry.area * (dx * dx + dy * dy);
+  }, 0);
+  return Object.freeze({ area, centroidX, centroidY, unitInertia });
+}
+function leafMassData(leaf) {
+  switch (leaf.kind) {
+    case "circle": {
+      const area = Math.PI * leaf.radius * leaf.radius;
+      return { area, centroidX: leaf.center[0], centroidY: leaf.center[1], unitInertia: area * leaf.radius * leaf.radius / 2 };
+    }
+    case "ellipse": {
+      const area = Math.PI * leaf.radiusX * leaf.radiusY;
+      return { area, centroidX: leaf.center[0], centroidY: leaf.center[1], unitInertia: area * (leaf.radiusX * leaf.radiusX + leaf.radiusY * leaf.radiusY) / 4 };
+    }
+    case "box": {
+      const width = leaf.halfWidth * 2;
+      const height = leaf.halfHeight * 2;
+      const area = width * height;
+      return { area, centroidX: leaf.center[0], centroidY: leaf.center[1], unitInertia: area * (width * width + height * height) / 12 };
+    }
+    case "capsule":
+      return capsuleMassData(leaf.start, leaf.end, leaf.radius);
+    case "polygon":
+      return polygonMassData2D(leaf.vertices);
+    case "segment":
+      return { area: 0, centroidX: (leaf.start[0] + leaf.end[0]) / 2, centroidY: (leaf.start[1] + leaf.end[1]) / 2, unitInertia: 0 };
+    case "rounded-box": {
+      const contour = roundedBoxContour(leaf.halfWidth, leaf.halfHeight, leaf.radii, leaf.center);
+      return polygonMassData2D(contour);
+    }
+  }
+}
+function capsuleMassData(start, end, radius) {
+  const dx = end[0] - start[0];
+  const dy = end[1] - start[1];
+  const length = Math.hypot(dx, dy);
+  const rectangleArea = 2 * radius * length;
+  const circleArea = Math.PI * radius * radius;
+  const area = rectangleArea + circleArea;
+  const rectangleInertia = rectangleArea * (length * length + 4 * radius * radius) / 12;
+  const capsInertia = Math.PI * radius ** 4 / 2 + circleArea * length * length / 4 + 4 * length * radius ** 3 / 3;
+  return Object.freeze({
+    area,
+    centroidX: (start[0] + end[0]) / 2,
+    centroidY: (start[1] + end[1]) / 2,
+    unitInertia: rectangleInertia + capsInertia
+  });
+}
+function lineCentroid(points, closed) {
+  const segmentCount = points.length - 1 + (closed ? 1 : 0);
+  let totalLength = 0;
+  let weightedX = 0;
+  let weightedY = 0;
+  for (let index = 0; index < segmentCount; index += 1) {
+    const start = points[index];
+    const end = points[(index + 1) % points.length];
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    totalLength += length;
+    weightedX += length * (start[0] + end[0]) / 2;
+    weightedY += length * (start[1] + end[1]) / 2;
+  }
+  if (totalLength > 0) {
+    return [weightedX / totalLength, weightedY / totalLength];
+  }
+  return [points.reduce((sum, point) => sum + point[0], 0) / points.length, points.reduce((sum, point) => sum + point[1], 0) / points.length];
+}
+function roundedBoxContour(halfWidth, halfHeight, radii, center) {
+  const points = [];
+  const cornerData = [
+    [halfWidth - radii[1], -halfHeight + radii[1], -Math.PI / 2, 0, radii[1]],
+    [halfWidth - radii[2], halfHeight - radii[2], 0, Math.PI / 2, radii[2]],
+    [-halfWidth + radii[3], halfHeight - radii[3], Math.PI / 2, Math.PI, radii[3]],
+    [-halfWidth + radii[0], -halfHeight + radii[0], Math.PI, 3 * Math.PI / 2, radii[0]]
+  ];
+  for (const [x, y, start, end, radius] of cornerData) {
+    const cornerPoints = radius === 0 ? [new Float64Array([center[0] + x, center[1] + y])] : flattenCircularSweep(center[0] + x, center[1] + y, radius, start, end, false);
+    points.push(...cornerPoints);
+  }
+  return canonicalizeContour2D(points.map(asReadonlyVector), {
+    strictlyConvex: false,
+    path: "roundedBox.contour"
+  });
+}
+function flattenCircularSweep(centerX, centerY, radius, startAngle, endAngle, counterclockwise) {
+  const sweep = directedSweep(startAngle, endAngle, counterclockwise);
+  const points = [pointOnCircle(centerX, centerY, radius, startAngle)];
+  appendFlattenedArc(points, centerX, centerY, radius, startAngle, startAngle + sweep, 0);
+  if (Math.abs(sweep) >= FULL_TURN_RADIANS) {
+    points[points.length - 1] = new Float64Array(points[0]);
+  }
+  return points;
+}
+function appendFlattenedArc(output, centerX, centerY, radius, startAngle, endAngle, depth) {
+  const middleAngle = (startAngle + endAngle) / 2;
+  const halfSweep = Math.abs(endAngle - startAngle) / 2;
+  const chordError = radius * (1 - Math.cos(halfSweep));
+  if (chordError <= CURVE_FLATTENING_TOLERANCE || depth >= CURVE_FLATTENING_MAX_DEPTH) {
+    output.push(pointOnCircle(centerX, centerY, radius, endAngle));
+    return;
+  }
+  appendFlattenedArc(output, centerX, centerY, radius, startAngle, middleAngle, depth + 1);
+  appendFlattenedArc(output, centerX, centerY, radius, middleAngle, endAngle, depth + 1);
+}
+function directedSweep(startAngle, endAngle, counterclockwise) {
+  const raw = endAngle - startAngle;
+  if (Math.abs(raw) >= FULL_TURN_RADIANS) {
+    return counterclockwise ? -FULL_TURN_RADIANS : FULL_TURN_RADIANS;
+  }
+  if (counterclockwise) {
+    const magnitude = (-raw % FULL_TURN_RADIANS + FULL_TURN_RADIANS) % FULL_TURN_RADIANS;
+    return -magnitude;
+  }
+  return (raw % FULL_TURN_RADIANS + FULL_TURN_RADIANS) % FULL_TURN_RADIANS;
+}
+function pointOnCircle(centerX, centerY, radius, angle) {
+  return new Float64Array([
+    centerX + radius * Math.cos(angle),
+    centerY + radius * Math.sin(angle)
+  ]);
+}
+function ownedVector(value, path) {
+  const copied = copyFiniteVector2(value, path);
+  return new Float64Array(copied);
+}
+function asReadonlyVector(value) {
+  return [value[0], value[1]];
+}
+export {
+  arcShape2D,
+  boundsOfShape2D,
+  boxShape2D,
+  capsuleShape2D,
+  chainShape2D,
+  circleShape2D,
+  ellipseShape2D,
+  massProperties2D,
+  polygonShape2D,
+  roundedBoxShape2D,
+  segmentShape2D,
+  transformShape2D,
+  wedgeShape2D
+};
+//# sourceMappingURL=shapes.js.map

package/dist/features/physics/lib/2d/shapes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/features/physics/lib/2d/shapes.ts"],
+  "sourcesContent": ["import type {\n  PibblPhysicsAabb2D,\n  PibblPhysicsMassProperties2D,\n  PibblPhysicsPose2D,\n  PibblPhysicsShape2D,\n  PibblPhysicsTransform2D,\n  PibblPhysicsVector2,\n} from '../../2d-geometry.js';\nimport {\n  copyFiniteVector2,\n  requireFiniteNumber,\n  requireNonnegativeNumber,\n  requirePositiveNumber,\n} from '../shared/validation.js';\nimport {\n  CURVE_FLATTENING_MAX_DEPTH,\n  CURVE_FLATTENING_TOLERANCE,\n  IDENTITY_POSE_2D,\n  canonicalizeContour2D,\n  cleanZero,\n  composePose2D,\n  copyPose2D,\n  freezeBounds2D,\n  polygonMassData2D,\n  transformPointInto,\n  triangulateContour2D,\n  type InternalPose2D,\n} from './math.js';\nimport { DEGREES_TO_RADIANS, GEOMETRY_EPSILON } from './numeric-policy.js';\nimport {\n  createShape2D,\n  requireShapeRecord2D,\n  type CapsuleLeaf2D,\n  type ConvexLeaf2D,\n  type PolygonLeaf2D,\n} from './shape-records.js';\n\nconst FULL_TURN_RADIANS = Math.PI * 2;\n\n/**\n * Creates an immutable circle collision shape without initializing a physics world.\n *\n * @param input - Circle radius and optional center. See {@link PibblPhysicsVector2}.\n * @returns An immutable circle collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function circleShape2D(\n  input: Readonly<{ radius: number; center?: PibblPhysicsVector2 }>,\n): PibblPhysicsShape2D {\n  const radius = requirePositiveNumber(input.radius, 'circle.radius');\n  const center = ownedVector(input.center ?? [0, 0], 'circle.center');\n  const area = Math.PI * radius * radius;\n  return createShapeFromLeaves(\n    [Object.freeze({ kind: 'circle', center, radius, canonicalLeafIndex: 0 })],\n    area,\n    center[0]!,\n    center[1]!,\n    area * radius * radius / 2,\n  );\n}\n\n/**\n * Creates an immutable ellipse collision shape without initializing a physics world.\n *\n * @param input - Ellipse radii, optional center, and rotation in degrees. See\n * {@link PibblPhysicsVector2} .\n * @returns An immutable ellipse collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function ellipseShape2D(\n  input: Readonly<{\n    radiusX: number;\n    radiusY: number;\n    center?: PibblPhysicsVector2;\n    rotationDegrees?: number;\n  }>,\n): PibblPhysicsShape2D {\n  const radiusX = requirePositiveNumber(input.radiusX, 'ellipse.radiusX');\n  const radiusY = requirePositiveNumber(input.radiusY, 'ellipse.radiusY');\n  const center = ownedVector(input.center ?? [0, 0], 'ellipse.center');\n  const rotationRadians =\n    requireFiniteNumber(input.rotationDegrees ?? 0, 'ellipse.rotationDegrees') *\n    DEGREES_TO_RADIANS;\n  const area = Math.PI * radiusX * radiusY;\n  return createShapeFromLeaves(\n    [Object.freeze({ kind: 'ellipse', center, radiusX, radiusY, rotationRadians, canonicalLeafIndex: 0 })],\n    area,\n    center[0]!,\n    center[1]!,\n    area * (radiusX * radiusX + radiusY * radiusY) / 4,\n  );\n}\n\n/**\n * Creates an immutable box collision shape without initializing a physics world.\n *\n * @param input - Box width, height, and optional center. See {@link PibblPhysicsVector2}.\n * @returns An immutable box collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function boxShape2D(\n  input: Readonly<{\n    width: number;\n    height: number;\n    center?: PibblPhysicsVector2;\n  }>,\n): PibblPhysicsShape2D {\n  const width = requirePositiveNumber(input.width, 'box.width');\n  const height = requirePositiveNumber(input.height, 'box.height');\n  const center = ownedVector(input.center ?? [0, 0], 'box.center');\n  const area = width * height;\n  return createShapeFromLeaves(\n    [Object.freeze({ kind: 'box', center, halfWidth: width / 2, halfHeight: height / 2, canonicalLeafIndex: 0 })],\n    area,\n    center[0]!,\n    center[1]!,\n    area * (width * width + height * height) / 12,\n  );\n}\n\n/**\n * Creates an immutable rounded box collision shape without initializing a physics world.\n *\n * @param input - Box dimensions, center, and uniform or per-corner radii. See\n * {@link PibblPhysicsVector2} .\n * @returns An immutable rounded-box collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function roundedBoxShape2D(\n  input: Readonly<{\n    width: number;\n    height: number;\n    radius:\n      | number\n      | readonly [\n          topLeft: number,\n          topRight: number,\n          bottomRight: number,\n          bottomLeft: number,\n        ];\n    center?: PibblPhysicsVector2;\n  }>,\n): PibblPhysicsShape2D {\n  const width = requirePositiveNumber(input.width, 'roundedBox.width');\n  const height = requirePositiveNumber(input.height, 'roundedBox.height');\n  const center = ownedVector(input.center ?? [0, 0], 'roundedBox.center');\n  const sourceRadii = typeof input.radius === 'number'\n    ? [input.radius, input.radius, input.radius, input.radius] as const\n    : input.radius;\n  const radii = new Float64Array(4);\n  const maximum = Math.min(width, height) / 2;\n  for (let index = 0; index < radii.length; index += 1) {\n    const radius = requireNonnegativeNumber(\n      sourceRadii[index]!,\n      `roundedBox.radius[${index}]`,\n    );\n    if (radius > maximum) {\n      throw new RangeError(\n        `roundedBox.radius[${index}] must not exceed ${String(maximum)}; received ${String(radius)}.`,\n      );\n    }\n    radii[index] = radius;\n  }\n  const contour = roundedBoxContour(width / 2, height / 2, radii, center);\n  const mass = polygonMassData2D(contour);\n  return createShapeFromLeaves(\n    [Object.freeze({\n      kind: 'rounded-box',\n      center,\n      halfWidth: width / 2,\n      halfHeight: height / 2,\n      radii,\n      canonicalLeafIndex: 0,\n    })],\n    mass.area,\n    mass.centroidX,\n    mass.centroidY,\n    mass.unitInertia,\n  );\n}\n\n/**\n * Creates an immutable capsule collision shape without initializing a physics world.\n *\n * @param input - Capsule centerline endpoints and radius. See {@link PibblPhysicsVector2}.\n * @returns An immutable capsule collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function capsuleShape2D(\n  input: Readonly<{\n    start: PibblPhysicsVector2;\n    end: PibblPhysicsVector2;\n    radius: number;\n  }>,\n): PibblPhysicsShape2D {\n  const start = ownedVector(input.start, 'capsule.start');\n  const end = ownedVector(input.end, 'capsule.end');\n  const radius = requirePositiveNumber(input.radius, 'capsule.radius');\n  const leaf: CapsuleLeaf2D = Object.freeze({\n    kind: 'capsule', start, end, radius, canonicalLeafIndex: 0,\n  });\n  const mass = capsuleMassData(start, end, radius);\n  return createShapeFromLeaves(\n    [leaf],\n    mass.area,\n    mass.centroidX,\n    mass.centroidY,\n    mass.unitInertia,\n  );\n}\n\n/**\n * Creates an immutable arc collision shape without initializing a physics world.\n *\n * @param input - Arc center, radius, angular endpoints in radians, sweep direction, and thickness.\n * See {@link PibblPhysicsVector2} .\n * @returns An immutable thick-arc collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function arcShape2D(\n  input: Readonly<{\n    center?: PibblPhysicsVector2;\n    radius: number;\n    startAngleRadians: number;\n    endAngleRadians: number;\n    counterclockwise?: boolean;\n    thickness: number;\n  }>,\n): PibblPhysicsShape2D {\n  const center = ownedVector(input.center ?? [0, 0], 'arc.center');\n  const radius = requirePositiveNumber(input.radius, 'arc.radius');\n  const startAngle = requireFiniteNumber(input.startAngleRadians, 'arc.startAngleRadians');\n  const endAngle = requireFiniteNumber(input.endAngleRadians, 'arc.endAngleRadians');\n  const thickness = requirePositiveNumber(input.thickness, 'arc.thickness');\n  const points = flattenCircularSweep(\n    center[0]!, center[1]!, radius, startAngle, endAngle, input.counterclockwise === true,\n  );\n  return chainFromOwnedPoints(points, false, thickness / 2);\n}\n\n/**\n * Creates an immutable wedge collision shape without initializing a physics world.\n *\n * @param input - Wedge center, radius, angular endpoints in radians, and sweep direction. See\n * {@link PibblPhysicsVector2} .\n * @returns An immutable wedge collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function wedgeShape2D(\n  input: Readonly<{\n    center?: PibblPhysicsVector2;\n    radius: number;\n    startAngleRadians: number;\n    endAngleRadians: number;\n    counterclockwise?: boolean;\n  }>,\n): PibblPhysicsShape2D {\n  const center = ownedVector(input.center ?? [0, 0], 'wedge.center');\n  const radius = requirePositiveNumber(input.radius, 'wedge.radius');\n  const startAngle = requireFiniteNumber(input.startAngleRadians, 'wedge.startAngleRadians');\n  const endAngle = requireFiniteNumber(input.endAngleRadians, 'wedge.endAngleRadians');\n  const points = flattenCircularSweep(\n    center[0]!, center[1]!, radius, startAngle, endAngle, input.counterclockwise === true,\n  );\n  const sweep = directedSweep(startAngle, endAngle, input.counterclockwise === true);\n  if (Math.abs(sweep) <= GEOMETRY_EPSILON) {\n    throw new RangeError('wedge angles must describe a nonzero sweep.');\n  }\n  const contourSource: PibblPhysicsVector2[] = Math.abs(sweep) >= FULL_TURN_RADIANS\n    ? points.slice(0, -1).map(asReadonlyVector)\n    : [asReadonlyVector(center), ...points.map(asReadonlyVector)];\n  const contour = canonicalizeContour2D(contourSource, {\n    strictlyConvex: false,\n    path: 'wedge.contour',\n  });\n  const triangles = triangulateContour2D(contour);\n  const leaves = triangles.map<PolygonLeaf2D>((vertices, canonicalLeafIndex) =>\n    Object.freeze({ kind: 'polygon', vertices, canonicalLeafIndex }),\n  );\n  const mass = aggregateLeafMass(leaves);\n  return createShapeFromLeaves(\n    leaves,\n    mass.area,\n    mass.centroidX,\n    mass.centroidY,\n    mass.unitInertia,\n  );\n}\n\n/**\n * Creates an immutable segment collision shape without initializing a physics world.\n *\n * @param input - Segment endpoints. See {@link PibblPhysicsVector2}.\n * @returns An immutable line-segment collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function segmentShape2D(\n  input: Readonly<{ start: PibblPhysicsVector2; end: PibblPhysicsVector2 }>,\n): PibblPhysicsShape2D {\n  const start = ownedVector(input.start, 'segment.start');\n  const end = ownedVector(input.end, 'segment.end');\n  return createShapeFromLeaves(\n    [Object.freeze({ kind: 'segment', start, end, canonicalLeafIndex: 0 })],\n    0,\n    (start[0]! + end[0]!) / 2,\n    (start[1]! + end[1]!) / 2,\n    0,\n  );\n}\n\n/**\n * Creates an immutable chain collision shape without initializing a physics world.\n *\n * @param input - Ordered chain points, closure policy, and optional radius. See\n * {@link PibblPhysicsVector2} .\n * @returns An immutable chain collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function chainShape2D(\n  input: Readonly<{\n    points: readonly PibblPhysicsVector2[];\n    closed?: boolean;\n    radius?: number;\n  }>,\n): PibblPhysicsShape2D {\n  if (input.points.length < 2) {\n    throw new RangeError('chain.points must contain at least two points.');\n  }\n  const points = input.points.map((point, index) =>\n    ownedVector(point, `chain.points[${index}]`),\n  );\n  const radius = requireNonnegativeNumber(input.radius ?? 0, 'chain.radius');\n  return chainFromOwnedPoints(points, input.closed === true, radius);\n}\n\n/**\n * Creates an immutable polygon collision shape without initializing a physics world.\n *\n * @param input - Ordered polygon vertices. See {@link PibblPhysicsVector2}.\n * @returns An immutable polygon collision shape. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsVector2}\n * @see {@link PibblPhysicsShape2D}\n */\nexport function polygonShape2D(\n  input: Readonly<{ points: readonly PibblPhysicsVector2[] }>,\n): PibblPhysicsShape2D {\n  const vertices = canonicalizeContour2D(input.points, {\n    strictlyConvex: true,\n    path: 'polygon.points',\n  });\n  const mass = polygonMassData2D(vertices);\n  return createShapeFromLeaves(\n    [Object.freeze({ kind: 'polygon', vertices, canonicalLeafIndex: 0 })],\n    mass.area,\n    mass.centroidX,\n    mass.centroidY,\n    mass.unitInertia,\n  );\n}\n\n/**\n * Computes axis-aligned bounds for an immutable shape at an optional pose.\n *\n * @param shape - Shape whose bounds are needed. See {@link PibblPhysicsShape2D}.\n * @param pose - Optional pose at which to evaluate the shape. See {@link PibblPhysicsPose2D}.\n * @returns Axis-aligned bounds of the posed shape. See {@link PibblPhysicsAabb2D}.\n *\n * @see {@link PibblPhysicsShape2D}\n * @see {@link PibblPhysicsPose2D}\n * @see {@link PibblPhysicsAabb2D}\n */\nexport function boundsOfShape2D(\n  shape: PibblPhysicsShape2D,\n  pose?: PibblPhysicsPose2D,\n): PibblPhysicsAabb2D {\n  const record = requireShapeRecord2D(shape);\n  const outerPose = copyPose2D(pose, 'pose');\n  return boundsForLeaves(record.leaves, composePose2D(outerPose, record.localPose));\n}\n\n/**\n * Computes shape area, centroid, mass, and rotational inertia at the requested density.\n *\n * @param shape - Shape whose mass properties are needed. See {@link PibblPhysicsShape2D}.\n * @param options - Optional material density.\n * @returns Mass, center of mass, and inertia for the shape. See {@link PibblPhysicsMassProperties2D}\n * .\n *\n * @see {@link PibblPhysicsShape2D}\n * @see {@link PibblPhysicsMassProperties2D}\n */\nexport function massProperties2D(\n  shape: PibblPhysicsShape2D,\n  options?: Readonly<{ density?: number }>,\n): PibblPhysicsMassProperties2D {\n  const record = requireShapeRecord2D(shape);\n  const density = requirePositiveNumber(options?.density ?? 1, 'options.density');\n  const transformedCentroid = new Float64Array(2);\n  transformPointInto(\n    transformedCentroid,\n    0,\n    record.centroidX,\n    record.centroidY,\n    record.localPose,\n  );\n  return Object.freeze({\n    area: cleanZero(record.area),\n    centroid: Object.freeze([\n      cleanZero(transformedCentroid[0]!),\n      cleanZero(transformedCentroid[1]!),\n    ] as const),\n    mass: cleanZero(record.area * density),\n    rotationalInertia: cleanZero(record.unitInertia * density),\n  });\n}\n\n/**\n * Returns independent shape geometry transformed by a rigid 2D pose.\n *\n * @param shape - Source shape; it is not modified. See {@link PibblPhysicsShape2D}.\n * @param transform - Transform to apply to the shape. See {@link PibblPhysicsTransform2D}.\n * @returns A shape containing the transformed geometry. See {@link PibblPhysicsShape2D}.\n *\n * @see {@link PibblPhysicsShape2D}\n * @see {@link PibblPhysicsTransform2D}\n */\nexport function transformShape2D(\n  shape: PibblPhysicsShape2D,\n  transform: PibblPhysicsTransform2D,\n): PibblPhysicsShape2D {\n  const source = requireShapeRecord2D(shape);\n  const localPose = composePose2D(copyPose2D(transform, 'transform'), source.localPose);\n  const localBounds = mutableBoundsForLeaves(source.leaves, localPose);\n  return createShape2D({\n    leaves: source.leaves,\n    localPose,\n    localBounds,\n    area: source.area,\n    centroidX: source.centroidX,\n    centroidY: source.centroidY,\n    unitInertia: source.unitInertia,\n  });\n}\n\nfunction createShapeFromLeaves(\n  leaves: readonly ConvexLeaf2D[],\n  area: number,\n  centroidX: number,\n  centroidY: number,\n  unitInertia: number,\n): PibblPhysicsShape2D {\n  return createShape2D({\n    leaves,\n    localBounds: mutableBoundsForLeaves(leaves, IDENTITY_POSE_2D),\n    area,\n    centroidX,\n    centroidY,\n    unitInertia: Math.max(0, unitInertia),\n  });\n}\n\nfunction chainFromOwnedPoints(\n  points: readonly Float64Array[],\n  closed: boolean,\n  radius: number,\n): PibblPhysicsShape2D {\n  const segmentCount = points.length === 1 ? 0 : points.length - 1 + (closed ? 1 : 0);\n  const leaves: ConvexLeaf2D[] = [];\n  for (let index = 0; index < segmentCount; index += 1) {\n    const start = points[index]!;\n    const end = points[(index + 1) % points.length]!;\n    leaves.push(Object.freeze(radius === 0\n      ? { kind: 'segment', start, end, canonicalLeafIndex: index }\n      : { kind: 'capsule', start, end, radius, canonicalLeafIndex: index }));\n  }\n  if (leaves.length === 0) {\n    const point = points[0]!;\n    const area = Math.PI * radius * radius;\n    leaves.push(Object.freeze({\n      kind: 'circle', center: point, radius, canonicalLeafIndex: 0,\n    }));\n    return createShapeFromLeaves(\n      leaves,\n      area,\n      point[0]!,\n      point[1]!,\n      area * radius * radius / 2,\n    );\n  }\n  if (radius > 0) {\n    const mass = aggregateLeafMass(leaves);\n    return createShapeFromLeaves(\n      leaves,\n      mass.area,\n      mass.centroidX,\n      mass.centroidY,\n      mass.unitInertia,\n    );\n  }\n  const centroid = lineCentroid(points, closed);\n  return createShapeFromLeaves(leaves, 0, centroid[0], centroid[1], 0);\n}\n\nfunction boundsForLeaves(\n  leaves: readonly ConvexLeaf2D[],\n  pose: InternalPose2D,\n): PibblPhysicsAabb2D {\n  const bounds = mutableBoundsForLeaves(leaves, pose);\n  return freezeBounds2D(bounds[0]!, bounds[1]!, bounds[2]!, bounds[3]!);\n}\n\nfunction mutableBoundsForLeaves(\n  leaves: readonly ConvexLeaf2D[],\n  pose: InternalPose2D,\n): Float64Array {\n  const result = new Float64Array([\n    Number.POSITIVE_INFINITY,\n    Number.POSITIVE_INFINITY,\n    Number.NEGATIVE_INFINITY,\n    Number.NEGATIVE_INFINITY,\n  ]);\n  const point = new Float64Array(2);\n  const include = (x: number, y: number, radius = 0): void => {\n    transformPointInto(point, 0, x, y, pose);\n    result[0] = Math.min(result[0]!, point[0]! - radius);\n    result[1] = Math.min(result[1]!, point[1]! - radius);\n    result[2] = Math.max(result[2]!, point[0]! + radius);\n    result[3] = Math.max(result[3]!, point[1]! + radius);\n  };\n  for (const leaf of leaves) {\n    switch (leaf.kind) {\n      case 'circle':\n        include(leaf.center[0]!, leaf.center[1]!, leaf.radius);\n        break;\n      case 'ellipse': {\n        transformPointInto(point, 0, leaf.center[0]!, leaf.center[1]!, pose);\n        const angle = pose.rotationRadians + leaf.rotationRadians;\n        const cosine = Math.cos(angle);\n        const sine = Math.sin(angle);\n        const extentX = Math.hypot(leaf.radiusX * cosine, leaf.radiusY * sine);\n        const extentY = Math.hypot(leaf.radiusX * sine, leaf.radiusY * cosine);\n        result[0] = Math.min(result[0]!, point[0]! - extentX);\n        result[1] = Math.min(result[1]!, point[1]! - extentY);\n        result[2] = Math.max(result[2]!, point[0]! + extentX);\n        result[3] = Math.max(result[3]!, point[1]! + extentY);\n        break;\n      }\n      case 'box':\n        includeBoxCorners(leaf.center, leaf.halfWidth, leaf.halfHeight, pose, result, point);\n        break;\n      case 'rounded-box':\n        includeRoundedBoxBounds(leaf, pose, result, point);\n        break;\n      case 'capsule':\n        include(leaf.start[0]!, leaf.start[1]!, leaf.radius);\n        include(leaf.end[0]!, leaf.end[1]!, leaf.radius);\n        break;\n      case 'segment':\n        include(leaf.start[0]!, leaf.start[1]!);\n        include(leaf.end[0]!, leaf.end[1]!);\n        break;\n      case 'polygon':\n        for (let offset = 0; offset < leaf.vertices.length; offset += 2) {\n          include(leaf.vertices[offset]!, leaf.vertices[offset + 1]!);\n        }\n        break;\n    }\n  }\n  return result;\n}\n\nfunction includeBoxCorners(\n  center: Float64Array,\n  halfWidth: number,\n  halfHeight: number,\n  pose: InternalPose2D,\n  bounds: Float64Array,\n  point: Float64Array,\n): void {\n  for (const xSign of [-1, 1]) {\n    for (const ySign of [-1, 1]) {\n      transformPointInto(\n        point,\n        0,\n        center[0]! + xSign * halfWidth,\n        center[1]! + ySign * halfHeight,\n        pose,\n      );\n      bounds[0] = Math.min(bounds[0]!, point[0]!);\n      bounds[1] = Math.min(bounds[1]!, point[1]!);\n      bounds[2] = Math.max(bounds[2]!, point[0]!);\n      bounds[3] = Math.max(bounds[3]!, point[1]!);\n    }\n  }\n}\n\nfunction includeRoundedBoxBounds(\n  leaf: Extract<ConvexLeaf2D, { kind: 'rounded-box' }>,\n  pose: InternalPose2D,\n  bounds: Float64Array,\n  point: Float64Array,\n): void {\n  const xSigns = [-1, 1, 1, -1] as const;\n  const ySigns = [-1, -1, 1, 1] as const;\n  for (let index = 0; index < 4; index += 1) {\n    const radius = leaf.radii[index]!;\n    transformPointInto(\n      point,\n      0,\n      leaf.center[0]! + xSigns[index]! * (leaf.halfWidth - radius),\n      leaf.center[1]! + ySigns[index]! * (leaf.halfHeight - radius),\n      pose,\n    );\n    bounds[0] = Math.min(bounds[0]!, point[0]! - radius);\n    bounds[1] = Math.min(bounds[1]!, point[1]! - radius);\n    bounds[2] = Math.max(bounds[2]!, point[0]! + radius);\n    bounds[3] = Math.max(bounds[3]!, point[1]! + radius);\n  }\n}\n\nfunction aggregateLeafMass(leaves: readonly ConvexLeaf2D[]): Readonly<{\n  area: number;\n  centroidX: number;\n  centroidY: number;\n  unitInertia: number;\n}> {\n  const entries = leaves.map(leafMassData);\n  const area = entries.reduce((sum, entry) => sum + entry.area, 0);\n  if (area === 0) {\n    return Object.freeze({ area: 0, centroidX: 0, centroidY: 0, unitInertia: 0 });\n  }\n  const centroidX = entries.reduce((sum, entry) => sum + entry.area * entry.centroidX, 0) / area;\n  const centroidY = entries.reduce((sum, entry) => sum + entry.area * entry.centroidY, 0) / area;\n  const unitInertia = entries.reduce((sum, entry) => {\n    const dx = entry.centroidX - centroidX;\n    const dy = entry.centroidY - centroidY;\n    return sum + entry.unitInertia + entry.area * (dx * dx + dy * dy);\n  }, 0);\n  return Object.freeze({ area, centroidX, centroidY, unitInertia });\n}\n\nfunction leafMassData(leaf: ConvexLeaf2D): Readonly<{\n  area: number;\n  centroidX: number;\n  centroidY: number;\n  unitInertia: number;\n}> {\n  switch (leaf.kind) {\n    case 'circle': {\n      const area = Math.PI * leaf.radius * leaf.radius;\n      return { area, centroidX: leaf.center[0]!, centroidY: leaf.center[1]!, unitInertia: area * leaf.radius * leaf.radius / 2 };\n    }\n    case 'ellipse': {\n      const area = Math.PI * leaf.radiusX * leaf.radiusY;\n      return { area, centroidX: leaf.center[0]!, centroidY: leaf.center[1]!, unitInertia: area * (leaf.radiusX * leaf.radiusX + leaf.radiusY * leaf.radiusY) / 4 };\n    }\n    case 'box': {\n      const width = leaf.halfWidth * 2;\n      const height = leaf.halfHeight * 2;\n      const area = width * height;\n      return { area, centroidX: leaf.center[0]!, centroidY: leaf.center[1]!, unitInertia: area * (width * width + height * height) / 12 };\n    }\n    case 'capsule':\n      return capsuleMassData(leaf.start, leaf.end, leaf.radius);\n    case 'polygon':\n      return polygonMassData2D(leaf.vertices);\n    case 'segment':\n      return { area: 0, centroidX: (leaf.start[0]! + leaf.end[0]!) / 2, centroidY: (leaf.start[1]! + leaf.end[1]!) / 2, unitInertia: 0 };\n    case 'rounded-box': {\n      const contour = roundedBoxContour(leaf.halfWidth, leaf.halfHeight, leaf.radii, leaf.center);\n      return polygonMassData2D(contour);\n    }\n  }\n}\n\nfunction capsuleMassData(\n  start: Float64Array,\n  end: Float64Array,\n  radius: number,\n): Readonly<{ area: number; centroidX: number; centroidY: number; unitInertia: number }> {\n  const dx = end[0]! - start[0]!;\n  const dy = end[1]! - start[1]!;\n  const length = Math.hypot(dx, dy);\n  const rectangleArea = 2 * radius * length;\n  const circleArea = Math.PI * radius * radius;\n  const area = rectangleArea + circleArea;\n  const rectangleInertia = rectangleArea * (length * length + 4 * radius * radius) / 12;\n  const capsInertia =\n    Math.PI * radius ** 4 / 2 +\n    circleArea * length * length / 4 +\n    4 * length * radius ** 3 / 3;\n  return Object.freeze({\n    area,\n    centroidX: (start[0]! + end[0]!) / 2,\n    centroidY: (start[1]! + end[1]!) / 2,\n    unitInertia: rectangleInertia + capsInertia,\n  });\n}\n\nfunction lineCentroid(\n  points: readonly Float64Array[],\n  closed: boolean,\n): readonly [number, number] {\n  const segmentCount = points.length - 1 + (closed ? 1 : 0);\n  let totalLength = 0;\n  let weightedX = 0;\n  let weightedY = 0;\n  for (let index = 0; index < segmentCount; index += 1) {\n    const start = points[index]!;\n    const end = points[(index + 1) % points.length]!;\n    const length = Math.hypot(end[0]! - start[0]!, end[1]! - start[1]!);\n    totalLength += length;\n    weightedX += length * (start[0]! + end[0]!) / 2;\n    weightedY += length * (start[1]! + end[1]!) / 2;\n  }\n  if (totalLength > 0) {\n    return [weightedX / totalLength, weightedY / totalLength];\n  }\n  return [points.reduce((sum, point) => sum + point[0]!, 0) / points.length, points.reduce((sum, point) => sum + point[1]!, 0) / points.length];\n}\n\nfunction roundedBoxContour(\n  halfWidth: number,\n  halfHeight: number,\n  radii: Float64Array,\n  center: Float64Array,\n): Float64Array {\n  const points: Float64Array[] = [];\n  const cornerData = [\n    [halfWidth - radii[1]!, -halfHeight + radii[1]!, -Math.PI / 2, 0, radii[1]!],\n    [halfWidth - radii[2]!, halfHeight - radii[2]!, 0, Math.PI / 2, radii[2]!],\n    [-halfWidth + radii[3]!, halfHeight - radii[3]!, Math.PI / 2, Math.PI, radii[3]!],\n    [-halfWidth + radii[0]!, -halfHeight + radii[0]!, Math.PI, 3 * Math.PI / 2, radii[0]!],\n  ] as const;\n  for (const [x, y, start, end, radius] of cornerData) {\n    const cornerPoints = radius === 0\n      ? [new Float64Array([center[0]! + x, center[1]! + y])]\n      : flattenCircularSweep(center[0]! + x, center[1]! + y, radius, start, end, false);\n    points.push(...cornerPoints);\n  }\n  return canonicalizeContour2D(points.map(asReadonlyVector), {\n    strictlyConvex: false,\n    path: 'roundedBox.contour',\n  });\n}\n\nfunction flattenCircularSweep(\n  centerX: number,\n  centerY: number,\n  radius: number,\n  startAngle: number,\n  endAngle: number,\n  counterclockwise: boolean,\n): Float64Array[] {\n  const sweep = directedSweep(startAngle, endAngle, counterclockwise);\n  const points = [pointOnCircle(centerX, centerY, radius, startAngle)];\n  appendFlattenedArc(points, centerX, centerY, radius, startAngle, startAngle + sweep, 0);\n  if (Math.abs(sweep) >= FULL_TURN_RADIANS) {\n    points[points.length - 1] = new Float64Array(points[0]!);\n  }\n  return points;\n}\n\nfunction appendFlattenedArc(\n  output: Float64Array[],\n  centerX: number,\n  centerY: number,\n  radius: number,\n  startAngle: number,\n  endAngle: number,\n  depth: number,\n): void {\n  const middleAngle = (startAngle + endAngle) / 2;\n  const halfSweep = Math.abs(endAngle - startAngle) / 2;\n  const chordError = radius * (1 - Math.cos(halfSweep));\n  if (\n    chordError <= CURVE_FLATTENING_TOLERANCE ||\n    depth >= CURVE_FLATTENING_MAX_DEPTH\n  ) {\n    output.push(pointOnCircle(centerX, centerY, radius, endAngle));\n    return;\n  }\n  appendFlattenedArc(output, centerX, centerY, radius, startAngle, middleAngle, depth + 1);\n  appendFlattenedArc(output, centerX, centerY, radius, middleAngle, endAngle, depth + 1);\n}\n\nfunction directedSweep(\n  startAngle: number,\n  endAngle: number,\n  counterclockwise: boolean,\n): number {\n  const raw = endAngle - startAngle;\n  if (Math.abs(raw) >= FULL_TURN_RADIANS) {\n    return counterclockwise ? -FULL_TURN_RADIANS : FULL_TURN_RADIANS;\n  }\n  if (counterclockwise) {\n    const magnitude = ((-raw % FULL_TURN_RADIANS) + FULL_TURN_RADIANS) % FULL_TURN_RADIANS;\n    return -magnitude;\n  }\n  return ((raw % FULL_TURN_RADIANS) + FULL_TURN_RADIANS) % FULL_TURN_RADIANS;\n}\n\nfunction pointOnCircle(\n  centerX: number,\n  centerY: number,\n  radius: number,\n  angle: number,\n): Float64Array {\n  return new Float64Array([\n    centerX + radius * Math.cos(angle),\n    centerY + radius * Math.sin(angle),\n  ]);\n}\n\nfunction ownedVector(value: PibblPhysicsVector2, path: string): Float64Array {\n  const copied = copyFiniteVector2(value, path);\n  return new Float64Array(copied);\n}\n\nfunction asReadonlyVector(value: Float64Array): PibblPhysicsVector2 {\n  return [value[0]!, value[1]!] as const;\n}\n"],
+  "mappings": "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",
+  "names": []
+}