melonjs 20.3.0 → 20.5.0

package/build/physics/builtin/body.d.ts

@@ -24,25 +24,6 @@ export default class Body {
      * @type {Bounds}
      */
     public bounds: Bounds;
-    /**
-     * The collision shapes of the body. Always an array — every
-     * mutation path goes through `push` / `includes`. The
-     * non-array `Point` that used to be in this union was a
-     * mis-doc and broke downstream `shapes.length` reads in
-     * TypeScript.
-     * @ignore
-     * @type {(Polygon|Line|Ellipse|Point)[]}
-     */
-    shapes: (Polygon | Line | Ellipse | Point)[];
-    /**
-     * The body collision mask, that defines what should collide with what.<br>
-     * (by default will collide with all entities)
-     * @ignore
-     * @type {number}
-     * @default collision.types.ALL_OBJECT
-     * @see collision.types
-     */
-    collisionMask: number;
     /**
      * define the collision type of the body for collision filtering
      * @public
@@ -405,14 +386,6 @@ export default class Body {
      * @returns {number}
      */
     getAngle(): number;
-    /**
-     * Sync `this.angle` to the renderable's `currentTransform`. Pivot is
-     * the body's bounds center (matches the matter adapter's rotation
-     * pivot — see `MatterAdapter.syncFromPhysics`). Internal helper used
-     * by both the per-step integrator and {@link Body#setAngle}.
-     * @ignore
-     */
-    _syncAngleTransform(): void;
     /**
      * apply an instantaneous impulse to this body — a single-step velocity
      * change scaled by inverse mass (`dv = J / m`). Useful for one-shot
@@ -464,26 +437,6 @@ export default class Body {
      * @param {boolean} [isSensor=true]
      */
     setSensor(isSensor?: boolean): void;
-    /**
-     * Give a stored shape its per-shape collision settings, carrying them over
-     * from the source object when `addShape` converted it (a `Rect` and a
-     * `Bounds` both become a `Polygon`, so anything set on the original would
-     * otherwise be dropped on the floor).
-     *
-     * Every field is written explicitly, including the defaults. That is not
-     * tidiness: converted shapes come from `polygonPool`, whose reset restores
-     * only position and vertices — a recycled instance would otherwise arrive
-     * still carrying the previous owner's `isTrigger` or mask and quietly
-     * change how an unrelated body collides.
-     *
-     * Idempotent, because `removeShape` re-adds every surviving shape through
-     * `addShape` and must not disturb their settings.
-     * @param {object} stored - the shape as held in `this.shapes`
-     * @param {object} [source] - the object passed to `addShape`; omitted when
-     * the shape was built here from a pool and has no user-supplied original
-     * @private
-     */
-    private _initShapeCollision;
     /**
      * add a collision shape to this body <br>
      * (note: me.Rect objects will be converted to me.Polygon before being added)
@@ -536,16 +489,6 @@ export default class Body {
      * this.body.addShape(me.loader.getJSON("shapesdef").banana);
      */
     addShape(shape: Rect | Polygon | Line | Ellipse | Point | Point[] | Bounds | object): number;
-    /**
-     * Recompute the default `pseudoInertia` from the current bounds.
-     * Uses the moment-of-inertia formula for a unit-mass rectangle —
-     * `(width² + height²) / 12` — which gives a value that scales
-     * sensibly with body size: a small body resists rotation less, a
-     * large body more. Clamped to a minimum of 1 to keep divisions
-     * well-defined even on degenerate 0-size bodies.
-     * @ignore
-     */
-    _recomputePseudoInertia(): void;
     /**
      * set the body vertices to the given one
      * @param {Vector2d[]} vertices - an array of me.Vector2d points defining a convex hull
@@ -645,8 +588,7 @@ export default class Body {
     forEach(callback: Function, thisArg?: object): void;
     /**
      * Returns true if the any of the shape composing the body contains the given point.
-     * @param {number|Vector2d} x -  x coordinate or a vector point to check
-     * @param {number} [y] -  y coordinate
+     * @param {...(number|Vector2d)} args - either `x, y` coordinates, or a single {@link Vector2d}
      * @returns {boolean} true if contains
      * @example
      * if (mySprite.body.contains(10, 10)) {
@@ -657,7 +599,7 @@ export default class Body {
      *   // do something
      * }
      */
-    contains(...args: any[]): boolean;
+    contains(...args: (number | Vector2d)[]): boolean;
     /**
      * Rotate this body (counter-clockwise) by the specified angle (in radians).
      * Unless specified the body will be rotated around its center point
@@ -693,11 +635,6 @@ export default class Body {
      * @returns {boolean} true if resulting velocity is different than 0
      */
     protected update(): boolean;
-    /**
-     * Destroy function<br>
-     * @ignore
-     */
-    destroy(): void;
 }
 import type Renderable from "../../renderable/renderable.js";
 import type Container from "../../renderable/container.js";

package/build/physics/builtin/body.d.ts.map

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

package/build/physics/builtin/detector.d.ts

@@ -14,286 +14,6 @@ declare class Detector {
      * @type {ResponseObject}
      */
     response: ResponseObject;
-    /**
-     * Pairs (key → [renderableA, renderableB]) that were colliding in
-     * the previous step. Diffed against `_frameSeen` at end of step
-     * to fire `onCollisionEnd` for pairs that just separated.
-     * @ignore
-     */
-    _activePairs: Map<any, any>;
-    /**
-     * Pairs seen during the current step. Built up as the per-object
-     * `collisions()` calls run; consumed by `endFrame()`.
-     * @ignore
-     */
-    _frameSeen: Map<any, any>;
-    /**
-     * Two-slot pool of "symmetric view" objects passed to the new
-     * collision lifecycle handlers (`onCollisionStart` /
-     * `onCollisionActive` / `onCollisionEnd`). Each view carries the
-     * receiver-symmetric form: `a` = receiver, `b` = partner,
-     * `normal` = MTV of receiver, `depth` = penetration scalar,
-     * plus the SAT-legacy `overlapN` / `overlapV` / `overlap` fields
-     * flipped to match the same convention.
-     *
-     * Two slots are needed because both views may be live at the
-     * same time (one handler can dispatch into the other through
-     * world mutation). Slot 0 is used for the original-a-side
-     * dispatch, slot 1 for the original-b-side.
-     * @ignore
-     */
-    _symViews: {
-        a: null;
-        b: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTriggerContact: boolean;
-    }[];
-    /**
-     * Shape-pair contacts that were overlapping in the previous step (#1596).
-     * Keyed by `_shapePairKey`, diffed against `_frameShapeSeen` in
-     * `endFrame()` to fire `onShapeCollisionEnd`. Populated only when someone
-     * subscribes, so a game that does not use the feature keeps these empty.
-     * @ignore
-     */
-    _activeShapePairs: Map<any, any>;
-    /** @ignore */
-    _frameShapeSeen: Map<any, any>;
-    /**
-     * Two-slot pool of receiver-symmetric shape-contact views, mirroring
-     * `_symViews`: `a` is the receiver, `b` the partner, and `shapeA` /
-     * `indexShapeA` are always the RECEIVER's shape. Two slots because both
-     * sides may be live at once when a handler mutates the world.
-     * @ignore
-     */
-    _shapeViews: {
-        a: null;
-        b: null;
-        shapeA: null;
-        shapeB: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTrigger: boolean;
-    }[];
-    /**
-     * The pair currently being enumerated, so the contact callback can be a
-     * single pre-bound function rather than a closure allocated per body pair
-     * per frame.
-     * @ignore
-     */
-    _contactObjA: Renderable | Container | Entity | Sprite | NineSliceSprite | null;
-    _contactObjB: any;
-    /** @ignore */
-    _onShapeContact: (shapeA: any, indexA: any, shapeB: any, indexB: any, isTrigger: any, res: any) => void;
-    /**
-     * Populate one of the pooled symmetric views from a SAT response.
-     * `flip=false` builds the view for `response.a`'s side (legacy
-     * fields kept as-is, `normal = -overlapN` = MTV of original a).
-     * `flip=true` builds it for `response.b`'s side: `a` / `b` swap,
-     * `overlapN` / `overlapV` negated, `normal = +overlapN` (the MTV
-     * of original b).
-     * @ignore
-     */
-    _fillSymView(slot: any, satResponse: any, flip: any): {
-        a: null;
-        b: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTriggerContact: boolean;
-    };
-    /**
-     * Called by the adapter at the start of a physics step. Resets the
-     * "seen this frame" set so the end-of-step diff can fire
-     * `onCollisionEnd` for pairs that no longer overlap.
-     * @ignore
-     */
-    beginFrame(): void;
-    /**
-     * Called by the adapter at the end of a physics step. Diffs the
-     * "seen this frame" set against the previous-frame active pairs:
-     *   - pairs in active but not seen → fire onCollisionEnd
-     *   - swap active ← seen for the next step's diff
-     * @ignore
-     */
-    endFrame(): void;
-    /**
-     * Identity-only shape-contact view for `onShapeCollisionEnd`: the shapes
-     * have separated, so every geometric field is zeroed rather than left
-     * holding the last overlap, which would read as a live contact.
-     * @ignore
-     */
-    _fillEndedView(slot: any, receiver: any, partner: any, ownShape: any, otherShape: any): {
-        a: null;
-        b: null;
-        shapeA: null;
-        shapeB: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTrigger: boolean;
-    };
-    /**
-     * Build a stable order-independent key for a pair of renderables,
-     * using their GUID. Returns undefined if either lacks a GUID (defensive
-     * — detached or pool-recycled objects mid-step).
-     * @ignore
-     */
-    _pairKey(a: any, b: any): string | undefined;
-    /**
-     * Re-run the narrowphase for a remembered shape pair and repopulate
-     * `response` from it.
-     *
-     * The scan clears `response` on every test, so whichever pair won has to be
-     * measured again before handlers and the solver read it. Indices are looked
-     * up here rather than carried from the scan because an enumeration handler
-     * may have mutated either body in between: `removeShape()` re-indexes, and
-     * `destroy()` empties the array outright. A shape that is no longer on its
-     * body has no contact left to resolve, so this reports failure and the
-     * caller falls through instead of throwing.
-     * @ignore
-     * @returns {boolean} true when the pair was re-measured
-     */
-    _retest(bodyA: any, bodyB: any, shapeA: any, shapeB: any, response: any): boolean;
-    /**
-     * Stable, order-independent key for one SHAPE pair (#1596).
-     *
-     * The renderable GUIDs order the pair, exactly as `_pairKey` does, and the
-     * two shape ids MUST swap alongside them: keying `guidA|guidB|idA|idB`
-     * without that swap gives the same physical contact two different keys
-     * depending on which object the outer loop visited first, and the contact
-     * would then End and Start every step.
-     *
-     * Shape identity is `_contactId`, stamped once in `Body#addShape` and never
-     * derived from array position, because `removeShape()` re-indexes every
-     * surviving shape.
-     * @ignore
-     */
-    _shapePairKey(a: any, b: any, shapeA: any, shapeB: any): string | undefined;
-    /**
-     * True when an object subscribes to any shape-contact event.
-     *
-     * This is the opt-in gate: `collides()` only runs the full M x N scan when
-     * this returns true for one of the two objects, so an application that
-     * never declares these handlers performs exactly the narrowphase work it
-     * did before the feature existed.
-     * @ignore
-     */
-    _wantsShapeContacts(obj: any): boolean;
-    /**
-     * Populate a pooled shape-contact view, same flip convention as
-     * `_fillSymView`: `flip=false` builds the view for `response.a`'s side,
-     * `flip=true` for `response.b`'s, so `shapeA` is always the receiver's.
-     * @ignore
-     */
-    _fillShapeView(slot: any, satResponse: any, flip: any, shapeA: any, shapeB: any, isTrigger: any): {
-        a: null;
-        b: null;
-        shapeA: null;
-        shapeB: null;
-        overlap: number;
-        overlapN: {
-            x: number;
-            y: number;
-        };
-        overlapV: {
-            x: number;
-            y: number;
-        };
-        normal: {
-            x: number;
-            y: number;
-        };
-        depth: number;
-        overlapNZ: number;
-        overlapZ: number;
-        normalZ: number;
-        indexShapeA: number;
-        indexShapeB: number;
-        isTrigger: boolean;
-    };
-    /**
-     * Fire Start / Active for one overlapping shape pair. Called back from
-     * `collides()` once per pair, in scan order.
-     * @ignore
-     */
-    _dispatchShapeContact(shapeA: any, shapeB: any, isTrigger: any, response: any): void;
-    /**
-     * Drop the references the enumeration callback reads.
-     *
-     * They are plain fields rather than a per-pair closure so the hot path
-     * allocates nothing, which means they outlive the pair unless cleared, and
-     * would hold two renderables (and everything they reach) against garbage
-     * collection until the next subscribed pair happened to overwrite them.
-     * @ignore
-     */
-    _clearContactPair(): void;
     /**
      * determine if two objects should collide (based on both respective objects body collision mask and type).<br>
      * you can redefine this function if you need any specific rules over what should collide with what.
@@ -309,38 +29,6 @@ declare class Detector {
      * @returns {boolean} true if colliding
      */
     collides(bodyA: Body, bodyB: Body, response?: ResponseObject, onContact?: undefined): boolean;
-    /**
-     * find all the collisions for the specified object using a broadphase algorithm
-     * @ignore
-     * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} objA - object to be tested for collision
-     * @returns {boolean} in case of collision, false otherwise
-     */
-    collisions(objA: Renderable | Container | Entity | Sprite | NineSliceSprite): boolean;
-    /**
-     * Checks for object colliding with the given line
-     * @ignore
-     * @param {Line} line - line to be tested for collision
-     * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.
-     * @returns {Array.<Renderable>} an array of intersecting physic objects
-     * @example
-     *    // define a line accross the viewport
-     *    let ray = new Line(
-     *        // absolute position of the line
-     *        0, 0, [
-     *        // starting point relative to the initial position
-     *        new Vector2d(0, 0),
-     *        // ending point
-     *        new Vector2d(app.viewport.width, app.viewport.height)
-     *    ]);
-     *
-     *    // check for collition
-     *    result = me.collision.rayCast(ray);
-     *
-     *    if (result.length > 0) {
-     *        // ...
-     *    }
-     */
-    rayCast(line: Line, result?: Array<Renderable>): Array<Renderable>;
 }
 import type Container from "../../renderable/container.js";
 import ResponseObject from "../response.js";

package/build/physics/builtin/detector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/detector.js"],"names":[],"mappings":";AAyEA;;GAEG;AACH;IACC;;OAEG;IACH,mBAFW,SAAS,EA2JnB;IAvJA,iBAAkB;IAElB;;;;OAIG;IACH,UAFU,cAAc,CAEY;IAEpC;;;;;OAKG;IACH,4BAA6B;IAC7B;;;;OAIG;IACH,0BAA2B;IAC3B;;;;;;;;;;;;;;OAcG;IACH;;;;;;;;;;;;;;;;;;;;;;;QAsCC;IAED;;;;;;OAMG;IACH,iCAAkC;IAClC,cAAc;IACd,+BAAgC;IAEhC;;;;;;OAMG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;QAmCC;IAED;;;;;OAKG;IACH,gFAAwB;IACxB,kBAAwB;IACxB,cAAc;IACd,wGASC;IAGF;;;;;;;;OAQG;IACH;;;;;;;;;;;;;;;;;;;;;;;MA0CC;IAED;;;;;OAKG;IACH,mBAGC;IAED;;;;;;OAMG;IACH,iBA0DC;IAED;;;;;OAKG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MAsBC;IAED;;;;;OAKG;IACH,6CAOC;IAED;;;;;;;;;;;;;OAaG;IACH,0EAFa,OAAO,CAuBnB;IAED;;;;;;;;;;;;;OAaG;IACH,4EAqBC;IAED;;;;;;;;OAQG;IACH,uCAMC;IAED;;;;;OAKG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MA2CC;IAED;;;;OAIG;IACH,qFAyCC;IAED;;;;;;;;OAQG;IACH,0BAGC;IAED;;;;;;OAMG;IACH,iBAJW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,KAClD,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CAiBnB;IAED;;;;;OAKG;IACH,gBAJW,IAAI,SACJ,IAAI,qDACF,OAAO,CAyJnB;IAED;;;;;OAKG;IACH,iBAHW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CA6QnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqC9B;CACD;2BA9hCyB,+BAA+B;2BA7D9B,gBAAgB;4BA8DhB,gCAAgC;wBAFpC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;0BAC9C,0BAA0B"}
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/detector.js"],"names":[],"mappings":";AA0EA;;GAEG;AACH;IACC;;OAEG;IACH,mBAFW,SAAS,EA2KnB;IAvKA,iBAAkB;IAElB;;;;OAIG;IACH,UAFU,cAAc,CAEY;IAEpC;;;;;;OAMG;IACH,4BAA6B;IAC7B;;;;;OAKG;IACH,0BAA2B;IAC3B;;;;;;;;;;;;;;;OAeG;IACH;;;;;;;;;;;;;;;;;;;;;;;QAsCC;IAED;;;;;;;OAOG;IACH,iCAAkC;IAClC;;;OAGG;IACH,+BAAgC;IAEhC;;;;;;;OAOG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;QAmCC;IAED;;;;;;OAMG;IACH,gFAAwB;IACxB;;;OAGG;IACH,kBAAwB;IACxB;;;OAGG;IACH,wGASC;IAGF;;;;;;;;;OASG;IACH;;;;;;;;;;;;;;;;;;;;;;;MA0CC;IAED;;;;;;OAMG;IACH,mBAGC;IAED;;;;;;;OAOG;IACH,iBA0DC;IAED;;;;;;OAMG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MAsBC;IAED;;;;;;OAMG;IACH,6CAOC;IAED;;;;;;;;;;;;;;OAcG;IACH,0EAFa,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;OAcG;IACH,4EAqBC;IAED;;;;;;;;;OASG;IACH,uCAMC;IAED;;;;;;OAMG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;MA2CC;IAED;;;;;OAKG;IACH,qFAyCC;IAED;;;;;;;;;OASG;IACH,0BAGC;IAED;;;;;;OAMG;IACH,iBAJW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,KAClD,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CAiBnB;IAED;;;;;OAKG;IACH,gBAJW,IAAI,SACJ,IAAI,qDACF,OAAO,CAyJnB;IAED;;;;;;OAMG;IACH,iBAHW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CA6QnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqC9B;CACD;2BA3jCyB,+BAA+B;2BA9D9B,gBAAgB;4BA+DhB,gCAAgC;wBAFpC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;0BAC9C,0BAA0B"}

package/build/physics/builtin/sat.d.ts

@@ -1,51 +1,4 @@
-/**
- * Checks whether polygons collide.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Polygon} polyA - a reference to the object A Polygon to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Polygon} polyB - a reference to the object B Polygon to be tested
- * @param {Response=} response - Response object (optional) that will be populated if they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testPolygonPolygon(a: Renderable | Container | Entity | Sprite | NineSliceSprite, polyA: Polygon, b: Renderable | Container | Entity | Sprite | NineSliceSprite, polyB: Polygon, response?: Response | undefined): boolean;
-/**
- * Check if two Ellipse collide.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
- * @param {Response=} response - Response object (optional) that will be populated if
- *   the circles intersect.
- * @returns {boolean} true if the circles intersect, false if they don't.
- */
-export function testEllipseEllipse(a: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseA: Ellipse, b: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseB: Ellipse, response?: Response | undefined): boolean;
-/**
- * Check if a polygon and an ellipse collide.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Polygon} polyA - a reference to the object A Polygon to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Ellipse} ellipseB - a reference to the object B Ellipse to be tested
- * @param {Response=} response - Response object (optional) that will be populated if they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testPolygonEllipse(a: Renderable | Container | Entity | Sprite | NineSliceSprite, polyA: Polygon, b: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseB: Ellipse, response?: Response | undefined): boolean;
-/**
- * Check if an ellipse and a polygon collide. <br>
- * **NOTE:** This is slightly less efficient than testPolygonEllipse as it just
- * runs testPolygonEllipse and reverses the response at the end.
- * @ignore
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} a - a reference to the object A.
- * @param {Ellipse} ellipseA - a reference to the object A Ellipse to be tested
- * @param {Renderable|Container|Entity|Sprite|NineSliceSprite} b - a reference to the object B.
- * @param {Polygon} polyB - a reference to the object B Polygon to be tested
- * @param {Response=} response - Response object (optional) that will be populated if
- *   they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testEllipsePolygon(a: Renderable | Container | Entity | Sprite | NineSliceSprite, ellipseA: Ellipse, b: Renderable | Container | Entity | Sprite | NineSliceSprite, polyB: Polygon, response?: Response | undefined): boolean;
+
 import type Renderable from "../../renderable/renderable.js";
 import type Container from "../../renderable/container.js";
 import type Entity from "../../renderable/entity/entity.js";

package/build/physics/builtin/sat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sat.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat.js"],"names":[],"mappings":"AAiNA;;;;;;;;;GASG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CA8CnB;AAED;;;;;;;;;;GAUG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiEnB;AAED;;;;;;;;;GASG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CAsKnB;AAED;;;;;;;;;;;;GAYG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiBnB;4BAvhB0B,gCAAgC;2BADjC,+BAA+B;wBADlC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;6BAC3C,6BAA6B;6BAC7B,6BAA6B"}
+{"version":3,"file":"sat.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat.js"],"names":[],"mappings":"AA2NA;;;;;;;;;;GAUG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CA8CnB;AAED;;;;;;;;;;;GAWG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiEnB;AAED;;;;;;;;;;GAUG;AACH,sCAPW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,aACP,QAAQ,YAAC,GACP,OAAO,CAsKnB;AAED;;;;;;;;;;;;;GAaG;AACH,sCARW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,YAClD,OAAO,KACP,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,SAClD,OAAO,aACP,QAAQ,YAAC,GAEP,OAAO,CAiBnB;4BAriB0B,gCAAgC;2BADjC,+BAA+B;wBADlC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;6BAC3C,6BAA6B;6BAC7B,6BAA6B"}

package/build/physics/builtin/sat3d.d.ts

@@ -1,59 +1,4 @@
-/**
- * Check whether two axis-aligned 3D boxes collide.
- *
- * This is the only narrowphase in the engine that can produce a **Z**
- * pushback. The separating-axis set of two AABBs is just the three world axes,
- * so there is no projection loop: penetration on each axis is
- * `(halfA + halfB) - |centerDelta|`, a non-positive value on any axis means
- * separated, and the minimum translation vector is the axis with the smallest
- * positive penetration.
- *
- * The MTV is a single axis, so exactly one of `overlapN.x`, `overlapN.y` and
- * `overlapNZ` comes back non-zero — see {@link ResponseObject#overlapNZ}. When
- * that axis is Z the 2D fields stay at zero, which is what makes a legacy 2D
- * `onCollision` handler safely inert on a depth-only contact rather than
- * wrong.
- * @ignore
- * @param {Renderable} a - a reference to the object A.
- * @param {Box3d} boxA - a reference to the object A Box3d to be tested
- * @param {Renderable} b - a reference to the object B.
- * @param {Box3d} boxB - a reference to the object B Box3d to be tested
- * @param {object} [response] - Response object that will be populated if they intersect.
- * @returns {boolean} true if they intersect, false if they don't.
- */
-export function testBox3dBox3d(a: Renderable, boxA: Box3d, b: Renderable, boxB: Box3d, response?: object): boolean;
-/**
- * Check whether a {@link Box3d} collides with a planar shape.
- *
- * The planar shape is treated as **unbounded along Z** — an infinitely
- * extruded prism of its own outline — so the pair reduces to the ordinary 2D
- * test between the box's XY footprint and that outline, and the box's z can
- * never make it miss. See {@link Box3d} for why that is the compatible
- * reading: it is what keeps an existing 2D game's world shapes colliding
- * unchanged the moment one `Box3d` body is introduced.
- *
- * `overlapZ` is left at `0` by construction, since neither participant has a
- * finite depth to resolve against.
- * @ignore
- */
-export function testBox3dPolygon(a: any, boxA: any, b: any, polyB: any, response: any): boolean;
-/**
- * Planar-shape-first form of {@link testBox3dPolygon}.
- * @ignore
- */
-export function testPolygonBox3d(a: any, polyA: any, b: any, boxB: any, response: any): boolean;
-/**
- * {@link Box3d} against an {@link Ellipse}, with the ellipse unbounded along
- * Z. See {@link testBox3dPolygon}.
- * @ignore
- */
-export function testBox3dEllipse(a: any, boxA: any, b: any, ellipseB: any, response: any): boolean;
-/**
- * {@link Ellipse} against a {@link Box3d}, with the ellipse unbounded along
- * Z. See {@link testBox3dPolygon}.
- * @ignore
- */
-export function testEllipseBox3d(a: any, ellipseA: any, b: any, boxB: any, response: any): boolean;
+
 import type Renderable from "../../renderable/renderable.js";
 import type { Box3d } from "../../geometries/box3d.ts";
 //# sourceMappingURL=sat3d.d.ts.map

package/build/physics/builtin/sat3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sat3d.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat3d.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kCAPW,UAAU,QACV,KAAK,KACL,UAAU,QACV,KAAK,aACL,MAAM,GACJ,OAAO,CA6EnB;AAED;;;;;;;;;;;;;GAaG;AACH,gGAEC;AAED;;;GAGG;AACH,gGAEC;AAED;;;;GAIG;AACH,mGAEC;AAED;;;;GAIG;AACH,mGAEC;4BAtK0B,gCAAgC;2BAHnC,2BAA2B"}
+{"version":3,"file":"sat3d.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/sat3d.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,kCAPW,UAAU,QACV,KAAK,KACL,UAAU,QACV,KAAK,aACL,MAAM,GACJ,OAAO,CA6EnB;AAED;;;;;;;;;;;;;;GAcG;AACH,gGAEC;AAED;;;;GAIG;AACH,gGAEC;AAED;;;;;GAKG;AACH,mGAEC;AAED;;;;;GAKG;AACH,mGAEC;4BA5K0B,gCAAgC;2BAHnC,2BAA2B"}

package/build/physics/collision.d.ts

@@ -15,8 +15,6 @@ export namespace collision {
     }
     /**
      * Checks for object colliding with the given line
-     * @name rayCast
-     * @memberof collision
      * @public
      * @param {Line} line - line to be tested for collision
      * @param {Array.<Renderable>} [result] - a user defined array that will be populated with intersecting physic objects.

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

@@ -1 +1 @@
-{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../src/physics/collision.js"],"names":[],"mappings":";qBAmBW,MAAM;kBAWN,MAAM;;;;;;;;;;;;;IAmEhB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,uBArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqB9B;;0BA1HqB,yBAAyB;4BACrB,+BAA+B"}
+{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../src/physics/collision.js"],"names":[],"mappings":";qBAiBW,MAAM;kBASN,MAAM;;;;;;;;;;;;;IAiEhB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,uBArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqB9B;;0BAlHqB,yBAAyB;4BACrB,+BAA+B"}

package/build/physics/response.d.ts

@@ -100,7 +100,6 @@ declare class ResponseObject {
      * Call this between tests if you are going to reuse a single <br>
      * Response object for multiple intersection tests <br>
      * (recommended as it will avoid allocating extra memory) <br>
-     * @name clear
      * @public
      * @returns {object} this object for chaining
      */

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

@@ -1 +1 @@
-{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/physics/response.js"],"names":[],"mappings":";;;;;;;;OAKc,UAAU;;;;OACV,UAAU;;;;aACV,MAAM;;;;cACN,QAAQ;;;;cACR,QAAQ;;;;eACR,MAAM;;;;cACN,MAAM;;;;UACN,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAbpB;;;;;;;;;;;;;;GAcG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,kBAAkB;IAClB,iBAAiB;IACjB,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,0BAA6B;IAC7B,gBAA+B;IAGhC;;;;;;;;OAQG;IACH,gBAFa,MAAM,CAelB;CACD;yBA3EwB,qBAAqB"}
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../src/physics/response.js"],"names":[],"mappings":";;;;;;;;OAKc,UAAU;;;;OACV,UAAU;;;;aACV,MAAM;;;;cACN,QAAQ;;;;cACR,QAAQ;;;;eACR,MAAM;;;;cACN,MAAM;;;;UACN,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAbpB;;;;;;;;;;;;;;GAcG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B;;;;;;;;;;;;;;;;;;OAkBG;IACH,kBAAkB;IAClB,iBAAiB;IACjB,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,0BAA6B;IAC7B,gBAA+B;IAGhC;;;;;;;OAOG;IACH,gBAFa,MAAM,CAelB;CACD;yBA1EwB,qBAAqB"}

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

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,YACN,cAAc,EAuIxB;IArHA;;;OAGG;IACH,KAFU,WAAW,CAED;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QANU,MAAM,CAMO;IAEvB;;;;;OAKG;IACH,YAAa;IAEb;;;;;;;OAOG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;;;;;;;;;;;OAcG;IACH,YAHU,OAAO,CAGK;IAEtB;;;;;;OAMG;IACH,SAFU,cAAc,CAEsB;IAG9C;;;;;;;;;;;;;;;OAeG;IACH,YAFU,OAAO,4BAA4B,EAAE,UAAU,CAEjB;IAcxC,0BAMC;IA2CF;;;;;;;;;;;OAWG;IACH,cAFa,GAAG,CAAC,IAAI,CAAC,CAOrB;IASD,eALa,QAAQ,EAOpB;IATD;;;OAGG;IACH,eAFa,QAAQ,CAIpB;IAKD;;;;OAIG;IACH,gBAFa,QAAQ,GAAG,SAAS,CAIhC;IAsCD;;;;;;;OAOG;IACH,cAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,iBAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,yBAIC;IAuBD;;;OAGG;IACH,SAFW,MAAM,QAWhB;CACD;sBAjXqB,4BAA4B;6BAatB,iCAAiC;oCAI1B,cAAc;sBAH5B,mBAAmB;8BAEX,qBAAqB;0BADzB,uBAAuB"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AA+BA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,YACN,cAAc,EAuIxB;IArHA;;;OAGG;IACH,KAFU,WAAW,CAED;IAEpB;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,QANU,MAAM,CAMO;IAEvB;;;;;OAKG;IACH,YAAa;IAEb;;;;;;;OAOG;IACH,WAHU,OAAO,CAGK;IAEtB;;;;;;;;;;;;;;OAcG;IACH,YAHU,OAAO,CAGK;IAEtB;;;;;;OAMG;IACH,SAFU,cAAc,CAEsB;IAG9C;;;;;;;;;;;;;;;OAeG;IACH,YAFU,OAAO,4BAA4B,EAAE,UAAU,CAEjB;IAcxC,0BAMC;IA4CF;;;;;;;;;;;OAWG;IACH,cAFa,GAAG,CAAC,IAAI,CAAC,CAOrB;IASD,eALa,QAAQ,EAOpB;IATD;;;OAGG;IACH,eAFa,QAAQ,CAIpB;IAKD;;;;OAIG;IACH,gBAFa,QAAQ,GAAG,SAAS,CAIhC;IAsCD;;;;;;;OAOG;IACH,cAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,iBAHW,IAAI,GACF,KAAK,CASjB;IAED;;;;;OAKG;IACH,yBAIC;IAuBD;;;OAGG;IACH,SAFW,MAAM,QAWhB;CACD;sBAnXqB,4BAA4B;6BAatB,iCAAiC;oCAI1B,cAAc;sBAH5B,mBAAmB;8BAEX,qBAAqB;0BADzB,uBAAuB"}