melonjs 19.1.0 → 19.2.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/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
@@ -151,8 +151,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,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"}

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

@@ -27,9 +27,22 @@ export default class QuadBatcher extends MaterialBatcher {
      * 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): void;
+    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
+     */
+    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

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

package/build/video/webgl/buffer/index.d.ts

@@ -1,54 +1,25 @@
 /**
- * A WebGL Index Buffer object.
- * Can be used for static patterns (e.g. quad indices) or dynamic indexed drawing.
+ * A WebGL Index Buffer — extends {@link IndexBuffer} with GL buffer binding and upload.
  * @ignore
  */
-export default class IndexBuffer {
+export default class WebGLIndexBuffer extends IndexBuffer {
     /**
      * @param {WebGLRenderingContext|WebGL2RenderingContext} gl - the WebGL context
      * @param {number} maxIndices - maximum number of indices this buffer can hold
      * @param {boolean} [useUint32=false] - use Uint32 indices (WebGL2) instead of Uint16 (WebGL1)
-     * @param {boolean} [dynamic=false] - if true, use STREAM_DRAW for frequent updates; if false, use STATIC_DRAW
      */
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, maxIndices: number, useUint32?: boolean, dynamic?: boolean);
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, maxIndices: number, useUint32?: boolean);
     gl: WebGLRenderingContext | WebGL2RenderingContext;
-    dynamic: boolean;
     type: 5123 | 5125;
-    data: Uint16Array<ArrayBuffer> | Uint32Array<ArrayBuffer>;
-    /**
-     * the current number of indices in the buffer
-     * @type {number}
-     */
-    length: number;
     buffer: WebGLBuffer;
-    /**
-     * Fill the buffer with a repeating quad index pattern [0,1,2, 2,1,3, 4,5,6, ...]
-     * and upload as a static buffer.
-     * @param {number} maxQuads - number of quads to generate indices for
-     */
-    fillQuadPattern(maxQuads: number): void;
-    /**
-     * Reset the index count (for dynamic buffers)
-     */
-    clear(): void;
-    /**
-     * Add indices to the buffer, rebased by the given vertex offset
-     * @param {number[]} indices - source indices to add
-     * @param {number} vertexOffset - value to add to each index (vertex count at time of insertion)
-     */
-    add(indices: number[], vertexOffset: number): void;
-    /**
-     * Add pre-computed absolute indices to the buffer (no rebasing)
-     * @param {number[]} indices - absolute index values to add
-     */
-    addRaw(indices: number[]): void;
     /**
      * Upload the current index data to the GPU (for dynamic buffers)
      */
     upload(): void;
     /**
-     * bind this index buffer
+     * Bind this index buffer
      */
     bind(): void;
 }
+import IndexBuffer from "../../buffer/index.js";
 //# sourceMappingURL=index.d.ts.map

package/build/video/webgl/buffer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;IACC;;;;;OAKG;IACH,gBALW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,YACP,OAAO,EAqBjB;IAlBA,mDAAY;IACZ,iBAAsB;IAGrB,kBAA2B;IAC3B,0DAAuC;IAMxC;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf,oBAA+B;IAGhC;;;;OAIG;IACH,0BAFW,MAAM,QAkBhB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,aAHW,MAAM,EAAE,gBACR,MAAM,QAOhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAOlB;IAED;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;CACD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,EAOjB;IAHA,mDAAY;IACZ,kBAA2D;IAC3D,oBAA+B;IAiBhC;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;CACD;wBApDuB,uBAAuB"}

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

@@ -0,0 +1,92 @@
+/**
+ * A shader effect that applies a 4x4 color transformation matrix.
+ * Provides chainable color adjustment methods that automatically update the GPU uniform.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // desaturate a sprite
+ * mySprite.shader = new ColorMatrixEffect(renderer).saturate(0.0);
+ * @example
+ * // combine brightness + contrast on a camera
+ * camera.shader = new ColorMatrixEffect(renderer).brightness(1.3).contrast(1.5);
+ * @example
+ * // update dynamically
+ * effect.reset().brightness(1.5).saturate(0.5);
+ */
+export default class ColorMatrixEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {ColorMatrix} [options.matrix] - an initial color matrix. Defaults to identity.
+     */
+    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+        matrix?: ColorMatrix | undefined;
+    });
+    /**
+     * the internal color matrix
+     * @ignore
+     */
+    _matrix: ColorMatrix;
+    /**
+     * Push the current matrix values to the GPU.
+     * @ignore
+     */
+    _syncUniform(): void;
+    /**
+     * Reset the color matrix to identity (no color change).
+     * @returns {this} this instance for chaining
+     */
+    reset(): this;
+    /**
+     * Apply a brightness adjustment.
+     * @param {number} amount - brightness multiplier (1.0 = normal, >1 brighter, <1 darker)
+     * @returns {this} this instance for chaining
+     */
+    brightness(amount: number): this;
+    /**
+     * Apply a contrast adjustment.
+     * @param {number} amount - contrast multiplier (1.0 = normal, >1 more contrast, <1 less)
+     * @returns {this} this instance for chaining
+     */
+    contrast(amount: number): this;
+    /**
+     * Apply a saturation adjustment.
+     * @param {number} amount - saturation level (0.0 = grayscale, 1.0 = normal, >1 over-saturated)
+     * @returns {this} this instance for chaining
+     */
+    saturate(amount: number): this;
+    /**
+     * Apply a hue rotation.
+     * @param {number} angle - rotation angle in radians
+     * @returns {this} this instance for chaining
+     */
+    hueRotate(angle: number): this;
+    /**
+     * Apply a sepia tone.
+     * @param {number} [amount=1.0] - sepia intensity (0.0 = original, 1.0 = full sepia)
+     * @returns {this} this instance for chaining
+     */
+    sepia(amount?: number): this;
+    /**
+     * Apply a color inversion.
+     * @param {number} [amount=1.0] - inversion amount (0.0 = original, 1.0 = fully inverted)
+     * @returns {this} this instance for chaining
+     */
+    invertColors(amount?: number): this;
+    /**
+     * Multiply the current matrix by another color matrix.
+     * @param {ColorMatrix} matrix - the matrix to multiply with
+     * @returns {this} this instance for chaining
+     */
+    multiply(matrix: ColorMatrix): this;
+    /**
+     * Multiplies the current matrix with a transform described by individual values.
+     * Accepts either 6 values (2D affine: a, b, c, d, e, f) or 16 values (full 4x4 column-major).
+     * @param {...number} args - 6 or 16 numeric values
+     * @returns {this} this instance for chaining
+     */
+    transform(...args: number[]): this;
+}
+import ShaderEffect from "../shadereffect.js";
+import { ColorMatrix } from "../../../math/color_matrix.ts";
+//# sourceMappingURL=colorMatrix.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/colorMatrix.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA8B,MAAM;KACtC,EAkBA;IANA;;;OAGG;IACH,qBAAkD;IAInD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,WAAW,GACT,IAAI,CAMhB;IAED;;;;;OAKG;IACH,mBAHc,MAAM,EAAA,GACP,IAAI,CAMhB;CACD;yBApJwB,oBAAoB;4BADjB,+BAA+B"}

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

@@ -1,7 +1,5 @@
 /**
  * A shader effect that desaturates (grayscales) the sprite.
- * The `intensity` uniform controls how much color is removed
- * (0.0 = full color, 1.0 = fully grayscale).
  * Commonly used for disabled states, death effects, or petrification.
  * @category Effects
  * @see {@link Renderable.shader} for usage
@@ -12,7 +10,7 @@
  * // partial desaturation (50%)
  * mySprite.shader = new DesaturateEffect(renderer, { intensity: 0.5 });
  */
-export default class DesaturateEffect extends ShaderEffect {
+export default class DesaturateEffect extends ColorMatrixEffect {
     /**
      * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
      * @param {object} [options] - effect options
@@ -28,5 +26,5 @@ export default class DesaturateEffect extends ShaderEffect {
      */
     setIntensity(value: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ColorMatrixEffect from "./colorMatrix.js";
 //# sourceMappingURL=desaturate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAgBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA/CwB,oBAAoB"}
+{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAnC6B,kBAAkB"}

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

@@ -9,7 +9,7 @@
  * // partial inversion
  * mySprite.shader = new InvertEffect(renderer, { intensity: 0.5 });
  */
-export default class InvertEffect extends ShaderEffect {
+export default class InvertEffect extends ColorMatrixEffect {
     /**
      * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
      * @param {object} [options] - effect options
@@ -25,5 +25,5 @@ export default class InvertEffect extends ShaderEffect {
      */
     setIntensity(value: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ColorMatrixEffect from "./colorMatrix.js";
 //# sourceMappingURL=invert.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAgBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA5CwB,oBAAoB"}
+{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAlC6B,kBAAkB"}

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

@@ -8,7 +8,7 @@
  * // partial sepia
  * mySprite.shader = new SepiaEffect(renderer, { intensity: 0.5 });
  */
-export default class SepiaEffect extends ShaderEffect {
+export default class SepiaEffect extends ColorMatrixEffect {
     /**
      * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
      * @param {object} [options] - effect options
@@ -24,5 +24,5 @@ export default class SepiaEffect extends ShaderEffect {
      */
     setIntensity(value: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ColorMatrixEffect from "./colorMatrix.js";
 //# sourceMappingURL=sepia.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAmBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA9CwB,oBAAoB"}
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAjC6B,kBAAkB"}