melonjs 19.4.0 → 19.5.0

package/build/physics/adapter.d.ts

@@ -0,0 +1,560 @@
+import type { Ellipse } from "../geometries/ellipse.ts";
+import type { Polygon } from "../geometries/polygon.ts";
+import type { Rect } from "../geometries/rectangle.ts";
+import type { Vector2d } from "../math/vector2d.ts";
+import type Renderable from "../renderable/renderable.js";
+import type { Bounds } from "./bounds.ts";
+import type World from "./world.js";
+/**
+ * Body simulation kind. `static` bodies never move (terrain, walls);
+ * `dynamic` bodies are simulated (player, projectiles); `kinematic`
+ * bodies are user-positioned but participate in collision (moving
+ * platforms, elevators).
+ */
+export type BodyType = "static" | "dynamic" | "kinematic";
+/** Collision shape that a physics body may be composed of. */
+export type BodyShape = Rect | Ellipse | Polygon;
+/**
+ * Collision response passed to the modern collision lifecycle hooks
+ * (`onCollisionStart`, `onCollisionActive`, `onCollisionEnd`) on every
+ * adapter.
+ *
+ * **Receiver-symmetric:** `a` is always the renderable whose handler is
+ * firing (`response.a === this`), `b` is always the partner (`response.b
+ * === other`). The same overlap is dispatched once to each side as a
+ * separate response with `a`/`b` swapped accordingly.
+ *
+ * **NOT the same contract as the legacy `onCollision`.** The legacy
+ * handler receives a different response shape (fixed `a`/`b` per pair,
+ * `overlapV` sign convention from b → a, fires 2× per frame for
+ * dynamic-dynamic pairs). See `Renderable.onCollision` JSDoc for that
+ * one.
+ * @example
+ *   onCollisionActive(response, other) {
+ *       if (response.normal.y < -0.7) {
+ *           // push-me-up direction ⇒ I'm on top of `other` (stomp)
+ *       }
+ *   }
+ */
+export interface CollisionResponse {
+    /** the renderable whose handler is firing — always `=== this`. */
+    a: Renderable;
+    /** the partner renderable — always `=== other`. */
+    b: Renderable;
+    /**
+     * Unit minimum-translation vector for the receiver: the direction `a`
+     * must move to separate from `b`. Same sign convention across every
+     * adapter — in canvas coordinates (y grows downward):
+     *
+     * - `normal.y < -0.7` → push me **up** ⇒ I'm on top of `b` (stomp / landed on)
+     * - `normal.y >  0.7` → push me **down** ⇒ I'm underneath `b`
+     * - `Math.abs(normal.x) > 0.7` → mostly horizontal contact (side hit)
+     */
+    normal: {
+        x: number;
+        y: number;
+    };
+    /** Penetration depth along the shortest-separation axis (always positive). */
+    depth: number;
+    /**
+     * Engine-native contact pair object. **Shape is adapter-specific** —
+     * `Matter.Pair` under `@melonjs/matter-adapter`, a `ContactPair`-shaped
+     * object under a future Rapier adapter, a `b2Contact` under a future
+     * Box2D adapter, etc. Reading this commits your code to a specific
+     * engine; use the portable `normal` / `depth` fields for
+     * adapter-portable handlers.
+     *
+     * Present only when the active adapter has a native pair concept;
+     * `undefined` under the built-in SAT adapter (which has no native
+     * pair representation — the SAT detector works pair-by-pair without
+     * persisting them).
+     */
+    pair?: unknown;
+    /**
+     * @deprecated Use `depth`. Built-in SAT legacy field; kept on modern
+     * handler dispatches for migration. `undefined` under
+     * `@melonjs/matter-adapter`.
+     */
+    overlap?: number;
+    /**
+     * @deprecated Use `normal`. Built-in SAT legacy field; flipped per
+     * receiver so the sign convention aligns with `normal` on the modern
+     * dispatch. `undefined` under `@melonjs/matter-adapter`.
+     */
+    overlapN?: {
+        x: number;
+        y: number;
+    };
+    /**
+     * @deprecated Built-in SAT legacy field, equal to `normal × depth`.
+     * Flipped per receiver. `undefined` under `@melonjs/matter-adapter`.
+     */
+    overlapV?: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Portable physics body handle returned by {@link PhysicsAdapter.addBody}
+ * and stored on `renderable.body`. Every adapter guarantees these
+ * methods so engine-portable code can read and mutate body state
+ * without knowing which adapter is active.
+ *
+ * Each adapter exports a concrete `Body` type (e.g.
+ * `MatterAdapter.Body`, `BuiltinAdapter.Body`) that extends this
+ * interface with its native fields — cast to the adapter-specific type
+ * only when reaching for engine-specific state (Matter's `frictionAir`,
+ * BuiltinAdapter's `vel`/`force`, etc.).
+ *
+ * Methods marked optional are not implemented by every adapter; check
+ * the adapter docs or fall back to the equivalent on the adapter
+ * itself (e.g. `adapter.setVelocity(r, v)` always works).
+ */
+export interface PhysicsBody {
+    /** Set linear velocity in viewport pixels per frame. */
+    setVelocity(x: number, y: number): void;
+    /** Read linear velocity; writes into `out` if provided to avoid an alloc. */
+    getVelocity(out?: Vector2d): Vector2d;
+    /**
+     * Apply a continuous force (integrated over the next step). When the
+     * optional application point is provided and differs from the body's
+     * centroid, a corresponding torque is generated:
+     * `τ = r × F`, where `r = point - centroid`. BuiltinAdapter routes the
+     * torque into {@link applyTorque}; MatterAdapter passes the point
+     * directly to `Matter.Body.applyForce`.
+     * @example
+     * // pure linear thrust (existing 2-arg form, unchanged):
+     * ship.body.applyForce(0, -0.05);
+     *
+     * // off-centre kick: pushes the crate to the right AND tips it over,
+     * // because the contact point is at the top of the crate, away from
+     * // its centroid:
+     * const topX = crate.pos.x + crate.width / 2;
+     * const topY = crate.pos.y;
+     * crate.body.applyForce(1.5, 0, topX, topY);
+     * @param x - force X component
+     * @param y - force Y component
+     * @param pointX - world X of the application point (defaults to centroid)
+     * @param pointY - world Y of the application point (defaults to centroid)
+     */
+    applyForce(x: number, y: number, pointX?: number, pointY?: number): void;
+    /** Apply an instantaneous impulse (`Δv = J / mass`). */
+    applyImpulse(x: number, y: number): void;
+    /**
+     * Toggle static (fixed-position, infinite-mass) state. Static bodies
+     * still participate in collisions; they just don't integrate.
+     */
+    setStatic(isStatic?: boolean): void;
+    /**
+     * Set the bit mask of collision types this body collides with.
+     * @see collision.types
+     */
+    setCollisionMask(mask: number): void;
+    /** Set the collision category bit for this body. */
+    setCollisionType?(type: number): void;
+    /** Toggle sensor mode (fires collision events without push-out). */
+    setSensor?(isSensor?: boolean): void;
+    /** Set mass directly (recomputes inertia where applicable). */
+    setMass?(m: number): void;
+    /** Set restitution / bounciness. */
+    setBounce?(r: number): void;
+    /** Set per-body gravity multiplier. */
+    setGravityScale?(scale: number): void;
+    /**
+     * Set angular velocity (rad / frame). BuiltinAdapter integrates this
+     * each step into the body's `angle` and updates the renderable's
+     * `currentTransform` (visual rotation only — SAT collisions remain
+     * axis-aligned). MatterAdapter routes to `Matter.Body.setAngularVelocity`,
+     * which participates fully in matter's rotational dynamics.
+     * @example
+     * // a coin sprite that spins continuously while sitting on the ground:
+     * coin.body.setAngularVelocity?.(0.05);
+     */
+    setAngularVelocity?(omega: number): void;
+    /**
+     * Read angular velocity (rad / frame). Returns 0 if rotation isn't tracked.
+     * @example
+     * if ((spinner.body.getAngularVelocity?.() ?? 0) > 1) {
+     *     spinner.body.setAngularVelocity?.(1); // cap spin
+     * }
+     */
+    getAngularVelocity?(): number;
+    /**
+     * Set absolute rotation angle (radians). Re-syncs the renderable's
+     * `currentTransform` immediately — no need to wait for the next
+     * physics step. Useful when you want to point a body at a target.
+     * @example
+     * // turret tracks the player every frame:
+     * const dx = player.centerX - turret.centerX;
+     * const dy = player.centerY - turret.centerY;
+     * turret.body.setAngle?.(Math.atan2(dy, dx));
+     */
+    setAngle?(rad: number): void;
+    /** Read absolute rotation angle (radians). */
+    getAngle?(): number;
+    /**
+     * Apply an angular impulse directly: `Δω = τ / pseudoInertia`. Bypasses
+     * the force/lever-arm computation in {@link applyForce} for the case
+     * where you want to spin something up without applying a linear force —
+     * a thruster, a power-up's intrinsic rotation, a knockback spin effect.
+     * @example
+     * // give a powerup a one-shot 360° spin-up burst on collection:
+     * powerup.body.applyTorque?.(50);
+     */
+    applyTorque?(torque: number): void;
+    /** Live alias of the collision category bit. */
+    collisionType: number;
+    /** Live alias of the collision mask bits. */
+    collisionMask: number;
+}
+/**
+ * Engine-portable body description, passed to {@link PhysicsAdapter.addBody}.
+ * Adapter-native fields (Box2D meters, Matter collisionFilter bits, etc.)
+ * are derived from these portable fields by each adapter.
+ */
+export interface BodyDefinition {
+    /** simulation kind */
+    type: BodyType;
+    /** collision shapes (one or more — compound body support) */
+    shapes: BodyShape[];
+    /** mass per unit area; defaults are adapter-specific */
+    density?: number;
+    /**
+     * Per-step velocity damping (Matter's `frictionAir`). Bleeds velocity
+     * off every frame regardless of contact, creating terminal velocity.
+     * Number applies uniformly; `{x, y}` damps each axis independently
+     * (melonJS-specific — Matter only supports scalar and will average).
+     */
+    frictionAir?: number | {
+        x: number;
+        y: number;
+    };
+    /**
+     * Bounciness (coefficient of restitution): `0` = inelastic (stops on
+     * contact), `1` = perfectly elastic (rebound speed equals impact speed).
+     * Typically in `[0, 1]`. Values `> 1` produce a super-elastic
+     * ("energy-gain") rebound — physically unrealistic but useful for
+     * arcade effects like pinball flippers, slingshot boosters, or
+     * trampoline pads. The value is not clamped at the interface level;
+     * how an adapter handles out-of-range values is adapter-specific.
+     */
+    restitution?: number;
+    /**
+     * Surface coefficient of friction during contact. Matter's
+     * `body.friction` — `0` = frictionless (objects slide past each
+     * other), `1` = high stick. Determines how much tangential velocity
+     * is transferred between contacting bodies. Combined with body
+     * rotation, this is what produces "throw" between colliding circles
+     * and "english" off a wall. Distinct from `frictionAir` (per-step
+     * drag with no contact required). Builtin SAT adapter ignores this.
+     */
+    friction?: number;
+    /**
+     * Per-body gravity multiplier. `0` disables gravity for this body;
+     * negative inverts it. Matches Matter's `body.gravityScale`.
+     */
+    gravityScale?: number;
+    /**
+     * Hard cap on velocity magnitude per axis. melonJS extension —
+     * Matter has no direct equivalent and uses `frictionAir`-induced
+     * terminal velocity instead; MatterAdapter implements this by
+     * clamping velocity in an `afterUpdate` hook.
+     */
+    maxVelocity?: {
+        x: number;
+        y: number;
+    };
+    /** disable rotation simulation; the body keeps its initial angle */
+    fixedRotation?: boolean;
+    /** the body generates collision events but no physical response */
+    isSensor?: boolean;
+    /**
+     * Bit flag identifying this body's collision type. See
+     * {@link collision.types}. Adapters translate to their native filter
+     * system (Matter `collisionFilter.category`, Box2D `categoryBits`).
+     */
+    collisionType?: number;
+    /**
+     * Bit mask of collision types this body can collide with. Defaults to
+     * `collision.types.ALL_OBJECT`.
+     */
+    collisionMask?: number;
+    /** arbitrary user data attached to the body */
+    userData?: unknown;
+}
+/**
+ * Adapter feature flags. The engine reads these to negotiate optional
+ * capabilities; user code can branch on them to gracefully degrade when
+ * a feature isn't available under the active adapter.
+ */
+export interface AdapterCapabilities {
+    /** supports joints, springs, hinges, etc. */
+    constraints: boolean;
+    /** supports continuous collision detection for fast-moving bodies */
+    continuousCollisionDetection: boolean;
+    /** supports body sleeping to reduce simulation cost when idle */
+    sleepingBodies: boolean;
+    /** supports {@link PhysicsAdapter.raycast} */
+    raycasts: boolean;
+    /**
+     * supports {@link BodyDefinition.maxVelocity} /
+     * {@link PhysicsAdapter.setMaxVelocity}. BuiltinAdapter does this
+     * via its kinematic integrator; MatterAdapter via an `afterUpdate`
+     * clamp. Adapters that can't enforce a hard cap report `false`.
+     */
+    velocityLimit: boolean;
+    /**
+     * supports {@link PhysicsAdapter.isGrounded}. Adapters that can't
+     * cheaply derive ground contact (no contact iteration) report `false`.
+     */
+    isGrounded: boolean;
+}
+/**
+ * Common adapter constructor options. Concrete adapters may extend this
+ * with their own engine-specific options.
+ */
+export interface AdapterOptions {
+    /** world gravity vector, default `(0, 0.98)` */
+    gravity?: Vector2d;
+}
+/** Result of a successful {@link PhysicsAdapter.raycast}. */
+export interface RaycastHit {
+    /** the renderable whose body the ray hit */
+    renderable: Renderable;
+    /** world-space hit point */
+    point: Vector2d;
+    /** surface normal at the hit point */
+    normal: Vector2d;
+    /** position along the ray, `0..1` from `from` to `to` */
+    fraction: number;
+}
+/**
+ * Swappable physics engine integration. `BuiltinAdapter` ships with
+ * melonjs and wraps the engine's native SAT-based physics; third-party
+ * adapters (e.g. `@melonjs/matter-adapter`) implement this interface to
+ * plug a different engine in.
+ *
+ * **Lifecycle contract:** one adapter per {@link World}, instantiated and
+ * passed to `Application` at construction, never swapped at runtime.
+ * Adapter state (bodies, constraints, sleeping flags, etc.) does not
+ * migrate between adapters.
+ *
+ * **Body handle convention:** {@link PhysicsAdapter.addBody} returns an
+ * opaque handle that becomes `renderable.body`. Each adapter chooses its
+ * own concrete body type — `BuiltinAdapter` returns the legacy
+ * {@link Body} class so existing property-based code (`body.vel.x = 5`,
+ * `body.isStatic = true`) keeps working unchanged. Third-party adapters
+ * return their engine's native body type. For adapter-agnostic code, use
+ * the portable methods on the adapter itself ({@link setVelocity},
+ * {@link applyForce}, etc.) instead of mutating the handle directly.
+ */
+export interface PhysicsAdapter {
+    /** advertised capabilities; user code may branch on these */
+    readonly capabilities: AdapterCapabilities;
+    /**
+     * Short adapter identifier exposed as `world.physic`. User code uses
+     * it to branch on which physics implementation is active without
+     * importing the adapter class — e.g.
+     *
+     * ```ts
+     * if (app.world.physic === "matter") {
+     *     // matter-only setup (constraints, etc.)
+     * }
+     * ```
+     *
+     * Convention: a single lowercase token. The first-party labels are
+     * `"builtin"` (default — `BuiltinAdapter`) and `"matter"`
+     * (`@melonjs/matter-adapter`). Third-party adapters should pick a
+     * concise identifier that won't collide with future official ones.
+     *
+     * The reserved value `"none"` is set on `world.physic` only when the
+     * user passes `physic: "none"` to `Application` to disable physics
+     * entirely; adapters should not use it.
+     *
+     * Defaults to `"builtin"` if an adapter doesn't declare its own — keeps
+     * legacy adapters wired in before this field was added still working.
+     */
+    readonly physicLabel?: string;
+    /**
+     * Optional display name reported on the startup banner. Defaults to
+     * the adapter class name. Third-party packages typically set this to
+     * their npm package id (e.g. `"@melonjs/matter-adapter"`).
+     */
+    readonly name?: string;
+    /**
+     * Optional package version reported on the startup banner. Set this
+     * when shipping the adapter as a separate npm package so users can
+     * tell which version is wired in at a glance.
+     */
+    readonly version?: string;
+    /**
+     * Optional URL (npm / homepage / repo) reported on the startup banner.
+     * Convention matches the debug-plugin's startup line.
+     */
+    readonly url?: string;
+    /** world gravity. Mutate to change at runtime. */
+    gravity: Vector2d;
+    /**
+     * Called once after the adapter is attached to a {@link World}.
+     * Adapters may register internal listeners, allocate native engine
+     * state, or read world bounds here.
+     */
+    init?(world: World): void;
+    /** Called when the adapter is being torn down; release native resources. */
+    destroy?(): void;
+    /** Advance the simulation by one frame. Called from `World.update(dt)`. */
+    step(dt: number): void;
+    /**
+     * Copy physics-engine body positions back to `renderable.pos` and
+     * rotations to the renderable's transform. Called after {@link step}
+     * each frame. Adapters that mutate the renderable directly during
+     * step (e.g. `BuiltinAdapter`) may leave this a no-op.
+     */
+    syncFromPhysics(): void;
+    /**
+     * Optional inverse of {@link syncFromPhysics} — push a single
+     * renderable's current pos/angle into the physics engine. Called by
+     * the engine when game code teleports a renderable. Adapters may
+     * also expose this via {@link setPosition} and skip implementing
+     * it directly.
+     */
+    syncToPhysics?(renderable: Renderable): void;
+    /**
+     * Register a body with the simulation. Returns an opaque handle that
+     * becomes `renderable.body`. Each adapter chooses its own concrete
+     * body type — see the class doc for the convention.
+     *
+     * **Prefer the declarative path.** Set `renderable.bodyDef` and call
+     * `Container.addChild(renderable)` — the container auto-invokes
+     * `addBody` AND inserts the renderable into the world's broadphase
+     * (QuadTree) in one atomic step. Direct calls to `addBody` only
+     * register the body with this adapter; they do NOT add the renderable
+     * to the world's container hierarchy, so the broadphase won't return
+     * it as a collision candidate. A body registered via direct `addBody`
+     * without a matching `addChild` will integrate (velocity, forces) but
+     * never collide.
+     */
+    addBody(renderable: Renderable, def: BodyDefinition): PhysicsBody;
+    /**
+     * Unregister a body. Called automatically when `Container.removeChild`
+     * detaches the renderable; direct calls are the inverse of a direct
+     * `addBody` (rare — use `removeChild` for the normal lifecycle).
+     */
+    removeBody(renderable: Renderable): void;
+    /** Replace the body's collision geometry without re-creating the body. */
+    updateShape?(renderable: Renderable, shapes: BodyShape[]): void;
+    /**
+     * Portable velocity / force / position API. Every adapter implements
+     * these by routing to its native engine. Use these instead of
+     * mutating the body handle directly when writing adapter-agnostic
+     * code.
+     */
+    getVelocity(renderable: Renderable, out?: Vector2d): Vector2d;
+    setVelocity(renderable: Renderable, v: Vector2d): void;
+    applyForce(renderable: Renderable, force: Vector2d, point?: Vector2d): void;
+    applyImpulse(renderable: Renderable, impulse: Vector2d, point?: Vector2d): void;
+    setPosition(renderable: Renderable, p: Vector2d): void;
+    setAngle?(renderable: Renderable, angle: number): void;
+    /** Read absolute rotation angle (radians). Returns 0 if not tracked. */
+    getAngle?(renderable: Renderable): number;
+    /** Set angular velocity (rad / frame). */
+    setAngularVelocity?(renderable: Renderable, omega: number): void;
+    /** Read angular velocity (rad / frame). Returns 0 if not tracked. */
+    getAngularVelocity?(renderable: Renderable): number;
+    /** Apply an angular impulse (`Δω = τ / inertia`). */
+    applyTorque?(renderable: Renderable, torque: number): void;
+    /**
+     * Runtime body-property mutators. Each maps to the corresponding
+     * {@link BodyDefinition} field and lets game code change a body's
+     * physical properties without re-creating it. Adapter implementations
+     * route to their native engine (BuiltinAdapter writes to the `Body`
+     * handle; MatterAdapter calls Matter's `Body.set*` helpers).
+     */
+    setStatic(renderable: Renderable, isStatic: boolean): void;
+    setGravityScale(renderable: Renderable, scale: number): void;
+    setFrictionAir(renderable: Renderable, friction: number | {
+        x: number;
+        y: number;
+    }): void;
+    setMaxVelocity(renderable: Renderable, limit: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Read the body's current velocity cap (mirror of
+     * {@link setMaxVelocity}). Returns plain `{x, y}` so callers don't
+     * need to import a vector type. Optional — adapters that don't
+     * implement velocity caps omit this method.
+     */
+    getMaxVelocity?(renderable: Renderable): {
+        x: number;
+        y: number;
+    };
+    setCollisionType(renderable: Renderable, type: number): void;
+    setCollisionMask(renderable: Renderable, mask: number): void;
+    /**
+     * Toggle a body between solid and sensor mode. A sensor still fires
+     * collision events (`onCollisionStart` / `onCollisionActive` /
+     * `onCollisionEnd`) but the engine does not push the bodies apart on
+     * contact — useful for one-way platforms, trigger zones, ground-snap
+     * ground assists, etc.
+     *
+     * Adapters without a native sensor flag emulate by toggling the
+     * collision mask between its previous value and `NO_OBJECT`.
+     */
+    setSensor?(renderable: Renderable, isSensor: boolean): void;
+    /**
+     * Whether the body has at least one active contact with a surface
+     * below it (collision normal pointing up). Capability-gated by
+     * {@link AdapterCapabilities.isGrounded}. melonJS extension — Matter
+     * has no direct equivalent and the MatterAdapter implements it by
+     * scanning active pairs each call.
+     */
+    isGrounded?(renderable: Renderable): boolean;
+    /**
+     * Spatial queries.
+     *
+     * `raycast` is capability-gated by {@link AdapterCapabilities.raycasts}.
+     * Adapters that don't support it may omit the method entirely
+     * (`typeof adapter.raycast === "function"`).
+     *
+     * `queryAABB` is mandatory — every adapter must support a region query
+     * (a broadphase walk is already needed for collision detection, so
+     * exposing it costs nothing).
+     */
+    raycast?(from: Vector2d, to: Vector2d): RaycastHit | null;
+    queryAABB(rect: Rect): Renderable[];
+    /**
+     * Return the body's axis-aligned bounding box in **renderable-local**
+     * coordinates (relative to `renderable.pos`). Writes into the
+     * supplied `out` Bounds so callers can poll allocation-free each
+     * frame. Returns `undefined` if the renderable has no registered
+     * body.
+     *
+     * Used by ecosystem tooling — most notably `@melonjs/debug-plugin`
+     * — to visualize the body's effective collision extent. The adapter
+     * owns coordinate-system conversion: builtin Body already stores
+     * bounds in local space, matter stores them in world space and the
+     * adapter subtracts `renderable.pos` before writing.
+     *
+     * Required by the adapter contract: any adapter that registers
+     * bodies MUST implement this. The output is the canonical, local-
+     * space representation tools rely on regardless of which engine
+     * the adapter wraps.
+     */
+    getBodyAABB(renderable: Renderable, out: Bounds): Bounds | undefined;
+    /**
+     * Return a snapshot of the body's collision shapes in
+     * **renderable-local** coordinates. The returned array is intended
+     * for read-only inspection (debug drawing, hit-region queries) —
+     * adapters may return a live reference for performance, so callers
+     * MUST NOT mutate it. Returns an empty array if no body.
+     *
+     * Pairs with {@link getBodyAABB} as the adapter-side debug surface;
+     * lets each adapter own its coordinate convention without polluting
+     * the underlying physics-engine body objects. Required by the
+     * adapter contract.
+     */
+    getBodyShapes(renderable: Renderable): readonly BodyShape[];
+}
+//# sourceMappingURL=adapter.d.ts.map

package/build/physics/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../src/physics/adapter.ts"],"names":[],"mappings":"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"}

package/build/physics/bounds.d.ts

@@ -128,6 +128,24 @@ export declare class Bounds {
      * @param [clear] - Whether to reset the bounds before adding the new bounds.
      */
     addBounds(bounds: Bounds, clear?: boolean): void;
+    /**
+     * Expand this bounds to include every shape in `shapes`. Each shape
+     * contributes its own `.getBounds()` (so `Rect`, `Polygon`, `Ellipse`,
+     * `Bounds`, and anything else implementing the same getter all work);
+     * shapes without `.getBounds()` are silently ignored. Use `clear=true`
+     * to compute a fresh union (matches the `add` / `addBounds` shape).
+     *
+     * Useful for sizing a renderable from its `bodyDef.shapes` before
+     * the underlying physics body has been constructed — used by the
+     * TMX shape factory and {@link Trigger}.
+     * @param shapes - one shape or an iterable of shapes
+     * @param [clear] - reset the bounds before unioning
+     */
+    addShapes(shapes: {
+        getBounds?: () => Bounds;
+    } | Iterable<{
+        getBounds?: () => Bounds;
+    }>, clear?: boolean): void;
     /**
      * Adds the given point to the bounds definition.
      * @param point - The point to add to the bounds.
@@ -184,11 +202,6 @@ export declare class Bounds {
      * @returns A new Bounds object that is a copy of this bounds.
      */
     clone(): Bounds;
-    /**
-     * Returns a polygon whose edges are the same as this bounds.
-     * @returns A new Polygon that represents this bounds.
-     */
-    toPolygon(): import("../index.ts").Polygon;
 }
 /**
  * A pool for creating and reusing Bounds objects.

package/build/physics/bounds.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bounds.d.ts","sourceRoot":"","sources":["../../src/physics/bounds.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"bounds.d.ts","sourceRoot":"","sources":["../../src/physics/bounds.ts"],"names":[],"mappings":"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"}