melonjs 18.0.0 → 18.2.0

package/build/video/webgl/{compositors/primitive_compositor.d.ts → batchers/primitive_batcher.d.ts}

@@ -5,13 +5,19 @@
 /**
  * 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
+ * @category Rendering
  */
-export default class PrimitiveCompositor extends Compositor {
+export default class PrimitiveBatcher extends Batcher {
     /**
      * Initialize the compositor
      * @ignore
      */
     init(renderer: any): void;
+    /**
+     * the current line width applied to the shader uniform
+     * @ignore
+     */
+    currentLineWidth: any;
     /**
      * Draw an array of vertices
      * @param {GLenum} mode - primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
@@ -19,7 +25,8 @@ export default class PrimitiveCompositor extends Compositor {
      * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
      */
     drawVertices(mode: GLenum, verts: Point[], vertexCount?: number): void;
+    #private;
 }
-import Compositor from "./compositor.js";
+import { Batcher } from "./batcher.js";
 import type { Point } from "./../../../geometries/point.ts";
-//# sourceMappingURL=primitive_compositor.d.ts.map
+//# sourceMappingURL=primitive_batcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"primitive_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/primitive_batcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAoCC;IALA;;;OAGG;IACH,sBAAyB;IA0B1B;;;;;OAKG;IACH,mBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QA2DhB;;CA0ED;wBAvNuB,cAAc;2BAId,gCAAgC"}

package/build/video/webgl/{compositors/quad_compositor.d.ts → batchers/quad_batcher.d.ts}

@@ -1,8 +1,9 @@
 /**
  * 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
+ * @category Rendering
  */
-export default class QuadCompositor extends Compositor {
+export default class QuadBatcher extends Batcher {
     /**
      * Initialize the compositor
      * @ignore
@@ -25,9 +26,9 @@ export default class QuadCompositor extends Compositor {
     createTexture2D(unit: number, pixels?: (new (width?: number, height?: number) => HTMLImageElement) | HTMLCanvasElement | ImageData | Uint8Array[] | Float32Array[], filter: number, repeat?: string, w?: number, h?: number, premultipliedAlpha?: boolean, mipmap?: boolean, texture: any): WebGLTexture;
     /**
      * delete the given WebGL texture
-     * @param {WebGLTexture} [texture] - a WebGL texture to delete
+     * @param {WebGLTexture|TextureAtlas} texture - a WebGL texture or TextureAtlas to delete
      */
-    deleteTexture2D(texture?: WebGLTexture): void;
+    deleteTexture2D(texture: WebGLTexture | TextureAtlas): void;
     /**
      * returns the WebGL texture associated to the given texture unit
      * @param {number} unit - Texture unit to which a texture is bound
@@ -67,6 +68,6 @@ export default class QuadCompositor extends Compositor {
      */
     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 Compositor from "./compositor.js";
+import { Batcher } from "./batcher.js";
 import type { TextureAtlas } from "./../../texture/atlas.js";
-//# sourceMappingURL=quad_compositor.d.ts.map
+//# sourceMappingURL=quad_batcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BA8CC;IAdA,wBAA4B;IAC5B,iCAAuB;IAoFxB;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,iBACL,YAAY,CAyGxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAkBnC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAalB;IAED;;OAEG;IACH,kEAqBC;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,QAuCjB;CACD;wBA3ZuB,cAAc;kCAIP,0BAA0B"}

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

@@ -0,0 +1,49 @@
+/**
+ * A WebGL Index Buffer object.
+ * Can be used for static patterns (e.g. quad indices) or dynamic indexed drawing.
+ * @ignore
+ */
+export default class 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);
+    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;
+    /**
+     * Upload the current index data to the GPU (for dynamic buffers)
+     */
+    upload(): void;
+    /**
+     * bind this index buffer
+     */
+    bind(): void;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;CACD"}

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

@@ -1,12 +1,12 @@
 /**
- * a Vertex Buffer object
+ * a fixed-size Vertex Buffer object.
+ * Compositors must check isFull() and flush before the buffer overflows.
  * @ignore
  */
 export default class VertexArrayBuffer {
-    constructor(vertex_size: any, vertex_per_obj: any);
+    constructor(vertexSize: any, maxVertex: any);
     vertexSize: any;
-    objSize: any;
-    maxVertex: number;
+    maxVertex: any;
     vertexCount: number;
     buffer: ArrayBuffer;
     bufferF32: Float32Array<ArrayBuffer>;
@@ -20,17 +20,20 @@ export default class VertexArrayBuffer {
      * return true if full
      * @ignore
      */
-    isFull(vertex?: any): boolean;
+    isFull(vertex: any): boolean;
     /**
-     * resize the vertex buffer, retaining its original contents
+     * push a new vertex to the buffer (quad format: x, y, u, v, tint)
      * @ignore
      */
-    resize(vertexCount: any): this;
+    push(x: any, y: any, u: any, v: any, tint: any): this;
     /**
-     * push a new vertex to the buffer
+     * push a new vertex with all-float data to the buffer
+     * @param {ArrayLike<number>} data - float values for one vertex
+     * @param {number} srcOffset - start index in the source data
+     * @param {number} count - number of floats to copy (should equal vertexSize)
      * @ignore
      */
-    push(x: any, y: any, u: any, v: any, tint: any): this;
+    pushFloats(data: ArrayLike<number>, srcOffset: number, count: number): this;
     /**
      * return a reference to the data in Float32 format
      * @ignore
@@ -41,15 +44,5 @@ export default class VertexArrayBuffer {
      * @ignore
      */
     toUint32(begin: any, end: any): Uint32Array<ArrayBuffer>;
-    /**
-     * return the size of the vertex in vertex
-     * @ignore
-     */
-    length(): number;
-    /**
-     * return true if empty
-     * @ignore
-     */
-    isEmpty(): boolean;
 }
 //# sourceMappingURL=vertex.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;IACC,mDAiBC;IAfA,gBAA6B;IAE7B,aAA6B;IAE7B,kBAAoB;IAEpB,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAG9C;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,+BAoBC;IAED;;;OAGG;IACH,sDAsBC;IAED;;;OAGG;IACH,2DAMC;IAED;;;OAGG;IACH,yDAMC;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,mBAEC;CACD"}
+{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;IACC,6CAeC;IAbA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAG9C;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,sDAYC;IAED;;;;;;OAMG;IACH,iBALW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAahB;IAED;;;OAGG;IACH,2DAMC;IAED;;;OAGG;IACH,yDAMC;CACD"}

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

@@ -1,5 +1,6 @@
 /**
  * a base GL Shader object
+ * @category Rendering
  */
 export default class GLShader {
     /**
@@ -82,9 +83,9 @@ export default class GLShader {
      * activate the given vertex attribute for this shader
      * @param {WebGLRenderingContext} gl - the current WebGL rendering context
      * @param {object[]} attributes - an array of vertex attributes
-     * @param {number} vertexByteSize - the size of a single vertex in bytes
+     * @param {number} stride - the size of a single vertex in bytes
      */
-    setVertexAttributes(gl: WebGLRenderingContext, attributes: object[], vertexByteSize: number): void;
+    setVertexAttributes(gl: WebGLRenderingContext, attributes: object[], stride: number): void;
     /**
      * destroy this shader objects resources (program, attributes, uniforms)
      */

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;;GAEG;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,QAe7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,kBACR,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,QAsBhB;IAED;;OAEG;IACH,gBAQC;CACD"}

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

@@ -0,0 +1,72 @@
+/**
+ * A simplified shader class for applying custom fragment effects to renderables.
+ * Only requires a fragment `apply()` function — the vertex shader, uniforms, and
+ * texture sampling boilerplate are handled automatically.
+ * In Canvas mode, the shader is silently disabled (all methods become no-ops).
+ * @category Rendering
+ * @example
+ * // create a grayscale effect
+ * mySprite.shader = new ShaderEffect(renderer, `
+ *     vec4 apply(vec4 color, vec2 uv) {
+ *         float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));
+ *         return vec4(vec3(gray), color.a);
+ *     }
+ * `);
+ * @example
+ * // create an effect with a custom uniform
+ * const pulse = new ShaderEffect(renderer, `
+ *     uniform float uTime;
+ *     vec4 apply(vec4 color, vec2 uv) {
+ *         float brightness = 0.8 + 0.2 * sin(uTime * 3.0);
+ *         return vec4(color.rgb * brightness, color.a);
+ *     }
+ * `);
+ * mySprite.shader = pulse;
+ * // update the uniform each frame
+ * pulse.setUniform("uTime", time);
+ */
+export default class ShaderEffect {
+    /**
+     * @param {WebGLRenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {string} fragmentBody - GLSL code containing a `vec4 apply(vec4 color, vec2 uv)` function
+     *   that receives the sampled pixel color and UV coordinates, and returns the modified color.
+     *   You can declare additional `uniform` variables before the `apply()` function.
+     * @param {string} [precision=auto detected] - float precision ('lowp', 'mediump' or 'highp')
+     */
+    constructor(renderer: WebGLRenderer | CanvasRenderer, fragmentBody: string, precision?: string);
+    /**
+     * whether this effect is active (false in Canvas mode)
+     * @type {boolean}
+     */
+    enabled: boolean;
+    /** @ignore */
+    _shader: GLShader | undefined;
+    /**
+     * Set the uniform to the given value
+     * @param {string} name - the uniform name
+     * @param {object|Float32Array} value - the value to assign to that uniform
+     */
+    setUniform(name: string, value: object | Float32Array): void;
+    /** @ignore */
+    bind(): void;
+    /** @ignore */
+    getAttribLocation(name: any): number;
+    /** @ignore */
+    setVertexAttributes(gl: any, attributes: any, stride: any): void;
+    /** @ignore */
+    get program(): WebGLProgram | null;
+    /** @ignore */
+    get vertex(): string | null;
+    /** @ignore */
+    get fragment(): string | null;
+    /** @ignore */
+    get attributes(): {};
+    /** @ignore */
+    get uniforms(): object;
+    /**
+     * destroy this shader effect
+     */
+    destroy(): void;
+}
+import GLShader from "./glshader.js";
+//# sourceMappingURL=shadereffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/shadereffect.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAOC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,gBAC5B,MAAM,cAGN,MAAM,EAiChB;IA5CD;;;OAGG;IACH,SAFU,OAAO,CAED;IAqCf,cAAc;IACd,8BAAyE;IAI1E;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAM7B;IAED,cAAc;IACd,aAIC;IAED,cAAc;IACd,qCAEC;IAED,cAAc;IACd,iEAIC;IAED,cAAc;IACd,mCAEC;IAED,cAAc;IACd,4BAEC;IAED,cAAc;IACd,8BAEC;IAED,cAAc;IACd,qBAEC;IAED,cAAc;IACd,uBAEC;IAED;;OAEG;IACH,gBAKC;CACD;qBA7IoB,eAAe"}

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

@@ -1,5 +1,6 @@
 /**
  * a WebGL renderer object
+ * @category Rendering
  */
 export default class WebGLRenderer extends Renderer {
     /**
@@ -9,13 +10,6 @@ export default class WebGLRenderer extends Renderer {
      * @readonly
      */
     readonly GPUVendor: string;
-    /**
-     * The renderer string of the underlying graphics driver.
-     * @type {string}
-     * @default undefined
-     * @readonly
-     */
-    readonly GPURenderer: string;
     /**
      * The WebGL context
      * @name gl
@@ -23,12 +17,9 @@ export default class WebGLRenderer extends Renderer {
      */
     gl: WebGLRenderingContext;
     /**
-     * sets or returns the thickness of lines for shape drawing (limited to strokeLine, strokePolygon and strokeRect)
+     * sets or returns the thickness of lines for shape drawing
      * @type {number}
      * @default 1
-     * @see WebGLRenderer#strokeLine
-     * @see WebGLRenderer#strokePolygon
-     * @see WebGLRenderer#strokeRect
      */
     lineWidth: number;
     /**
@@ -50,41 +41,35 @@ export default class WebGLRenderer extends Renderer {
      */
     readonly maxTextures: number;
     /**
+     * reusable scratch array for fillRect (2 triangles = 6 vertices)
      * @ignore
      */
-    _colorStack: any[];
-    /**
-     * @ignore
-     */
-    _matrixStack: any[];
-    /**
-     * @ignore
-     */
-    _scissorStack: any[];
-    /**
-     * @ignore
-     */
-    _blendStack: any[];
+    _rectTriangles: {
+        x: number;
+        y: number;
+    }[];
+    _polyVerts: any[];
     /**
      * The current transformation matrix used for transformations on the overall scene
+     * (alias to renderState.currentTransform for backward compatibility)
      * @type {Matrix2d}
      */
     currentTransform: Matrix2d;
     /**
-     * The current compositor used by the renderer
-     * @type {Compositor}
+     * The current batcher used by the renderer
+     * @type {Batcher}
      */
-    currentCompositor: Compositor;
+    currentBatcher: Batcher;
     /**
      * a reference to the current shader program used by the renderer
      * @type {WebGLProgram}
      */
     currentProgram: WebGLProgram;
     /**
-     * The list of active compositors
-     * @type {Map<Compositor>}
+     * The list of active batchers
+     * @type {Map<Batcher>}
      */
-    compositors: Map<Compositor, any>;
+    batchers: Map<Batcher, any>;
     depthTest: any;
     customShader: any;
     cache: TextureCache;
@@ -95,30 +80,19 @@ export default class WebGLRenderer extends Renderer {
      */
     get WebGLVersion(): number;
     /**
-     * return the list of supported compressed texture formats
-     * @return {Object}
-     */
-    getSupportedCompressedTextureFormats(): Object;
-    /**
-     * return true if the given compressed texture format is supported
-     * @param {Number} format
-     * @returns
-     */
-    hasSupportedCompressedFormats(format: number): boolean;
-    /**
-     * add a new compositor to this renderer
-     * @param {Compositor} compositor - a compositor instance
-     * @param {string} name - a name uniquely identifying this compositor
-     * @param {boolean} [activate=false] - true if the given compositor should be set as the active one
+     * add a new batcher to this renderer
+     * @param {Batcher} batcher - a batcher instance
+     * @param {string} name - a name uniquely identifying this batcher
+     * @param {boolean} [activate=false] - true if the given batcher should be set as the active one
      */
-    addCompositor(compositor: Compositor, name?: string, activate?: boolean): void;
+    addBatcher(batcher: Batcher, name?: string, activate?: boolean): void;
     /**
-     * set the active compositor for this renderer
-     * @param {string} name - a compositor name
-     * @param {GLShader} [shader] - an optional shader program to be used, instead of the default one, when activating the compositor
-     * @returns {Compositor} an instance to the current active compositor
+     * set the active batcher for this renderer
+     * @param {string} name - a batcher name
+     * @param {GLShader} [shader] - an optional shader program to be used, instead of the default one, when activating the batcher
+     * @returns {Batcher} an instance to the current active batcher
      */
-    setCompositor(name?: string, shader?: GLShader): Compositor;
+    setBatcher(name?: string, shader?: GLShader): Batcher;
     /**
      * Reset the gl transform to identity
      */
@@ -160,7 +134,7 @@ export default class WebGLRenderer extends Renderer {
     clearRect(x: number, y: number, width: number, height: number): void;
     /**
      * Draw an image to the gl context
-     * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame} image - An element to draw into the context.
+     * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame|CompressedImage} image - An element to draw into the context.
      * @param {number} sx - The X coordinate of the top left corner of the sub-rectangle of the source image to draw into the destination context.
      * @param {number} sy - The Y coordinate of the top left corner of the sub-rectangle of the source image to draw into the destination context.
      * @param {number} sw - The width of the sub-rectangle of the source image to draw into the destination context. If not specified, the entire rectangle from the coordinates specified by sx and sy to the bottom-right corner of the image is used.
@@ -177,7 +151,7 @@ export default class WebGLRenderer extends Renderer {
      * // Clip the image and position the clipped part on the canvas:
      * renderer.drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);
      */
-    drawImage(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
+    drawImage(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame | CompressedImage, sx: number, sy: number, sw: number, sh: number, dx: number, dy: number, dw: number, dh: number): void;
     /**
      * Draw a pattern within the given rectangle.
      * @param {TextureAtlas} pattern - Pattern object
@@ -254,21 +228,30 @@ export default class WebGLRenderer extends Renderer {
      */
     getContext(): WebGLRenderingContext;
     /**
-     * set a blend mode for the given context. <br>
-     * Supported blend mode between Canvas and WebGL remderer : <br>
-     * - "normal" : this is the default mode and draws new content on top of the existing content <br>
-     * <img src="../images/normal-blendmode.png" width="510"/> <br>
-     * - "multiply" : the pixels of the top layer are multiplied with the corresponding pixel of the bottom layer. A darker picture is the result. <br>
-     * <img src="../images/multiply-blendmode.png" width="510"/> <br>
-     * - "additive or lighter" : where both content overlap the color is determined by adding color values. <br>
-     * <img src="../images/lighter-blendmode.png" width="510"/> <br>
-     * - "screen" : The pixels are inverted, multiplied, and inverted again. A lighter picture is the result (opposite of multiply) <br>
-     * <img src="../images/screen-blendmode.png" width="510"/> <br>
+     * set the current blend mode for this renderer. <br>
+     * All renderers support: <br>
+     * - "normal" : draws new content on top of the existing content <br>
+     * <img src="../images/normal-blendmode.png" width="180"/> <br>
+     * - "add", "additive", or "lighter" : color values are added together <br>
+     * <img src="../images/add-blendmode.png" width="180"/> <br>
+     * - "multiply" : pixels are multiplied, resulting in a darker picture <br>
+     * <img src="../images/multiply-blendmode.png" width="180"/> <br>
+     * - "screen" : pixels are inverted, multiplied, and inverted again (opposite of multiply) <br>
+     * <img src="../images/screen-blendmode.png" width="180"/> <br>
+     * WebGL2 additionally supports: <br>
+     * - "darken" : retains the darkest pixels of both layers <br>
+     * <img src="../images/darken-blendmode.png" width="180"/> <br>
+     * - "lighten" : retains the lightest pixels of both layers <br>
+     * <img src="../images/lighten-blendmode.png" width="180"/> <br>
+     * Other CSS blend modes ("overlay", "color-dodge", "color-burn", "hard-light", "soft-light",
+     * "difference", "exclusion") may be supported by the Canvas renderer (browser-dependent)
+     * and will always fall back to "normal" in WebGL. <br>
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
-     * @param {string} [mode="normal"] - blend mode : "normal", "multiply", "lighter", "additive", "screen"
-     * @param {WebGLRenderingContext} [gl] - a WebGL context
+     * @param {string} [mode="normal"] - blend mode
+     * @param {boolean} [premultipliedAlpha=true] - whether textures use premultiplied alpha (affects source blend factor)
+     * @returns {string} the blend mode actually applied (may differ if the requested mode is unsupported)
      */
-    setBlendMode(mode?: string, gl?: WebGLRenderingContext): void;
+    setBlendMode(mode?: string, premultipliedAlpha?: boolean): string;
     /**
      * restores the most recently saved renderer state by popping the top entry in the drawing state stack
      * @example
@@ -440,7 +423,7 @@ export default class WebGLRenderer extends Renderer {
      */
     strokePoint(x: number, y: number): void;
     /**
-     * Draw a a point at the specified coordinates
+     * Draw a point at the specified coordinates
      * @param {number} x - x axis of the coordinate for the point.
      * @param {number} y - y axis of the coordinate for the point.
      */
@@ -494,10 +477,11 @@ export default class WebGLRenderer extends Renderer {
      * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
     setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean): void;
+    #private;
 }
 import Renderer from "./../renderer.js";
-import { Matrix2d } from "../../math/matrix2d.ts";
-import type Compositor from "./compositors/compositor.js";
+import type { Matrix2d } from "../../math/matrix2d.ts";
+import type { Batcher } from "./batchers/batcher.js";
 import TextureCache from "./../texture/cache.js";
 import { TextureAtlas } from "./../texture/atlas.js";
 import { Color } from "./../../math/color.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,9 +1,12 @@
 {
 	"name": "melonjs",
-	"version": "18.0.0",
+	"version": "18.2.0",
 	"description": "melonJS Game Engine",
 	"homepage": "http://www.melonjs.org/",
 	"type": "module",
+	"sideEffects": [
+		"./src/polyfill/**"
+	],
 	"keywords": [
 		"2D",
 		"HTML5",
@@ -35,11 +38,15 @@
 	"author": "Olivier Biot (AltByte Pte Ltd)",
 	"funding": "https://github.com/sponsors/melonjs",
 	"engines": {
-		"node": ">= 20"
+		"node": "^20.19.0 || >=22.12.0"
 	},
 	"types": "./build/index.d.ts",
+	"module": "./build/index.js",
 	"exports": {
-		".": "./build/index.js"
+		".": {
+			"types": "./build/index.d.ts",
+			"import": "./build/index.js"
+		}
 	},
 	"files": [
 		"build",
@@ -53,7 +60,7 @@
 	},
 	"devDependencies": {
 		"@types/howler": "^2.2.12",
-		"@types/node": "^25.4.0",
+		"@types/node": "^25.5.0",
 		"concurrently": "^9.2.1",
 		"del-cli": "^7.0.0",
 		"esbuild": "^0.27.3",
@@ -62,24 +69,23 @@
 		"tsx": "^4.21.0",
 		"type-fest": "^5.4.3",
 		"typedoc": "^0.28.16",
-		"typedoc-plugin-missing-exports": "^4.1.2",
 		"typescript": "^5.9.3",
-		"vite": "~7.3.1",
-		"vite-plugin-glsl": "workspace:^"
+		"vite": "^8.0.0",
+		"vite-plugin-glsl": "^1.5.6"
 	},
 	"scripts": {
 		"dev": "concurrently --raw \"pnpm build:watch\" \"pnpm tsc:watch\" \"pnpm doc:watch\"",
 		"tsc:watch": "tsc --project tsconfig.build.json --watch --noUnusedParameters false --noUnusedLocals false --preserveWatchOutput",
 		"build:watch": "tsx scripts/build.js watch",
-		"build": "tsx scripts/build.js && pnpm types",
-		"dist": "pnpm clean && pnpm vitest run && pnpm build && pnpm doc",
-		"doc": "typedoc src/index.js --plugin typedoc-plugin-missing-exports --tsconfig tsconfig.build.json",
-		"doc:watch": "typedoc src/index.js --plugin typedoc-plugin-missing-exports --watch --skipErrorChecking --preserveWatchOutput --logLevel Error",
+		"lint": "eslint src tests",
+		"build": "pnpm lint && tsx scripts/build.js && pnpm types",
+		"dist": "pnpm clean && pnpm lint && pnpm vitest run && pnpm build && pnpm doc",
+		"doc": "typedoc src/index.js --tsconfig tsconfig.build.json --readme DOC_README.md --hideGenerator --name 'melonJS' --navigation.includeCategories true --categorizeByGroup false",
+		"doc:watch": "typedoc src/index.js --tsconfig tsconfig.build.json --readme DOC_README.md --hideGenerator --name 'melonJS' --navigation.includeCategories true --categorizeByGroup false --watch --skipErrorChecking --preserveWatchOutput --logLevel Error",
 		"serve": "serve docs",
 		"prepublishOnly": "pnpm dist",
 		"clean": "tsx scripts/clean.js",
 		"types": "tsc --project tsconfig.build.json",
 		"test:types": "tsc"
-	},
-	"packageManager": "pnpm@9.5.0"
+	}
 }

package/build/video/webgl/compositors/compositor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"compositor.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/compositors/compositor.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;GAEG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,sBAZW,aAAa,YAErB;QAA2B,SAAS,EACpC;YAAmC,IAAI,EAA/B,MAAM;YACqB,IAAI,EAA/B,MAAM;YACqB,IAAI,EAA/B,MAAM;YACsB,UAAU,EAAtC,OAAO;YACoB,MAAM,EAAjC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SAChB;KAAA,EAGA;IAED;;;OAGG;IACH,yCA0FC;IAxFA,cAAwB;IAGxB,QAAqB;IAGrB,WAAkC;IAGlC,gBAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAE9B;;;;OAIG;IACH,yBAA6B;IAE7B;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,mCAAuB;IAEvB;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IAiCvB;;;OAGG;IACH,cAMC;IAED;;OAEG;IACH,aAIC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAYlB;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,QACN,MAAM,QACN,MAAM,cACN,OAAO,UACP,MAAM,QAqChB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAgChB;CACD;qBA3PoB,gBAAgB;8BADP,qBAAqB;8BAMxB,2BAA2B;+BADxB,wBAAwB"}

package/build/video/webgl/compositors/primitive_compositor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"primitive_compositor.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/compositors/primitive_compositor.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;GAGG;AACH;IACC;;;OAGG;IACH,0BAuBC;IAED;;;;;OAKG;IACH,mBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QAkChB;CACD;uBAhFsB,iBAAiB;2BAIhB,gCAAgC"}

package/build/video/webgl/compositors/quad_compositor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quad_compositor.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/compositors/quad_compositor.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH;IACC;;;OAGG;IACH,0BAkCC;IAFA,wBAA4B;IAC5B,iCAAuB;IAoBxB;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,iBACL,YAAY,CAsFxB;IAED;;;OAGG;IACH,0BAFW,YAAY,QAKtB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAalB;IAED;;OAEG;IACH,kEAqBC;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,QAoCjB;CACD;uBAvTsB,iBAAiB;kCAIT,0BAA0B"}