melonjs 19.1.0 → 19.3.0

package/build/video/rendertarget/canvasrendertarget.d.ts

@@ -1,9 +1,12 @@
 export default CanvasRenderTarget;
 /**
- * CanvasRenderTarget is 2D render target which exposes a Canvas interface.
+ * A 2D canvas render target for offscreen texture generation.
+ * Used by Text, Gradient, Light2d and Particle systems to render into
+ * a canvas that is then uploaded as a WebGL texture.
+ * @augments RenderTarget
  * @category Rendering
  */
-declare class CanvasRenderTarget {
+declare class CanvasRenderTarget extends RenderTarget {
     /**
      * @param {number} width - the desired width of the canvas
      * @param {number} height - the desired height of the canvas
@@ -23,15 +26,26 @@ declare class CanvasRenderTarget {
         willReadFrequently?: boolean | undefined;
         antiAlias?: boolean | undefined;
     });
-    /**
-     * the canvas created for this CanvasRenderTarget
-     * @type {HTMLCanvasElement|OffscreenCanvas}
-     */
-    /**
-     * the rendering context of this CanvasRenderTarget
-     * @type {CanvasRenderingContext2D|WebGLRenderingContext}
-     */
-    attributes: CanvasRenderingContext2D | WebGLRenderingContext;
+    attributes: {
+        offscreenCanvas: boolean;
+        willReadFrequently: boolean;
+        antiAlias: boolean;
+        context: string;
+        transparent: boolean;
+        premultipliedAlpha: boolean;
+        stencil: boolean;
+        blendMode: string;
+        failIfMajorPerformanceCaveat: boolean;
+        preferWebGL1: boolean;
+        powerPreference: string;
+    } & {
+        context?: string | undefined;
+        preferWebGL1?: boolean | undefined;
+        transparent?: boolean | undefined;
+        offscreenCanvas?: boolean | undefined;
+        willReadFrequently?: boolean | undefined;
+        antiAlias?: boolean | undefined;
+    };
     canvas: any;
     context: any;
     WebGLVersion: any;
@@ -39,21 +53,11 @@ declare class CanvasRenderTarget {
      * @ignore
      */
     onResetEvent(width: any, height: any): void;
-    /**
-     * Clears the content of the canvas texture
-     */
-    clear(): void;
     /**
      * enable/disable image smoothing (scaling interpolation)
      * @param {boolean} [enable=false] - whether to enable or not image smoothing (scaling interpolation)
      */
     setAntiAlias(enable?: boolean): void;
-    /**
-     * Resizes the canvas texture to the given width and height.
-     * @param {number} width - the desired width
-     * @param {number} height - the desired height
-     */
-    resize(width: number, height: number): void;
     /**
      * Returns an ImageData object representing the underlying pixel data for a specified portion of this canvas texture.
      * (Note: when using getImageData(), it is highly recommended to use the `willReadFrequently` attribute when creatimg the corresponding canvas texture)
@@ -64,34 +68,6 @@ declare class CanvasRenderTarget {
      * @returns {ImageData} The ImageData extracted from this CanvasRenderTarget.
      */
     getImageData(x: number, y: number, width: number, height: number): ImageData;
-    /**
-     * creates a Blob object representing the image contained in this canvas texture
-     * @param {string} [type="image/png"] - A string indicating the image format
-     * @param {number} [quality] - A Number between 0 and 1 indicating the image quality to be used when creating images using file formats that support lossy compression (such as image/jpeg or image/webp). A user agent will use its default quality value if this option is not specified, or if the number is outside the allowed range.
-     * @returns {Promise} A Promise returning a Blob object representing the image contained in this canvas texture
-     * @example
-     * renderTarget.convertToBlob().then((blob) => console.log(blob));
-     */
-    toBlob(type?: string, quality?: number): Promise<any>;
-    /**
-     * creates an ImageBitmap object from the most recently rendered image of this canvas texture
-     * @param {string} [type="image/png"] - A string indicating the image format
-     * @param {number} [quality] - A Number between 0 and 1 indicating the image quality to be used when creating images using file formats that support lossy compression (such as image/jpeg or image/webp). A user agent will use its default quality value if this option is not specified, or if the number is outside the allowed range.
-     * @returns {Promise} A Promise returning an ImageBitmap.
-     * @example
-     * renderTarget.transferToImageBitmap().then((bitmap) => console.log(bitmap));
-     */
-    toImageBitmap(type?: string, quality?: number): Promise<any>;
-    /**
-     * returns a data URL containing a representation of the most recently rendered image of this canvas texture
-     * (not supported by OffscreenCanvas)
-     * @param {string} [type="image/png"] - A string indicating the image format
-     * @param {number} [quality] - A Number between 0 and 1 indicating the image quality to be used when creating images using file formats that support lossy compression (such as image/jpeg or image/webp). A user agent will use its default quality value if this option is not specified, or if the number is outside the allowed range.
-     * @returns {Promise} A Promise returning a string containing the requested data URL.
-     * @example
-     * renderer.toDataURL().then((dataURL) => console.log(dataURL));
-     */
-    toDataURL(type?: string, quality?: number): Promise<any>;
     /**
      * invalidate the current CanvasRenderTarget, and force a reupload of the corresponding texture
      * (call this if you modify the canvas content between two draw calls)
@@ -105,21 +81,8 @@ declare class CanvasRenderTarget {
      * @ignore
      */
     destroy(renderer?: CanvasRenderer | WebGLRenderer): void;
-    public set width(val: number);
-    /**
-     * The width of this canvas texture in pixels
-     * @public
-     * @type {number}
-     */
-    public get width(): number;
-    public set height(val: number);
-    /**
-     * The height of this canvas texture in pixels
-     * @public
-     * @type {number}
-     */
-    public get height(): number;
 }
+import RenderTarget from "./rendertarget.ts";
 import type CanvasRenderer from "./../canvas/canvas_renderer.js";
 import type WebGLRenderer from "./../webgl/webgl_renderer.js";
 //# sourceMappingURL=canvasrendertarget.d.ts.map

package/build/video/rendertarget/canvasrendertarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA8EA;;;GAGG;AACH;IACC;;;;;;;;;;OAUG;IACH,mBAVW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,YAAY;QACZ,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAuCA;IArCA;;;OAGG;IAGH;;;OAGG;IAGH,YAJU,wBAAwB,GAAC,qBAAqB,CAIU;IASjE,YAA+B;IAUhC,aAA0D;IAE1D,kBAAgC;IAMjC;;OAEG;IACH,4CAGC;IAED;;OAEG;IACH,cAGC;IAED;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,QAKhB;IAED;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,YACN,MAAM,gBAmBhB;IAED;;;;;;;OAOG;IACH,qBANW,MAAM,YACN,MAAM,gBAmBhB;IAED;;;;;;;;OAQG;IACH,iBANW,MAAM,YACN,MAAM,gBAShB;IAED;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAatC;IALC,mBAEC;IAKH;;;;OAIG;IACH,mBAHW,cAAc,GAAC,aAAa,QAoBtC;IAWD,sBANU,MAAM,EAQf;IAXD;;;;OAIG;IACH,oBAFU,MAAM,CAIf;IAeD,uBANU,MAAM,EAQf;IAXD;;;;OAIG;IACH,qBAFU,MAAM,CAIf;CAKD;gCA3U8B,gCAAgC;+BACjC,8BAA8B"}
+{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA+EA;;;;;;GAMG;AACH;IACC;;;;;;;;;;OAUG;IACH,mBAVW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,YAAY;QACZ,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EA6BA;IAzBA;;;;;;;;;;;;;;;;;;;MAAkE;IASjE,YAA+B;IAUhC,aAA0D;IAE1D,kBAAgC;IAMjC;;OAEG;IACH,4CAGC;IAUD;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAYD;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAoDD;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAatC;IALC,mBAEC;IAKH;;;;OAIG;IACH,mBAHW,cAAc,GAAC,aAAa,QAoBtC;CA2BD;yBA3TwB,mBAAmB;gCAIb,gCAAgC;+BACjC,8BAA8B"}

package/build/video/rendertarget/render_target_pool.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @import RenderTarget from "./rendertarget.ts";
+ */
+/**
+ * Manages a pool of {@link RenderTarget} instances for post-effect processing.
+ * Renderer-agnostic — the actual RenderTarget creation is delegated to a
+ * factory function provided by the renderer (WebGL, WebGPU, etc.).
+ *
+ * Camera effects use pool indices 0 and 1 (capture + ping-pong),
+ * sprite effects use indices 2 and 3.
+ * Render targets are lazily created and resized to match the required dimensions.
+ * @ignore
+ */
+export default class RenderTargetPool {
+    /**
+     * @param {function(number, number): RenderTarget} factory - creates a RenderTarget with the given width and height
+     */
+    constructor(factory: (arg0: number, arg1: number) => RenderTarget);
+    /** @type {function(number, number): RenderTarget} */
+    _factory: (arg0: number, arg1: number) => RenderTarget;
+    /** @type {RenderTarget[]} */
+    _pool: RenderTarget[];
+    /** @type {number} */
+    _activeBase: number;
+    /** @type {number} */
+    _previousBase: number;
+    /**
+     * Get or create a render target at the given pool index, resized to the given dimensions.
+     * @param {number} index - pool index
+     * @param {number} width - desired width in pixels
+     * @param {number} height - desired height in pixels
+     * @returns {RenderTarget} the render target
+     */
+    get(index: number, width: number, height: number): RenderTarget;
+    /**
+     * Prepare render targets for a post-effect pass.
+     * Allocates/resizes the capture target and optionally the ping-pong target.
+     * @param {boolean} isCamera - true for camera effects (indices 0+1), false for sprite (indices 2+3)
+     * @param {number} effectCount - number of enabled effects
+     * @param {number} width - target width in pixels
+     * @param {number} height - target height in pixels
+     * @returns {RenderTarget} the capture target (ready to bind)
+     */
+    begin(isCamera: boolean, effectCount: number, width: number, height: number): RenderTarget;
+    /**
+     * Get the capture render target for the current active pass.
+     * @returns {RenderTarget|undefined} the capture target, or undefined if no active pass
+     */
+    getCaptureTarget(): RenderTarget | undefined;
+    /**
+     * Get the ping-pong render target for the current active pass.
+     * @returns {RenderTarget|undefined} the ping-pong target, or undefined if no active pass
+     */
+    getPingPongTarget(): RenderTarget | undefined;
+    /**
+     * End the current pass and restore the previous active base.
+     * Returns the parent render target to rebind (or null for screen).
+     * @returns {RenderTarget|null} the parent target, or null if returning to screen
+     */
+    end(): RenderTarget | null;
+    /**
+     * Resize all existing render targets in the pool to the given dimensions.
+     * @param {number} width - new width in pixels
+     * @param {number} height - new height in pixels
+     */
+    resizeAll(width: number, height: number): void;
+    /**
+     * Destroy all render targets and clear the pool.
+     */
+    destroy(): void;
+}
+import type RenderTarget from "./rendertarget.ts";
+//# sourceMappingURL=render_target_pool.d.ts.map

package/build/video/rendertarget/render_target_pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render_target_pool.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/render_target_pool.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH;IACC;;OAEG;IACH,qBAFW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAG,YAAY,EAWhD;IARA,qDAAqD;IACrD,UADW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAG,YAAY,CAC1B;IACvB,6BAA6B;IAC7B,OADW,YAAY,EAAE,CACV;IACf,qBAAqB;IACrB,aADW,MAAM,CACI;IACrB,qBAAqB;IACrB,eADW,MAAM,CACM;IAGxB;;;;;;OAMG;IACH,WALW,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CASxB;IAED;;;;;;;;OAQG;IACH,gBANW,OAAO,eACP,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAexB;IAED;;;OAGG;IACH,oBAFa,YAAY,GAAC,SAAS,CAOlC;IAED;;;OAGG;IACH,qBAFa,YAAY,GAAC,SAAS,CAOlC;IAED;;;;OAIG;IACH,OAFa,YAAY,GAAC,IAAI,CAS7B;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,QAQhB;IAED;;OAEG;IACH,gBASC;CACD;8BAlI4B,mBAAmB"}

package/build/video/rendertarget/rendertarget.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Abstract base class for offscreen render targets.
+ * Provides a renderer-agnostic interface for binding, clearing, resizing,
+ * and reading back pixel data from an offscreen surface.
+ * Concrete implementations:
+ * - {@link WebGLRenderTarget} — WebGL framebuffer object (FBO) for post-processing
+ * - {@link CanvasRenderTarget} — 2D canvas surface for texture generation
+ *
+ * A future WebGPU implementation would extend this class with
+ * GPUTexture / GPURenderPassDescriptor management.
+ * @category Rendering
+ */
+export default abstract class RenderTarget {
+    /**
+     * The width of this render target in pixels.
+     */
+    width: number;
+    /**
+     * The height of this render target in pixels.
+     */
+    height: number;
+    /**
+     * Bind this render target as the active draw destination.
+     * All subsequent draw calls will render into this target until {@link unbind} is called.
+     * No-op by default — subclasses override for GPU render targets (e.g. WebGL FBOs).
+     */
+    bind(): void;
+    /**
+     * Unbind this render target, restoring the default (screen) output.
+     * No-op by default — subclasses override for GPU render targets.
+     */
+    unbind(): void;
+    /**
+     * Resize the render target's backing storage to the given dimensions.
+     * @param width - new width in pixels
+     * @param height - new height in pixels
+     */
+    abstract resize(width: number, height: number): void;
+    /**
+     * Clear the render target contents.
+     */
+    abstract clear(): void;
+    /**
+     * Release all resources held by this render target.
+     * The target must not be used after calling destroy.
+     */
+    abstract destroy(): void;
+    /**
+     * Read back pixel data from this render target.
+     * @param x - x coordinate of the top-left corner (default 0)
+     * @param y - y coordinate of the top-left corner (default 0)
+     * @param width - width of the area to read (default full width)
+     * @param height - height of the area to read (default full height)
+     * @returns an ImageData object containing the pixel data
+     */
+    abstract getImageData(x?: number, y?: number, width?: number, height?: number): ImageData;
+    /**
+     * Creates a Blob object representing the image contained in this render target.
+     * @param type - a string indicating the image format (default "image/png")
+     * @param quality - a number between 0 and 1 for lossy formats (e.g. image/jpeg)
+     * @returns a Promise resolving to a Blob
+     */
+    toBlob(type?: string, quality?: number): Promise<Blob>;
+    /**
+     * Creates an ImageBitmap object from the current contents of this render target.
+     * @returns a Promise resolving to an ImageBitmap
+     */
+    toImageBitmap(): Promise<ImageBitmap>;
+    /**
+     * Returns a data URL containing a representation of the current contents.
+     * @param type - a string indicating the image format (default "image/png")
+     * @param quality - a number between 0 and 1 for lossy formats (e.g. image/jpeg)
+     * @returns a Promise resolving to a data URL string
+     */
+    toDataURL(type?: string, quality?: number): Promise<string>;
+}
+//# sourceMappingURL=rendertarget.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/rendertarget.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,YAAY;IACzC;;OAEG;IACK,KAAK,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACK,MAAM,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,IAAI,IAAI,IAAI;IAEZ;;;OAGG;IACH,MAAM,IAAI,IAAI;IAEd;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAEpD;;OAEG;IACH,QAAQ,CAAC,KAAK,IAAI,IAAI;IAEtB;;;OAGG;IACH,QAAQ,CAAC,OAAO,IAAI,IAAI;IAExB;;;;;;;OAOG;IACH,QAAQ,CAAC,YAAY,CACpB,CAAC,CAAC,EAAE,MAAM,EACV,CAAC,CAAC,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACb,SAAS;IAEZ;;;;;OAKG;IACH,MAAM,CAAC,IAAI,SAAc,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAsC3D;;;OAGG;IACH,aAAa,IAAI,OAAO,CAAC,WAAW,CAAC;IAKrC;;;;;OAKG;IACH,SAAS,CAAC,IAAI,SAAc,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAiBhE"}

package/build/video/rendertarget/webglrendertarget.d.ts

@@ -0,0 +1,30 @@
+/**
+ * A WebGL Framebuffer Object (FBO) render target for offscreen rendering.
+ * Used by the post-processing pipeline to render a camera's output to a texture,
+ * which can then be drawn to the screen through a post-process shader.
+ * @augments RenderTarget
+ * @ignore
+ */
+export default class WebGLRenderTarget extends RenderTarget {
+    /**
+     * @param {WebGLRenderingContext|WebGL2RenderingContext} gl - the WebGL context
+     * @param {number} width - initial width in pixels
+     * @param {number} height - initial height in pixels
+     */
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, width: number, height: number);
+    gl: WebGLRenderingContext | WebGL2RenderingContext;
+    framebuffer: WebGLFramebuffer;
+    texture: WebGLTexture;
+    depthStencilBuffer: WebGLRenderbuffer;
+    /**
+     * (Re)attach the depth/stencil renderbuffer at the given size and
+     * update `_hasStencil` based on the resulting framebuffer status.
+     * Falls back to depth-only when packed depth+stencil fails; warns
+     * once if even depth-only is incomplete.
+     * @ignore
+     */
+    _applyDepthStencil(width: any, height: any): void;
+    _hasStencil: boolean | undefined;
+}
+import RenderTarget from "./rendertarget.ts";
+//# sourceMappingURL=webglrendertarget.d.ts.map

package/build/video/rendertarget/webglrendertarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webglrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webglrendertarget.js"],"names":[],"mappings":"AA8DA;;;;;;GAMG;AACH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,SAC5C,MAAM,UACN,MAAM,EAqDhB;IAjDA,mDAAY;IAKZ,8BAAyC;IAMzC,sBAAiC;IAoBjC,sCAAiD;IAoBlD;;;;;;OAMG;IACH,kDAkBC;IAVA,iCAAoC;CAmIrC;yBAlRwB,mBAAmB"}

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

@@ -103,10 +103,10 @@ export class Batcher {
     glVertexBuffer: WebGLBuffer | null | undefined;
     /**
      * the dynamic index buffer (only for indexed batchers)
-     * @type {IndexBuffer|null}
+     * @type {WebGLIndexBuffer|null}
      * @ignore
      */
-    indexBuffer: IndexBuffer | null | undefined;
+    indexBuffer: WebGLIndexBuffer | null | undefined;
     /**
      * Reset batcher internal state
      * @ignore
@@ -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
@@ -151,8 +157,8 @@ export class Batcher {
 }
 export default Batcher;
 import GLShader from "../glshader.js";
-import VertexArrayBuffer from "../buffer/vertex.js";
-import IndexBuffer from "../buffer/index.js";
+import VertexArrayBuffer from "../../buffer/vertex.js";
+import WebGLIndexBuffer from "../buffer/index.js";
 import type { Matrix3d } from "../../../math/matrix3d.ts";
 import type WebGLRenderer from "./../webgl_renderer.js";
 //# sourceMappingURL=batcher.d.ts.map

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,4CAAuB;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;8BADP,qBAAqB;wBAD3B,oBAAoB;8BAOjB,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,14 +27,39 @@ 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
      * shader is active, and disabled for custom ShaderEffect shaders.
      * @see GLShader
-     * @param {GLShader} shader - a reference to a GLShader instance
+     * @see ShaderEffect
+     * @param {GLShader|ShaderEffect} shader - a reference to a GLShader or ShaderEffect instance
+     */
+    useShader(shader: GLShader | ShaderEffect): void;
+    /**
+     * Draw a screen-aligned quad with the given raw WebGL texture through the given shader.
+     * Binds the texture to unit 0, pushes 4 vertices (Y-flipped UVs), flushes,
+     * then unbinds the texture.
+     * @param {WebGLTexture} source - the raw GL texture to blit
+     * @param {number} x - destination x
+     * @param {number} y - destination y
+     * @param {number} width - destination width
+     * @param {number} height - destination height
+     * @param {GLShader|ShaderEffect} shader - the shader effect to apply
      */
-    useShader(shader: GLShader): void;
+    blitTexture(source: WebGLTexture, x: number, y: number, width: number, height: number, shader: GLShader | ShaderEffect): void;
     /**
      * Add a textured quad
      * @param {TextureAtlas} texture - Source texture atlas
@@ -42,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;;;;;;OAMG;IACH,kBAFW,QAAQ,QAKlB;IAgED;;;;;;;;;;;;;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;gCAzO+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"}