melonjs 19.2.0 → 19.3.0

package/build/video/renderstate.d.ts

@@ -82,6 +82,26 @@ export default class RenderState {
      * @param {boolean} [scissorTestActive=false] - whether scissor/clip is currently enabled
      */
     save(scissorTestActive?: boolean): void;
+    /**
+     * Inspect the scissor box that the next `restore()` would install,
+     * without mutating any state. Lets renderers detect whether a
+     * pending `restore()` will actually change the scissor (and
+     * decide, e.g., whether to flush GPU work first).
+     *
+     * Returns:
+     * - `Int32Array` (length 4) — `[x, y, width, height]` of the
+     *   saved scissor when scissor was active at the matching `save()`
+     *   call.
+     * - `null` — when the saved state had scissor disabled, or the
+     *   stack is empty. Treat this as "next scissor will be inactive".
+     *
+     * The returned array is a **live reference into the internal
+     * stack** — zero allocation on a hot path. Callers MUST treat it
+     * as read-only; mutating it corrupts subsequent `restore()` calls.
+     * @ignore
+     * @returns {Int32Array | null}
+     */
+    peekScissor(): Int32Array | null;
     /**
      * Restore state from the stack.
      * Color, tint, transform, and scissor are restored in place.

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

@@ -1 +1 @@
-{"version":3,"file":"renderstate.d.ts","sourceRoot":"","sources":["../../src/video/renderstate.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAEE;;;OAGG;IACH,cAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,aAFU,KAAK,CAEiC;IAEhD;;;OAGG;IACH,kBAFU,QAAQ,CAEoB;IAEtC;;;OAGG;IACH,gBAFU,UAAU,CAEmB;IAEvC;;;OAGG;IACH,iBAFU,QAAQ,GAAC,IAAI,CAEI;IAE3B;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEA;IAElB;;;OAGG;IACH,kBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,eAFU,YAAY,GAAC,SAAS,CAEF;IAI9B;;OAEG;IACH,uBAAwB;IAExB;;;OAGG;IACH,oBAAoB;IAEpB,cAAc;IACd,qBAEE;IAEF,cAAc;IACd,oBAEE;IAEF,cAAc;IACd,yBAEE;IAEF,cAAc;IACd,yCAEE;IAEF,cAAc;IACd,sBAAoD;IAEpD,cAAc;IACd,wCAAyD;IAEzD,cAAc;IACd,sBAAoD;IAEpD,cAAc;IACd,mBAAiD;IAEjD,cAAc;IACd,oBAAkD;IAGnD;;;OAGG;IACH,yBAFW,OAAO,QAyBjB;IAED;;;;;;;;OAQG;IACH,qBAJW,MAAM,gBACN,MAAM,GACJ;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAyBhE;IAED;;;;OAIG;IACH,aAHW,MAAM,UACN,MAAM,QAUhB;IAED,sDAAsD;IACtD,oBAiBC;CACD;sBAnNqB,oBAAoB;yBACjB,qBAAqB;8BAGnB,eAAe"}
+{"version":3,"file":"renderstate.d.ts","sourceRoot":"","sources":["../../src/video/renderstate.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;GAOG;AACH;IAEE;;;OAGG;IACH,cAFU,KAAK,CAE4B;IAE3C;;;OAGG;IACH,aAFU,KAAK,CAEiC;IAEhD;;;OAGG;IACH,kBAFU,QAAQ,CAEoB;IAEtC;;;OAGG;IACH,gBAFU,UAAU,CAEmB;IAEvC;;;OAGG;IACH,iBAFU,QAAQ,GAAC,IAAI,CAEI;IAE3B;;;OAGG;IACH,UAFU,MAAM,EAAE,CAEA;IAElB;;;OAGG;IACH,kBAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,eAFU,YAAY,GAAC,SAAS,CAEF;IAI9B;;OAEG;IACH,uBAAwB;IAExB;;;OAGG;IACH,oBAAoB;IAEpB,cAAc;IACd,qBAEE;IAEF,cAAc;IACd,oBAEE;IAEF,cAAc;IACd,yBAEE;IAEF,cAAc;IACd,yCAEE;IAEF,cAAc;IACd,sBAAoD;IAEpD,cAAc;IACd,wCAAyD;IAEzD,cAAc;IACd,sBAAoD;IAEpD,cAAc;IACd,mBAAiD;IAEjD,cAAc;IACd,oBAAkD;IAGnD;;;OAGG;IACH,yBAFW,OAAO,QAyBjB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,eAFa,UAAU,GAAG,IAAI,CAQ7B;IAED;;;;;;;;OAQG;IACH,qBAJW,MAAM,gBACN,MAAM,GACJ;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAyBhE;IAED;;;;OAIG;IACH,aAHW,MAAM,UACN,MAAM,QAUhB;IAED,sDAAsD;IACtD,oBAiBC;CACD;sBA9OqB,oBAAoB;yBACjB,qBAAqB;8BAGnB,eAAe"}

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

@@ -46,7 +46,7 @@ export class TextureAtlas {
     /**
      * @param {object|object[]} atlases - atlas information. See {@link loader.getJSON}
      * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|CompressedImage|string|OffscreenCanvas[]|HTMLImageElement[]|HTMLCanvasElement[]|string[]} [src=atlas.meta.image] - Image source
-     * @param {boolean} [cache=false] - Use true to skip caching this Texture
+     * @param {boolean|object} [options] - either a boolean (legacy `cache` flag — `false` disables `TextureCache` registration; default behavior is to cache) or an options object `{ cache?: boolean, normalMap?: HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|string }`. When `normalMap` is provided, the atlas exposes a paired normal-map texture sharing the same UVs as the color texture (used by the WebGL renderer's lit pipeline). `HTMLVideoElement` is intentionally not supported as a normal map (would freeze on frame 0 due to per-image GL texture caching).
      * @example
      * // create a texture atlas from a JSON Object
      * game.texture = new me.TextureAtlas(
@@ -68,8 +68,16 @@ export class TextureAtlas {
      *         anchorPoint : new me.Vector2d(0.5, 0.5)
      *     },
      *     me.loader.getImage("spritesheet")
+     * );
+     *
+     * // SpriteIlluminator workflow: pair the color atlas with its normal map
+     * game.texture = new me.TextureAtlas(
+     *     me.loader.getJSON("scene"),
+     *     me.loader.getImage("scene"),
+     *     { normalMap: me.loader.getImage("scene_n") }
+     * );
      */
-    constructor(atlases: object | object[], src?: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | CompressedImage | string | OffscreenCanvas[] | HTMLImageElement[] | HTMLCanvasElement[] | string[], cache?: boolean);
+    constructor(atlases: object | object[], src?: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | CompressedImage | string | OffscreenCanvas[] | HTMLImageElement[] | HTMLCanvasElement[] | string[], options?: boolean | object);
     /**
      * to identify the atlas format (e.g. texture packer)
      * @ignore
@@ -81,6 +89,14 @@ export class TextureAtlas {
      * @ignore
      */
     sources: Map<any, any>;
+    /**
+     * paired normal-map source(s), keyed identically to `sources`.
+     * Populated from the constructor's `options.normalMap`. Used by
+     * the WebGL renderer's lit pipeline for per-pixel lighting.
+     * @type {Map}
+     * @ignore
+     */
+    normalSources: Map<any, any>;
     /**
      * the atlas dictionnaries
      * @type {Map}
@@ -122,6 +138,14 @@ export class TextureAtlas {
      * @returns {HTMLImageElement|HTMLCanvasElement}
      */
     getTexture(region?: object): HTMLImageElement | HTMLCanvasElement;
+    /**
+     * Return the paired normal-map texture for the given region, or `null`
+     * if no normal map was provided to this atlas. The normal map shares
+     * the same UV layout as the color texture returned by {@link TextureAtlas#getTexture}.
+     * @param {object} [region] - region name in case of multipack textures
+     * @returns {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|null}
+     */
+    getNormalTexture(region?: object): HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap | null;
     /**
      * add a region to the atlas
      * @param {string} name - region mame

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

@@ -1 +1 @@
-{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/video/texture/atlas.js"],"names":[],"mappings":"AASA;;;GAGG;AAEH;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;EAoBC;AAED;;;GAGG;AACH,+FAYC;AAED;;;;;;;;;;GAUG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,qBAzBW,MAAM,GAAC,MAAM,EAAE,QACf,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,eAAe,GAAC,MAAM,GAAC,eAAe,EAAE,GAAC,gBAAgB,EAAE,GAAC,iBAAiB,EAAE,GAAC,MAAM,EAAE,UAC3I,OAAO,EAsKjB;IA9IA;;;OAGG;IACH,sBAAkB;IAElB;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,2BAA4B;IAE5B;;;OAGG;IACH;;;;;;MAA6D;IAW1D,YAA8C;IAsGlD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,CAQ9C;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,GAAC,MAAM,OACb,MAAM,OACN,MAAM,OACN,MAAM,GACJ,YAAY,CAsCxB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,YAAY,CAoBxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,2BA1BW,MAAM,aACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,eAAe,CAqClC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BAnBW,MAAM,EAAE,GAAC,MAAM,EAAE,GAGf,MAAM,CAyElB;IAED,2DA2CC;CACD;mBArlBkB,8BAA8B;iCAQjB,uCAAuC"}
+{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/video/texture/atlas.js"],"names":[],"mappings":"AASA;;;GAGG;AAEH;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;EAoBC;AAED;;;GAGG;AACH,+FAYC;AAED;;;;;;;;;;GAUG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,qBAjCW,MAAM,GAAC,MAAM,EAAE,QACf,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,eAAe,GAAC,MAAM,GAAC,eAAe,EAAE,GAAC,gBAAgB,EAAE,GAAC,iBAAiB,EAAE,GAAC,MAAM,EAAE,YAC3I,OAAO,GAAC,MAAM,EAsOxB;IAjMA;;;OAGG;IACH,sBAAkB;IAElB;;;;OAIG;IACH,uBAAwB;IAExB;;;;;;OAMG;IACH,6BAA8B;IAE9B;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,2BAA4B;IAE5B;;;OAGG;IACH;;;;;;MAA6D;IAW1D,YAA8C;IAgJlD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,CAQ9C;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAU/E;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,GAAC,MAAM,OACb,MAAM,OACN,MAAM,OACN,MAAM,GACJ,YAAY,CAsCxB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,YAAY,CAoBxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,2BA1BW,MAAM,aACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,eAAe,CAqClC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BAnBW,MAAM,EAAE,GAAC,MAAM,EAAE,GAGf,MAAM,CAyElB;IAED,2DA2CC;CACD;mBAtqBkB,8BAA8B;iCAQjB,uCAAuC"}

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

@@ -116,6 +116,12 @@ export class Batcher {
      * called by the WebGL renderer when a batcher becomes the current one
      */
     bind(): void;
+    /**
+     * called by the WebGL renderer when this batcher is being replaced by another.
+     * Disables this batcher's vertex attribute locations so they don't leak across
+     * (otherwise stale stride/offset state can cause INVALID_OPERATION on the next draw).
+     */
+    unbind(): void;
     /**
      * Select the shader to use for compositing
      * @see GLShader

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

@@ -1 +1 @@
-{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;;;;;;;;;;;;;OAeG;IACH,sBAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,EAGA;IAED;;;OAGG;IACH,yCA6HC;IA3HA,cAAwB;IAGxB,QAAqB;IAGrB,gBAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAE9B;;;;OAIG;IACH,yBAA6B;IAE7B;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IAqCtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAUxB;;;OAGG;IACH,cAUC;IAED;;OAEG;IACH,aAYC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAqBlB;IAHE,uCAA4B;IAK/B;;;;;;;OAOG;IACH,mBANW,MAAM,QACN,MAAM,QACN,MAAM,cACN,OAAO,UACP,MAAM,QA+BhB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAyEhB;CACD;;qBAhXoB,gBAAgB;8BAFP,wBAAwB;6BACzB,oBAAoB;8BAMtB,2BAA2B;+BADxB,wBAAwB"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;;;;;;;;;;;;;OAeG;IACH,sBAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,EAGA;IAED;;;OAGG;IACH,yCA6HC;IA3HA,cAAwB;IAGxB,QAAqB;IAGrB,gBAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAE9B;;;;OAIG;IACH,yBAA6B;IAE7B;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IAqCtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAUxB;;;OAGG;IACH,cAUC;IAED;;OAEG;IACH,aAYC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QA8BlB;IAHE,uCAA4B;IAK/B;;;;;;;OAOG;IACH,mBANW,MAAM,QACN,MAAM,QACN,MAAM,cACN,OAAO,UACP,MAAM,QA+BhB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAyEhB;CACD;;qBA7YoB,gBAAgB;8BAFP,wBAAwB;6BACzB,oBAAoB;8BAMtB,2BAA2B;+BADxB,wBAAwB"}

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

@@ -0,0 +1,109 @@
+/**
+ * additional import for TypeScript
+ * @import {TextureAtlas} from "./../../texture/atlas.js";
+ */
+/**
+ * Lit-aware variant of `QuadBatcher` for the SpriteIlluminator workflow.
+ *
+ * Adds a 5th vertex attribute (`aNormalTextureId`) so each quad knows
+ * which paired normal-map sampler to read, and bundles the per-frame
+ * light uniforms (`uLightPos`, `uLightColor`, `uLightHeight`, `uAmbient`)
+ * that the lit fragment shader iterates.
+ *
+ * Texture-slot capacity is halved relative to `QuadBatcher` because each
+ * sprite may need a paired (color, normal) sampler — color goes to unit
+ * `n`, normal to unit `maxBatchTextures + n`. The `WebGLRenderer` only
+ * dispatches sprites here when the scene actually needs lighting (active
+ * `Light2d` AND the sprite has a `normalMap`); unlit sprites stay on
+ * `QuadBatcher` and pay nothing.
+ * @category Rendering
+ */
+export default class LitQuadBatcher extends QuadBatcher {
+    /**
+     * normal-map texture per color slot — keyed by the same unit index as
+     * `boundTextures`. Used by `addQuad` to detect when a normal-map slot
+     * needs (re-)uploading, mirroring the color-texture cache.
+     * @type {Array<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|null>}
+     * @ignore
+     */
+    boundNormalMaps: (ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | null)[] | undefined;
+    /**
+     * Map from a normal-map source image to its GL texture object.
+     * @type {Map<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap, WebGLTexture>}
+     * @ignore
+     */
+    normalMapTextures: Map<ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, WebGLTexture> | undefined;
+    _lightCount: number | undefined;
+    _maxLights: number | undefined;
+    /**
+     * Bind the paired normal sampler uniforms (`uNormalSampler0..N-1`)
+     * to texture units `maxBatchTextures..2*maxBatchTextures-1`. Called
+     * from `init` and `reset`.
+     * @ignore
+     */
+    bindNormalSamplers(): void;
+    /**
+     * Upload per-frame Light2d uniforms used by the lit fragment path.
+     * Called once per camera per frame (before the world tree walk).
+     * Lights past `MAX_LIGHTS` are silently ignored.
+     *
+     * Coordinates must be supplied in the same space as the renderer's
+     * pre-projection vertex coords (i.e. camera-local / FBO-local),
+     * matching `Stage.drawLighting`'s convention.
+     * @param {object} uniforms
+     * @param {Float32Array} uniforms.positions - flat array of `[x, y, radius, intensity]` per light, length = 4 * count
+     * @param {Float32Array} uniforms.colors - flat array of `[r, g, b]` per light, length = 3 * count
+     * @param {Float32Array} [uniforms.heights] - flat array of per-light height, length = MAX_LIGHTS
+     * @param {number} uniforms.count - number of lights to render (clamped to MAX_LIGHTS)
+     * @param {number[]} [uniforms.ambient] - `[r, g, b]` ambient floor (0..1 each)
+     */
+    setLightUniforms(uniforms: {
+        positions: Float32Array;
+        colors: Float32Array;
+        heights?: Float32Array<ArrayBufferLike> | undefined;
+        count: number;
+        ambient?: number[] | undefined;
+    }): void;
+    /**
+     * Bind a normal-map image to the given GL texture unit. Uploads on
+     * first use (via `uploadNormalMap`) and rebinds the cached
+     * `WebGLTexture` on subsequent calls. Mirrors the
+     * `bindTexture2D` / `createTexture2D` split used by `MaterialBatcher`,
+     * but for normal-map textures which live outside the color
+     * `TextureCache` (cached per-image in `normalMapTextures`).
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
+     * @param {number} unit - GL texture unit (already offset by `maxBatchTextures`)
+     */
+    bindNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number): void;
+    /**
+     * Upload a normal-map image to GL and cache the resulting `WebGLTexture`
+     * for future `bindNormalMap` calls. Not meant to be called directly —
+     * `bindNormalMap` invokes this on the first use of a given image.
+     *
+     * `premultipliedAlpha = false` — normal maps store linear-encoded
+     * surface normals; multiplying through alpha would corrupt the
+     * encoding for any non-opaque texel.
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
+     * @param {number} unit - GL texture unit (already offset by `maxBatchTextures`)
+     */
+    uploadNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number): void;
+    /**
+     * Add a textured quad with optional paired normal map.
+     * @param {TextureAtlas} texture - Source texture atlas
+     * @param {number} x - Destination x-coordinate
+     * @param {number} y - Destination y-coordinate
+     * @param {number} w - Destination width
+     * @param {number} h - Destination height
+     * @param {number} u0 - Texture UV (u0) value
+     * @param {number} v0 - Texture UV (v0) value
+     * @param {number} u1 - Texture UV (u1) value
+     * @param {number} v1 - Texture UV (v1) value
+     * @param {number} tint - tint color (UINT32 argb)
+     * @param {boolean} [reupload=false] - Force the texture to be reuploaded
+     * @param {HTMLImageElement|HTMLCanvasElement|null} [normalMap=null] - paired normal-map (SpriteIlluminator workflow)
+     */
+    addQuad(texture: TextureAtlas, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number, reupload?: boolean, normalMap?: HTMLImageElement | HTMLCanvasElement | null): void;
+}
+import QuadBatcher from "./quad_batcher.js";
+import type { TextureAtlas } from "./../../texture/atlas.js";
+//# sourceMappingURL=lit_quad_batcher.d.ts.map

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

@@ -0,0 +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;IAoEE;;;;;;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,QA0EjD;CAwDD;wBAtXoC,mBAAmB;kCAIzB,0BAA0B"}

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

@@ -1,3 +1,8 @@
+/**
+ * additional import for TypeScript
+ * @import {TextureAtlas} from "./../../texture/atlas.js";
+ */
+export const V_ARRAY: Vector2d[];
 /**
  * A WebGL Compositor object. This class handles all of the WebGL state<br>
  * Pushes texture regions or shape geometry into WebGL buffers, automatically flushes to GPU
@@ -22,6 +27,18 @@ export default class QuadBatcher extends MaterialBatcher {
      * @ignore
      */
     useMultiTexture: boolean | undefined;
+    /**
+     * (Re-)create the index buffer for quad batching (4 verts + 6 indices per quad).
+     * Called from `init` and `reset` (after context loss).
+     * @ignore
+     */
+    createIndexBuffer(): void;
+    /**
+     * Bind the color sampler uniforms (`uSampler0..uSamplerN-1`) to their
+     * respective texture units. Called from `init` and `reset`.
+     * @ignore
+     */
+    bindColorSamplers(): void;
     /**
      * Select the shader to use for compositing.
      * Multi-texture batching is automatically enabled when the default
@@ -55,10 +72,11 @@ export default class QuadBatcher extends MaterialBatcher {
      * @param {number} u1 - Texture UV (u1) value.
      * @param {number} v1 - Texture UV (v1) value.
      * @param {number} tint - tint color to be applied to the texture in UINT32 (argb) format
-     * @param {boolean} reupload - Force the texture to be reuploaded even if already bound
+     * @param {boolean} [reupload=false] - Force the texture to be reuploaded even if already bound
      */
     addQuad(texture: TextureAtlas, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number, reupload?: boolean): void;
 }
+import { Vector2d } from "../../../math/vector2d.ts";
 import { MaterialBatcher } from "./material_batcher.js";
 import type { TextureAtlas } from "./../../texture/atlas.js";
 //# sourceMappingURL=quad_batcher.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAkEC;IAjEA;;;;OAIG;IACH,qCAA0D;IA4C1D;;;;;OAKG;IACH,qCAA2B;IAY5B;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAgED;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QA4B/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAqDjB;CACD;gCAjR+B,uBAAuB;kCAIxB,0BAA0B"}
+{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAMA;;;GAGG;AAMH,iCAKE;AAEF;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAwDC;IAvDA;;;;OAIG;IACH,qCAA0D;IAyC1D;;;;;OAKG;IACH,qCAA2B;IAK5B;;;;OAIG;IACH,0BAQC;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAoDD;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QAoD/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAqDjB;CACD;yBApTwB,2BAA2B;gCAIpB,uBAAuB;kCAIxB,0BAA0B"}

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

@@ -0,0 +1,105 @@
+/**
+ * additional import for TypeScript
+ * @import { Color } from "../../../math/color.ts";
+ * @import { default as WebGLRenderer } from "../webgl_renderer.js";
+ */
+/**
+ * A procedural radial-gradient shader effect: solid color at the center
+ * fading linearly to fully transparent at the edge of the host quad.
+ * The falloff is naturally elliptical for non-square quads.
+ *
+ * **UV-space caveat.** The `apply(color, uv)` function receives
+ * `vRegion` — the atlas UVs of the host quad. The falloff math
+ * (`length(uv * 2 - 1)`) assumes those UVs span `[0, 1] × [0, 1]`,
+ * which is true when the quad samples a full-rect texture (a
+ * dedicated 1×1 white pixel, a non-atlased Sprite, an FBO blit, or
+ * the engine-provided light atlas used by `WebGLRenderer.drawLight`).
+ * If you attach this effect to a Sprite that uses a *sub-region* of a
+ * larger atlas, `uv` will be in `[u0..u1] × [v0..v1]` and the radial
+ * center will be misplaced. For atlas-based renderables, set the
+ * effect's `uColor`/`uIntensity` and pair it with a Sprite whose
+ * texture covers a full atlas, or use a Sprite created from a
+ * standalone image.
+ *
+ * The falloff curve is **linear** (`f = clamp(1 - d, 0, 1)`) to match
+ * the Canvas 2D `createRadialGradient` two-stop output exactly. Output
+ * is premultiplied so the result composes correctly under additive
+ * (`"lighter"`) blending across overlapping quads.
+ *
+ * Color & intensity come from **two stacked sources**, multiplied
+ * together: the `uColor`/`uIntensity` uniforms (set per-effect via
+ * `setColor` / `setIntensity` — the natural API for a single-instance
+ * shader attached to a renderable) AND the per-vertex tint coming
+ * through `aColor` (used by `WebGLRenderer.drawLight` to encode each
+ * light's color + intensity in the vertex stream so multiple lights
+ * sharing this shader can batch into a single draw call). For typical
+ * standalone usage the per-vertex tint is `(1,1,1,1)` and the uniforms
+ * drive the look; for the Light2d batching path the uniforms stay at
+ * defaults and the tint carries everything.
+ * @category Effects
+ * @example
+ * // Soft white spot, 50% peak alpha at center
+ * const spot = new RadialGradientEffect(renderer, { intensity: 0.5 });
+ * @example
+ * // Tinted hotspot — orange center, full brightness, sized via the
+ * // host quad's bounds
+ * const hot = new RadialGradientEffect(renderer, {
+ *     color: new Color(255, 128, 64),
+ *     intensity: 1.0,
+ * });
+ * hot.setIntensity(2.0); // pulse brighter at runtime
+ * @example
+ * // Pickup highlight — attach to any Renderable so it renders inside
+ * // the renderable's bounding rect (anchorPoint applies). Combine with
+ * // `blendMode = "lighter"` for the additive glow look.
+ * pickup.shader = new RadialGradientEffect(renderer, {
+ *     color: new Color(120, 255, 200), // mint green
+ *     intensity: 0.8,
+ * });
+ * pickup.blendMode = "lighter";
+ * @example
+ * // Damage / impact indicator — short-lived elliptical flash on hit.
+ * // The quad's width/height drive the falloff aspect for free.
+ * const flash = new RadialGradientEffect(renderer, {
+ *     color: new Color(255, 32, 32),
+ *     intensity: 1.5,
+ * });
+ * // animate intensity to fade out
+ * tween.to({ intensity: 0 }, 200).onUpdate((s) => flash.setIntensity(s.intensity));
+ * @example
+ * // Debug overlay — draw a soft circle wherever the player is to mark
+ * // a trigger zone, without baking a texture per zone.
+ * const zoneMarker = new RadialGradientEffect(renderer, {
+ *     color: new Color(80, 160, 255),
+ *     intensity: 0.4,
+ * });
+ */
+export default class RadialGradientEffect extends ShaderEffect {
+    /**
+     * @param {WebGLRenderer} renderer - the current renderer instance
+     * @param {object} [options] - initial uniform values
+     * @param {Color} [options.color] - center color (0..255 RGB); defaults to white
+     * @param {number} [options.intensity=1] - peak alpha at the center (0..1+)
+     */
+    constructor(renderer: WebGLRenderer, options?: {
+        color?: Color | undefined;
+        intensity?: number | undefined;
+    });
+    _colorBuf: Float32Array<ArrayBuffer>;
+    /**
+     * Set the center color. RGB only — alpha is ignored (the radial
+     * falloff supplies the per-pixel alpha).
+     * @param {Color} color - 0..255 RGB color
+     */
+    setColor(color: Color): void;
+    /**
+     * Set the peak intensity. Acts as a brightness multiplier on the
+     * falloff curve; values above 1 over-saturate the center of the gradient.
+     * @param {number} intensity - 0..1+ multiplier
+     */
+    setIntensity(intensity: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+import type { Color } from "../../../math/color.ts";
+import type { default as WebGLRenderer } from "../webgl_renderer.js";
+//# sourceMappingURL=radialGradient.d.ts.map

package/build/video/webgl/effects/radialGradient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,YAErB;QAAwB,KAAK;QACJ,SAAS;KACpC,EA0CA;IAZA,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBArJwB,oBAAoB;2BAInB,wBAAwB;8CACL,sBAAsB"}

package/build/video/webgl/glshader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAyEhB;IAjDA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAKf;IAED;;;OAGG;IACH,UAFU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,KAAK,EAAE,CAEiC;IAElD;;;OAGG;IACH,SAFU,YAAY,CAOrB;IAED;;;OAGG;IACH,UAFU,MAAM,CAE8B;IAM/C;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CASjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QAiB7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAsBhB;IAED;;OAEG;IACH,gBAQC;CACD"}
+{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAyEhB;IAjDA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAKf;IAED;;;OAGG;IACH,UAFU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,KAAK,EAAE,CAEiC;IAElD;;;OAGG;IACH,SAFU,YAAY,CAOrB;IAED;;;OAGG;IACH,UAFU,MAAM,CAE8B;IAM/C;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CASjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QAiB7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;OAEG;IACH,gBAQC;CACD"}

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

@@ -0,0 +1,13 @@
+/**
+ * Constants shared between the lit fragment shader (`multitexture-lit.js`),
+ * the lit batcher (`LitQuadBatcher`), and the uniform packer (`pack.ts`).
+ * Kept in a tiny standalone module so the three consumers don't depend on
+ * each other transitively for a single integer.
+ */
+/**
+ * Maximum number of `Light2d` instances the lit fragment shader supports
+ * concurrently per draw call. Lights past this index are ignored. Sized
+ * to keep the GLSL uniform arrays comfortably within WebGL1 limits.
+ */
+export declare const MAX_LIGHTS = 8;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU,IAAI,CAAC"}

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

@@ -0,0 +1,76 @@
+/**
+ * Per-frame scratch buffer for `packLights()`. Pre-allocates one entry
+ * per light slot so the per-camera-per-frame upload doesn't allocate.
+ */
+export interface LightUniformScratch {
+    positions: Float32Array;
+    colors: Float32Array;
+    heights: Float32Array;
+    ambient: number[];
+}
+/**
+ * Result of `packLights()` — typed-array views into the scratch plus the
+ * actual count. `WebGLRenderer.setLightUniforms` forwards this to
+ * `LitQuadBatcher.setLightUniforms` for upload.
+ */
+export interface LightUniforms extends LightUniformScratch {
+    count: number;
+}
+/**
+ * Allocate a fresh scratch buffer sized for `MAX_LIGHTS` slots. One per
+ * renderer is enough; reuse across frames.
+ */
+export declare function createLightUniformScratch(): LightUniformScratch;
+/**
+ * Light2d-shaped duck-type — anything `packLights()` reads from. Avoids
+ * importing `Light2d` directly (keeps this module renderer-agnostic).
+ */
+interface LightLike {
+    getBounds(): {
+        centerX: number;
+        centerY: number;
+        width: number;
+        height: number;
+    };
+    intensity: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    lightHeight: number;
+}
+/** Color-shaped duck-type for the ambient floor. */
+interface ColorLike {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Pack the active scene lights into the scratch buffer in a shape the
+ * lit fragment shader uploads directly.
+ *
+ * Light positions are translated from world-space (where
+ * `light.getBounds().centerX/Y` lives) into the renderer's
+ * pre-projection coords by subtracting `(translateX, translateY)` —
+ * the same translate `Camera2d.draw()` applies to the world container.
+ * This matches what `Stage.drawLighting` does for the cutout pass, so
+ * the lit fragment's `lightPos - vWorldPos` math lines up with the
+ * camera's view.
+ *
+ * Lights past `MAX_LIGHTS` (8) are silently dropped. Unused slots are
+ * zero-filled so stale data from a previous frame can't leak into the
+ * shader.
+ *
+ * Pure function: deterministic given the same inputs, no I/O, scratch
+ * is the only mutable target.
+ * @param lights - active lights iterable (e.g. `Stage._activeLights`); falsy treated as empty
+ * @param ambient - ambient floor color (0..255 RGB); falsy treated as black
+ * @param translateX - world-to-screen X translate (matches `Camera2d.draw()`)
+ * @param translateY - world-to-screen Y translate
+ * @param scratch - pre-allocated scratch (see `createLightUniformScratch`)
+ * @returns the scratch with `count` filled in
+ */
+export declare function packLights(lights: Iterable<LightLike> | null | undefined, ambient: ColorLike | null | undefined, translateX: number, translateY: number, scratch: LightUniformScratch): LightUniforms;
+export {};
+//# sourceMappingURL=pack.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/pack.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IACnC,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACzD,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,mBAAmB,CAO/D;AAED;;;GAGG;AACH,UAAU,SAAS;IAClB,SAAS,IAAI;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KACf,CAAC;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,oDAAoD;AACpD,UAAU,SAAS;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CACzB,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9C,OAAO,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,EACrC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC1B,aAAa,CA4Cf"}

package/build/video/webgl/shaders/multitexture-lit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generate the fragment shader for `LitQuadBatcher` — the SpriteIlluminator
+ * path that supports per-pixel normal-map lighting from up to `MAX_LIGHTS`
+ * point lights.
+ *
+ * Sprites without a `normalMap` push `aNormalTextureId = -1` and take the
+ * unlit fast path inside this same shader (sample color, multiply by
+ * vertex color, return) so lit and unlit sprites can share the lit batch
+ * when they coexist with active lights. The cost vs the truly-unlit
+ * `QuadBatcher` shader is one varying read + one comparison per fragment.
+ *
+ * The light's "height above the sprite plane" is encoded as a small
+ * fraction of the light's radius (default `0.075`) so that lights
+ * exactly at a fragment's screen position don't produce degenerate
+ * flat shading.
+ * @param {number} maxTextures - the number of color/normal texture units to support
+ * @returns {string} GLSL fragment shader source
+ * @ignore
+ */
+export function buildLitMultiTextureFragment(maxTextures: number): string;
+export { MAX_LIGHTS };
+import { MAX_LIGHTS } from "../lighting/constants.ts";
+//# sourceMappingURL=multitexture-lit.d.ts.map

package/build/video/webgl/shaders/multitexture-lit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multitexture-lit.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/shaders/multitexture-lit.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAJW,MAAM,GACJ,MAAM,CAiFlB;;2BAjI0B,0BAA0B"}

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

@@ -60,6 +60,7 @@ export default class WebGLRenderer extends Renderer {
         x: number;
         y: number;
     }[];
+    _clipAABB: Bounds;
     _polyVerts: any[];
     _currentGradient: any;
     /**
@@ -91,6 +92,8 @@ export default class WebGLRenderer extends Renderer {
      * @default 1
      */
     get WebGLVersion(): number;
+    _lightShader: RadialGradientEffect | undefined;
+    _lightAtlas: TextureAtlas | undefined;
     /**
      * add a new batcher to this renderer
      * @param {Batcher} batcher - a batcher instance
@@ -122,6 +125,18 @@ export default class WebGLRenderer extends Renderer {
      * let basic      = renderer.createPattern(image, "no-repeat");
      */
     createPattern(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame, repeat: string): TextureAtlas;
+    _lightUniformsScratch: import("./lighting/pack.ts").LightUniformScratch | undefined;
+    /**
+     * Lazy-init a shared 1×1 white `TextureAtlas` used as the source
+     * texture for `drawLight`'s procedural shader. The shader ignores
+     * the sampled color, but `addQuad`'s vertex format includes a
+     * texture-unit attribute so we still need a real texture; sharing
+     * one across every light keeps them on the same multi-texture slot
+     * (no flush on light switch).
+     * @returns {TextureAtlas}
+     * @ignore
+     */
+    _getLightAtlas(): TextureAtlas;
     /** @ignore */
     endPostEffect(renderable: any): void;
     /**
@@ -512,8 +527,10 @@ export default class WebGLRenderer extends Renderer {
 }
 import Renderer from "./../renderer.js";
 import { Matrix3d } from "../../math/matrix3d.ts";
+import { Bounds } from "../../physics/bounds.ts";
 import type { Batcher } from "./batchers/batcher.js";
 import TextureCache from "./../texture/cache.js";
+import RadialGradientEffect from "./effects/radialGradient.js";
 import { TextureAtlas } from "./../texture/atlas.js";
 import { Color } from "./../../math/color.ts";
 import type { Rect } from "./../../geometries/rectangle.ts";

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "melonjs",
-	"version": "19.2.0",
+	"version": "19.3.0",
 	"description": "melonJS Game Engine",
 	"homepage": "http://www.melonjs.org/",
 	"type": "module",