melonjs 20.3.0 → 20.4.0

package/build/renderable/container.d.ts

@@ -40,30 +40,12 @@ export default class Container extends Renderable {
      * @ignore root
      */
     constructor(x?: number, y?: number, width?: number, height?: number, root?: boolean);
-    /**
-     * keep track of pending sort
-     * @ignore
-     */
-    pendingSort: any;
     /**
      * whether the container is the root of the scene
      * @type {boolean}
      * @default false
      */
     root: boolean;
-    /**
-     * The array of children of this container.
-     * @ignore
-     */
-    children: any[] | undefined;
-    /**
-     * The property of the child object that should be used to sort on this container
-     * value : "x", "y", "z"
-     * @type {string}
-     * @default "z"
-     */
-    _sortOn: string;
-    _comparator: (a: any, b: any) => number;
     /**
      * Specify if the children list should be automatically sorted when adding a new child
      * @type {boolean}
@@ -332,43 +314,6 @@ export default class Container extends Renderable {
      * @param {boolean} [recursive=false] - recursively sort sub-containers
      */
     sortNow(recursive?: boolean): void;
-    /**
-     * Z Sorting function
-     * @ignore
-     */
-    _sortZ(a: any, b: any): number;
-    /**
-     * Reverse Z Sorting function
-     * @ignore
-     */
-    _sortReverseZ(a: any, b: any): number;
-    /**
-     * Camera-distance sorting function used by `sortOn = "depth"`.
-     * Orders children by ascending squared distance from the cached
-     * camera position — closest first in the array, so
-     * {@link Container#draw}'s reverse-iteration walk paints far→near
-     * (correct painter's algorithm for alpha-blended sprites under
-     * perspective). The cached position is refreshed by
-     * {@link captureDepthCamera} just before each sort runs; this
-     * comparator stays tight (zero allocation, six subtracts + three
-     * mul-adds per pair) for the hot O(N log N) path.
-     *
-     * Container children are `Renderable` instances with an
-     * `ObservableVector3d` pos — `pos.z` is always defined, no guard
-     * needed here.
-     * @ignore
-     */
-    _sortDepth(a: any, b: any): number;
-    /**
-     * X Sorting function
-     * @ignore
-     */
-    _sortX(a: any, b: any): number;
-    /**
-     * Y Sorting function
-     * @ignore
-     */
-    _sortY(a: any, b: any): number;
     /**
      * A container additionally offsets its children by its own position — the
      * `translate()` at the top of {@link Container#draw} — which is what makes

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/draggable.d.ts

@@ -35,11 +35,6 @@ export class Draggable extends Renderable {
      * @returns {boolean} false if the object stopped being dragged
      */
     dragEnd(): boolean;
-    /**
-     * Destructor
-     * @ignore
-     */
-    destroy(): void;
 }
 import Renderable from "./../renderable/renderable.js";
 import { Vector2d } from "../math/vector2d.ts";

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

@@ -1 +1 @@
-{"version":3,"file":"draggable.d.ts","sourceRoot":"","sources":["../../src/renderable/draggable.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH;IAUE,kBAAqB;IACrB,YAAkB;IAClB,qBAAoC;IAIrC;;;;;;;OAOG;IACH,mBA8BC;IAnBA,kDAEC;IAED,gEAIC;IAED,8DAIC;IAOF;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;OAGG;IACH,YAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,WAFa,OAAO,CAOnB;IAED;;;OAGG;IACH,gBAQC;CACD;uBAxHsB,+BAA+B;yBAD7B,qBAAqB"}
+{"version":3,"file":"draggable.d.ts","sourceRoot":"","sources":["../../src/renderable/draggable.js"],"names":[],"mappings":"AAYA;;;;GAIG;AACH;IAUE,kBAAqB;IACrB,YAAkB;IAClB,qBAAoC;IAIrC;;;;;;;OAOG;IACH,mBA8BC;IAnBA,kDAEC;IAED,gEAIC;IAED,8DAIC;IAOF;;;;OAIG;IACH,aAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;OAGG;IACH,YAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,WAFa,OAAO,CAOnB;IAED;;;;OAIG;IACH,gBAQC;CACD;uBAzHsB,+BAA+B;yBAD7B,qBAAqB"}

package/build/renderable/dragndrop.d.ts

@@ -9,23 +9,17 @@
 export class DropTarget extends Renderable {
     /**
      * constant for the overlaps method
-     * @constant
      * @type {string}
-     * @name CHECKMETHOD_OVERLAP
      */
     CHECKMETHOD_OVERLAP: string;
     /**
      * constant for the contains method
-     * @constant
      * @type {string}
-     * @name CHECKMETHOD_CONTAINS
      */
     CHECKMETHOD_CONTAINS: string;
     /**
      * the checkmethod we want to use
-     * @constant
      * @type {string}
-     * @name checkMethod
      * @default "CHECKMETHOD_OVERLAP"
      */
     checkMethod: string;
@@ -45,12 +39,7 @@ export class DropTarget extends Renderable {
      * Gets called when a draggable entity is dropped on the current entity
      * @param {Draggable} draggable - the draggable object that is dropped
      */
-    drop(): void;
-    /**
-     * Destructor
-     * @ignore
-     */
-    destroy(): void;
+    drop(draggable: Draggable): void;
 }
 import Renderable from "./../renderable/renderable.js";
 import type { Draggable } from "./draggable.js";

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

@@ -1 +1 @@
-{"version":3,"file":"dragndrop.d.ts","sourceRoot":"","sources":["../../src/renderable/dragndrop.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;GAGG;AACH;IAYE;;;;;OAKG;IACH,qBAHU,MAAM,CAGqB;IAErC;;;;;OAKG;IACH,sBAHU,MAAM,CAGsB;IAEtC;;;;;;OAMG;IACH,aAJU,MAAM,CAI2B;IAE3C,kCAA8D;IAG/D;;;OAGG;IACH,4BAFW,MAAM,QAQhB;IAED;;;;OAIG;IACH,aAHW,MAAM,aACN,SAAS,QAUnB;IAED;;;OAGG;IACH,aAAS;IAET;;;OAGG;IACH,gBAGC;CACD;uBA7FsB,+BAA+B;+BAKxB,gBAAgB"}
+{"version":3,"file":"dragndrop.d.ts","sourceRoot":"","sources":["../../src/renderable/dragndrop.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;GAGG;AACH;IAYE;;;OAGG;IACH,qBAFU,MAAM,CAEqB;IAErC;;;OAGG;IACH,sBAFU,MAAM,CAEsB;IAEtC;;;;OAIG;IACH,aAHU,MAAM,CAG2B;IAE3C,kCAA8D;IAG/D;;;OAGG;IACH,4BAFW,MAAM,QAQhB;IAED;;;;OAIG;IACH,aAHW,MAAM,aACN,SAAS,QAUnB;IAED;;;OAGG;IAEH,gBAHW,SAAS,QAGF;IAElB;;;;OAIG;IACH,gBAGC;CACD;uBAzFsB,+BAA+B;+BAKxB,gBAAgB"}

package/build/renderable/entity/entity.d.ts

@@ -150,7 +150,6 @@
  * @category Game Objects
  */
 export default class Entity extends Renderable {
-    static _deprecationWarned: boolean;
     /**
      * @param {number} x - the x coordinates of the entity object
      * @param {number} y - the y coordinates of the entity object
@@ -185,11 +184,6 @@ export default class Entity extends Renderable {
         collisionMask?: number | undefined;
         shapes?: Rect[] | Polygon[] | Line[] | Ellipse[] | undefined;
     });
-    /**
-     * The array of renderable children of this entity.
-     * @ignore
-     */
-    children: any[];
     set renderable(value: Renderable);
     /**
      * The entity renderable component (can be any objects deriving from me.Renderable, like me.Sprite for example)
@@ -207,8 +201,6 @@ export default class Entity extends Renderable {
      * @type {boolean}
      */
     alive: boolean;
-    /** @ignore */
-    update(dt: any): boolean;
     /**
      * update the bounding box for this entity.
      * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates

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

@@ -1 +1 @@
-{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/renderable/entity/entity.js"],"names":[],"mappings":"AAQA;;;;;;;;IAQI;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6IG;AACH;IACC,mCAAkC;IAElC;;;;;;;;;;;;;;;;;OAiBG;IACH,eAjBW,MAAM,KACN,MAAM,YAGd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,IAAI;QACJ,EAAE;QACI,KAAK;QACkB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACjB,UAAU;QACV,WAAW;QACX,IAAI;QACJ,aAAa;QACc,MAAM;KAC3D,EA0FF;IA9EA;;;OAGG;IACH,gBAAkB;IAqFnB,sBAPU,UAAU,EAmBnB;IArBD;;;OAGG;IAEH,kBAHU,UAAU,CAKnB;IAnDA;;;OAGG;IACH,IAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,OAFU,OAAO,CAEA;IAwDlB,cAAc;IACd,yBAKC;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,MAAM,CA0BlB;IAED;;OAEG;IACH,qBAEC;IAED,6BAkBC;IAED;;;;;;;;OAQG;IACH,iCAHW,QAAQ,GACN,QAAQ,CAgBpB;IAsCD;;OAEG;IACH,0BAIC;CACD;uBAxasB,kBAAkB;4BAQhB,2BAA2B;0BAH7B,iCAAiC;6BAE9B,6BAA6B;0BAHhC,4BAA4B;6BAEzB,+BAA+B"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/renderable/entity/entity.js"],"names":[],"mappings":"AAQA;;;;;;;;IAQI;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6IG;AACH;IACC;;;OAGG;IACH,mCAAkC;IAElC;;;;;;;;;;;;;;;;;OAiBG;IACH,eAjBW,MAAM,KACN,MAAM,YAGd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,IAAI;QACJ,EAAE;QACI,KAAK;QACkB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;QACjB,UAAU;QACV,WAAW;QACX,IAAI;QACJ,aAAa;QACc,MAAM;KAC3D,EA2FF;IA/EA;;;;OAIG;IACH,gBAAkB;IAqFnB,sBAPU,UAAU,EAmBnB;IArBD;;;OAGG;IAEH,kBAHU,UAAU,CAKnB;IAnDA;;;OAGG;IACH,IAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,OAFU,OAAO,CAEA;IAwDlB;;;OAGG;IACH,yBAKC;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,MAAM,CA0BlB;IAED;;OAEG;IACH,qBAEC;IAED,6BAkBC;IAED;;;;;;;;OAQG;IACH,iCAHW,QAAQ,GACN,QAAQ,CAgBpB;IAuCD;;OAEG;IACH,0BAIC;CACD;uBAjbsB,kBAAkB;4BAQhB,2BAA2B;0BAH7B,iCAAiC;6BAE9B,6BAA6B;0BAHhC,4BAA4B;6BAEzB,+BAA+B"}

package/build/renderable/frameAnimation.d.ts

@@ -41,22 +41,8 @@ export default class FrameAnimation {
      * {@link Sprite3d} remaps its quad's UVs + vertices).
      */
     constructor(host: object, applyFrame: (region: object) => void);
-    /**
-     * the host renderable this engine draws through.
-     * @type {object}
-     * @ignore
-     */
-    host: object;
-    /**
-     * geometry hook invoked on every frame change (see constructor).
-     * @type {(region: object) => void}
-     * @ignore
-     */
-    _applyFrame: (region: object) => void;
     /** defined animations, keyed by id @type {object} */
     anim: object;
-    /** animation to chain to / completion callback on cycle end @ignore */
-    resetAnim: (() => unknown) | (() => false | undefined) | (() => boolean) | (() => void) | undefined;
     /** current frame info @type {object} */
     current: object;
     /** elapsed time within the current frame, in ms @type {number} */
@@ -65,10 +51,6 @@ export default class FrameAnimation {
     animationspeed: number;
     /** pause flag — freezes the current frame @type {boolean} */
     animationpause: boolean;
-    /** per-play speed multiplier (1 = authored speed) @ignore */
-    _animSpeed: number;
-    /** set once a `loop:false` animation has finished its single cycle @ignore */
-    _animDone: boolean;
     /**
      * add an animation definition (see {@link Sprite#addAnimation}).
      * @param {string} name - animation id
@@ -118,29 +100,6 @@ export default class FrameAnimation {
      * @returns {number} the current animation frame index
      */
     getCurrentAnimationFrame(): number;
-    /**
-     * the frame object for the given index within the current animation.
-     * @param {number} id - the frame id
-     * @returns {object} the frame data
-     */
-    /**
-     * Whether the current animation is still resolvable.
-     *
-     * `update()` hands control to user code in the middle of its frame loop:
-     * `onended`, and the completion callback behind `resetAnim`. That code is
-     * free to tear the host down — "remove me once the animation finishes" is
-     * an entirely reasonable reaction, and `removeChildNow()` destroys the
-     * sprite, whose `destroy()` empties `anim`. Everything after the callback
-     * reads out of `anim`, so the loop has to check it is still there rather
-     * than resume into a map the callback just cleared.
-     *
-     * A callback that switches animations with `setCurrentAnimation()` leaves
-     * this true, which is the point: only a genuinely torn-down host stops the
-     * loop.
-     * @ignore
-     * @returns {boolean} true while the current animation can still be read
-     */
-    _isCurrentAnimationLive(): boolean;
     getAnimationFrameObjectByIndex(id: any): any;
     /**
      * clear the frame timer and the play-once "done" hold, without changing the

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

@@ -1 +1 @@
-{"version":3,"file":"frameAnimation.d.ts","sourceRoot":"","sources":["../../src/renderable/frameAnimation.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACC;;;;;;;;;;;OAWG;IACH,kBAXW,MAAM,cAMN,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EA2DlC;IArDA;;;;OAIG;IACH,MAHU,MAAM,CAGA;IAEhB;;;;OAIG;IACH,aAHU,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAGL;IAE7B,qDAAqD;IACrD,MAD2C,MAAM,CACnC;IAEd,uEAAuE;IACvE,oGAA0B;IAE1B,wCAAwC;IACxC,SAD8B,MAAM,CAiBnC;IAED,kEAAkE;IAClE,IADwD,MAAM,CACnD;IAEX,qEAAqE;IACrE,gBAD2D,MAAM,CACxC;IAEzB,6DAA6D;IAC7D,gBADkD,OAAO,CAC9B;IAE3B,6DAA6D;IAC7D,mBAAmB;IAEnB,8EAA8E;IAC9E,mBAAsB;IAGvB;;;;;;OAMG;IACH,mBALW,MAAM,SACN,MAAM,EAAE,GAAC,MAAM,EAAE,GAAC,MAAM,EAAE,mBAC1B,MAAM,GACJ,MAAM,CAoElB;IAED;;;;;;OAMG;IACH,0BALW,MAAM,cACN,MAAM,cAAU,MAAM,gBACtB,OAAO,GACL,MAAM,CA4ElB;IAED;;;;;OAKG;IACH,wBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qBAFa,MAAM,EAAE,CAIpB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;OAEG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH;;;;;;;;;;;;;;;;OAgBG;IACH,2BAFa,OAAO,CAQnB;IAED,6CAEC;IAED;;;;OAIG;IACH,mBAGC;IAED;;;OAGG;IACH,eAKC;IAED;;;;;;;;OAQG;IACH,WAHW,MAAM,GACJ,OAAO,CAmEnB;IAED;;;OAGG;IACH,gBAOC;CACD"}
+{"version":3,"file":"frameAnimation.d.ts","sourceRoot":"","sources":["../../src/renderable/frameAnimation.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACC;;;;;;;;;;;OAWG;IACH,kBAXW,MAAM,cAMN,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,EAyElC;IAnEA;;;;;OAKG;IACH,MAJU,MAAM,CAIA;IAEhB;;;;;OAKG;IACH,aAJU,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAIL;IAE7B,qDAAqD;IACrD,MAD2C,MAAM,CACnC;IAEd;;;;OAIG;IACH,oGAA0B;IAE1B,wCAAwC;IACxC,SAD8B,MAAM,CAiBnC;IAED,kEAAkE;IAClE,IADwD,MAAM,CACnD;IAEX,qEAAqE;IACrE,gBAD2D,MAAM,CACxC;IAEzB,6DAA6D;IAC7D,gBADkD,OAAO,CAC9B;IAE3B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,mBAAsB;IAGvB;;;;;;OAMG;IACH,mBALW,MAAM,SACN,MAAM,EAAE,GAAC,MAAM,EAAE,GAAC,MAAM,EAAE,mBAC1B,MAAM,GACJ,MAAM,CAoElB;IAED;;;;;;OAMG;IACH,0BALW,MAAM,cACN,MAAM,cAAU,MAAM,gBACtB,OAAO,GACL,MAAM,CA4ElB;IAED;;;;;OAKG;IACH,wBAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qBAFa,MAAM,EAAE,CAIpB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,CAOlB;IAED;;OAEG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH;;;;;;;;;;;;;;;;;OAiBG;IACH,2BAFa,OAAO,CAQnB;IAED,6CAEC;IAED;;;;OAIG;IACH,mBAGC;IAED;;;OAGG;IACH,eAKC;IAED;;;;;;;;OAQG;IACH,WAHW,MAAM,GACJ,OAAO,CAmEnB;IAED;;;OAGG;IACH,gBAOC;CACD"}

package/build/renderable/groundshadow.d.ts

@@ -1,92 +1,2 @@
-/**
- * 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

@@ -1 +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"}
+{"version":3,"file":"groundshadow.d.ts","sourceRoot":"","sources":["../../src/renderable/groundshadow.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;GAUG;AACH,oCAJa,iBAAiB,GAAC,eAAe,CAuC7C;AAED;;;;;GAKG;AACH,2CAEC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,4CANW,YAAY,eACZ,MAAM,GACJ,OAAO,CA+BnB;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wCARW,MAAM,OACN,OAAO,wBAGL,MAAM,CAkClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6CATW,MAAM,8BAEN,MAAM,SACN,MAAM,WACN,MAAM,GACJ,MAAM,CAuClB;AAED;;;;;;GAMG;AACH,6CAJW,MAAM,QAWhB"}

package/build/renderable/imagelayer.d.ts

@@ -59,7 +59,6 @@ export default class ImageLayer extends Sprite {
      * @default 'repeat'
      */
     get repeat(): string;
-    _repeat: string | undefined;
     repeatX: boolean | undefined;
     repeatY: boolean | undefined;
     onActivateEvent(): void;
@@ -69,34 +68,6 @@ export default class ImageLayer extends Sprite {
      * @param {number} h - new height
      */
     resize(w: number, h: number): this;
-    /**
-     * createPattern function
-     * @ignore
-     */
-    createPattern(): void;
-    _pattern: any;
-    /**
-     * updateLayer function
-     * @ignore
-     */
-    updateLayer(): void;
-    /**
-     * Override the default preDraw to skip the base class's anchor offset
-     * translation and `autoTransform` application — `ImageLayer.draw()`
-     * computes its own world-space position from the viewport, the parallax
-     * `ratio`, anchor, and zoom, so applying anchor/transform here would
-     * double-translate the layer.
-     *
-     * Coordinate-sensitive setup (flip, stencil mask) is intentionally
-     * deferred to `draw()` where it runs *after* the per-camera zoom
-     * translate/scale — that way it stays correctly aligned at any
-     * `viewport.zoom` and across multiple cameras. Coordinate-independent
-     * setup (alpha, post-effects, tint, blend) stays here. The inherited
-     * `Renderable.postDraw` cleans up symmetrically (`clearTint` /
-     * `clearMask` / `endPostEffect` / `restore`).
-     * @ignore
-     */
-    preDraw(renderer: any): void;
     /**
      * draw this ImageLayer (automatically called by melonJS)
      * @protected

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

@@ -1 +1 @@
-{"version":3,"file":"imagelayer.d.ts","sourceRoot":"","sources":["../../src/renderable/imagelayer.js"],"names":[],"mappings":"AAaA;;;GAGG;AAEH;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,eAhBW,MAAM,KACN,MAAM,YAEd;QAA4E,KAAK,EAAzE,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,MAAM;QACvC,IAAI;QACJ,CAAC;QACQ,KAAK;QACsB,MAAM;QACN,WAAW;eAAvC,MAAM;eAAG,MAAM;;KACjD,EAgEF;IAlCA;;;;;;;;;OASG;IACH,OAHU,QAAQ,CAGqB;IAyCxC,kBAPU,MAAM,EA2Bf;IAnCD;;;;;;;;;;OAUG;IACH,cAHU,MAAM,CAKf;IAGA,4BAAoB;IAGlB,6BAAoB;IACpB,6BAAoB;IAkBvB,wBAsBC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAOhB;IAED;;;OAGG;IACH,sBAKC;IAJA,cAGC;IAGF;;;OAGG;IACH,oBA+CC;IAED;;;;;;;;;;;;;;;OAeG;IACH,6BAmBC;IAED;;;;;OAKG;IACH,yBAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QAyElB;IAGD,0BAMC;CAWD;mBAxWkB,aAAa;8BAIL,qBAAqB"}
+{"version":3,"file":"imagelayer.d.ts","sourceRoot":"","sources":["../../src/renderable/imagelayer.js"],"names":[],"mappings":"AAaA;;;GAGG;AAEH;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,eAhBW,MAAM,KACN,MAAM,YAEd;QAA4E,KAAK,EAAzE,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,MAAM;QACvC,IAAI;QACJ,CAAC;QACQ,KAAK;QACsB,MAAM;QACN,WAAW;eAAvC,MAAM;eAAG,MAAM;;KACjD,EAgEF;IAlCA;;;;;;;;;OASG;IACH,OAHU,QAAQ,CAGqB;IAyCxC,kBAPU,MAAM,EA+Bf;IAvCD;;;;;;;;;;OAUG;IACH,cAHU,MAAM,CAKf;IAGA;;;OAGG;IACH,4BAAoB;IAGlB,6BAAoB;IACpB,6BAAoB;IAkBvB,wBAsBC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAOhB;IAED;;;;OAIG;IACH,sBASC;IARA;;;OAGG;IACH,cAGC;IAGF;;;;OAIG;IACH,oBA+CC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,6BAmBC;IAED;;;;;OAKG;IACH,yBAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QAyElB;IAGD,0BAMC;CAYD;mBApXkB,aAAa;8BAIL,qBAAqB"}

package/build/renderable/instanced_mesh.d.ts

@@ -28,6 +28,32 @@
  * Requires a GPU backend (`renderer.supportsInstancing`). Under the Canvas
  * renderer the instances are drawn one at a time through the ordinary CPU
  * mesh path — correct, but without any of the benefit.
+ *
+ * ### When a plain {@link Mesh} each is the better answer
+ *
+ * One `InstancedMesh` is **one geometry and one material**, and four things
+ * move from per-object to per-group:
+ *
+ * - **Depth sorting.** The set has a single sort key — its own `pos` — so it
+ *   orders against the rest of the scene as one object. Opaque instances still
+ *   resolve against each other per pixel through the depth buffer; blended
+ *   ones cannot be sorted among themselves at all.
+ * - **Ground shadows.** {@link Mesh#castGroundShadow} becomes one instanced
+ *   shadow draw covering the whole set, not a blob computed per object.
+ * - **Removal.** {@link InstancedMesh#removeInstance} swaps the last instance
+ *   into the hole, so any index a caller was holding now refers to a different
+ *   object.
+ * - **Colour.** {@link Mesh#tint} applies to the set; per-instance colour has
+ *   to be declared up front with `instanceColors` and set through
+ *   {@link InstancedMesh#setInstanceColor}.
+ *
+ * So the question is not how many there are, but whether the game addresses
+ * them **individually**. Scenery — trees, rocks, grass, debris — instances
+ * cleanly, because nothing ever asks about one of them. Collision-tested props
+ * are fine too: the positions are yours either way and instancing only changes
+ * how they are drawn. Collectibles and enemies usually are not, because
+ * removing them one at a time makes the index swap the caller's problem, and
+ * at small counts a pooled `Mesh` each is less code and no slower.
  * @augments Mesh
  * @category Rendering
  * @example
@@ -67,14 +93,6 @@ export default class InstancedMesh extends Mesh {
         instanceColors?: boolean | undefined;
         instanceData?: boolean | undefined;
     });
-    /**
-     * How this mesh's per-instance records are laid out — record width and
-     * the offset of each opt-in slot. Consumed by the batchers to describe
-     * the instance vertex buffer.
-     * @type {object}
-     * @ignore
-     */
-    instanceLayout: object;
     /**
      * The packed instance records, `instanceLayout.floats` per instance.
      * Editable in place for bulk updates — announce those with
@@ -84,27 +102,6 @@ export default class InstancedMesh extends Mesh {
      * @type {Float32Array}
      */
     instanceBuffer: Float32Array;
-    /**
-     * bumped whenever the buffer is reallocated, so a renderer holding a
-     * GPU copy knows its capacity assumption is stale
-     * @type {number}
-     * @ignore
-     */
-    _instanceVersion: number;
-    /** @ignore */
-    _instanceRevision: number;
-    /** @ignore */
-    _spanFromRevision: number;
-    /** @ignore */
-    _dirtyFirst: number;
-    /** @ignore */
-    _dirtyLast: number;
-    /** @ignore */
-    _instanceCount: number;
-    /** @ignore */
-    _visibleInstanceCount: number;
-    /** @ignore */
-    _cullRevision: number;
     set instanceCount(count: number);
     /**
      * How many instances this mesh holds.
@@ -197,50 +194,6 @@ export default class InstancedMesh extends Mesh {
      * forest.needsInstanceUpdate = true;
      */
     set needsInstanceUpdate(value: any);
-    /**
-     * The dirty span, in floats, as `[first, lastExclusive)`. Empty when
-     * nothing changed since the last upload.
-     * @returns {number[]} the span
-     * @ignore
-     */
-    dirtyRange(): number[];
-    /**
-     * What one GPU buffer must upload to catch up, given the revision it last
-     * reached. Replaces a shared "clear the dirty flag" step, which the first
-     * consumer would drain out from under the second.
-     * @param {number} uploadedRevision - the revision that buffer holds
-     * @returns {object} `{first, count, full, revision}` — float span, or `full`
-     * @ignore
-     */
-    instanceUpload(uploadedRevision: number): object;
-    /**
-     * Called by the batcher once the dirty span has been uploaded.
-     * @ignore
-     */
-    clearInstanceDirty(): void;
-    /**
-     * The world-space bounding box of every instance, so the whole group
-     * frustum-culls as one object.
-     *
-     * Bounds the prototype geometry through each instance transform and then
-     * through the group placement — correct before the first draw, like the
-     * base implementation, and independent of what any draw left behind.
-     * @returns {AABB3d} the union of all instance bounds (reused instance)
-     */
-    /**
-     * Resize the renderable's own 2D bounds box so it encloses every
-     * instance.
-     *
-     * This is what makes the group frustum-cull correctly. `Camera3d.isVisible`
-     * tests a sphere derived from `getBounds()` — the flat width/height box —
-     * **not** {@link InstancedMesh#getBounds3d}. Left at the prototype's size,
-     * a forest scattered over thousands of units presents a box a few tens of
-     * pixels across at the group origin: pan the camera just past that origin
-     * and every instance disappears at once, while still on screen.
-     * @ignore
-     */
-    _refreshCullVolume(): any;
-    _cullRadius: number | undefined;
     /**
      * Draw the instanced mesh. Under a GPU backend this is one instanced
      * draw call; the Canvas renderer has no instancing, so each instance is
@@ -249,37 +202,6 @@ export default class InstancedMesh extends Mesh {
      * @param {Camera2d} [viewport] - the camera rendering this frame
      */
     draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
-    /**
-     * Fallback for renderers without instancing (Canvas): walk the instances
-     * and draw the prototype once per instance, composing the group and
-     * instance transforms by hand. Correct, and as slow as the uninstanced
-     * scene it replaces — the point is that a scene authored for instancing
-     * still renders everywhere.
-     * @param {CanvasRenderer} renderer - a renderer instance
-     * @param {Camera2d} [viewport] - the camera rendering this frame
-     * @ignore
-     */
-    _drawInstancesIndividually(renderer: CanvasRenderer, viewport?: Camera2d): void;
-    /**
-     * Release the instance records along with the mesh.
-     * @ignore
-     */
-    /**
-     * Draw a ground shadow for every visible instance — one call for the whole
-     * set, over the instance buffer the mesh itself just drew from (#1515).
-     *
-     * The group matrix is passed with its Y basis column zeroed and its
-     * translation Y set to the ground, so whatever Y the shadow vertex stage
-     * produces is flattened onto the floor. That is what lets the ground
-     * height reach the shader without a new uniform.
-     *
-     * One ground height serves the whole set — flat terrain. Per-instance
-     * ground height would have to ride the `instanceData` slot, which the
-     * built-in shading already reads as emissive.
-     * @param {WebGLRenderer} renderer - the active renderer
-     * @ignore
-     */
-    _drawInstancedGroundShadow(renderer: WebGLRenderer): void;
 }
 import Mesh from "./mesh.js";
 import { Matrix3d } from "../math/matrix3d.ts";

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

@@ -1 +1 @@
-{"version":3,"file":"instanced_mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/instanced_mesh.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IACC;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,YAEd;QAA0B,aAAa;QACZ,cAAc;QACd,YAAY;KACzC,EAiEA;IA7DA;;;;;;OAMG;IACH,gBAHU,MAAM,CAMf;IAED;;;;;;;OAOG;IACH,gBAFU,YAAY,CAEmB;IAEzC;;;;;OAKG;IACH,kBAHU,MAAM,CAGS;IAUzB,cAAc;IACd,0BAA0B;IAG1B,cAAc;IACd,0BAA0B;IAE1B,cAAc;IACd,oBAA2B;IAC3B,cAAc;IACd,mBAAmB;IAEnB,cAAc;IACd,uBAAuB;IACvB,cAAc;IACd,8BAA+B;IAE/B,cAAc;IACd,sBAAuB;IAoBxB,yBANU,MAAM,EAgDf;IAvDD;;;;;;;;OAQG;IACH,qBAFU,MAAM,CAIf;IA8DD,gCAVU,MAAM,EAiBf;IAvBD;;;;;;;;;OASG;IACH,4BAJU,MAAM,CAQf;IAWD;;;;;;;OAOG;IACH,wBANW,QAAQ,YAEhB;QAAwB,KAAK;QACF,IAAI;KAC/B,GAAU,MAAM,CAqBlB;IAED;;;;;;;;;OASG;IACH,sBAFW,MAAM,QAiBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,aACN,QAAQ,QAYlB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,QAAQ,GACN,QAAQ,GAAC,SAAS,CAW9B;IAED;;;;OAIG;IACH,wBAHW,MAAM,SACN,KAAK,QAaf;IAED;;;;;;;OAOG;IACH,uBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,QAahB;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,SACN,MAAM,QAyBhB;IAED;;;;;;;;OAQG;IAEH,oCAIC;IAED;;;;;OAKG;IACH,cAHa,MAAM,EAAE,CAYpB;IAED;;;;;;;OAOG;IACH,iCAJW,MAAM,GACJ,MAAM,CAclB;IAED;;;OAGG;IACH,2BAIC;IAED;;;;;;;;OAQG;IACH;;;;;;;;;;;OAWG;IACH,0BA8BC;IAVC,gCAAsC;IAkDxC;;;;;;OAMG;IACH,eAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QA6BlB;IAED;;;;;;;;;OASG;IACH,qCAJW,cAAc,aACd,QAAQ,QA6BlB;IAED;;;OAGG;IACH;;;;;;;;;;;;;;OAcG;IACH,qCAHW,aAAa,QAqEvB;CAOD;iBAlsBgB,WAAW;yBATH,qBAAqB"}
+{"version":3,"file":"instanced_mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/instanced_mesh.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;IACC;;;;;;;OAOG;IACH,eAPW,MAAM,KACN,MAAM,YAEd;QAA0B,aAAa;QACZ,cAAc;QACd,YAAY;KACzC,EAwFA;IApFA;;;;;;;OAOG;IACH,gBAJU,MAAM,CAOf;IAED;;;;;;;OAOG;IACH,gBAFU,YAAY,CAEmB;IAEzC;;;;;;OAMG;IACH,kBAJU,MAAM,CAIS;IAUzB;;;OAGG;IACH,0BAA0B;IAG1B;;;OAGG;IACH,0BAA0B;IAE1B;;;OAGG;IACH,oBAA2B;IAC3B;;;OAGG;IACH,mBAAmB;IAEnB;;;OAGG;IACH,uBAAuB;IACvB;;;OAGG;IACH,8BAA+B;IAE/B;;;OAGG;IACH,sBAAuB;IAoBxB,yBANU,MAAM,EAgDf;IAvDD;;;;;;;;OAQG;IACH,qBAFU,MAAM,CAIf;IA8DD,gCAVU,MAAM,EAiBf;IAvBD;;;;;;;;;OASG;IACH,4BAJU,MAAM,CAQf;IAWD;;;;;;;OAOG;IACH,wBANW,QAAQ,YAEhB;QAAwB,KAAK;QACF,IAAI;KAC/B,GAAU,MAAM,CAqBlB;IAED;;;;;;;;;OASG;IACH,sBAFW,MAAM,QAiBhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,aACN,QAAQ,QAYlB;IAED;;;;;OAKG;IACH,mBAJW,MAAM,QACN,QAAQ,GACN,QAAQ,GAAC,SAAS,CAW9B;IAED;;;;OAIG;IACH,wBAHW,MAAM,SACN,KAAK,QAaf;IAED;;;;;;;OAOG;IACH,uBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,QAahB;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,SACN,MAAM,QAyBhB;IAED;;;;;;;;OAQG;IAEH,oCAIC;IAED;;;;;;OAMG;IACH,cAJa,MAAM,EAAE,CAapB;IAED;;;;;;;;OAQG;IACH,iCALW,MAAM,GACJ,MAAM,CAelB;IAED;;;;OAIG;IACH,2BAIC;IAED;;;;;;;;OAQG;IACH;;;;;;;;;;;;OAYG;IACH,0BAkCC;IAdC;;;OAGG;IACH,gCAAsC;IAqDxC;;;;;;OAMG;IACH,eAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QA6BlB;IAED;;;;;;;;;;OAUG;IACH,qCALW,cAAc,aACd,QAAQ,QA8BlB;IAED;;;;OAIG;IACH;;;;;;;;;;;;;;;OAeG;IACH,qCAJW,aAAa,QAsEvB;CAOD;iBAjwBgB,WAAW;yBATH,qBAAqB"}