# packages/core/src/features/physics/lib/2d/shapes.ts This is the source snapshot used to build these API details. [View this revision on GitHub](https://github.com/benlesh/pibbl/blob/272a94aaf62e0bd6ad8726a4c607a76a9ec44ca1/packages/core/src/features/physics/lib/2d/shapes.ts#L232). [Back to reference](/reference/functions/physics-2d/) 
1 import type {
2   PibblPhysicsAabb2D,
3   PibblPhysicsMassProperties2D,
4   PibblPhysicsPose2D,
5   PibblPhysicsShape2D,
6   PibblPhysicsTransform2D,
7   PibblPhysicsVector2,
8 } from '../../2d-geometry.js';
9 import {
10   copyFiniteVector2,
11   requireFiniteNumber,
12   requireNonnegativeNumber,
13   requirePositiveNumber,
14 } from '../shared/validation.js';
15 import {
16   CURVE_FLATTENING_MAX_DEPTH,
17   CURVE_FLATTENING_TOLERANCE,
18   IDENTITY_POSE_2D,
19   canonicalizeContour2D,
20   cleanZero,
21   composePose2D,
22   copyPose2D,
23   freezeBounds2D,
24   polygonMassData2D,
25   transformPointInto,
26   triangulateContour2D,
27   type InternalPose2D,
28 } from './math.js';
29 import { DEGREES_TO_RADIANS, GEOMETRY_EPSILON } from './numeric-policy.js';
30 import {
31   createShape2D,
32   requireShapeRecord2D,
33   type CapsuleLeaf2D,
34   type ConvexLeaf2D,
35   type PolygonLeaf2D,
36 } from './shape-records.js';
37 
38 const FULL_TURN_RADIANS = Math.PI * 2;
39 
40 /**
41  * Creates an immutable circle collision shape without initializing a physics world.
42  *
43  * @param input - Circle radius and optional center. See {@link PibblPhysicsVector2}.
44  * @returns An immutable circle collision shape. See {@link PibblPhysicsShape2D}.
45  *
46  * @see {@link PibblPhysicsVector2}
47  * @see {@link PibblPhysicsShape2D}
48  */
49 export function circleShape2D(
50   input: Readonly<{ radius: number; center?: PibblPhysicsVector2 }>,
51 ): PibblPhysicsShape2D {
52   const radius = requirePositiveNumber(input.radius, 'circle.radius');
53   const center = ownedVector(input.center ?? [0, 0], 'circle.center');
54   const area = Math.PI * radius * radius;
55   return createShapeFromLeaves(
56     [Object.freeze({ kind: 'circle', center, radius, canonicalLeafIndex: 0 })],
57     area,
58     center[0]!,
59     center[1]!,
60     area * radius * radius / 2,
61   );
62 }
63 
64 /**
65  * Creates an immutable ellipse collision shape without initializing a physics world.
66  *
67  * @param input - Ellipse radii, optional center, and rotation in degrees. See
68  * {@link PibblPhysicsVector2} .
69  * @returns An immutable ellipse collision shape. See {@link PibblPhysicsShape2D}.
70  *
71  * @see {@link PibblPhysicsVector2}
72  * @see {@link PibblPhysicsShape2D}
73  */
74 export function ellipseShape2D(
75   input: Readonly<{
76     radiusX: number;
77     radiusY: number;
78     center?: PibblPhysicsVector2;
79     rotationDegrees?: number;
80   }>,
81 ): PibblPhysicsShape2D {
82   const radiusX = requirePositiveNumber(input.radiusX, 'ellipse.radiusX');
83   const radiusY = requirePositiveNumber(input.radiusY, 'ellipse.radiusY');
84   const center = ownedVector(input.center ?? [0, 0], 'ellipse.center');
85   const rotationRadians =
86     requireFiniteNumber(input.rotationDegrees ?? 0, 'ellipse.rotationDegrees') *
87     DEGREES_TO_RADIANS;
88   const area = Math.PI * radiusX * radiusY;
89   return createShapeFromLeaves(
90     [Object.freeze({ kind: 'ellipse', center, radiusX, radiusY, rotationRadians, canonicalLeafIndex: 0 })],
91     area,
92     center[0]!,
93     center[1]!,
94     area * (radiusX * radiusX + radiusY * radiusY) / 4,
95   );
96 }
97 
98 /**
99  * Creates an immutable box collision shape without initializing a physics world.
100  *
101  * @param input - Box width, height, and optional center. See {@link PibblPhysicsVector2}.
102  * @returns An immutable box collision shape. See {@link PibblPhysicsShape2D}.
103  *
104  * @see {@link PibblPhysicsVector2}
105  * @see {@link PibblPhysicsShape2D}
106  */
107 export function boxShape2D(
108   input: Readonly<{
109     width: number;
110     height: number;
111     center?: PibblPhysicsVector2;
112   }>,
113 ): PibblPhysicsShape2D {
114   const width = requirePositiveNumber(input.width, 'box.width');
115   const height = requirePositiveNumber(input.height, 'box.height');
116   const center = ownedVector(input.center ?? [0, 0], 'box.center');
117   const area = width * height;
118   return createShapeFromLeaves(
119     [Object.freeze({ kind: 'box', center, halfWidth: width / 2, halfHeight: height / 2, canonicalLeafIndex: 0 })],
120     area,
121     center[0]!,
122     center[1]!,
123     area * (width * width + height * height) / 12,
124   );
125 }
126 
127 /**
128  * Creates an immutable rounded box collision shape without initializing a physics world.
129  *
130  * @param input - Box dimensions, center, and uniform or per-corner radii. See
131  * {@link PibblPhysicsVector2} .
132  * @returns An immutable rounded-box collision shape. See {@link PibblPhysicsShape2D}.
133  *
134  * @see {@link PibblPhysicsVector2}
135  * @see {@link PibblPhysicsShape2D}
136  */
137 export function roundedBoxShape2D(
138   input: Readonly<{
139     width: number;
140     height: number;
141     radius:
142       | number
143       | readonly [
144           topLeft: number,
145           topRight: number,
146           bottomRight: number,
147           bottomLeft: number,
148         ];
149     center?: PibblPhysicsVector2;
150   }>,
151 ): PibblPhysicsShape2D {
152   const width = requirePositiveNumber(input.width, 'roundedBox.width');
153   const height = requirePositiveNumber(input.height, 'roundedBox.height');
154   const center = ownedVector(input.center ?? [0, 0], 'roundedBox.center');
155   const sourceRadii = typeof input.radius === 'number'
156     ? [input.radius, input.radius, input.radius, input.radius] as const
157     : input.radius;
158   const radii = new Float64Array(4);
159   const maximum = Math.min(width, height) / 2;
160   for (let index = 0; index < radii.length; index += 1) {
161     const radius = requireNonnegativeNumber(
162       sourceRadii[index]!,
163       `roundedBox.radius[${index}]`,
164     );
165     if (radius > maximum) {
166       throw new RangeError(
167         `roundedBox.radius[${index}] must not exceed ${String(maximum)}; received ${String(radius)}.`,
168       );
169     }
170     radii[index] = radius;
171   }
172   const contour = roundedBoxContour(width / 2, height / 2, radii, center);
173   const mass = polygonMassData2D(contour);
174   return createShapeFromLeaves(
175     [Object.freeze({
176       kind: 'rounded-box',
177       center,
178       halfWidth: width / 2,
179       halfHeight: height / 2,
180       radii,
181       canonicalLeafIndex: 0,
182     })],
183     mass.area,
184     mass.centroidX,
185     mass.centroidY,
186     mass.unitInertia,
187   );
188 }
189 
190 /**
191  * Creates an immutable capsule collision shape without initializing a physics world.
192  *
193  * @param input - Capsule centerline endpoints and radius. See {@link PibblPhysicsVector2}.
194  * @returns An immutable capsule collision shape. See {@link PibblPhysicsShape2D}.
195  *
196  * @see {@link PibblPhysicsVector2}
197  * @see {@link PibblPhysicsShape2D}
198  */
199 export function capsuleShape2D(
200   input: Readonly<{
201     start: PibblPhysicsVector2;
202     end: PibblPhysicsVector2;
203     radius: number;
204   }>,
205 ): PibblPhysicsShape2D {
206   const start = ownedVector(input.start, 'capsule.start');
207   const end = ownedVector(input.end, 'capsule.end');
208   const radius = requirePositiveNumber(input.radius, 'capsule.radius');
209   const leaf: CapsuleLeaf2D = Object.freeze({
210     kind: 'capsule', start, end, radius, canonicalLeafIndex: 0,
211   });
212   const mass = capsuleMassData(start, end, radius);
213   return createShapeFromLeaves(
214     [leaf],
215     mass.area,
216     mass.centroidX,
217     mass.centroidY,
218     mass.unitInertia,
219   );
220 }
221 
222 /**
223  * Creates an immutable arc collision shape without initializing a physics world.
224  *
225  * @param input - Arc center, radius, angular endpoints in radians, sweep direction, and thickness.
226  * See {@link PibblPhysicsVector2} .
227  * @returns An immutable thick-arc collision shape. See {@link PibblPhysicsShape2D}.
228  *
229  * @see {@link PibblPhysicsVector2}
230  * @see {@link PibblPhysicsShape2D}
231  */
232 export function arcShape2D(
233   input: Readonly<{
234     center?: PibblPhysicsVector2;
235     radius: number;
236     startAngleRadians: number;
237     endAngleRadians: number;
238     counterclockwise?: boolean;
239     thickness: number;
240   }>,
241 ): PibblPhysicsShape2D {
242   const center = ownedVector(input.center ?? [0, 0], 'arc.center');
243   const radius = requirePositiveNumber(input.radius, 'arc.radius');
244   const startAngle = requireFiniteNumber(input.startAngleRadians, 'arc.startAngleRadians');
245   const endAngle = requireFiniteNumber(input.endAngleRadians, 'arc.endAngleRadians');
246   const thickness = requirePositiveNumber(input.thickness, 'arc.thickness');
247   const points = flattenCircularSweep(
248     center[0]!, center[1]!, radius, startAngle, endAngle, input.counterclockwise === true,
249   );
250   return chainFromOwnedPoints(points, false, thickness / 2);
251 }
252 
253 /**
254  * Creates an immutable wedge collision shape without initializing a physics world.
255  *
256  * @param input - Wedge center, radius, angular endpoints in radians, and sweep direction. See
257  * {@link PibblPhysicsVector2} .
258  * @returns An immutable wedge collision shape. See {@link PibblPhysicsShape2D}.
259  *
260  * @see {@link PibblPhysicsVector2}
261  * @see {@link PibblPhysicsShape2D}
262  */
263 export function wedgeShape2D(
264   input: Readonly<{
265     center?: PibblPhysicsVector2;
266     radius: number;
267     startAngleRadians: number;
268     endAngleRadians: number;
269     counterclockwise?: boolean;
270   }>,
271 ): PibblPhysicsShape2D {
272   const center = ownedVector(input.center ?? [0, 0], 'wedge.center');
273   const radius = requirePositiveNumber(input.radius, 'wedge.radius');
274   const startAngle = requireFiniteNumber(input.startAngleRadians, 'wedge.startAngleRadians');
275   const endAngle = requireFiniteNumber(input.endAngleRadians, 'wedge.endAngleRadians');
276   const points = flattenCircularSweep(
277     center[0]!, center[1]!, radius, startAngle, endAngle, input.counterclockwise === true,
278   );
279   const sweep = directedSweep(startAngle, endAngle, input.counterclockwise === true);
280   if (Math.abs(sweep) <= GEOMETRY_EPSILON) {
281     throw new RangeError('wedge angles must describe a nonzero sweep.');
282   }
283   const contourSource: PibblPhysicsVector2[] = Math.abs(sweep) >= FULL_TURN_RADIANS
284     ? points.slice(0, -1).map(asReadonlyVector)
285     : [asReadonlyVector(center), ...points.map(asReadonlyVector)];
286   const contour = canonicalizeContour2D(contourSource, {
287     strictlyConvex: false,
288     path: 'wedge.contour',
289   });
290   const triangles = triangulateContour2D(contour);
291   const leaves = triangles.map<PolygonLeaf2D>((vertices, canonicalLeafIndex) =>
292     Object.freeze({ kind: 'polygon', vertices, canonicalLeafIndex }),
293   );
294   const mass = aggregateLeafMass(leaves);
295   return createShapeFromLeaves(
296     leaves,
297     mass.area,
298     mass.centroidX,
299     mass.centroidY,
300     mass.unitInertia,
301   );
302 }
303 
304 /**
305  * Creates an immutable segment collision shape without initializing a physics world.
306  *
307  * @param input - Segment endpoints. See {@link PibblPhysicsVector2}.
308  * @returns An immutable line-segment collision shape. See {@link PibblPhysicsShape2D}.
309  *
310  * @see {@link PibblPhysicsVector2}
311  * @see {@link PibblPhysicsShape2D}
312  */
313 export function segmentShape2D(
314   input: Readonly<{ start: PibblPhysicsVector2; end: PibblPhysicsVector2 }>,
315 ): PibblPhysicsShape2D {
316   const start = ownedVector(input.start, 'segment.start');
317   const end = ownedVector(input.end, 'segment.end');
318   return createShapeFromLeaves(
319     [Object.freeze({ kind: 'segment', start, end, canonicalLeafIndex: 0 })],
320     0,
321     (start[0]! + end[0]!) / 2,
322     (start[1]! + end[1]!) / 2,
323     0,
324   );
325 }
326 
327 /**
328  * Creates an immutable chain collision shape without initializing a physics world.
329  *
330  * @param input - Ordered chain points, closure policy, and optional radius. See
331  * {@link PibblPhysicsVector2} .
332  * @returns An immutable chain collision shape. See {@link PibblPhysicsShape2D}.
333  *
334  * @see {@link PibblPhysicsVector2}
335  * @see {@link PibblPhysicsShape2D}
336  */
337 export function chainShape2D(
338   input: Readonly<{
339     points: readonly PibblPhysicsVector2[];
340     closed?: boolean;
341     radius?: number;
342   }>,
343 ): PibblPhysicsShape2D {
344   if (input.points.length < 2) {
345     throw new RangeError('chain.points must contain at least two points.');
346   }
347   const points = input.points.map((point, index) =>
348     ownedVector(point, `chain.points[${index}]`),
349   );
350   const radius = requireNonnegativeNumber(input.radius ?? 0, 'chain.radius');
351   return chainFromOwnedPoints(points, input.closed === true, radius);
352 }
353 
354 /**
355  * Creates an immutable polygon collision shape without initializing a physics world.
356  *
357  * @param input - Ordered polygon vertices. See {@link PibblPhysicsVector2}.
358  * @returns An immutable polygon collision shape. See {@link PibblPhysicsShape2D}.
359  *
360  * @see {@link PibblPhysicsVector2}
361  * @see {@link PibblPhysicsShape2D}
362  */
363 export function polygonShape2D(
364   input: Readonly<{ points: readonly PibblPhysicsVector2[] }>,
365 ): PibblPhysicsShape2D {
366   const vertices = canonicalizeContour2D(input.points, {
367     strictlyConvex: true,
368     path: 'polygon.points',
369   });
370   const mass = polygonMassData2D(vertices);
371   return createShapeFromLeaves(
372     [Object.freeze({ kind: 'polygon', vertices, canonicalLeafIndex: 0 })],
373     mass.area,
374     mass.centroidX,
375     mass.centroidY,
376     mass.unitInertia,
377   );
378 }
379 
380 /**
381  * Computes axis-aligned bounds for an immutable shape at an optional pose.
382  *
383  * @param shape - Shape whose bounds are needed. See {@link PibblPhysicsShape2D}.
384  * @param pose - Optional pose at which to evaluate the shape. See {@link PibblPhysicsPose2D}.
385  * @returns Axis-aligned bounds of the posed shape. See {@link PibblPhysicsAabb2D}.
386  *
387  * @see {@link PibblPhysicsShape2D}
388  * @see {@link PibblPhysicsPose2D}
389  * @see {@link PibblPhysicsAabb2D}
390  */
391 export function boundsOfShape2D(
392   shape: PibblPhysicsShape2D,
393   pose?: PibblPhysicsPose2D,
394 ): PibblPhysicsAabb2D {
395   const record = requireShapeRecord2D(shape);
396   const outerPose = copyPose2D(pose, 'pose');
397   return boundsForLeaves(record.leaves, composePose2D(outerPose, record.localPose));
398 }
399 
400 /**
401  * Computes shape area, centroid, mass, and rotational inertia at the requested density.
402  *
403  * @param shape - Shape whose mass properties are needed. See {@link PibblPhysicsShape2D}.
404  * @param options - Optional material density.
405  * @returns Mass, center of mass, and inertia for the shape. See {@link PibblPhysicsMassProperties2D}
406  * .
407  *
408  * @see {@link PibblPhysicsShape2D}
409  * @see {@link PibblPhysicsMassProperties2D}
410  */
411 export function massProperties2D(
412   shape: PibblPhysicsShape2D,
413   options?: Readonly<{ density?: number }>,
414 ): PibblPhysicsMassProperties2D {
415   const record = requireShapeRecord2D(shape);
416   const density = requirePositiveNumber(options?.density ?? 1, 'options.density');
417   const transformedCentroid = new Float64Array(2);
418   transformPointInto(
419     transformedCentroid,
420     0,
421     record.centroidX,
422     record.centroidY,
423     record.localPose,
424   );
425   return Object.freeze({
426     area: cleanZero(record.area),
427     centroid: Object.freeze([
428       cleanZero(transformedCentroid[0]!),
429       cleanZero(transformedCentroid[1]!),
430     ] as const),
431     mass: cleanZero(record.area * density),
432     rotationalInertia: cleanZero(record.unitInertia * density),
433   });
434 }
435 
436 /**
437  * Returns independent shape geometry transformed by a rigid 2D pose.
438  *
439  * @param shape - Source shape; it is not modified. See {@link PibblPhysicsShape2D}.
440  * @param transform - Transform to apply to the shape. See {@link PibblPhysicsTransform2D}.
441  * @returns A shape containing the transformed geometry. See {@link PibblPhysicsShape2D}.
442  *
443  * @see {@link PibblPhysicsShape2D}
444  * @see {@link PibblPhysicsTransform2D}
445  */
446 export function transformShape2D(
447   shape: PibblPhysicsShape2D,
448   transform: PibblPhysicsTransform2D,
449 ): PibblPhysicsShape2D {
450   const source = requireShapeRecord2D(shape);
451   const localPose = composePose2D(copyPose2D(transform, 'transform'), source.localPose);
452   const localBounds = mutableBoundsForLeaves(source.leaves, localPose);
453   return createShape2D({
454     leaves: source.leaves,
455     localPose,
456     localBounds,
457     area: source.area,
458     centroidX: source.centroidX,
459     centroidY: source.centroidY,
460     unitInertia: source.unitInertia,
461   });
462 }
463 
464 function createShapeFromLeaves(
465   leaves: readonly ConvexLeaf2D[],
466   area: number,
467   centroidX: number,
468   centroidY: number,
469   unitInertia: number,
470 ): PibblPhysicsShape2D {
471   return createShape2D({
472     leaves,
473     localBounds: mutableBoundsForLeaves(leaves, IDENTITY_POSE_2D),
474     area,
475     centroidX,
476     centroidY,
477     unitInertia: Math.max(0, unitInertia),
478   });
479 }
480 
481 function chainFromOwnedPoints(
482   points: readonly Float64Array[],
483   closed: boolean,
484   radius: number,
485 ): PibblPhysicsShape2D {
486   const segmentCount = points.length === 1 ? 0 : points.length - 1 + (closed ? 1 : 0);
487   const leaves: ConvexLeaf2D[] = [];
488   for (let index = 0; index < segmentCount; index += 1) {
489     const start = points[index]!;
490     const end = points[(index + 1) % points.length]!;
491     leaves.push(Object.freeze(radius === 0
492       ? { kind: 'segment', start, end, canonicalLeafIndex: index }
493       : { kind: 'capsule', start, end, radius, canonicalLeafIndex: index }));
494   }
495   if (leaves.length === 0) {
496     const point = points[0]!;
497     const area = Math.PI * radius * radius;
498     leaves.push(Object.freeze({
499       kind: 'circle', center: point, radius, canonicalLeafIndex: 0,
500     }));
501     return createShapeFromLeaves(
502       leaves,
503       area,
504       point[0]!,
505       point[1]!,
506       area * radius * radius / 2,
507     );
508   }
509   if (radius > 0) {
510     const mass = aggregateLeafMass(leaves);
511     return createShapeFromLeaves(
512       leaves,
513       mass.area,
514       mass.centroidX,
515       mass.centroidY,
516       mass.unitInertia,
517     );
518   }
519   const centroid = lineCentroid(points, closed);
520   return createShapeFromLeaves(leaves, 0, centroid[0], centroid[1], 0);
521 }
522 
523 function boundsForLeaves(
524   leaves: readonly ConvexLeaf2D[],
525   pose: InternalPose2D,
526 ): PibblPhysicsAabb2D {
527   const bounds = mutableBoundsForLeaves(leaves, pose);
528   return freezeBounds2D(bounds[0]!, bounds[1]!, bounds[2]!, bounds[3]!);
529 }
530 
531 function mutableBoundsForLeaves(
532   leaves: readonly ConvexLeaf2D[],
533   pose: InternalPose2D,
534 ): Float64Array {
535   const result = new Float64Array([
536     Number.POSITIVE_INFINITY,
537     Number.POSITIVE_INFINITY,
538     Number.NEGATIVE_INFINITY,
539     Number.NEGATIVE_INFINITY,
540   ]);
541   const point = new Float64Array(2);
542   const include = (x: number, y: number, radius = 0): void => {
543     transformPointInto(point, 0, x, y, pose);
544     result[0] = Math.min(result[0]!, point[0]! - radius);
545     result[1] = Math.min(result[1]!, point[1]! - radius);
546     result[2] = Math.max(result[2]!, point[0]! + radius);
547     result[3] = Math.max(result[3]!, point[1]! + radius);
548   };
549   for (const leaf of leaves) {
550     switch (leaf.kind) {
551       case 'circle':
552         include(leaf.center[0]!, leaf.center[1]!, leaf.radius);
553         break;
554       case 'ellipse': {
555         transformPointInto(point, 0, leaf.center[0]!, leaf.center[1]!, pose);
556         const angle = pose.rotationRadians + leaf.rotationRadians;
557         const cosine = Math.cos(angle);
558         const sine = Math.sin(angle);
559         const extentX = Math.hypot(leaf.radiusX * cosine, leaf.radiusY * sine);
560         const extentY = Math.hypot(leaf.radiusX * sine, leaf.radiusY * cosine);
561         result[0] = Math.min(result[0]!, point[0]! - extentX);
562         result[1] = Math.min(result[1]!, point[1]! - extentY);
563         result[2] = Math.max(result[2]!, point[0]! + extentX);
564         result[3] = Math.max(result[3]!, point[1]! + extentY);
565         break;
566       }
567       case 'box':
568         includeBoxCorners(leaf.center, leaf.halfWidth, leaf.halfHeight, pose, result, point);
569         break;
570       case 'rounded-box':
571         includeRoundedBoxBounds(leaf, pose, result, point);
572         break;
573       case 'capsule':
574         include(leaf.start[0]!, leaf.start[1]!, leaf.radius);
575         include(leaf.end[0]!, leaf.end[1]!, leaf.radius);
576         break;
577       case 'segment':
578         include(leaf.start[0]!, leaf.start[1]!);
579         include(leaf.end[0]!, leaf.end[1]!);
580         break;
581       case 'polygon':
582         for (let offset = 0; offset < leaf.vertices.length; offset += 2) {
583           include(leaf.vertices[offset]!, leaf.vertices[offset + 1]!);
584         }
585         break;
586     }
587   }
588   return result;
589 }
590 
591 function includeBoxCorners(
592   center: Float64Array,
593   halfWidth: number,
594   halfHeight: number,
595   pose: InternalPose2D,
596   bounds: Float64Array,
597   point: Float64Array,
598 ): void {
599   for (const xSign of [-1, 1]) {
600     for (const ySign of [-1, 1]) {
601       transformPointInto(
602         point,
603         0,
604         center[0]! + xSign * halfWidth,
605         center[1]! + ySign * halfHeight,
606         pose,
607       );
608       bounds[0] = Math.min(bounds[0]!, point[0]!);
609       bounds[1] = Math.min(bounds[1]!, point[1]!);
610       bounds[2] = Math.max(bounds[2]!, point[0]!);
611       bounds[3] = Math.max(bounds[3]!, point[1]!);
612     }
613   }
614 }
615 
616 function includeRoundedBoxBounds(
617   leaf: Extract<ConvexLeaf2D, { kind: 'rounded-box' }>,
618   pose: InternalPose2D,
619   bounds: Float64Array,
620   point: Float64Array,
621 ): void {
622   const xSigns = [-1, 1, 1, -1] as const;
623   const ySigns = [-1, -1, 1, 1] as const;
624   for (let index = 0; index < 4; index += 1) {
625     const radius = leaf.radii[index]!;
626     transformPointInto(
627       point,
628       0,
629       leaf.center[0]! + xSigns[index]! * (leaf.halfWidth - radius),
630       leaf.center[1]! + ySigns[index]! * (leaf.halfHeight - radius),
631       pose,
632     );
633     bounds[0] = Math.min(bounds[0]!, point[0]! - radius);
634     bounds[1] = Math.min(bounds[1]!, point[1]! - radius);
635     bounds[2] = Math.max(bounds[2]!, point[0]! + radius);
636     bounds[3] = Math.max(bounds[3]!, point[1]! + radius);
637   }
638 }
639 
640 function aggregateLeafMass(leaves: readonly ConvexLeaf2D[]): Readonly<{
641   area: number;
642   centroidX: number;
643   centroidY: number;
644   unitInertia: number;
645 }> {
646   const entries = leaves.map(leafMassData);
647   const area = entries.reduce((sum, entry) => sum + entry.area, 0);
648   if (area === 0) {
649     return Object.freeze({ area: 0, centroidX: 0, centroidY: 0, unitInertia: 0 });
650   }
651   const centroidX = entries.reduce((sum, entry) => sum + entry.area * entry.centroidX, 0) / area;
652   const centroidY = entries.reduce((sum, entry) => sum + entry.area * entry.centroidY, 0) / area;
653   const unitInertia = entries.reduce((sum, entry) => {
654     const dx = entry.centroidX - centroidX;
655     const dy = entry.centroidY - centroidY;
656     return sum + entry.unitInertia + entry.area * (dx * dx + dy * dy);
657   }, 0);
658   return Object.freeze({ area, centroidX, centroidY, unitInertia });
659 }
660 
661 function leafMassData(leaf: ConvexLeaf2D): Readonly<{
662   area: number;
663   centroidX: number;
664   centroidY: number;
665   unitInertia: number;
666 }> {
667   switch (leaf.kind) {
668     case 'circle': {
669       const area = Math.PI * leaf.radius * leaf.radius;
670       return { area, centroidX: leaf.center[0]!, centroidY: leaf.center[1]!, unitInertia: area * leaf.radius * leaf.radius / 2 };
671     }
672     case 'ellipse': {
673       const area = Math.PI * leaf.radiusX * leaf.radiusY;
674       return { area, centroidX: leaf.center[0]!, centroidY: leaf.center[1]!, unitInertia: area * (leaf.radiusX * leaf.radiusX + leaf.radiusY * leaf.radiusY) / 4 };
675     }
676     case 'box': {
677       const width = leaf.halfWidth * 2;
678       const height = leaf.halfHeight * 2;
679       const area = width * height;
680       return { area, centroidX: leaf.center[0]!, centroidY: leaf.center[1]!, unitInertia: area * (width * width + height * height) / 12 };
681     }
682     case 'capsule':
683       return capsuleMassData(leaf.start, leaf.end, leaf.radius);
684     case 'polygon':
685       return polygonMassData2D(leaf.vertices);
686     case 'segment':
687       return { area: 0, centroidX: (leaf.start[0]! + leaf.end[0]!) / 2, centroidY: (leaf.start[1]! + leaf.end[1]!) / 2, unitInertia: 0 };
688     case 'rounded-box': {
689       const contour = roundedBoxContour(leaf.halfWidth, leaf.halfHeight, leaf.radii, leaf.center);
690       return polygonMassData2D(contour);
691     }
692   }
693 }
694 
695 function capsuleMassData(
696   start: Float64Array,
697   end: Float64Array,
698   radius: number,
699 ): Readonly<{ area: number; centroidX: number; centroidY: number; unitInertia: number }> {
700   const dx = end[0]! - start[0]!;
701   const dy = end[1]! - start[1]!;
702   const length = Math.hypot(dx, dy);
703   const rectangleArea = 2 * radius * length;
704   const circleArea = Math.PI * radius * radius;
705   const area = rectangleArea + circleArea;
706   const rectangleInertia = rectangleArea * (length * length + 4 * radius * radius) / 12;
707   const capsInertia =
708     Math.PI * radius ** 4 / 2 +
709     circleArea * length * length / 4 +
710     4 * length * radius ** 3 / 3;
711   return Object.freeze({
712     area,
713     centroidX: (start[0]! + end[0]!) / 2,
714     centroidY: (start[1]! + end[1]!) / 2,
715     unitInertia: rectangleInertia + capsInertia,
716   });
717 }
718 
719 function lineCentroid(
720   points: readonly Float64Array[],
721   closed: boolean,
722 ): readonly [number, number] {
723   const segmentCount = points.length - 1 + (closed ? 1 : 0);
724   let totalLength = 0;
725   let weightedX = 0;
726   let weightedY = 0;
727   for (let index = 0; index < segmentCount; index += 1) {
728     const start = points[index]!;
729     const end = points[(index + 1) % points.length]!;
730     const length = Math.hypot(end[0]! - start[0]!, end[1]! - start[1]!);
731     totalLength += length;
732     weightedX += length * (start[0]! + end[0]!) / 2;
733     weightedY += length * (start[1]! + end[1]!) / 2;
734   }
735   if (totalLength > 0) {
736     return [weightedX / totalLength, weightedY / totalLength];
737   }
738   return [points.reduce((sum, point) => sum + point[0]!, 0) / points.length, points.reduce((sum, point) => sum + point[1]!, 0) / points.length];
739 }
740 
741 function roundedBoxContour(
742   halfWidth: number,
743   halfHeight: number,
744   radii: Float64Array,
745   center: Float64Array,
746 ): Float64Array {
747   const points: Float64Array[] = [];
748   const cornerData = [
749     [halfWidth - radii[1]!, -halfHeight + radii[1]!, -Math.PI / 2, 0, radii[1]!],
750     [halfWidth - radii[2]!, halfHeight - radii[2]!, 0, Math.PI / 2, radii[2]!],
751     [-halfWidth + radii[3]!, halfHeight - radii[3]!, Math.PI / 2, Math.PI, radii[3]!],
752     [-halfWidth + radii[0]!, -halfHeight + radii[0]!, Math.PI, 3 * Math.PI / 2, radii[0]!],
753   ] as const;
754   for (const [x, y, start, end, radius] of cornerData) {
755     const cornerPoints = radius === 0
756       ? [new Float64Array([center[0]! + x, center[1]! + y])]
757       : flattenCircularSweep(center[0]! + x, center[1]! + y, radius, start, end, false);
758     points.push(...cornerPoints);
759   }
760   return canonicalizeContour2D(points.map(asReadonlyVector), {
761     strictlyConvex: false,
762     path: 'roundedBox.contour',
763   });
764 }
765 
766 function flattenCircularSweep(
767   centerX: number,
768   centerY: number,
769   radius: number,
770   startAngle: number,
771   endAngle: number,
772   counterclockwise: boolean,
773 ): Float64Array[] {
774   const sweep = directedSweep(startAngle, endAngle, counterclockwise);
775   const points = [pointOnCircle(centerX, centerY, radius, startAngle)];
776   appendFlattenedArc(points, centerX, centerY, radius, startAngle, startAngle + sweep, 0);
777   if (Math.abs(sweep) >= FULL_TURN_RADIANS) {
778     points[points.length - 1] = new Float64Array(points[0]!);
779   }
780   return points;
781 }
782 
783 function appendFlattenedArc(
784   output: Float64Array[],
785   centerX: number,
786   centerY: number,
787   radius: number,
788   startAngle: number,
789   endAngle: number,
790   depth: number,
791 ): void {
792   const middleAngle = (startAngle + endAngle) / 2;
793   const halfSweep = Math.abs(endAngle - startAngle) / 2;
794   const chordError = radius * (1 - Math.cos(halfSweep));
795   if (
796     chordError <= CURVE_FLATTENING_TOLERANCE ||
797     depth >= CURVE_FLATTENING_MAX_DEPTH
798   ) {
799     output.push(pointOnCircle(centerX, centerY, radius, endAngle));
800     return;
801   }
802   appendFlattenedArc(output, centerX, centerY, radius, startAngle, middleAngle, depth + 1);
803   appendFlattenedArc(output, centerX, centerY, radius, middleAngle, endAngle, depth + 1);
804 }
805 
806 function directedSweep(
807   startAngle: number,
808   endAngle: number,
809   counterclockwise: boolean,
810 ): number {
811   const raw = endAngle - startAngle;
812   if (Math.abs(raw) >= FULL_TURN_RADIANS) {
813     return counterclockwise ? -FULL_TURN_RADIANS : FULL_TURN_RADIANS;
814   }
815   if (counterclockwise) {
816     const magnitude = ((-raw % FULL_TURN_RADIANS) + FULL_TURN_RADIANS) % FULL_TURN_RADIANS;
817     return -magnitude;
818   }
819   return ((raw % FULL_TURN_RADIANS) + FULL_TURN_RADIANS) % FULL_TURN_RADIANS;
820 }
821 
822 function pointOnCircle(
823   centerX: number,
824   centerY: number,
825   radius: number,
826   angle: number,
827 ): Float64Array {
828   return new Float64Array([
829     centerX + radius * Math.cos(angle),
830     centerY + radius * Math.sin(angle),
831   ]);
832 }
833 
834 function ownedVector(value: PibblPhysicsVector2, path: string): Float64Array {
835   const copied = copyFiniteVector2(value, path);
836   return new Float64Array(copied);
837 }
838 
839 function asReadonlyVector(value: Float64Array): PibblPhysicsVector2 {
840   return [value[0]!, value[1]!] as const;
841 }
842
## Documentation version Documentation built with @pibbl/core 0.0.2, revision 272a94a. ALPHA — NOT FOR PRODUCTION USE.