melonjs 20.7.0 → 20.8.0

package/build/renderable/container.d.ts

@@ -10,7 +10,7 @@
  * @import NineSliceSprite from "./nineslicesprite.js";
  * @import ImageLayer from "./imagelayer.js";
  * @import ColorLayer from "./colorlayer.js";
- * @import Light2d from "./light2d.js";
+ * @import Light2d from "../lighting/light2d.ts";
  * @import UIBaseElement from "./ui/uibaseelement.ts";
  * @import UISpriteElement from "./ui/uispriteelement.ts";
  * @import UITextButton from "./ui/uitextbutton.ts";
@@ -19,6 +19,9 @@
  * @import {Bounds} from "./../physics/bounds.ts";
  * @import CanvasRenderer from "./../video/canvas/canvas_renderer.js";
  * @import WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+ * @import {Matrix3d} from "../math/matrix3d.ts";
+ * @import Camera2d from "../camera/camera2d.ts";
+ * @import Renderer from "../video/renderer.js";
  */
 /**
  * Container represents a collection of child objects.
@@ -144,7 +147,13 @@ export default class Container extends Renderable {
      * if the given child implements an onActivateEvent method, that method will be called
      * once the child is added to this container.
      * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child - Child to be added
-     * @param {number} [z] - forces the z index of the child to the specified value
+     * @param {number} [z] - forces the z index of the child to the specified
+     * value. This depth is scoped to THIS container: it orders the child among
+     * its siblings only, and says nothing about children of another container.
+     * Both drawing and pointer hit-testing resolve a cross-container pair at
+     * the common ancestor instead, so to put a whole subtree in front use
+     * {@link Container#moveToTop} on the container rather than a large `z` on
+     * something inside it. Left out, `autoDepth` numbers children from 1.
      * @returns {Renderable} the added child
      */
     addChild(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText, z?: number): Renderable;
@@ -256,12 +265,6 @@ export default class Container extends Renderable {
      * @returns {Renderable[]} an array of renderable object
      */
     getChildren(): Renderable[];
-    /**
-     * update the bounding box for this container.
-     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
-     * @returns {Bounds} this container bounding box Rectangle object
-     */
-    updateBounds(absolute?: boolean): Bounds;
     /**
      * Checks if this container is root or if it's attached to the root container.
      * @returns {boolean} true if this container is root or if it's attached to the root container
@@ -313,6 +316,11 @@ export default class Container extends Renderable {
     moveDown(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): void;
     /**
      * Move the specified child to the top(z depth).
+     *
+     * Moves the whole subtree: the child's own children keep their depths among
+     * themselves and come with it, because depth is resolved per container. This
+     * is how one overlapping panel is brought in front of another, for drawing
+     * and for pointer hit-testing alike.
      * @param {Renderable|Entity|Sprite|Collectable|Trigger|Draggable|DropTarget|NineSliceSprite|ImageLayer|ColorLayer|Light2d|UIBaseElement|UISpriteElement|UITextButton|Text|BitmapText} child - Child to be moved
      */
     moveToTop(child: Renderable | Entity | Sprite | Collectable | Trigger | Draggable | DropTarget | NineSliceSprite | ImageLayer | ColorLayer | Light2d | UIBaseElement | UISpriteElement | UITextButton | Text | BitmapText): void;
@@ -337,15 +345,11 @@ export default class Container extends Renderable {
      */
     sortNow(recursive?: boolean): void;
     /**
-     * A container additionally offsets its children by its own position — the
-     * `translate()` at the top of {@link Container#draw} — which is what makes
-     * a child's coordinates mean "relative to my parent" rather than naming a
-     * place in the world. A leaf renderable has no such term.
-     * @protected
-     * @param {Matrix3d} out - matrix to write into
-     * @returns {Matrix3d} `out`, for chaining
+     * draw this renderable (automatically called by melonJS)
+     * @param {Renderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the viewport to (re)draw
      */
-    protected getLocalTransform(out: Matrix3d): Matrix3d;
+    draw(renderer: Renderer, viewport?: Camera2d): void;
 }
 import Renderable from "./renderable.js";
 import type { Color } from "./../math/color.ts";
@@ -358,10 +362,12 @@ import type { DropTarget } from "./dragndrop.js";
 import type NineSliceSprite from "./nineslicesprite.js";
 import type ImageLayer from "./imagelayer.js";
 import type ColorLayer from "./colorlayer.js";
+import type Light2d from "../lighting/light2d.ts";
 import type UIBaseElement from "./ui/uibaseelement.ts";
 import type UISpriteElement from "./ui/uispriteelement.ts";
 import type UITextButton from "./ui/uitextbutton.ts";
 import type Text from "./text/text.js";
 import type BitmapText from "./text/bitmaptext.js";
-import type { Bounds } from "./../physics/bounds.ts";
+import type Renderer from "../video/renderer.js";
+import type Camera2d from "../camera/camera2d.ts";
 //# sourceMappingURL=container.d.ts.map

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

@@ -6,6 +6,10 @@
  * @import {Bounds} from "./../../physics/bounds.ts";
  * @import CanvasRenderer from "./../../video/canvas/canvas_renderer.js";
  * @import WebGLRenderer from "./../../video/webgl/webgl_renderer.js";
+ * @import {Matrix3d} from "../../math/matrix3d.ts";
+ * @import {Vector2d} from "../../math/vector2d.ts";
+ * @import Camera2d from "../../camera/camera2d.ts";
+ * @import Renderer from "../../video/renderer.js";
  **/
 /**
  * a Generic Object Entity
@@ -178,7 +182,7 @@ export default class Entity extends Renderable {
         anchorPoint?: string | Vector2d | {
             x: number;
             y: number;
-        };
+        } | undefined;
         framewidth?: number | undefined;
         frameheight?: number | undefined;
         type?: string | undefined;
@@ -203,34 +207,26 @@ export default class Entity extends Renderable {
      * @type {boolean}
      */
     alive: boolean;
-    /**
-     * update the bounding box for this entity.
-     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
-     * @returns {Bounds} this entity bounding box Rectangle object
-     */
-    updateBounds(absolute?: boolean): Bounds;
     /**
      * update the bounds when the body is modified
      */
     onBodyUpdate(): void;
     preDraw(renderer: any): void;
     /**
-     * An entity replaces {@link Renderable#preDraw} wholesale — no flip, no
-     * conjugation, no anchor offset, just its position biased by the body
-     * bounds — so the inherited composition would describe a transform this
-     * class never applies. Mirrors the `preDraw` above instead.
-     * @protected
-     * @param {Matrix3d} out - matrix to write into
-     * @returns {Matrix3d} `out`, for chaining
+     * draw this entity (automatically called by melonJS)
+     * @param {Renderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the viewport to (re)draw
      */
-    protected getLocalTransform(out: Matrix3d): Matrix3d;
+    draw(renderer: Renderer, viewport?: Camera2d): void;
     /**
      * onDeactivateEvent Notification function
      */
     onDeactivateEvent(): void;
 }
 import Renderable from "../renderable.js";
-import type { Bounds } from "./../../physics/bounds.ts";
+import type Renderer from "../../video/renderer.js";
+import type Camera2d from "../../camera/camera2d.ts";
+import type { Vector2d } from "../../math/vector2d.ts";
 import type { Rect } from "./../../geometries/rectangle.ts";
 import type { Polygon } from "../../geometries/polygon.ts";
 import type { Line } from "./../../geometries/line.ts";

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;;;OAGG;IACH,mCAAkC;IAElC;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAlBW,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;QACjC,OAAO;KACjC,EAgGF;IApFA;;;;OAIG;IACH,gBAAkB;IA0FnB,sBAPU,UAAU,EAmBnB;IArBD;;;OAGG;IAEH,kBAHU,UAAU,CAKnB;IAxDA;;;OAGG;IACH,IAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,OAFU,OAAO,CAEA;IA6DlB;;;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;uBAvbsB,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;;;;;;;;;;;;IAYI;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6IG;AACH;IACC;;;OAGG;IACH,mCAAkC;IAElC;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAlBW,MAAM,KACN,MAAM,YAGd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,IAAI;QACJ,EAAE;QACI,KAAK;QACkB,WAAW;eAAvC,MAAM;eAAG,MAAM;;QAChB,UAAU;QACV,WAAW;QACX,IAAI;QACJ,aAAa;QACc,MAAM;QACjC,OAAO;KACjC,EAgGF;IApFA;;;;OAIG;IACH,gBAAkB;IA0FnB,sBAPU,UAAU,EAmBnB;IArBD;;;OAGG;IAEH,kBAHU,UAAU,CAKnB;IAxDA;;;OAGG;IACH,IAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,OAFU,OAAO,CAEA;IA6DlB;;;OAGG;IACH,yBAKC;IAiCD;;OAEG;IACH,qBAEC;IAED,6BAkBC;IA2BD;;;;OAIG;IACH,eAHW,QAAQ,aACR,QAAQ,QAclB;IAoBD;;OAEG;IACH,0BAIC;CACD;uBA3bsB,kBAAkB;0BAchB,yBAAyB;0BADzB,0BAA0B;8BADxB,wBAAwB;0BAP5B,iCAAiC;6BAE9B,6BAA6B;0BAHhC,4BAA4B;6BAEzB,+BAA+B"}

package/build/renderable/frameAnimation.d.ts

@@ -1,7 +1,7 @@
 /**
  * additional import for TypeScript
  * @import { TextureAtlas } from "../video/texture/atlas.js";
- * @import { Vector2d } from "../math/vector2d.js";
+ * @import { Vector2d } from "../math/vector2d.ts";
  */
 /**
  * The shared **frame-animation engine** behind {@link Sprite} (2D) and

package/build/renderable/groundshadow.d.ts

@@ -1,2 +1,3 @@
 
+export function getInstancedShadowQuad(mesh: any, MeshClass: any, axX: any, axZ: any, azX: any, azZ: any, version: any, nx?: number, ny?: number, nz?: number): any;
 //# 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":"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"}
+{"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;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,kCATW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,YAAY,QAoBtB;AAgBD;;;;;;;;;;;;;;GAcG;AACH,oCAPW,MAAM,MACN,MAAM,MACN,MAAM,OACN,YAAY,QAgBtB;AAcD;;;;;;;;;;GAUG;AACH,4CALW,MAAM,GACJ,MAAM,CASlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iCAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,GACnB,YAAY,GAAC,MAAM,EAAE,CASjC;AAuDD,oKAgFC;AAED;;;;;;GAMG;AACH,6CAJW,MAAM,QAWhB;AAzPD;;;;;;;;;;;GAWG;AACH,yCAAkE;AA+BlE,oDAAoD;AACpD;;;;;;;;GAQG;AACH,iCAAkC,CAAC,CAAC"}

package/build/renderable/imagelayer.d.ts

@@ -1,6 +1,11 @@
 /**
  * additional import for TypeScript
- * @import {Vector2d} from "../math/vector2d.js";
+ * @import {Vector2d} from "../math/vector2d.ts";
+ * @import Camera2d from "../camera/camera2d.ts";
+ * @import CanvasRenderer from "../video/canvas/canvas_renderer.js";
+ * @import {CompressedImage} from "../loader/parsers/compressed_textures/compressed_image.js";
+ * @import WebGLRenderer from "../video/webgl/webgl_renderer.js";
+ * @import Renderer from "../video/renderer.js";
  */
 /**
  * a generic Image Layer Object
@@ -70,13 +75,15 @@ export default class ImageLayer extends Sprite {
     resize(w: number, h: number): this;
     /**
      * draw this ImageLayer (automatically called by melonJS)
-     * @protected
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
+     * @param {Renderer} renderer - a renderer instance
      * @param {Camera2d} [viewport] - the viewport to (re)draw
      */
-    protected draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
+    draw(renderer: Renderer, viewport?: Camera2d): void;
     onDeactivateEvent(): void;
 }
 import Sprite from "./sprite.js";
-import type { Vector2d } from "../math/vector2d.js";
+import type { Vector2d } from "../math/vector2d.ts";
+import type Renderer from "../video/renderer.js";
+import type Camera2d from "../camera/camera2d.ts";
+import type { CompressedImage } from "../loader/parsers/compressed_textures/compressed_image.js";
 //# sourceMappingURL=imagelayer.d.ts.map

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,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"}
+{"version":3,"file":"imagelayer.d.ts","sourceRoot":"","sources":["../../src/renderable/imagelayer.js"],"names":[],"mappings":"AAaA;;;;;;;;GAQG;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;;;;OAIG;IACH,eAHW,QAAQ,aACR,QAAQ,QAyElB;IAGD,0BAMC;CAYD;mBAxXkB,aAAa;8BAIL,qBAAqB;0BAKvB,sBAAsB;0BAJtB,uBAAuB;qCAEd,2DAA2D"}

package/build/renderable/instanced_mesh.d.ts

@@ -139,7 +139,7 @@ export default class InstancedMesh extends Mesh {
      * @returns {number} the new instance's index
      */
     addInstance(transform?: Matrix3d, options?: {
-        color?: any;
+        color?: Color | undefined;
         data?: number[] | undefined;
     }): number;
     /**
@@ -199,14 +199,6 @@ export default class InstancedMesh extends Mesh {
      * forest.needsInstanceUpdate = true;
      */
     set needsInstanceUpdate(value: any);
-    /**
-     * Draw the instanced mesh. Under a GPU backend this is one instanced
-     * draw call; the Canvas renderer has no instancing, so each instance is
-     * drawn through the ordinary mesh path instead.
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
-     * @param {Camera2d} [viewport] - the camera rendering this frame
-     */
-    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
 }
 /**
  * Everything {@link InstancedMesh} takes: the instancing settings, plus every
@@ -230,4 +222,5 @@ export type InstancedMeshOwnSettings = {
 export type InstancedMeshSettings = InstancedMeshOwnSettings & import("./mesh.js").MeshSettings;
 import Mesh from "./mesh.js";
 import { Matrix3d } from "../math/matrix3d.ts";
+import type { Color } from "../math/color.ts";
 //# sourceMappingURL=instanced_mesh.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;IACC;;;;OAIG;IACH,eAJW,MAAM,KACN,MAAM,YACN,qBAAqB,EAyF/B;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;;;;;;;;;;oBA1qBa,MAAM;;;;qBACN,OAAO;;;;mBACP,OAAO;;oCAIR,wBAAwB,GAAG,OAAO,WAAW,EAAE,YAAY;iBAxGvD,WAAW;yBATH,qBAAqB"}
+{"version":3,"file":"instanced_mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/instanced_mesh.js"],"names":[],"mappings":"AA4CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;IACC;;;;OAIG;IACH,eAJW,MAAM,KACN,MAAM,YACN,qBAAqB,EAyF/B;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,yCAkCC;IAdC;;;OAGG;IACH,gCAAsC;IAyFxC;;;;;;;;;;OAUG;IACH,qCALW,cAAc,aACd,QAAQ,QA8BlB;IAED;;;;OAIG;IACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,qCAlBW,aAAa,QA2PvB;CAOD;;;;;;;;;;oBAj2Ba,MAAM;;;;qBACN,OAAO;;;;mBACP,OAAO;;oCAIR,wBAAwB,GAAG,OAAO,WAAW,EAAE,YAAY;iBAxHvD,WAAW;yBAfH,qBAAqB;2BAqBtB,kBAAkB;4BAEjB,sBAAsB;gCAHhB,oCAAoC;0BAD1C,uBAAuB;+BAGlB,kCAAkC"}

package/build/renderable/mesh.d.ts

@@ -305,6 +305,45 @@ export default class Mesh extends Renderable {
      * });
      */
     transparent: boolean | undefined;
+    /**
+     * Whether geometry in front of this mesh hides it.
+     *
+     * Depth TEST, not depth WRITE. The two are different questions and the
+     * engine answers them in different places: writing is policy, and the
+     * transparent pass already turns it off for everything blended so
+     * overlapping draws blend instead of fighting. Testing is an authoring
+     * choice, and this is it.
+     *
+     * `false` is for something with no surface to be occluded ON. An
+     * additive glow is the case that forced it: it is a screen-space
+     * effect wearing a mesh's clothes, carrying a world position only so
+     * it can sort and move with the thing it belongs to. Left depth
+     * tested, a flat billboard is sliced along a straight line the moment
+     * any geometry is nearer at some pixel — most visibly where a glowing
+     * object passes near the limb of something round.
+     *
+     * Leave it `true` for anything that is genuinely in the scene. A
+     * muzzle flash behind a wall should still be behind the wall; this is
+     * not a synonym for "additive".
+     *
+     * Honoured in the transparent pass, so a mesh wanting it also wants
+     * {@link Mesh#transparent}. The Canvas renderer has no depth buffer
+     * and ignores it.
+     * @type {boolean}
+     * @default true
+     * @example
+     * // a glow that belongs to the rock, but is never cut by the planet
+     * const halo = new Sprite3d(0, 0, {
+     *     image: glowTexture,
+     *     width: 64, height: 64,
+     *     billboard: "spherical",
+     *     blendMode: "additive",
+     *     transparent: true,
+     *     alphaCutoff: 0,
+     *     depthTest: false,
+     * });
+     */
+    depthTest: boolean;
     /**
      * World Y of the floor the shadow lands on, or `undefined` (the
      * default) to mean "this object is standing on the ground" — the
@@ -321,6 +360,13 @@ export default class Mesh extends Renderable {
      * object above it.
      * @type {number|undefined}
      * @default undefined
+     * @example
+     * // a collectible bobbing above the floor: naming the floor is what
+     * // lets the blob shrink and fade as it rises. Left unset the blob
+     * // rides the object's own base and never leaves it.
+     * const coin = new Mesh(x, floorY, { ...geometry, castGroundShadow: true });
+     * coin.shadowGroundY = floorY;
+     * coin.pos.y = floorY - 40 - 30 * Math.sin(t);
      */
     shadowGroundY: number | undefined;
     /**
@@ -330,6 +376,148 @@ export default class Mesh extends Renderable {
      * @default 0.45
      */
     shadowOpacity: number;
+    /**
+     * Multiplier for the ground shadow's footprint, independent of the
+     * object's size, ground height and opacity. Values above `1` can reveal
+     * the blob beneath a wide prop; values below `1` tighten it.
+     * Non-positive or non-finite values hide the shadow. Can be changed live
+     * on an {@link InstancedMesh} too: the set's shared quad is rewritten in
+     * place rather than rebuilt, so animating it allocates nothing.
+     * @type {number}
+     * @default 1
+     * @example
+     * // a crate's own blob hides underneath it, so widen it until the edge
+     * // shows; `0` and below hide the shadow and leave the mesh drawn
+     * crate.shadowScale = 1.6;
+     */
+    shadowScale: number;
+    /**
+     * How far to slide the ground shadow along
+     * {@link Mesh#shadowDirectionX}/{@link Mesh#shadowDirectionZ}, in
+     * multiples of the blob's OWN radius, which is what gives the look of
+     * a light that is not directly overhead.
+     *
+     * A ratio rather than a world distance. The distance that reads right
+     * is the one that shifts a stretched ellipse far enough for its
+     * trailing edge to stay at the caster's feet, which is about
+     * `stretch - 1` of its radius, so a world distance has to be retuned
+     * for every size of thing and cannot serve the parts of one glTF model
+     * at all. {@link Mesh#shadowScale} rides in that radius, so widening
+     * the blob carries the offset with it.
+     *
+     * Honoured ONLY when {@link Mesh#shadowGroundY} is set. The blob is a
+     * flat quad on one named plane with no contact with terrain, so sliding
+     * it across a plane the game has not named puts it somewhere there may
+     * be no floor at all. Setting `shadowGroundY` is the game saying where
+     * its floor is, and that is the only case where an offset is honest.
+     *
+     * An {@link InstancedMesh} honours it too, as one throw shared by the
+     * whole set, measured in the SET's own blob radius.
+     * @type {number}
+     * @default 0
+     */
+    shadowOffset: number;
+    /**
+     * How much longer the ground shadow is along its direction, for the
+     * look of a low light. `1` leaves it round.
+     *
+     * Clamped to 3, and the blob fades as it stretches: this is art
+     * direction, not a projection, and the further it is pulled the less
+     * there is to believe. Values below `1` are treated as `1`; shortening
+     * the blob is what {@link Mesh#shadowScale} is for.
+     *
+     * An {@link InstancedMesh} honours it too: one stretch along one
+     * direction for the whole set, baked into the quad its blobs share
+     * rather than into the matrix that also places them.
+     * @type {number}
+     * @default 1
+     */
+    shadowStretch: number;
+    /**
+     * X of the ground direction the shadow is cast along.
+     * @type {number}
+     * @default 0
+     * @see Mesh#shadowOffset
+     */
+    shadowDirectionX: number;
+    /**
+     * Z of the ground direction the shadow is cast along. Together with
+     * {@link Mesh#shadowDirectionX}, a zero-length pair means no offset and
+     * no stretch.
+     * @type {number}
+     * @default 0
+     * @see Mesh#shadowOffset
+     */
+    shadowDirectionZ: number;
+    /**
+     * A {@link Light3d} to take the shadow direction from, instead of
+     * setting it by hand.
+     *
+     * Read every draw, so a sun that moves carries the shadow with it.
+     * NOTHING is inferred: the engine never picks a dominant light for you,
+     * because a scene with several has no non-arbitrary answer and one with
+     * none has no answer at all. Name the light or get no direction.
+     * @type {Light3d|undefined}
+     * @example
+     * // one sun, every shadow in the scene following it. Read every draw,
+     * // so a day/night cycle needs nothing else.
+     * const sun = new Light3d({ direction: [0.4, 1, 0.2] });
+     * app.world.addChild(sun);
+     * for (const prop of props) {
+     *     prop.castGroundShadow = true;
+     *     prop.shadowGroundY = floorY;
+     *     prop.shadowLight = sun;   // instead of shadowDirectionX / Z
+     *     prop.shadowOffset = 0.8;  // slid out from its feet, in blob radii
+     *     prop.shadowStretch = 2;   // and pulled long, for a low sun
+     * }
+     * // later: turning the sun turns every blob with it
+     * sun.direction.set(Math.sin(t), 1, Math.cos(t)).normalize();
+     */
+    shadowLight: Light3d | undefined;
+    /**
+     * Takes an array or a `Vector3d` and keeps a normalized copy of its own,
+     * so a game that goes on mutating what it passed does not steer this
+     * mesh's shadow by accident. `undefined` puts the blob back level.
+     * @param {number[]|Vector3d|undefined} value - the floor's up normal
+     * @example
+     * // a prop standing on a 20 degree hillside: `shadowGroundY` says where
+     * // the floor is, this says which way it faces. World up is (0, -1, 0),
+     * // because render space is Y-down.
+     * prop.shadowGroundY = groundAt(prop.pos.x);
+     * prop.shadowGroundNormal = [Math.sin(0.35), -Math.cos(0.35), 0];
+     */
+    set shadowGroundNormal(value: number[] | Vector3d | undefined);
+    /**
+     * The UP normal of the floor this object's shadow lands on, for a
+     * surface that is not level.
+     *
+     * {@link Mesh#shadowGroundY} says where the floor is and this says
+     * which way it faces, so it is honoured only alongside it: tilting the
+     * fallback plane, which is the caster's own bounds, has no anchor to
+     * tilt about. Defaults to world up, which is `(0, -1, 0)` because
+     * render space is Y-down, and that default reproduces a level blob
+     * exactly.
+     *
+     * The blob is ROTATED onto the plane, not projected, so it keeps its
+     * shape; it still sits directly under the caster rather than sliding
+     * along the slope, and it is still a flat quad with no contact with
+     * what it lies on. The tilt is clamped at 75 degrees, past which an
+     * edge-on blob has nothing left to show.
+     *
+     * On an {@link InstancedMesh} the plane serves the WHOLE set: it passes
+     * through the set's origin at `shadowGroundY` and faces this way, and
+     * every blob is projected onto it whatever height its own instance sits
+     * at, exactly as the level case puts every blob at one height. A scatter
+     * spread over curved ground is therefore one set per flat facet, each
+     * with the facet's own plane, not one set with an averaged normal.
+     * @type {Vector3d|undefined}
+     * @default undefined
+     * @example
+     * // a prop resting on a 20 degree slope that falls away along +x
+     * prop.shadowGroundY = floorY;
+     * prop.shadowGroundNormal = [Math.sin(0.35), -Math.cos(0.35), 0];
+     */
+    get shadowGroundNormal(): Vector3d | undefined;
     /**
      * whether to cull back-facing triangles
      * @type {boolean}
@@ -502,6 +690,29 @@ export default class Mesh extends Renderable {
      * }
      */
     setVertexColor(index: number, color: Color): void;
+    set shader(value: GLShader | undefined);
+    /**
+     * A custom shader hosted on this mesh's draw, replacing the built-in
+     * mesh shading: a {@link GLShader} carrying a `{vertex, fragment}`
+     * GLSL program (hosted by the WebGL renderer) and/or a complete
+     * `wgsl` module (hosted by the WebGPU renderer — see the GLShader
+     * class docs for the module contract). One object serves both
+     * backends; a shader without a realization for the active backend
+     * (or `null`) degrades to the built-in shading. The tint, texture,
+     * placement and (for `lit` meshes) light data keep flowing through
+     * their usual uniforms — the custom shader decides what to do with
+     * them.
+     * @type {GLShader|undefined}
+     * @example
+     * me.loader.preload([{ name: "toon", type: "shader", src: {
+     *     vertex: "shaders/toon.vert",     // GLSL pair for WebGL
+     *     fragment: "shaders/toon.frag",
+     *     wgsl: "shaders/toon.wgsl",       // complete module for WebGPU
+     * }}], () => {
+     *     myMesh.addPostEffect(me.loader.getShader("toon"));
+     * });
+     */
+    get shader(): GLShader | undefined;
     /**
      * The mesh's world-space 3D axis-aligned bounding box. This is the 3D analog
      * of {@link Renderable#getBounds} (which returns a flat 2D box from
@@ -517,6 +728,41 @@ export default class Mesh extends Renderable {
      * @returns {AABB3d} the world-space bounding box (reused instance)
      */
     getBounds3d(): AABB3d;
+    /**
+     * Draw the mesh (automatically called by melonJS). Picks between two
+     * projection paths based on the camera that was active when this mesh
+     * was added to the world (captured in {@link Mesh#onActivateEvent}):
+     *
+     * - **Camera3d** → world-space output via {@link Mesh#_projectVerticesWorld}.
+     *   Vertices land in world coordinates at `(pos.x, pos.y, depth)`; the
+     *   camera's perspective handles the final projection per-frame on the
+     *   GPU. Triangle winding is reversed once at first draw so back-face
+     *   culling stays correct under the Y-flip.
+     * - **Camera2d** (or no camera) → legacy self-projection via
+     *   {@link Mesh#projectionMatrix} × {@link Renderable#currentTransform},
+     *   emitting vertices in pixel-ish space directly. Backwards-compatible
+     *   with single-mesh-in-a-2D-scene usage.
+     *
+     * Multi-material meshes need no extra `drawMesh` calls per material vs
+     * single-material — each material's diffuse color is baked into
+     * `vertexColors` at construction time and pushed through the renderer's
+     * per-vertex `aColor` (GPU backends) or per-triangle solid-fill (Canvas)
+     * path. The GPU batchers may still chunk very large meshes across multiple
+     * `drawElements` calls to fit its vertex/index buffer limits, and split the
+     * draw once per entry in {@link Mesh#textureGroups} when the materials
+     * carry different diffuse textures (#1573).
+     *
+     * The active path is picked from the `viewport` passed in by
+     * `Container.draw`, NOT from the activation-time `_useWorldSpace`
+     * flag. The flag is kept as a fallback only for callers that
+     * invoke `draw(renderer)` without a viewport (tests, batched
+     * builds). Without the per-draw read, a stage with multiple
+     * cameras (Camera3d main + Camera2d minimap, say) would run the
+     * wrong projection on whichever camera didn't match activation.
+     * @param {Renderer} renderer - a renderer instance
+     * @param {Camera2d} [viewport] - the camera rendering this frame
+     */
+    draw(renderer: Renderer, viewport?: Camera2d): void;
     /**
      * Render the mesh at its current state (transforms, projection, tint) to an offscreen canvas.
      * The returned canvas can be used with `renderer.drawImage()`, as a `Sprite` image source,
@@ -576,7 +822,7 @@ export type MeshSettings = {
     /**
      * - display width in pixels. With normalization on (the default) the model is scaled to fit this size; with `normalize: false` this is the uniform pixels-per-unit scale applied to the raw geometry. With `normalize: false` and an explicit `scale`, an omitted `width`/`height` is derived from the GEOMETRY's own extent, the way a Sprite takes its size from its frame — a mesh that reports no extent misleads frustum culling, pointer picking and the physics broadphase alike.
      */
-    width: number;
+    width?: number;
     /**
      * - display height in pixels (normalized models only; ignored when `normalize: false`)
      */
@@ -649,6 +895,10 @@ export type MeshSettings = {
      * - draw in the transparent pass (blended, back-to-front, no depth write). Omit and a mesh goes transparent whenever its draw alpha is fractional; `true` for soft-alpha textures; `false` to stay opaque however faded
      */
     transparent?: boolean;
+    /**
+     * - whether geometry in front of this mesh hides it. `false` draws it over whatever is already there, for a glow or an overlay that has no surface to be occluded ON. Separate from the depth WRITE the transparent pass turns off on its own. Transparent pass only, GPU backends only
+     */
+    depthTest?: boolean;
     /**
      * - set `false` to exempt this mesh from the camera's distance fog ({@link Camera3d#setFog}); omit to fog whenever the camera does
      */
@@ -661,14 +911,43 @@ export type MeshSettings = {
      * - opacity of the shadow directly beneath the object, before any height fade.
      */
     shadowOpacity?: number;
+    /**
+     * - multiplier for the ground shadow's footprint. Non-positive or non-finite values hide the shadow without hiding the mesh.
+     */
+    shadowScale?: number;
+    /**
+     * - how far to slide the shadow along `shadowDirectionX`/`shadowDirectionZ`, in multiples of the blob's own radius, for the look of a light that is not directly overhead. A ratio rather than a world distance so one value serves casters of any size. Honoured only when `shadowGroundY` is set, since the blob is a flat quad and sliding it off a plane the game has NOT named puts it somewhere there is no floor. On an `InstancedMesh` it is one throw for the whole set.
+     */
+    shadowOffset?: number;
+    /**
+     * - how much longer the blob is along `shadowDirectionX`/`shadowDirectionZ`, for the look of a low light. Clamped to 3, and the shadow fades as it stretches. On an `InstancedMesh` it is one stretch for the whole set.
+     */
+    shadowStretch?: number;
+    /**
+     * - x of the ground direction the shadow is cast along. Together with `shadowDirectionZ`, zero length means no offset and no stretch.
+     */
+    shadowDirectionX?: number;
+    /**
+     * - z of the ground direction the shadow is cast along.
+     */
+    shadowDirectionZ?: number;
+    /**
+     * - the UP normal of the floor the shadow lands on, for a surface that is not level. Needs `shadowGroundY`, which says where that floor is; this says which way it faces. Defaults to world up, and the tilt is clamped at 75 degrees. On an `InstancedMesh` one plane serves the whole set, through the set's origin at `shadowGroundY`, so a scatter over curved ground is one set per facet.
+     */
+    shadowGroundNormal?: number[] | Vector3d;
+    /**
+     * - a {@link Light3d} to take the direction from instead of setting it by hand. Read every draw, so a moving sun carries the shadow with it. Nothing is inferred from the scene: no light here means no direction.
+     */
+    shadowLight?: Light3d;
 };
 import Renderable from "./renderable.js";
 import { TextureAtlas } from "./../video/texture/atlas.js";
+import { Vector3d } from "../math/vector3d.ts";
 import { Color } from "../math/color.ts";
 import { Matrix3d } from "../math/matrix3d.ts";
-import { Vector2d } from "../math/vector2d.ts";
-import { Polygon } from "../geometries/polygon.ts";
+import type GLShader from "../video/webgl/glshader.js";
 import { AABB3d } from "../physics/broadphase/aabb3d.ts";
-import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+import Renderer from "./../video/renderer.js";
+import type Camera2d from "../camera/camera2d.ts";
 import Texture2d from "./../video/texture/texture2d.ts";
 //# sourceMappingURL=mesh.d.ts.map