melonjs 20.6.0 → 20.8.0

package/build/renderable/mesh.d.ts

@@ -167,6 +167,23 @@ export default class Mesh extends Renderable {
      * @type {TextureAtlas|undefined}
      */
     alphaMap: TextureAtlas | undefined;
+    /**
+     * Tangent-space normal map (MTL `map_bump` / `bump` / `norm`), or
+     * `undefined`. Perturbs the interpolated vertex normal per fragment,
+     * so a flat face can carry surface detail — rivets, grain, panel
+     * seams — that the geometry does not have.
+     *
+     * The tangent frame is derived per fragment from the screen-space
+     * derivatives of position and UV rather than from an authored tangent
+     * attribute, so a normal map costs no change to the vertex format and
+     * works on any mesh that already has UVs. The trade is accuracy under
+     * extreme UV distortion, which low-poly props do not have.
+     *
+     * Only meaningful on a `lit` mesh: with no lights there is no shading
+     * term for a perturbed normal to change. GPU mesh path only.
+     * @type {TextureAtlas|undefined}
+     */
+    normalMap: TextureAtlas | undefined;
     /**
      * Cast a soft dark ellipse — a "blob" shadow — on the ground beneath
      * this mesh (#1515).
@@ -288,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
@@ -304,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;
     /**
@@ -313,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}
@@ -411,12 +616,13 @@ export default class Mesh extends Renderable {
      * The Canvas renderer ignores this: a multi-material mesh takes its
      * per-triangle solid-fill path there and never samples a texture at
      * all.
-     * @type {Array<{texture: TextureAtlas, start: number, count: number}>|undefined}
+     * @type {Array<{texture: TextureAtlas, start: number, count: number, normalMap: TextureAtlas|undefined}>|undefined}
      */
     textureGroups: Array<{
         texture: TextureAtlas;
         start: number;
         count: number;
+        normalMap: TextureAtlas | undefined;
     }> | undefined;
     /**
      * Per-mesh texture wrap mode (`"repeat"` / `"repeat-x"` / `"repeat-y"`
@@ -484,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
@@ -499,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,
@@ -558,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`)
      */
@@ -615,6 +879,10 @@ export type MeshSettings = {
      * - specular exponent for the lit path (MTL `Ns`). `0` for a fully diffuse surface.
      */
     shininess?: number;
+    /**
+     * - tangent-space normal map (MTL `map_bump`/`bump`/`norm`), perturbing the lit path's shading normal per fragment. Needs `lit` to have any effect, and a `Camera3d`. See the [Material Textures example](https://melonjs.github.io/melonJS/examples/#/material-textures).
+     */
+    normalMap?: string | TextureAtlas | HTMLImageElement;
     /**
      * - per-texel opacity map, sampled in addition to the diffuse texture (MTL `map_d`).
      */
@@ -627,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
      */
@@ -639,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

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"}