@pibbl/core 0.0.1

package/dist/features/physics/lib/2d/runtime/world-component.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/features/physics/lib/2d/runtime/world-component.ts"],
+  "sourcesContent": ["import type { PibblComponent } from \"@pibbl/core\";\nimport {\n  pibblInternalCurrentSimulationOwner,\n  pibblInternalCurrentWorldTransform,\n  setCurrentComponentAfterRender,\n  useInternalHookSlot,\n} from \"@pibbl/core/internal\";\nimport type {\n  PibblPhysicsWorld2DProps,\n  PibblPhysicsWorldHandle2D,\n} from \"../types.js\";\nimport { resolveSignalFields } from \"../../shared/signal-inputs.js\";\nimport type { PibblResolvedPhysicsWorld2DProps } from \"./world-props.js\";\nimport { pushPhysicsWorld2D, requireCurrentPhysicsWorld2D } from \"./context.js\";\nimport { PhysicsWorld2DController } from \"./controller.js\";\n\nconst renderPhysicsWorld2D: PibblComponent<PibblPhysicsWorld2DProps> = (props) => {\n  const resolvedProps = resolveSignalFields<PibblResolvedPhysicsWorld2DProps>(\n    props,\n    WORLD_STRUCTURAL_FIELDS,\n  );\n  const owner = pibblInternalCurrentSimulationOwner();\n  const slot = useInternalHookSlot(\"physicsWorld2DController\", (teardowns) => {\n    const controller = new PhysicsWorld2DController(owner, resolvedProps);\n    teardowns.add(() => controller.dispose());\n    return controller;\n  });\n  const controller = slot.value;\n  controller.beginRender(resolvedProps, pibblInternalCurrentWorldTransform());\n  const popWorld = pushPhysicsWorld2D(controller);\n  try {\n    setCurrentComponentAfterRender(popWorld);\n  } catch (error) {\n    popWorld();\n    throw error;\n  }\n  return props.children;\n};\n\nconst WORLD_STRUCTURAL_FIELDS = new Set<PropertyKey>([\"children\"]);\n\n/**\n * Owns one transparent, component-scoped 2D physics world.\n *\n * @see {@link PibblComponent}\n * @see {@link PibblPhysicsWorld2DProps}\n */\nexport const PhysicsWorld2D = renderPhysicsWorld2D;\n\n/**\n * Returns the nearest 2D physics world while a descendant is evaluating.\n *\n * @returns A stable world handle that can be attached to a physics world. See\n * {@link PibblPhysicsWorldHandle2D} .\n *\n * @see {@link PibblPhysicsWorldHandle2D}\n */\nexport function pibblPhysicsWorld2D(): PibblPhysicsWorldHandle2D {\n  return requireCurrentPhysicsWorld2D().handle;\n}\n"],
+  "mappings": "AACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP,SAAS,2BAA2B;AAEpC,SAAS,oBAAoB,oCAAoC;AACjE,SAAS,gCAAgC;AAEzC,MAAM,uBAAiE,CAAC,UAAU;AAChF,QAAM,gBAAgB;AAAA,IACpB;AAAA,IACA;AAAA,EACF;AACA,QAAM,QAAQ,oCAAoC;AAClD,QAAM,OAAO,oBAAoB,4BAA4B,CAAC,cAAc;AAC1E,UAAMA,cAAa,IAAI,yBAAyB,OAAO,aAAa;AACpE,cAAU,IAAI,MAAMA,YAAW,QAAQ,CAAC;AACxC,WAAOA;AAAA,EACT,CAAC;AACD,QAAM,aAAa,KAAK;AACxB,aAAW,YAAY,eAAe,mCAAmC,CAAC;AAC1E,QAAM,WAAW,mBAAmB,UAAU;AAC9C,MAAI;AACF,mCAA+B,QAAQ;AAAA,EACzC,SAAS,OAAO;AACd,aAAS;AACT,UAAM;AAAA,EACR;AACA,SAAO,MAAM;AACf;AAEA,MAAM,0BAA0B,oBAAI,IAAiB,CAAC,UAAU,CAAC;AAQ1D,MAAM,iBAAiB;AAUvB,SAAS,sBAAiD;AAC/D,SAAO,6BAA6B,EAAE;AACxC;",
+  "names": ["controller"]
+}

package/dist/features/physics/lib/2d/runtime/world-props.d.ts

@@ -0,0 +1,16 @@
+import type { PibblNodeInput } from "@pibbl/core";
+import type { PibblPhysicsVector2 } from "../../../2d-geometry.js";
+import type { PibblPhysicsBodyStateHandler2D, PibblPhysicsSolverOptions } from "../types.js";
+export interface PibblResolvedPhysicsWorld2DProps {
+    readonly space?: "root" | "local";
+    readonly gravity?: PibblPhysicsVector2;
+    readonly fixedStepMilliseconds?: number;
+    readonly maxCatchUpSteps?: number;
+    readonly interpolation?: "linear" | "none";
+    readonly sleeping?: boolean;
+    readonly solver?: PibblPhysicsSolverOptions;
+    readonly onSleep?: PibblPhysicsBodyStateHandler2D;
+    readonly onWake?: PibblPhysicsBodyStateHandler2D;
+    readonly onError?: (error: unknown) => void;
+    readonly children?: PibblNodeInput;
+}

package/dist/features/physics/lib/2d/shape-records.d.ts

@@ -0,0 +1,60 @@
+import type { PibblPhysicsShape2D } from '../../2d-geometry.js';
+import { type InternalPose2D } from './math.js';
+interface LeafBase2D {
+    readonly canonicalLeafIndex: number;
+}
+export interface CircleLeaf2D extends LeafBase2D {
+    readonly kind: 'circle';
+    readonly center: Float64Array;
+    readonly radius: number;
+}
+export interface EllipseLeaf2D extends LeafBase2D {
+    readonly kind: 'ellipse';
+    readonly center: Float64Array;
+    readonly radiusX: number;
+    readonly radiusY: number;
+    readonly rotationRadians: number;
+}
+export interface BoxLeaf2D extends LeafBase2D {
+    readonly kind: 'box';
+    readonly center: Float64Array;
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+}
+export interface RoundedBoxLeaf2D extends LeafBase2D {
+    readonly kind: 'rounded-box';
+    readonly center: Float64Array;
+    readonly halfWidth: number;
+    readonly halfHeight: number;
+    readonly radii: Float64Array;
+}
+export interface CapsuleLeaf2D extends LeafBase2D {
+    readonly kind: 'capsule';
+    readonly start: Float64Array;
+    readonly end: Float64Array;
+    readonly radius: number;
+}
+export interface SegmentLeaf2D extends LeafBase2D {
+    readonly kind: 'segment';
+    readonly start: Float64Array;
+    readonly end: Float64Array;
+}
+export interface PolygonLeaf2D extends LeafBase2D {
+    readonly kind: 'polygon';
+    readonly vertices: Float64Array;
+}
+export type ConvexLeaf2D = CircleLeaf2D | EllipseLeaf2D | BoxLeaf2D | RoundedBoxLeaf2D | CapsuleLeaf2D | SegmentLeaf2D | PolygonLeaf2D;
+export interface ShapeRecord2D {
+    readonly leaves: readonly ConvexLeaf2D[];
+    readonly localPose: InternalPose2D;
+    readonly localBounds: Float64Array;
+    readonly area: number;
+    readonly centroidX: number;
+    readonly centroidY: number;
+    readonly unitInertia: number;
+}
+export declare function createShape2D(record: Omit<ShapeRecord2D, 'localPose'> & Readonly<{
+    localPose?: InternalPose2D;
+}>): PibblPhysicsShape2D;
+export declare function requireShapeRecord2D(shape: PibblPhysicsShape2D): ShapeRecord2D;
+export {};

package/dist/features/physics/lib/2d/shape-records.js

@@ -0,0 +1,26 @@
+import { IDENTITY_POSE_2D } from "./math.js";
+const shapeRecords2D = /* @__PURE__ */ new WeakMap();
+function createShape2D(record) {
+  const shell = Object.freeze({});
+  shapeRecords2D.set(
+    shell,
+    Object.freeze({
+      ...record,
+      leaves: Object.isFrozen(record.leaves) ? record.leaves : Object.freeze([...record.leaves]),
+      localPose: record.localPose ?? IDENTITY_POSE_2D
+    })
+  );
+  return shell;
+}
+function requireShapeRecord2D(shape) {
+  const record = typeof shape === "object" && shape !== null ? shapeRecords2D.get(shape) : void 0;
+  if (record === void 0) {
+    throw new TypeError("shape must be a Pibbl physics 2D shape.");
+  }
+  return record;
+}
+export {
+  createShape2D,
+  requireShapeRecord2D
+};
+//# sourceMappingURL=shape-records.js.map

package/dist/features/physics/lib/2d/shape-records.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/features/physics/lib/2d/shape-records.ts"],
+  "sourcesContent": ["import type { PibblPhysicsShape2D } from '../../2d-geometry.js';\nimport { IDENTITY_POSE_2D, type InternalPose2D } from './math.js';\n\ninterface LeafBase2D {\n  readonly canonicalLeafIndex: number;\n}\n\nexport interface CircleLeaf2D extends LeafBase2D {\n  readonly kind: 'circle';\n  readonly center: Float64Array;\n  readonly radius: number;\n}\n\nexport interface EllipseLeaf2D extends LeafBase2D {\n  readonly kind: 'ellipse';\n  readonly center: Float64Array;\n  readonly radiusX: number;\n  readonly radiusY: number;\n  readonly rotationRadians: number;\n}\n\nexport interface BoxLeaf2D extends LeafBase2D {\n  readonly kind: 'box';\n  readonly center: Float64Array;\n  readonly halfWidth: number;\n  readonly halfHeight: number;\n}\n\nexport interface RoundedBoxLeaf2D extends LeafBase2D {\n  readonly kind: 'rounded-box';\n  readonly center: Float64Array;\n  readonly halfWidth: number;\n  readonly halfHeight: number;\n  readonly radii: Float64Array;\n}\n\nexport interface CapsuleLeaf2D extends LeafBase2D {\n  readonly kind: 'capsule';\n  readonly start: Float64Array;\n  readonly end: Float64Array;\n  readonly radius: number;\n}\n\nexport interface SegmentLeaf2D extends LeafBase2D {\n  readonly kind: 'segment';\n  readonly start: Float64Array;\n  readonly end: Float64Array;\n}\n\nexport interface PolygonLeaf2D extends LeafBase2D {\n  readonly kind: 'polygon';\n  readonly vertices: Float64Array;\n}\n\nexport type ConvexLeaf2D =\n  | CircleLeaf2D\n  | EllipseLeaf2D\n  | BoxLeaf2D\n  | RoundedBoxLeaf2D\n  | CapsuleLeaf2D\n  | SegmentLeaf2D\n  | PolygonLeaf2D;\n\nexport interface ShapeRecord2D {\n  readonly leaves: readonly ConvexLeaf2D[];\n  readonly localPose: InternalPose2D;\n  readonly localBounds: Float64Array;\n  readonly area: number;\n  readonly centroidX: number;\n  readonly centroidY: number;\n  readonly unitInertia: number;\n}\n\nconst shapeRecords2D = new WeakMap<object, ShapeRecord2D>();\n\nexport function createShape2D(\n  record: Omit<ShapeRecord2D, 'localPose'> &\n    Readonly<{ localPose?: InternalPose2D }>,\n): PibblPhysicsShape2D {\n  const shell = Object.freeze({}) as PibblPhysicsShape2D;\n  shapeRecords2D.set(\n    shell,\n    Object.freeze({\n      ...record,\n      leaves: Object.isFrozen(record.leaves)\n        ? record.leaves\n        : Object.freeze([...record.leaves]),\n      localPose: record.localPose ?? IDENTITY_POSE_2D,\n    }),\n  );\n  return shell;\n}\n\nexport function requireShapeRecord2D(shape: PibblPhysicsShape2D): ShapeRecord2D {\n  const record =\n    typeof shape === 'object' && shape !== null\n      ? shapeRecords2D.get(shape)\n      : undefined;\n  if (record === undefined) {\n    throw new TypeError('shape must be a Pibbl physics 2D shape.');\n  }\n  return record;\n}\n"],
+  "mappings": "AACA,SAAS,wBAA6C;AAwEtD,MAAM,iBAAiB,oBAAI,QAA+B;AAEnD,SAAS,cACd,QAEqB;AACrB,QAAM,QAAQ,OAAO,OAAO,CAAC,CAAC;AAC9B,iBAAe;AAAA,IACb;AAAA,IACA,OAAO,OAAO;AAAA,MACZ,GAAG;AAAA,MACH,QAAQ,OAAO,SAAS,OAAO,MAAM,IACjC,OAAO,SACP,OAAO,OAAO,CAAC,GAAG,OAAO,MAAM,CAAC;AAAA,MACpC,WAAW,OAAO,aAAa;AAAA,IACjC,CAAC;AAAA,EACH;AACA,SAAO;AACT;AAEO,SAAS,qBAAqB,OAA2C;AAC9E,QAAM,SACJ,OAAO,UAAU,YAAY,UAAU,OACnC,eAAe,IAAI,KAAK,IACxB;AACN,MAAI,WAAW,QAAW;AACxB,UAAM,IAAI,UAAU,yCAAyC;AAAA,EAC/D;AACA,SAAO;AACT;",
+  "names": []
+}

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

@@ -0,0 +1,191 @@
+import type { PibblPhysicsAabb2D, PibblPhysicsMassProperties2D, PibblPhysicsPose2D, PibblPhysicsShape2D, PibblPhysicsTransform2D, PibblPhysicsVector2 } from '../../2d-geometry.js';
+/**
+ * Creates an immutable circle collision shape without initializing a physics world.
+ *
+ * @param input - Circle radius and optional center. See {@link PibblPhysicsVector2}.
+ * @returns An immutable circle collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function circleShape2D(input: Readonly<{
+    radius: number;
+    center?: PibblPhysicsVector2;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable ellipse collision shape without initializing a physics world.
+ *
+ * @param input - Ellipse radii, optional center, and rotation in degrees. See
+ * {@link PibblPhysicsVector2} .
+ * @returns An immutable ellipse collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function ellipseShape2D(input: Readonly<{
+    radiusX: number;
+    radiusY: number;
+    center?: PibblPhysicsVector2;
+    rotationDegrees?: number;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable box collision shape without initializing a physics world.
+ *
+ * @param input - Box width, height, and optional center. See {@link PibblPhysicsVector2}.
+ * @returns An immutable box collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function boxShape2D(input: Readonly<{
+    width: number;
+    height: number;
+    center?: PibblPhysicsVector2;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable rounded box collision shape without initializing a physics world.
+ *
+ * @param input - Box dimensions, center, and uniform or per-corner radii. See
+ * {@link PibblPhysicsVector2} .
+ * @returns An immutable rounded-box collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function roundedBoxShape2D(input: Readonly<{
+    width: number;
+    height: number;
+    radius: number | readonly [
+        topLeft: number,
+        topRight: number,
+        bottomRight: number,
+        bottomLeft: number
+    ];
+    center?: PibblPhysicsVector2;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable capsule collision shape without initializing a physics world.
+ *
+ * @param input - Capsule centerline endpoints and radius. See {@link PibblPhysicsVector2}.
+ * @returns An immutable capsule collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function capsuleShape2D(input: Readonly<{
+    start: PibblPhysicsVector2;
+    end: PibblPhysicsVector2;
+    radius: number;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable arc collision shape without initializing a physics world.
+ *
+ * @param input - Arc center, radius, angular endpoints in radians, sweep direction, and thickness.
+ * See {@link PibblPhysicsVector2} .
+ * @returns An immutable thick-arc collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function arcShape2D(input: Readonly<{
+    center?: PibblPhysicsVector2;
+    radius: number;
+    startAngleRadians: number;
+    endAngleRadians: number;
+    counterclockwise?: boolean;
+    thickness: number;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable wedge collision shape without initializing a physics world.
+ *
+ * @param input - Wedge center, radius, angular endpoints in radians, and sweep direction. See
+ * {@link PibblPhysicsVector2} .
+ * @returns An immutable wedge collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function wedgeShape2D(input: Readonly<{
+    center?: PibblPhysicsVector2;
+    radius: number;
+    startAngleRadians: number;
+    endAngleRadians: number;
+    counterclockwise?: boolean;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable segment collision shape without initializing a physics world.
+ *
+ * @param input - Segment endpoints. See {@link PibblPhysicsVector2}.
+ * @returns An immutable line-segment collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function segmentShape2D(input: Readonly<{
+    start: PibblPhysicsVector2;
+    end: PibblPhysicsVector2;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable chain collision shape without initializing a physics world.
+ *
+ * @param input - Ordered chain points, closure policy, and optional radius. See
+ * {@link PibblPhysicsVector2} .
+ * @returns An immutable chain collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function chainShape2D(input: Readonly<{
+    points: readonly PibblPhysicsVector2[];
+    closed?: boolean;
+    radius?: number;
+}>): PibblPhysicsShape2D;
+/**
+ * Creates an immutable polygon collision shape without initializing a physics world.
+ *
+ * @param input - Ordered polygon vertices. See {@link PibblPhysicsVector2}.
+ * @returns An immutable polygon collision shape. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsVector2}
+ * @see {@link PibblPhysicsShape2D}
+ */
+export declare function polygonShape2D(input: Readonly<{
+    points: readonly PibblPhysicsVector2[];
+}>): PibblPhysicsShape2D;
+/**
+ * Computes axis-aligned bounds for an immutable shape at an optional pose.
+ *
+ * @param shape - Shape whose bounds are needed. See {@link PibblPhysicsShape2D}.
+ * @param pose - Optional pose at which to evaluate the shape. See {@link PibblPhysicsPose2D}.
+ * @returns Axis-aligned bounds of the posed shape. See {@link PibblPhysicsAabb2D}.
+ *
+ * @see {@link PibblPhysicsShape2D}
+ * @see {@link PibblPhysicsPose2D}
+ * @see {@link PibblPhysicsAabb2D}
+ */
+export declare function boundsOfShape2D(shape: PibblPhysicsShape2D, pose?: PibblPhysicsPose2D): PibblPhysicsAabb2D;
+/**
+ * Computes shape area, centroid, mass, and rotational inertia at the requested density.
+ *
+ * @param shape - Shape whose mass properties are needed. See {@link PibblPhysicsShape2D}.
+ * @param options - Optional material density.
+ * @returns Mass, center of mass, and inertia for the shape. See {@link PibblPhysicsMassProperties2D}
+ * .
+ *
+ * @see {@link PibblPhysicsShape2D}
+ * @see {@link PibblPhysicsMassProperties2D}
+ */
+export declare function massProperties2D(shape: PibblPhysicsShape2D, options?: Readonly<{
+    density?: number;
+}>): PibblPhysicsMassProperties2D;
+/**
+ * Returns independent shape geometry transformed by a rigid 2D pose.
+ *
+ * @param shape - Source shape; it is not modified. See {@link PibblPhysicsShape2D}.
+ * @param transform - Transform to apply to the shape. See {@link PibblPhysicsTransform2D}.
+ * @returns A shape containing the transformed geometry. See {@link PibblPhysicsShape2D}.
+ *
+ * @see {@link PibblPhysicsShape2D}
+ * @see {@link PibblPhysicsTransform2D}
+ */
+export declare function transformShape2D(shape: PibblPhysicsShape2D, transform: PibblPhysicsTransform2D): PibblPhysicsShape2D;