melonjs 19.9.1 → 20.1.0

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

@@ -59,7 +59,66 @@ declare class Detector {
             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: Container | Renderable | 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
@@ -86,6 +145,12 @@ declare class Detector {
             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
@@ -102,6 +167,38 @@ declare class Detector {
      * @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
@@ -109,6 +206,94 @@ declare class Detector {
      * @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.
@@ -123,7 +308,7 @@ declare class Detector {
      * @param {Body} bodyB - a reference to body B.
      * @returns {boolean} true if colliding
      */
-    collides(bodyA: Body, bodyB: Body, response?: ResponseObject): boolean;
+    collides(bodyA: Body, bodyB: Body, response?: ResponseObject, onContact?: undefined): boolean;
     /**
      * find all the collisions for the specified object using a broadphase algorithm
      * @ignore

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":";AA4CA;;GAEG;AACH;IACC;;OAEG;IACH,mBAFW,SAAS,EA6DnB;IAzDA,iBAAkB;IAElB;;;;OAIG;IACH,UAFU,cAAc,CAEY;IAEpC;;;;;OAKG;IACH,4BAA6B;IAC7B;;;;OAIG;IACH,0BAA2B;IAC3B;;;;;;;;;;;;;;OAcG;IACH;;;;;;;;;;;;;;;;;QAmBC;IAGF;;;;;;;;OAQG;IACH;;;;;;;;;;;;;;;;;MA4BC;IAED;;;;;OAKG;IACH,mBAEC;IAED;;;;;;OAMG;IACH,iBA6BC;IAED;;;;;OAKG;IACH,6CAOC;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,8BACF,OAAO,CAkCnB;IAED;;;;;OAKG;IACH,iBAHW,UAAU,GAAC,SAAS,GAAC,MAAM,GAAC,MAAM,GAAC,eAAe,GAChD,OAAO,CAqLnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqC9B;CACD;2BA3dyB,+BAA+B;2BAhC9B,gBAAgB;4BAiChB,gCAAgC;wBAFpC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;0BAC9C,0BAA0B"}
+{"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,CA0PnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,cArBW,IAAI,WACJ,KAAK,CAAE,UAAU,CAAC,GAChB,KAAK,CAAE,UAAU,CAAC,CAqC9B;CACD;2BA3gCyB,+BAA+B;2BA7D9B,gBAAgB;4BA8DhB,gCAAgC;wBAFpC,mCAAmC;wBAGnC,4BAA4B;iCACnB,qCAAqC;0BAC9C,0BAA0B"}

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

@@ -1 +1 @@
-{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/raycast.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AA+KrC,wBAAgB,YAAY,CAC3B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACT,UAAU,EAAE,CA8Gd"}
+{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../src/physics/builtin/raycast.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AA+KrC,wBAAgB,YAAY,CAC3B,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACT,UAAU,EAAE,CAoHd"}

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

@@ -0,0 +1,59 @@
+/**
+ * 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

@@ -0,0 +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"}

package/build/physics/response.d.ts

@@ -23,6 +23,14 @@ export type ResponseObject = {
      * The shortest colliding axis (unit-vector)
      */
     overlapN: Vector2d;
+    /**
+     * The Z component of the shortest colliding axis, as a unit scalar (`-1`, `0` or `1`). Always `0` for a collision between planar shapes
+     */
+    overlapNZ: number;
+    /**
+     * The Z component of the overlap vector (i.e. `overlapNZ * overlap`). Always `0` for a collision between planar shapes
+     */
+    overlapZ: number;
     /**
      * Whether the first object is entirely inside the second
      */
@@ -48,6 +56,8 @@ export type ResponseObject = {
  * @property {number} overlap Magnitude of the overlap on the shortest colliding axis
  * @property {Vector2d} overlapV The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
  * @property {Vector2d} overlapN The shortest colliding axis (unit-vector)
+ * @property {number} overlapNZ The Z component of the shortest colliding axis, as a unit scalar (`-1`, `0` or `1`). Always `0` for a collision between planar shapes
+ * @property {number} overlapZ The Z component of the overlap vector (i.e. `overlapNZ * overlap`). Always `0` for a collision between planar shapes
  * @property {boolean} aInB Whether the first object is entirely inside the second
  * @property {boolean} bInA Whether the second object is entirely inside the first
  * @property {number} indexShapeA The index of the colliding shape for the object a body
@@ -58,10 +68,32 @@ declare class ResponseObject {
     b: any;
     overlapN: Vector2d;
     overlapV: Vector2d;
+    /**
+     * Z half of the minimum translation axis.
+     *
+     * Z arrives as **scalars beside** `overlapN` / `overlapV` rather than
+     * by widening them to {@link Vector3d}, because `Vector3d` is not a
+     * subclass of {@link Vector2d} — retyping them would break every
+     * existing consumer of a 2D collision response.
+     *
+     * The minimum translation axis is a single axis, so at most one of
+     * `overlapN.x`, `overlapN.y` and `overlapNZ` is ever non-zero. The 2D
+     * invariant `overlapV = overlapN * overlap` therefore extends
+     * unchanged as `overlapZ = overlapNZ * overlap`, and a collision
+     * resolved along Z leaves `overlapN` / `overlapV` at zero — a legacy
+     * 2D handler reading them applies no push, which is correct, because
+     * there is no 2D push to apply.
+     *
+     * Only ever non-zero when both shapes are a {@link Box3d}; every
+     * planar shape pair leaves these at `0`.
+     */
+    overlapNZ: number;
+    overlapZ: number;
     aInB: boolean;
     bInA: boolean;
     indexShapeA: number;
     indexShapeB: number;
+    isTriggerContact: boolean;
     overlap: number;
     /**
      * Set some values of the response back to their defaults. <br>

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;;;;UACR,OAAO;;;;UACP,OAAO;;;;iBACP,MAAM;;;;iBACN,MAAM;;AAXpB;;;;;;;;;;;;GAYG;AACH;IAEE,OAAa;IACb,OAAa;IACb,mBAA8B;IAC9B,mBAA8B;IAC9B,cAAgB;IAChB,cAAgB;IAChB,oBAAqB;IACrB,oBAAqB;IACrB,gBAA+B;IAGhC;;;;;;;;OAQG;IACH,gBAFa,MAAM,CASlB;CACD;yBA7CwB,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;;;;;;;;OAQG;IACH,gBAFa,MAAM,CAelB;CACD;yBA3EwB,qBAAqB"}

package/build/physics/world.d.ts

@@ -100,6 +100,7 @@ export default class World extends Container {
      * @type {import("./broadphase/broadphase.ts").Broadphase}
      */
     broadphase: import("./broadphase/broadphase.ts").Broadphase;
+    onLevelLoaded: () => void;
     /**
      * Active physics bodies in this simulation. Backed by the active
      * adapter; mutating this set directly is no longer the recommended

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

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/physics/world.js"],"names":[],"mappings":"AA6BA;;;GAGG;AACH;IACC;;;;;;OAMG;IACH,gBANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,YACN,cAAc,EAkIxB;IAhHA;;;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;IA2CzC;;;;;;;;;;;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;sBA5VqB,4BAA4B;6BAYtB,iCAAiC;oCAI1B,cAAc;sBAH5B,mBAAmB;8BAEX,qBAAqB;0BADzB,uBAAuB"}
+{"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"}

package/build/renderable/container.d.ts

@@ -104,6 +104,7 @@ export default class Container extends Renderable {
      * this.backgroundColor.setColor(255, 0, 0);
      */
     backgroundColor: Color;
+    onCanvasResize: (() => void) | undefined;
     set sortOn(value: "x" | "y" | "z" | "depth");
     /**
      * The property of the child object that should be used to sort on

package/build/renderable/container.d.ts.map

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

package/build/renderable/groundshadow.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Bake (once) a radial alpha ramp: opaque white at the centre, fading to
+ * fully transparent at the rim.
+ *
+ * White rather than black because the colour comes from the draw tint — that
+ * way the same bake serves a black shadow, a tinted one, or a coloured pool
+ * of light, and nothing has to be re-baked to change it.
+ * @returns {HTMLCanvasElement|OffscreenCanvas} the shared falloff canvas
+ * @ignore
+ */
+export function getShadowFalloff(): HTMLCanvasElement | OffscreenCanvas;
+/**
+ * Drop the shared bake. Only the tests need this — the canvas is CPU-side and
+ * costs 64 KB, so an application never has a reason to release it.
+ * @ignore
+ */
+export function resetShadowFalloff(): void;
+/**
+ * Whether a mesh's geometry has any vertical extent at all.
+ *
+ * The test a **blanket** opt-in needs: a ground shadow says "this object is
+ * standing above the floor", and a flat plane lying in the floor is the floor.
+ * Shadowing it with itself smears a blob the size of the whole ground across
+ * it, which is what a scene-wide `castGroundShadow` would otherwise do to
+ * every glTF scene that ships one. A per-object opt-in bypasses this — that
+ * one is an explicit instruction.
+ *
+ * Deliberately model-space and unrotated: the caller asks about the geometry,
+ * not about where it currently sits.
+ * @param {Float32Array} vertices - model-space vertex positions (x, y, z)
+ * @param {number} vertexCount - how many vertices to read
+ * @returns {boolean} true when the geometry is not flat in Y
+ * @ignore
+ */
+export function hasVerticalExtent(vertices: Float32Array, vertexCount: number): boolean;
+/**
+ * Borrow the shadow quad for a renderer, building it on first use.
+ *
+ * Cached **on the renderer**, not at module level, for two reasons: a `Mesh`
+ * resolves its texture through the active renderer's texture cache, so a
+ * module-level one would bind itself to whichever application happened to
+ * construct it first; and hanging it off the renderer means it dies with the
+ * renderer instead of outliving it.
+ *
+ * Two are kept — lit and unlit — so the shadow can be drawn through whichever
+ * mesh batcher its owner is already using. Sharing one unlit quad between lit
+ * owners would force a `litMesh → mesh → litMesh` batcher transition per
+ * shadowed object, each costing a bind/unbind pair and a flush: far more than
+ * the single draw the shadow is supposed to be.
+ *
+ * Retained geometry is keyed per mesh object, so one quad uploads once and
+ * every shadow in the scene redraws it at a different matrix for free.
+ * @param {object} renderer - the active renderer
+ * @param {boolean} lit - whether the owning mesh draws lit
+ * @param {Function} MeshClass - the `Mesh` constructor (passed in to avoid a
+ * circular import: `Mesh` owns the shadow, not the other way round)
+ * @returns {object} the shared shadow quad for that tier
+ * @ignore
+ */
+export function getShadowQuad(renderer: object, lit: boolean, MeshClass: Function): object;
+/**
+ * The blob quad an `InstancedMesh` draws from — sized to the prototype's own
+ * footprint (#1515).
+ *
+ * The shared quad is a unit square, and the instanced vertex stage scales it by
+ * each record's horizontal scale alone. That silently assumes the prototype
+ * geometry is exactly 1 unit across, which is true of almost nothing: glTF
+ * meshes load with `normalize: false` and keep their authored size, so a tree
+ * 3 units wide got a blob sized for a 1-unit tree. It also skipped the contact
+ * spread and the minor-axis floor the per-object tier applies, so the SAME
+ * asset drew a different shadow depending on whether it was instanced.
+ *
+ * Baking the extents into four vertices fixes it with no shader change and no
+ * per-draw uniform: retained geometry is keyed per mesh object, so this uploads
+ * once per `InstancedMesh` and is redrawn for free.
+ * @param {object} mesh - the InstancedMesh casting the shadows
+ * @param {Function} MeshClass - the `Mesh` constructor (avoids a circular import)
+ * @param {number} halfX - model-space half-extent along X, spread applied
+ * @param {number} halfZ - model-space half-extent along Z, spread applied
+ * @param {number} version - the prototype's geometry version
+ * @returns {object} the quad to draw this scatter's blobs from
+ * @ignore
+ */
+export function getInstancedShadowQuad(mesh: object, MeshClass: Function, halfX: number, halfZ: number, version: number): object;
+/**
+ * Release the shadow quads a renderer built, if any. Called from renderer
+ * teardown so the retained GPU geometry goes with it.
+ * @param {object} renderer - the renderer being torn down
+ * @ignore
+ */
+export function releaseShadowQuads(renderer: object): void;
+//# sourceMappingURL=groundshadow.d.ts.map

package/build/renderable/groundshadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groundshadow.d.ts","sourceRoot":"","sources":["../../src/renderable/groundshadow.js"],"names":[],"mappings":"AAyCA;;;;;;;;;GASG;AACH,oCAHa,iBAAiB,GAAC,eAAe,CAsC7C;AAED;;;;GAIG;AACH,2CAEC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,4CALW,YAAY,eACZ,MAAM,GACJ,OAAO,CA8BnB;AAiBD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wCAPW,MAAM,OACN,OAAO,wBAGL,MAAM,CAiClB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6CARW,MAAM,8BAEN,MAAM,SACN,MAAM,WACN,MAAM,GACJ,MAAM,CAsClB;AAED;;;;;GAKG;AACH,6CAHW,MAAM,QAUhB"}