melonjs 19.7.1 → 19.8.0

package/build/renderable/sprite3d.d.ts

@@ -0,0 +1,314 @@
+/**
+ * A textured **quad in 3D space** — the 3D counterpart of {@link Sprite},
+ * for rendering sprites under a {@link Camera3d} (the 2.5D workflow: characters,
+ * pickups, foliage, signs, particles in a 3D scene). It's a thin {@link Mesh}
+ * subclass, so it rides the same world-space mesh pipeline (depth testing,
+ * frustum culling) and supports the same material features (`lit`, `emissive`,
+ * `alphaCutoff`).
+ *
+ * Its headline feature is **billboarding** — keeping the quad facing the camera
+ * regardless of camera orientation (see {@link Sprite3d#billboard}). With
+ * billboarding off it's a fixed-orientation quad (decals, posters, ground
+ * markers).
+ *
+ * **Frame animation** is supported through the same API as {@link Sprite}
+ * ({@link Sprite3d#addAnimation}, {@link Sprite3d#setCurrentAnimation},
+ * {@link Sprite3d#play}/`pause`/`stop`) — pass `framewidth`/`frameheight` for a
+ * spritesheet, or a packed {@link TextureAtlas}, exactly as you would for a 2D
+ * `Sprite`. Both share the {@link FrameAnimation} engine, so the timing, looping
+ * and chaining behavior is identical; `Sprite3d` maps the current frame onto the
+ * quad each step — including packer **rotated** and **trimmed** regions, mapped
+ * to full parity with the 2D `Sprite`.
+ *
+ * **Camera3d only.** Like {@link Mesh}, `Sprite3d` renders through the 3D
+ * world-space path; under a 2D `Camera2d` it falls back to the mesh's
+ * self-projection and **billboarding has no effect** (a 2D scene has no camera
+ * orientation to face). Use a regular {@link Sprite} for 2D.
+ * @augments Mesh
+ * @category Game Objects
+ * @example
+ * import { Application, Camera3d, Sprite3d } from "melonjs";
+ *
+ * // a 3D app (Camera3d is required for billboarding)
+ * const app = new Application(1024, 768, { cameraClass: Camera3d });
+ *
+ * // a tree that always faces the camera but stays upright (2.5D).
+ * // its texture has a transparent background — the mesh pass is opaque, so
+ * // `alphaCutoff` (default 0.5) discards those texels for a clean silhouette.
+ * const tree = new Sprite3d(0, 0, {
+ *     image: "tree",        // a preloaded image with transparency
+ *     width: 64, height: 96,
+ *     z: -200,              // 3D depth (world z)
+ *     billboard: true,      // = "cylindrical"
+ *     // alphaCutoff: 0.5,  // the default — lower it to keep softer edges,
+ *                           // or set 0 for a fully-opaque quad
+ * });
+ * app.world.addChild(tree);   // add it to the game world, like any Renderable
+ *
+ * // an animated, fully camera-facing pickup from a spritesheet, mirrored
+ * const coin = new Sprite3d(0, 0, {
+ *     image: "coins",
+ *     framewidth: 32, frameheight: 32,
+ *     width: 48, height: 48,
+ *     billboard: "spherical",
+ *     alphaCutoff: 0.5,     // cut out the transparent frame background
+ * });
+ * coin.addAnimation("spin", [0, 1, 2, 3, 4, 5]);
+ * coin.setCurrentAnimation("spin");
+ * coin.flipX();             // face the other way (mirrors the sprite)
+ * app.world.addChild(coin);
+ */
+export default class Sprite3d extends Mesh {
+    /**
+     * @param {number} x - world x position
+     * @param {number} y - world y position
+     * @param {object} settings - configuration
+     * @param {HTMLImageElement|TextureAtlas|string} [settings.image] - the sprite texture (image name, image, or atlas). Alias: `settings.texture`.
+     * @param {number} [settings.width=settings.framewidth] - quad width in world units (pixels)
+     * @param {number} [settings.height=settings.width] - quad height in world units
+     * @param {number} [settings.framewidth] - width of a single frame within a spritesheet (enables frame animation)
+     * @param {number} [settings.frameheight] - height of a single frame within a spritesheet
+     * @param {string} [settings.region] - region name when using a texture atlas (see {@link TextureAtlas})
+     * @param {object[]} [settings.anims] - predefined animations (same shape as {@link Sprite})
+     * @param {number} [settings.z=0] - 3D depth (world z); also settable later via `.depth`
+     * @param {boolean|string} [settings.billboard=false] - billboard mode: `false` (fixed orientation), `true` / `"cylindrical"` (faces the camera but stays upright — the 2.5D default), or `"spherical"` (faces the camera on all axes). Only applies under a `Camera3d`.
+     * @param {boolean} [settings.flipX=false] - mirror the sprite horizontally (see {@link Sprite3d#flipX})
+     * @param {boolean} [settings.flipY=false] - mirror the sprite vertically (see {@link Sprite3d#flipY})
+     * @param {boolean} [settings.lit=false] - shade through the lit mesh batcher (see {@link Mesh})
+     * @param {number[]|Float32Array} [settings.emissive] - emissive color (see {@link Mesh})
+     * @param {number} [settings.alphaCutoff=0.5] - alpha cutout threshold (see {@link Mesh}). The mesh pass is opaque (no alpha blending), so this defaults to `0.5` to discard a sprite's transparent background (clean cutout silhouette, correct depth, no sorting). Set `0` for a fully-opaque quad, or tune the threshold.
+     */
+    constructor(x: number, y: number, settings: {
+        image?: string | HTMLImageElement | TextureAtlas | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        framewidth?: number | undefined;
+        frameheight?: number | undefined;
+        region?: string | undefined;
+        anims?: object[] | undefined;
+        z?: number | undefined;
+        billboard?: string | boolean | undefined;
+        flipX?: boolean | undefined;
+        flipY?: boolean | undefined;
+        lit?: boolean | undefined;
+        emissive?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        alphaCutoff?: number | undefined;
+    });
+    /**
+     * the quad's half-width in world units (see {@link Sprite3d#billboard}).
+     * @type {number}
+     * @ignore
+     */
+    _halfW: number;
+    /** @ignore */
+    _halfH: number;
+    /** @ignore */
+    _refLw: number;
+    /** @ignore */
+    _refLh: number;
+    /** @ignore */
+    _flipX: boolean;
+    /** @ignore */
+    _flipY: boolean;
+    /** @ignore */
+    _region: object | null;
+    /**
+     * a callback fired when the current animation completes a cycle.
+     * @type {Function}
+     */
+    onended: Function;
+    /** the frame-aware atlas (== this.texture) @ignore */
+    source: any;
+    /** the atlas region dictionary @ignore */
+    textureAtlas: any;
+    /** name→index map for named-region atlases @ignore */
+    atlasIndices: any;
+    /** the shared frame-animation engine @ignore */
+    _frameAnim: FrameAnimation;
+    /**
+     * Billboard mode — keeps the quad facing the active {@link Camera3d}:
+     * - `false` (default) — fixed orientation (a flat quad in the XY plane;
+     *   decals, posters, ground markers).
+     * - `true` / `"cylindrical"` — faces the camera but stays upright
+     *   (rotates only around the world up axis). The 2.5D default — trees,
+     *   characters, items.
+     * - `"spherical"` — faces the camera on all axes (particles, glints).
+     *
+     * **Only applies under a `Camera3d`**; ignored on the 2D path.
+     *
+     * Note: while billboarding, orientation comes from the camera, so the
+     * renderable's `currentTransform` (`rotate()` / `scale()` / parent-container
+     * transforms) and `meshScale` are **not** applied — only `pos` / `depth`,
+     * `flipX` / `flipY`, and the quad's authored size. With billboarding `false`
+     * the standard {@link Mesh} world transform applies as usual.
+     * @type {boolean|string}
+     * @default false
+     */
+    billboard: boolean | string;
+    /** the camera captured at draw time for the billboard projection @ignore */
+    _billboardCam: Camera3d | null;
+    /**
+     * defined animations, keyed by id (see {@link Sprite3d#addAnimation}).
+     * @type {object}
+     */
+    get anim(): object;
+    /**
+     * current frame information (name / index / texture offset & size / trim).
+     * @type {object}
+     */
+    get current(): object;
+    set dt(value: number);
+    /**
+     * elapsed time within the current animation frame, in milliseconds.
+     * @type {number}
+     */
+    get dt(): number;
+    set animationspeed(value: number);
+    /**
+     * animation cycling speed (delay between frames in ms).
+     * @type {number}
+     * @default 100
+     */
+    get animationspeed(): number;
+    set animationpause(value: boolean);
+    /**
+     * pause the frame animation, freezing the current frame.
+     * @type {boolean}
+     * @default false
+     */
+    get animationpause(): boolean;
+    /**
+     * Add an animation, identical to {@link Sprite#addAnimation}.
+     * @param {string} name - animation id
+     * @param {number[]|string[]|object[]} index - frame indices / names (see {@link Sprite#addAnimation})
+     * @param {number} [animationspeed] - cycling speed in ms
+     * @returns {number} number of frames added
+     */
+    addAnimation(name: string, index: number[] | string[] | object[], animationspeed?: number): number;
+    /**
+     * Select the active animation, identical to {@link Sprite#setCurrentAnimation}.
+     * @param {string} name - animation id
+     * @param {string|Function|object} [resetAnim] - loop / chain / completion behavior
+     * @param {boolean} [preserve_dt=false]
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    setCurrentAnimation(name: string, resetAnim?: string | Function | object, preserve_dt?: boolean): Sprite3d;
+    /**
+     * Reverse the given (or current) animation in place (see {@link Sprite#reverseAnimation}).
+     * @param {string} [name] - animation id
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    reverseAnimation(name?: string): Sprite3d;
+    /**
+     * Mirror the sprite horizontally (e.g. flip a character to face the other
+     * way). Unlike the 2D {@link Sprite}, the flip mirrors the quad's local
+     * geometry so it works for every billboard mode and for rotated/trimmed atlas
+     * regions alike. Takes effect immediately on the current frame.
+     * @param {boolean} [flip=true]
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    flipX(flip?: boolean): Sprite3d;
+    /**
+     * Mirror the sprite vertically. See {@link Sprite3d#flipX}.
+     * @param {boolean} [flip=true]
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    flipY(flip?: boolean): Sprite3d;
+    /**
+     * @returns {boolean} true if the sprite is mirrored horizontally.
+     */
+    isFlippedX(): boolean;
+    /**
+     * @returns {boolean} true if the sprite is mirrored vertically.
+     */
+    isFlippedY(): boolean;
+    /**
+     * Play (and optionally switch to) an animation, identical to {@link Sprite#play}.
+     * @param {string} [name] - animation id to play; omit to resume
+     * @param {string|Function|object} [options] - loop / chain / completion behavior
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    play(name?: string, options?: string | Function | object): Sprite3d;
+    /**
+     * Pause the current animation, freezing the current frame (see {@link Sprite#pause}).
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    pause(): Sprite3d;
+    /**
+     * Stop and reset the current animation to its first frame (see {@link Sprite#stop}).
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    stop(): Sprite3d;
+    /**
+     * Force the current animation frame index (see {@link Sprite#setAnimationFrame}).
+     * @param {number} [index=0] - animation frame index
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    setAnimationFrame(index?: number): Sprite3d;
+    /**
+     * Apply a texture region directly (see {@link Sprite#setRegion}).
+     * @param {object} region - typically from `texture.getRegion(name)`
+     * @returns {Sprite3d} Reference to this object for method chaining
+     */
+    setRegion(region: object): Sprite3d;
+    /**
+     * @param {string} name - animation id
+     * @returns {boolean} true if `name` is the current animation (see {@link Sprite#isCurrentAnimation}).
+     */
+    isCurrentAnimation(name: string): boolean;
+    /**
+     * @returns {string[]} the names of every defined animation (see {@link Sprite#getAnimationNames}).
+     */
+    getAnimationNames(): string[];
+    /**
+     * @returns {number} the current animation frame index (see {@link Sprite#getCurrentAnimationFrame}).
+     */
+    getCurrentAnimationFrame(): number;
+    /**
+     * The frame object for the given index within the current animation.
+     * @param {number} id - the frame id
+     * @returns {object} the frame data
+     * @ignore
+     */
+    getAnimationFrameObjectByIndex(id: number): object;
+    /**
+     * Apply the current frame's texture region to the quad — the geometry hook
+     * called by the shared {@link FrameAnimation} engine (the 3D counterpart of
+     * {@link Sprite}'s sub-texture / size / anchor swap). Rewrites both the quad's
+     * UVs (the atlas sub-rect, with a 90° corner permutation for packer-rotated
+     * regions) and its local vertices (the trimmed art's sub-rectangle within the
+     * logical frame, scaled into the quad's world footprint), so trimmed and
+     * rotated `TextureAtlas` regions render at full parity with the 2D `Sprite`.
+     * @param {object} region - the texture region object
+     * @ignore
+     */
+    _applyFrame(region: object): void;
+    /**
+     * Release resources (returns the engine's pooled `current.offset` to the
+     * pool), then defer to the standard mesh/renderable teardown.
+     * @ignore
+     */
+    destroy(): void;
+    /**
+     * Capture the rendering camera so {@link Sprite3d#_projectVerticesWorld} can
+     * orient the billboard toward it. Read from the per-draw `viewport` (passed
+     * by `Container.draw`), so a multi-camera stage billboards correctly against
+     * whichever camera is drawing. When no `Camera3d` viewport is supplied the
+     * billboard is inactive and the quad renders fixed-orientation.
+     * @param {CanvasRenderer|WebGLRenderer} renderer
+     * @param {Camera2d} [viewport]
+     * @ignore
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
+    /**
+     * Orient the quad toward the camera when billboarding; otherwise defer to the
+     * standard {@link Mesh} world projection (a fixed-orientation quad).
+     * @ignore
+     */
+    _projectVerticesWorld(offsetX: any, offsetY: any, offsetZ: any): void;
+}
+import Mesh from "./mesh.js";
+import FrameAnimation from "./frameAnimation.js";
+import Camera3d from "../camera/camera3d.ts";
+import { TextureAtlas } from "../video/texture/atlas.js";
+//# sourceMappingURL=sprite3d.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sprite3d.d.ts","sourceRoot":"","sources":["../../src/renderable/sprite3d.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;IACC;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAlBW,MAAM,KACN,MAAM,YAEd;QAAwD,KAAK;QACnC,KAAK;QACL,MAAM;QACN,UAAU;QACV,WAAW;QACX,MAAM;QACJ,KAAK;QACP,CAAC;QACO,SAAS;QAChB,KAAK;QACL,KAAK;QACL,GAAG;QACW,QAAQ;QACvB,WAAW;KACvC,EAiMA;IAnHA;;;;OAIG;IACH,QAHU,MAAM,CAGA;IAChB,cAAc;IACd,eAAgB;IAIhB,cAAc;IACd,eAAe;IACf,cAAc;IACd,eAAe;IAKf,cAAc;IACd,gBAAmB;IACnB,cAAc;IACd,gBAAmB;IAEnB,cAAc;IACd,uBAAmB;IAKnB;;;OAGG;IACH,kBAAwB;IACxB,sDAAsD;IACtD,YAA0B;IAM1B,0CAA0C;IAC1C,kBAA6D;IAC7D,sDAAsD;IACtD,kBAAyC;IACzC,gDAAgD;IAChD,2BAEE;IAKF;;;;;;;;;;;;;;;;;;OAkBG;IACH,WAHU,OAAO,GAAC,MAAM,CAGoB;IAE5C,4EAA4E;IAC5E,+BAAyB;IAyC1B;;;OAGG;IACH,YAFU,MAAM,CAIf;IAED;;;OAGG;IACH,eAFU,MAAM,CAIf;IASD,cALU,MAAM,EAOf;IATD;;;OAGG;IACH,UAFU,MAAM,CAIf;IAaD,0BANU,MAAM,EAQf;IAVD;;;;OAIG;IACH,sBAHU,MAAM,CAKf;IAaD,0BANU,OAAO,EAQhB;IAVD;;;;OAIG;IACH,sBAHU,OAAO,CAKhB;IAKD;;;;;;OAMG;IACH,mBALW,MAAM,SACN,MAAM,EAAE,GAAC,MAAM,EAAE,GAAC,MAAM,EAAE,mBAC1B,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,0BALW,MAAM,cACN,MAAM,cAAU,MAAM,gBACtB,OAAO,GACL,QAAQ,CAKpB;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,QAAQ,CAQpB;IAED;;;;;;;OAOG;IACH,aAHW,OAAO,GACL,QAAQ,CASpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,QAAQ,CAQpB;IAED;;OAEG;IACH,cAFa,OAAO,CAInB;IAED;;OAEG;IACH,cAFa,OAAO,CAInB;IAED;;;;;OAKG;IACH,YAJW,MAAM,YACN,MAAM,cAAU,MAAM,GACpB,QAAQ,CAQpB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAKpB;IAED;;;OAGG;IACH,QAFa,QAAQ,CAMpB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,QAAQ,CAKpB;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,QAAQ,CAKpB;IAED;;;OAGG;IACH,yBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qBAFa,MAAM,EAAE,CAIpB;IAED;;OAEG;IACH,4BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,mCAJW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;OAUG;IACH,oBAHW,MAAM,QAoGhB;IAgBD;;;;OAIG;IACH,gBAIC;IAED;;;;;;;;;OASG;IACH,eAJW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QAMlB;IAED;;;;OAIG;IACH,sEA2DC;CACD;iBA5tBgB,WAAW;2BADD,qBAAqB;qBAJ3B,uBAAuB;6BAGf,2BAA2B"}

package/build/state/stage.d.ts

@@ -1,8 +1,9 @@
 import type Application from "./../application/application.ts";
 import Camera2d from "./../camera/camera2d.ts";
+import type Light2d from "./../lighting/light2d.ts";
+import type { Light3d } from "./../lighting/light3d.ts";
 import { Color } from "./../math/color.ts";
 import type World from "./../physics/world.js";
-import type Light2d from "./../renderable/light2d.js";
 import type Renderer from "./../video/renderer.js";
 interface StageSettings {
     cameras: Camera2d[];
@@ -61,6 +62,13 @@ export default class Stage {
      * @ignore
      */
     _activeLights: Set<Light2d>;
+    /**
+     * Internal set of active 3D lights, auto-populated by `Light3d`'s
+     * `onActivateEvent` / `onDeactivateEvent` hooks. Read by the lit mesh
+     * batcher each frame to shade `lit` meshes under a `Camera3d`.
+     * @ignore
+     */
+    _activeLights3d: Set<Light3d>;
     /**
      * an ambient light that will be added to the stage rendering
      * @default "#000000"
@@ -99,6 +107,17 @@ export default class Stage {
      * @ignore
      */
     _unregisterLight(light: Light2d): void;
+    /**
+     * Called by `Light3d.onActivateEvent` to register a 3D light with the stage.
+     * Read by the lit mesh batcher. Users normally don't call this.
+     * @ignore
+     */
+    _registerLight3d(light: Light3d): void;
+    /**
+     * Called by `Light3d.onDeactivateEvent` to deregister a 3D light.
+     * @ignore
+     */
+    _unregisterLight3d(light: Light3d): void;
     /**
      * Object reset function
      * @ignore

package/build/state/stage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../../src/state/stage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,iCAAiC,CAAC;AAC/D,OAAO,QAAQ,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,4BAA4B,CAAC;AAEtD,OAAO,KAAK,QAAQ,MAAM,wBAAwB,CAAC;AAEnD,UAAU,aAAa;IACtB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,KACb,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,KACR,QAAQ,CAAC;IACd,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAC9D,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,CAAC;CAC5C;AAUD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACzB;;;;OAIG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAE/B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE7B;;;;;OAKG;IACH,aAAa,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAE5B;;;;OAIG;IACH,YAAY,EAAE,KAAK,CAAC;IAEpB;;;;;;;;OAQG;IACH,oBAAoB,EAAE,KAAK,CAAC;IAE5B;;OAEG;IACH,QAAQ,EAAE,aAAa,CAAC;IAExB;;;;;OAKG;gBACS,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC;IAS7C;;;;OAIG;IACH,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAIpC;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAItC;;;OAGG;IACH,KAAK,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI;IAsHtD;;;;;OAKG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAgB3B;;;;;;;;;OASG;IACH,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAM5C;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CACX,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,QAAQ,EAChB,UAAU,GAAE,MAAuC,EACnD,UAAU,GAAE,MAAuC,GACjD,IAAI;IAiCP;;;OAGG;IACH,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;IAkB/B;;;;;;;OAOG;IACH,YAAY,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAOxD;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;CAMtC"}
+{"version":3,"file":"stage.d.ts","sourceRoot":"","sources":["../../src/state/stage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,iCAAiC,CAAC;AAC/D,OAAO,QAAQ,MAAM,yBAAyB,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,KAAK,KAAK,MAAM,uBAAuB,CAAC;AAE/C,OAAO,KAAK,QAAQ,MAAM,wBAAwB,CAAC;AAEnD,UAAU,aAAa;IACtB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,KACb,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,KACR,QAAQ,CAAC;IACd,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IAC9D,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,IAAI,CAAC;CAC5C;AAUD;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACzB;;;;OAIG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IAE/B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE7B;;;;;OAKG;IACH,aAAa,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAE5B;;;;;OAKG;IACH,eAAe,EAAE,GAAG,CAAC,OAAO,CAAC,CAAC;IAE9B;;;;OAIG;IACH,YAAY,EAAE,KAAK,CAAC;IAEpB;;;;;;;;OAQG;IACH,oBAAoB,EAAE,KAAK,CAAC;IAE5B;;OAEG;IACH,QAAQ,EAAE,aAAa,CAAC;IAExB;;;;;OAKG;gBACS,QAAQ,CAAC,EAAE,OAAO,CAAC,aAAa,CAAC;IAU7C;;;;OAIG;IACH,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAIpC;;;OAGG;IACH,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAItC;;;;OAIG;IACH,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAItC;;;OAGG;IACH,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI;IAIxC;;;OAGG;IACH,KAAK,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,SAAS,EAAE,OAAO,EAAE,GAAG,IAAI;IAsHtD;;;;;OAKG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAgB3B;;;;;;;;;OASG;IACH,IAAI,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAM5C;;;;;;;;;;;;;;;;;OAiBG;IACH,YAAY,CACX,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,QAAQ,EAChB,UAAU,GAAE,MAAuC,EACnD,UAAU,GAAE,MAAuC,GACjD,IAAI;IAiCP;;;OAGG;IACH,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;IAmB/B;;;;;;;OAOG;IACH,YAAY,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI;IAOxD;;;;OAIG;IACH,cAAc,CAAC,GAAG,EAAE,WAAW,GAAG,IAAI;CAMtC"}

package/build/video/buffer/vertex.d.ts

@@ -54,6 +54,13 @@ export default class VertexArrayBuffer {
      * @ignore
      */
     pushMesh(x: any, y: any, z: any, u: any, v: any, tint: any): this;
+    /**
+     * push a new lit-mesh vertex (mesh format + a world-space normal):
+     * x, y, z, u, v, tint, nx, ny, nz. Used by the lit mesh batcher, whose
+     * vertex layout is 12 floats (the 9 of {@link pushMesh} plus `aNormal`).
+     * @ignore
+     */
+    pushMeshLit(x: any, y: any, z: any, u: any, v: any, tint: any, nx: any, ny: any, nz: any): this;
     /**
      * return a reference to the data in Float32 format
      * @ignore

package/build/video/buffer/vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;IACC,6CAyBC;IAvBA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAU7C,kCAA2C;IAG5C;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;;;;;;;OAWG;IACH,QAVW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,cACN,MAAM,oBACN,MAAM,QA6BhB;IAED;;;;;;OAMG;IACH,iBALW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAahB;IAED;;;;;;;;OAQG;IACH,kEAgBC;IAED;;;OAGG;IACH,2DAMC;IAED;;;OAGG;IACH,yDAMC;IAED;;;;;;OAMG;IACH,+DAMC;CACD"}
+{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;IACC,6CAyBC;IAvBA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAU7C,kCAA2C;IAG5C;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;;;;;;;OAWG;IACH,QAVW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,cACN,MAAM,oBACN,MAAM,QA6BhB;IAED;;;;;;OAMG;IACH,iBALW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAahB;IAED;;;;;;;;OAQG;IACH,kEAgBC;IAED;;;;;OAKG;IACH,gGAoBC;IAED;;;OAGG;IACH,2DAMC;IAED;;;OAGG;IACH,yDAMC;IAED;;;;;;OAMG;IACH,+DAMC;CACD"}

package/build/video/renderer.d.ts

@@ -449,6 +449,27 @@ declare class Renderer {
      * @param {boolean} [enable=false]
      */
     setAntiAlias(enable?: boolean): void;
+    /**
+     * Resolve the default texture filter **mode** for this renderer, decoupled
+     * from {@link Renderer#setAntiAlias} (which controls polygon-edge MSAA on GPU
+     * backends). Honors the `textureFilter` setting (`"nearest"` / `"linear"`),
+     * falling back to the `antiAlias` setting when it's `"auto"` (the default).
+     *
+     * Backend-neutral on purpose: it returns the mode as a string so each GPU
+     * backend maps it to its own enum (WebGL `gl.LINEAR` / `gl.NEAREST`, a future
+     * WebGPU renderer `GPUFilterMode`). The Canvas renderer has no per-texture
+     * filtering, so this is informational there.
+     * @returns {"linear"|"nearest"} the resolved default filter mode
+     */
+    getDefaultTextureFilter(): "linear" | "nearest";
+    /**
+     * Set the default texture magnification/minification filter at runtime,
+     * decoupled from {@link Renderer#setAntiAlias}. The base implementation just
+     * records the setting (the Canvas renderer has no per-texture filtering);
+     * GPU backends override this to re-apply the filter to live textures.
+     * @param {"auto"|"nearest"|"linear"} [mode="auto"] - `"auto"` follows `antiAlias`
+     */
+    setTextureFilter(mode?: "auto" | "nearest" | "linear"): void;
     /**
      * set/change the current projection matrix (GPU renderers only —
      * the Canvas renderer applies projection via the 2D context's transform stack).

package/build/video/renderer.d.ts.map

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

package/build/video/texture/atlas.d.ts

@@ -30,7 +30,7 @@ export function createAtlas(width: any, height: any, name?: string, repeat?: str
  * return a string that identifies the texture atlas type
  * @ignore
  */
-export function identifyFormat(app: any): "texturepacker" | "shoebox" | "aseprite" | "melonJS";
+export function identifyFormat(app: any): "melonJS" | "texturepacker" | "shoebox" | "aseprite";
 /**
  * A Texture atlas class, currently supports : <br>
  * - [TexturePacker]{@link http://www.codeandweb.com/texturepacker/} : through JSON export (standard and multipack texture atlas) <br>

package/build/video/webgl/batchers/lit_mesh_batcher.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A {@link MeshBatcher} variant that shades meshes with the active stage's
+ * {@link Light3d} lights (half-Lambert diffuse from directional lights +
+ * ambient). It extends the unlit batcher, adding a world-space `aNormal`
+ * vertex attribute (12-float layout vs 9) and a lit shader.
+ *
+ * Meshes opt in via `mesh.lit` — so standalone, unlit meshes keep the lean
+ * 9-float `MeshBatcher` and pay nothing for lighting. Both batchers share the
+ * mesh-mode depth-clear state (a single clear per target) since this one
+ * inherits {@link MeshBatcher#bind}.
+ * @category Rendering
+ */
+export default class LitMeshBatcher extends MeshBatcher {
+    /** push the 12-float lit vertex, appending the mesh's world-space normal. @ignore */
+    _pushVertex(vertexData: any, x: any, y: any, z: any, u: any, v: any, color: any, mesh: any, i3: any): void;
+}
+import MeshBatcher from "./mesh_batcher.js";
+//# sourceMappingURL=lit_mesh_batcher.d.ts.map

package/build/video/webgl/batchers/lit_mesh_batcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;GAWG;AACH;IAqBC,qFAAqF;IACrF,2GAaC;CA0BD;wBAzFuB,mBAAmB"}

package/build/video/webgl/batchers/lit_quad_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAsEE;;;;;;OAMG;IACH,6GAAmD;IAEnD;;;;OAIG;IACH,uHAAkC;IAElC,gCAAoB;IACpB,+BAA4B;IAK7B;;;;;OAKG;IACH,2BAOC;IAsBD;;;;;;;;;;;;;;OAcG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAgBA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAahB;IAED;;;;;;;;;;OAUG;IACH,uBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,gBAAgB,GAAC,iBAAiB,GAAC,IAAI,QAkHjD;CA0DD;wBAlaoC,mBAAmB;kCAIzB,0BAA0B"}
+{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAsEE;;;;;;OAMG;IACH,6GAAmD;IAEnD;;;;OAIG;IACH,uHAAkC;IAElC,gCAAoB;IACpB,+BAA4B;IAK7B;;;;;OAKG;IACH,2BAOC;IAsBD;;;;;;;;;;;;;;OAcG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAgBA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAahB;IAED;;;;;;;;;;OAUG;IACH,uBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAgBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,gBAAgB,GAAC,iBAAiB,GAAC,IAAI,QAkHjD;CA0DD;wBAjaoC,mBAAmB;kCAIzB,0BAA0B"}

package/build/video/webgl/batchers/mesh_batcher.d.ts

@@ -29,20 +29,61 @@ export default class MeshBatcher extends MaterialBatcher {
      * @ignore
      */
     init(renderer: any): void;
+    currentAlphaCutoff: any;
+    currentEmissiveR: any;
+    currentEmissiveG: any;
+    currentEmissiveB: any;
+    _onTargetChanged: (() => void) | null | undefined;
     /**
-     * Tracks whether the active framebuffer's depth attachment still
-     * needs a clear before this batcher's next draw. Flipped to
-     * `true` by the `RENDER_TARGET_CHANGED` listener installed
-     * below (frame start, post-effect FBO bind/unbind), back to
-     * `false` by the first `bind()` of the new target after the
-     * lazy clear runs. Lifts depth clearing from per-mesh (legacy)
-     * to per-target — same model Three.js uses. The GPU's `LEQUAL`
-     * depth test then resolves inter-mesh occlusion per pixel
-     * against the accumulated buffer.
+     * The vertex attribute layout. The base (unlit) mesh batcher is
+     * `aVertex` (3) + `aRegion` (2) + `aColor` (4) = 9 floats. Subclasses
+     * (e.g. {@link LitMeshBatcher}) append their own attributes.
      * @ignore
      */
-    _depthDirty: boolean | undefined;
-    _onTargetChanged: (() => void) | null | undefined;
+    _attributeLayout(renderer: any): {
+        name: string;
+        size: number;
+        type: any;
+        normalized: boolean;
+        offset: number;
+    }[];
+    /**
+     * The shader sources for this batcher (unlit by default). Subclasses
+     * override to supply a lit shader.
+     * @ignore
+     */
+    _shaderSources(): {
+        vertex: any;
+        fragment: any;
+    };
+    /**
+     * Invalidate the per-mesh `uAlphaCutoff` / `uEmissive` caches when the bound
+     * shader (GL program) changes — the new program's uniforms are at their own
+     * defaults, so the next mesh must re-issue them rather than trust the cache.
+     * Mirrors the base batcher's `currentSamplerUnit` reset (same condition), and
+     * matters when a custom mesh shader declaring those uniforms is interleaved
+     * with the built-in one on this batcher (e.g. `drawMesh` swapping a custom
+     * shader in and back out).
+     * @ignore
+     */
+    useShader(shader: any): void;
+    /**
+     * Write one vertex into the buffer. The base (unlit) layout is
+     * `x, y, z, u, v, color`. Subclasses override to append per-vertex data
+     * matching their {@link MeshBatcher#_attributeLayout} (e.g.
+     * {@link LitMeshBatcher} pushes the world-space normal too).
+     * @param {object} vertexData - the batcher's vertex buffer
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} u
+     * @param {number} v
+     * @param {number} color - packed ARGB Uint32
+     * @param {object} _mesh - the source mesh (unused here; for subclasses)
+     * @param {number} _i3 - the source vertex's `index * 3` (for subclasses)
+     * @ignore
+     */
+    _pushVertex(vertexData: object, x: number, y: number, z: number, u: number, v: number, color: number, _mesh: object, _i3: number): void;
     /**
      * Add a textured mesh to the batch. When the mesh has a
      * `vertexColors` array (multi-material OBJ + bound MTL), each

package/build/video/webgl/batchers/mesh_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/mesh_batcher.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;OAGG;IACH,0BAuEC;IA1BA;;;;;;;;;;;OAWG;IACH,iCAAuB;IAStB,kDAEC;IA4DH;;;;;;;;;;;;;;OAcG;IACH,cAHW,MAAM,QACN,MAAM,QAuFhB;CACD;gCAtS+B,uBAAuB"}
+{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/mesh_batcher.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;OAGG;IACH,0BA8BC;IApBA,wBAA4B;IAI5B,sBAA0B;IAC1B,sBAA0B;IAC1B,sBAA0B;IASzB,kDAEC;IAKH;;;;;OAKG;IACH;;;;;;QAgCC;IAED;;;;OAIG;IACH;;;MAEC;IAED;;;;;;;;;OASG;IACH,6BAWC;IAyDD;;;;;;;;;;;;;;;OAeG;IACH,wBAXW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,SACN,MAAM,OACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAHW,MAAM,QACN,MAAM,QAoJhB;CACD;gCArc+B,uBAAuB"}

package/build/video/webgl/effects/shine.d.ts

@@ -1,7 +1,7 @@
 /**
  * A shader effect that sweeps a bright highlight band across the sprite —
  * the classic "shine" pass commonly used for coins, gems, polished metal,
- * and hover-highlighted UI elements. Similar to pixi-filters' ShineFilter.
+ * and hover-highlighted UI elements.
  *
  * Set `bands` > 1 to tile the sweep into N parallel glints (useful for the
  * "etched grooves" look of a coin's rim). An optional subtle brightness

package/build/video/webgl/lighting/pack3d.d.ts

@@ -0,0 +1,32 @@
+import type { Light3d } from "../../../lighting/light3d.ts";
+/**
+ * Uniform-ready packing of the active 3D lights for the mesh-lit shader.
+ * @ignore
+ */
+export interface PackedMeshLighting {
+    /** number of active directional lights, clamped to `MAX_LIGHTS`. */
+    count: number;
+    /** `MAX_LIGHTS × 3` surface→light directions (already negated, normalized). */
+    directions: Float32Array;
+    /** `MAX_LIGHTS × 3` directional light colors premultiplied by intensity. */
+    colors: Float32Array;
+    /** the summed ambient color (RGB, 0..1+). */
+    ambient: Float32Array;
+}
+/**
+ * Pack an iterable of {@link Light3d} (e.g. the active `Stage`'s 3D-light set)
+ * into the uniform arrays the mesh-lit shader reads:
+ * - **directional** lights contribute a surface→light direction (negated travel
+ *   direction, normalized) + a color premultiplied by intensity, up to
+ *   `MAX_LIGHTS`. Re-normalized here so a direction mutated at runtime without
+ *   re-normalizing still shades correctly.
+ * - **ambient** lights are summed into a single flat ambient color.
+ *
+ * Other types (`"point"`) are skipped — not shaded yet. The same buffers are
+ * returned each call (overwritten in place).
+ * @param lights - iterable of lights, or `null`/`undefined` (treated as empty)
+ * @returns the packed lighting (reused instance)
+ * @ignore
+ */
+export declare function packMeshLights(lights: Iterable<Light3d> | null | undefined): PackedMeshLighting;
+//# sourceMappingURL=pack3d.d.ts.map

package/build/video/webgl/lighting/pack3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack3d.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/pack3d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAG5D;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAC;IACd,+EAA+E;IAC/E,UAAU,EAAE,YAAY,CAAC;IACzB,4EAA4E;IAC5E,MAAM,EAAE,YAAY,CAAC;IACrB,6CAA6C;IAC7C,OAAO,EAAE,YAAY,CAAC;CACtB;AAcD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAC1C,kBAAkB,CAuCpB"}

package/build/video/webgl/webgl_renderer.d.ts

@@ -316,6 +316,24 @@ export default class WebGLRenderer extends Renderer {
      */
     setBlendMode(mode?: string, premultipliedAlpha?: boolean): string;
     currentPremultipliedAlpha: any;
+    /**
+     * Map the backend-neutral default filter mode
+     * ({@link Renderer#getDefaultTextureFilter}) to the GL enum
+     * (`gl.LINEAR` / `gl.NEAREST`) used for textures that don't carry their own
+     * `texture.filter`. The neutral resolver lives on the base renderer so a
+     * future WebGPU backend reuses it and maps to `GPUFilterMode` instead.
+     * @returns {number} `gl.LINEAR` or `gl.NEAREST`
+     * @ignore
+     */
+    _glTextureFilter(): number;
+    /**
+     * Re-apply a min/mag filter to every currently-bound texture across all
+     * batchers (see https://github.com/melonjs/melonJS/issues/1279). Shared by
+     * {@link WebGLRenderer#setAntiAlias} and {@link WebGLRenderer#setTextureFilter}.
+     * @param {number} filter - `gl.LINEAR` or `gl.NEAREST`
+     * @ignore
+     */
+    _reapplyTextureFilter(filter: number): void;
     /**
      * Return the global alpha
      * @returns {number} global alpha value