melonjs 20.7.0 → 20.9.0

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;AAuBD;;;;;;;;;;;;;;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;AAhQD;;;;;;;;;;;;;;;;;;GAkBG;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;
     /**
@@ -200,13 +200,61 @@ export default class InstancedMesh extends Mesh {
      */
     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
+     * Release the instance records along with the mesh.
+     * @ignore
+     * @internal
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
+    /**
+     * 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 ROW replaced by the floor's
+     * plane equation and its translation Y set to the ground, so whatever Y
+     * the shadow vertex stage produces is projected onto the floor. That is
+     * what lets the ground reach the shader without a new uniform, and it
+     * is why a tilted floor costs no shader change either: a gradient in
+     * that row is a slope, zero is level.
+     *
+     * One plane serves the whole set, level or tilted. 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
+     * @internal
+     * @example
+     * // A scatter's blobs share ONE plane, so a scatter over curved ground is
+     * // one set per flat facet, each with that facet's own plane. Everything
+     * // else is one value for the whole set, which is all a set can carry.
+     * const bank = new InstancedMesh(0, 0, {
+     *     ...fernGeometry,
+     *     instanceCount: 60,
+     *     castGroundShadow: true,
+     *     shadowGroundY: planeHeightAtTheSetsOrigin,
+     *     shadowGroundNormal: [facetNx, facetNy, 0],  // world up is (0,-1,0)
+     *     shadowLight: sun,
+     *     shadowOffset: 0.6,
+     *     shadowStretch: 1.8,
+     * });
+     */
+    /**
+     * Refused here, rather than accepted and quietly ignored.
+     *
+     * A set gets ONE plane and ONE shared quad, and this tier builds that
+     * plane through the set's own origin so the translation's x and z drop
+     * out of the intercept, which is then `groundY + lift / nY`. An
+     * arbitrary point does not drop out, and that `nY` is why the tilt
+     * ceiling cannot be lifted here either. Supporting it means a different
+     * derivation, not a different value.
+     *
+     * Inherited from {@link Mesh} it would have stored the point and handed
+     * it back from the getter while changing nothing on screen, which is the
+     * worse failure: a game would have every reason to believe it worked.
+     * @param {number[]|Vector3d|undefined} value - ignored
+     * @see Mesh#shadowGroundPoint
+     */
+    set shadowGroundPoint(value: number[] | Vector3d | undefined);
+    /** @ignore */
+    get shadowGroundPoint(): number[] | Vector3d | undefined;
 }
 /**
  * Everything {@link InstancedMesh} takes: the instancing settings, plus every
@@ -230,4 +278,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;;;;;;;;;;;;;;;OAeG;IACH,6BAHW,MAAM,EAAE,GAAC,QAAQ,GAAC,SAAS,EAUrC;IAED,cAAc;IACd,yBAbW,MAAM,EAAE,GAAC,QAAQ,GAAC,SAAS,CAerC;IAVC,wCAA8B;IAYhC,gDAyOC;CAOD;;;;;;;;;;oBA/3Ba,MAAM;;;;qBACN,OAAO;;;;mBACP,OAAO;;oCAIR,wBAAwB,GAAG,OAAO,WAAW,EAAE,YAAY;iBAxHvD,WAAW;yBAfH,qBAAqB;2BAqBtB,kBAAkB;4BAEjB,sBAAsB;gCAHhB,oCAAoC;0BAD1C,uBAAuB"}

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,14 @@ 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);
+     * @see Mesh#shadowGroundPoint
      */
     shadowGroundY: number | undefined;
     /**
@@ -330,6 +377,196 @@ 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 the floor has been NAMED, by
+     * {@link Mesh#shadowGroundY} or by {@link Mesh#shadowGroundPoint}. 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. Naming the floor is the game saying
+     * where it 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 copy of its own, so a game
+     * placing these from one scratch vector per frame does not end up with
+     * every shadow in the scene sharing a point. `undefined` goes back to
+     * `shadowGroundY` and the caster's own column.
+     * @param {number[]|Vector3d|undefined} value - the point on the floor
+     * @example
+     * // a rock resting on a globe: the contact point is radially below it,
+     * // and the floor it lands on faces the same way
+     * rock.shadowGroundPoint = surfacePoint;
+     * rock.shadowGroundNormal = outwardNormal;
+     */
+    set shadowGroundPoint(value: number[] | Vector3d | undefined);
+    /**
+     * The point on the floor the blob lands on, for ground that is not flat.
+     *
+     * {@link Mesh#shadowGroundY} names a HEIGHT and lets the caster's own
+     * vertical column supply the rest, which is a flat-world assumption: the
+     * blob can only ever be directly below the thing casting it. That is the
+     * right answer for a platformer, and the wrong one anywhere "down" is not
+     * world down. On a sphere it is radial, so a blob pinned to the column
+     * lands BESIDE its caster by the drop times the tangent of the tilt.
+     *
+     * Set this and the blob goes where you put it. It supersedes
+     * `shadowGroundY`, which it already contains, and it names a floor the
+     * same way, so {@link Mesh#shadowOffset} and the height fade work with it;
+     * pair it with {@link Mesh#shadowGroundNormal} to say which way that floor
+     * faces, and the fade is then measured along that normal rather than
+     * straight down.
+     * Per object only. An {@link InstancedMesh} shares one plane across a
+     * set, built through the set's own origin, and refuses this with a
+     * warning rather than accepting it silently. `level.load()` and
+     * `GLTFScene` do not forward it either, since one point shared by every
+     * part of a scene would stack that scene's blobs on a single spot; set
+     * it on the part you want after the load.
+     * @type {Vector3d|undefined}
+     * @default undefined
+     * @see Mesh#shadowGroundY
+     * @see Mesh#shadowGroundNormal
+     */
+    get shadowGroundPoint(): Vector3d | 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 sits directly under the caster rather than sliding along the
+     * slope, unless {@link Mesh#shadowGroundPoint} says otherwise, and it is
+     * still a flat quad with no contact with what it lies on.
+     *
+     * The tilt is clamped at 75 degrees ALONGSIDE `shadowGroundY`, past
+     * which an edge-on blob has nothing left to show. That ceiling measures
+     * the tilt from world up, which stands in for "tilted away from the
+     * viewer" only while the camera looks down the Y axis; it is lifted
+     * alongside `shadowGroundPoint`, where a point and a normal state the
+     * plane outright and there is nothing left to guess.
+     *
+     * 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 +739,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 +777,69 @@ export default class Mesh extends Renderable {
      * @returns {AABB3d} the world-space bounding box (reused instance)
      */
     getBounds3d(): AABB3d;
+    /**
+     * Tint this mesh from a LINEAR material factor.
+     *
+     * The counterpart of {@link Renderable#setTint}, which takes an ordinary
+     * sRGB colour: this one takes the form a renderer's own colour space
+     * states it in, which in practice means a glTF `baseColorFactor`, and
+     * encodes it. Scaling such a value by 255 into `setColor` instead renders
+     * the material 60 to 70 counts too dark in the midtones.
+     *
+     * The same thing the `baseColorFactor` SETTING does at construction, so a
+     * material that changes during play is reached the same way as one that
+     * is set up front. `emissive`, `specular` and `shininess` are all
+     * settable after construction; this was the one material value that was
+     * not.
+     *
+     * A METHOD rather than a property, deliberately: the factor is encoded
+     * into {@link Renderable#tint} and nothing holds the original, so a
+     * readable `baseColorFactor` would either have to invert the encoding or
+     * keep a copy that goes stale the moment anything writes `tint`.
+     * @param {number[]|Float32Array} factor - `[r, g, b]` in 0..1, linear
+     * @returns {this} this mesh, for chaining
+     * @example
+     * // what the glTF loader hands back, applied by hand
+     * mesh.setBaseColorFactor(node.baseColorFactor);
+     * // and the sRGB counterpart, for a colour a game picked
+     * mesh.setTint("#ff8800");
+     */
+    setBaseColorFactor(factor: number[] | Float32Array): this;
+    /**
+     * 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 +899,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`)
      */
@@ -625,6 +948,10 @@ export type MeshSettings = {
      * - per-vertex normals for the lit path. An explicit value wins over the ones an OBJ or glTF source supplies; omit it and they are taken from the model, or generated from the geometry when the mesh is `lit`. Generated normals average per vertex where faces share vertices (smooth shading) and equal the face normal where they do not (flat shading) — the geometry decides, not a flag.
      */
     normals?: number[] | Float32Array;
+    /**
+     * - the material's base colour factor `[r, g, b]` in 0..1, LINEAR, applied as the mesh tint. That is the form a glTF material states it in (spec 3.9.2) and the form the loader hands back, so a mesh built from a node passes the node's own field straight through. It is ENCODED rather than scaled: a linear factor pushed through `tint.setColor` by multiplying by 255 renders every untextured material 60 to 70 counts too dark in the midtones, which reads as a lighting fault and gets debugged as one. For an ordinary sRGB colour use {@link Renderable#setTint}. The type admits `undefined` deliberately: the loader declares the field optional, so `baseColorFactor: node.baseColorFactor` is the headline use and it has to compile for a consumer building under `exactOptionalPropertyTypes`.
+     */
+    baseColorFactor?: number[] | Float32Array | undefined;
     /**
      * - specular color `[r, g, b]` (0..1) for the lit path. Set by the OBJ loader from MTL `Ks`, and derived from glTF metallic/roughness.
      */
@@ -649,6 +976,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 +992,48 @@ 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 the floor has been named, by `shadowGroundY` or by `shadowGroundPoint`, 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 point on the floor the blob lands on, for ground that is not flat. Supersedes `shadowGroundY`, which can only put the blob on the caster's own vertical column; anywhere "down" is not world down, such as on a sphere, that lands the blob beside its caster rather than under it. Names a floor the same way `shadowGroundY` does, so `shadowOffset` and the height fade work with it.
+     */
+    shadowGroundPoint?: number[] | Vector3d;
+    /**
+     * - the UP normal of the floor the shadow lands on, for a surface that is not level. Needs the floor to be named, by `shadowGroundY` or by `shadowGroundPoint`; this says which way it faces. Defaults to world up. The tilt is clamped at 75 degrees alongside `shadowGroundY`, and NOT clamped alongside `shadowGroundPoint`, which states the plane outright. 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 type { Light3d } from "../lighting/light3d.ts";
+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

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

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

package/build/renderable/nineslicesprite.d.ts

@@ -47,20 +47,8 @@ export default class NineSliceSprite extends Sprite {
         anchorPoint?: string | Vector2d | {
             x: number;
             y: number;
-        };
+        } | undefined;
     });
-    set width(value: number);
-    /**
-     * width of the NineSliceSprite
-     * @type {number}
-     */
-    get width(): number;
-    set height(value: number);
-    /**
-     * height of the NineSliceSprite
-     * @type {number}
-     */
-    get height(): number;
     nss_width: number;
     nss_height: number;
     insetx: number | undefined;
@@ -68,5 +56,7 @@ export default class NineSliceSprite extends Sprite {
 }
 import Sprite from "./sprite.js";
 import type { TextureAtlas } from "./../video/texture/atlas.js";
+import type { CompressedImage } from "../loader/parsers/compressed_textures/compressed_image.js";
 import type { Color } from "./../math/color.ts";
+import type { Vector2d } from "../math/vector2d.ts";
 //# sourceMappingURL=nineslicesprite.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"nineslicesprite.d.ts","sourceRoot":"","sources":["../../src/renderable/nineslicesprite.js"],"names":[],"mappings":"AAkBA;;;;;;GAMG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAxBW,MAAM,KACN,MAAM,YAEd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,MAAM;QACN,MAAM;QACyD,KAAK,EAAtF,gBAAgB,GAAC,iBAAiB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACpD,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACwB,WAAW,GAA1D,MAAM,GAAC,QAAQ,GAAC;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAA;SAAC;KAC3C,EA8BF;IASD,iBALU,MAAM,EAOf;IATD;;;OAGG;IACH,aAFU,MAAM,CAIf;IAYD,kBALU,MAAM,EAOf;IATD;;;OAGG;IACH,cAFU,MAAM,CAIf;IAxBA,kBAA2B;IAC3B,mBAA6B;IAE7B,2BAA6B;IAC7B,2BAA6B;IAmD9B;;;OAGG;IACH,0BA6EC;CACD;mBA7MkB,aAAa;kCAKC,6BAA6B;2BADtC,oBAAoB"}
+{"version":3,"file":"nineslicesprite.d.ts","sourceRoot":"","sources":["../../src/renderable/nineslicesprite.js"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,eAxBW,MAAM,KACN,MAAM,YAEd;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,MAAM;QACN,MAAM;QACyD,KAAK,EAAtF,gBAAgB,GAAC,iBAAiB,GAAC,YAAY,GAAC,eAAe,GAAC,MAAM;QACpD,IAAI;QACJ,MAAM;QACN,UAAU;QACV,WAAW;QACL,IAAI;QACV,KAAK;QACL,KAAK;QACwB,WAAW;eAAvC,MAAM;eAAG,MAAM;;KAC1C,EA8BF;IALA,kBAA2B;IAC3B,mBAA6B;IAE7B,2BAA6B;IAC7B,2BAA6B;IAmD9B;;;OAGG;IACH,0BA6EC;CACD;mBA/MkB,aAAa;kCAKC,6BAA6B;qCAC5B,2DAA2D;2BAFrE,oBAAoB;8BAGjB,qBAAqB"}