melonjs 14.5.0 → 15.1.0

package/dist/types/video/renderer.d.ts

@@ -13,6 +13,7 @@ export default class Renderer {
      * @param {boolean} [options.transparent=false] - Whether to enable transparency on the canvas
      * @param {boolean} [options.premultipliedAlpha=true] - in WebGL, whether the renderer will assume that colors have premultiplied alpha when canvas transparency is enabled
      * @param {boolean} [options.blendMode="normal"] - the default blend mode to use ("normal", "multiply")
+     * @param {boolean} [options.depthBuffer="sorting"] - ~Experimental~ the default method to sort object on the z axis in WebGL ("sorting", "z-buffer")
      * @param {boolean} [options.subPixel=false] - Whether to enable subpixel rendering (performance hit when enabled)
      * @param {boolean} [options.verbose=false] - Enable the verbose mode that provides additional details as to what the renderer is doing
      * @param {number} [options.zoomX=width] - The actual width of the canvas with scaling applied
@@ -27,6 +28,7 @@ export default class Renderer {
         transparent?: boolean | undefined;
         premultipliedAlpha?: boolean | undefined;
         blendMode?: boolean | undefined;
+        depthBuffer?: boolean | undefined;
         subPixel?: boolean | undefined;
         verbose?: boolean | undefined;
         zoomX?: number | undefined;
@@ -56,6 +58,12 @@ export default class Renderer {
      * @type {boolean}
      */
     isContextValid: boolean;
+    /**
+     * the default method to sort object ("sorting", "z-buffer")
+     * @type {string}
+     * @default "sorting"
+     */
+    depthTest: string;
     /**
      * The Path2D instance used by the renderer to draw primitives
      * @type {Path2D}
@@ -188,7 +196,7 @@ export default class Renderer {
      * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
      * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
-    setMask(mask?: Polygon | Rect | Ellipse | RoundRect | Line | undefined): void;
+    setMask(mask?: Polygon | Line | Ellipse | Rect | RoundRect | undefined): void;
     /**
      * disable (remove) the rendering mask set through setMask.
      * @see Renderer#setMask
@@ -206,9 +214,45 @@ export default class Renderer {
      */
     clearTint(): void;
     /**
-     * @ignore
-     */
-    drawFont(): void;
+     * creates a Blob object representing the last rendered frame
+     * @param {Object} [options] - An object with the following properties:
+     * @param {String} [options.type="image/png"] - A string indicating the image format
+     * @param {Number} [options.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.
+     * @return {Promise} A Promise returning a Blob object representing the last rendered frame
+     * @example
+     * renderer.convertToBlob().then((blob) => console.log(blob));
+     */
+    toBlob(options?: {
+        type?: string | undefined;
+        quality?: number | undefined;
+    } | undefined): Promise<any>;
+    /**
+     * creates an ImageBitmap object of the last frame rendered
+     * (not supported by standard Canvas)
+     * @param {Object} [options] - An object with the following properties:
+     * @param {String} [options.type="image/png"] - A string indicating the image format
+     * @param {Number} [options.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.
+     * @return {Promise} A Promise returning an ImageBitmap.
+     * @example
+     * renderer.transferToImageBitmap().then((image) => console.log(image));
+     */
+    toImageBitmap(options?: {
+        type?: string | undefined;
+        quality?: number | undefined;
+    } | undefined): Promise<any>;
+    /**
+     * returns a data URL containing a representation of the last frame rendered
+     * @param {Object} [options] - An object with the following properties:
+     * @param {String} [options.type="image/png"] - A string indicating the image format
+     * @param {Number} [options.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.
+     * @return {Promise} A Promise returning a string containing the requested data URL.
+     * @example
+     * renderer.toDataURL().then((dataURL) => console.log(dataURL));
+     */
+    toDataURL(options?: {
+        type?: string | undefined;
+        quality?: number | undefined;
+    } | undefined): Promise<any>;
 }
 import Vector2d from "../math/vector2.js";
 import Path2D from "./../geometries/path2d.js";

package/dist/types/video/texture/atlas.d.ts

@@ -152,13 +152,13 @@ export class TextureAtlas {
      * ...
      * ...
      * // create a new "coin" sprite
-     * var sprite = game.texture.createSpriteFromName("coin.png");
+     * let sprite = game.texture.createSpriteFromName("coin.png");
      * // set the renderable position to bottom center
      * sprite.anchorPoint.set(0.5, 1.0);
      * ...
      * ...
      * // create a 9-slice sprite
-     * var dialogPanel = game.texture.createSpriteFromName(
+     * let dialogPanel = game.texture.createSpriteFromName(
      *    "rpg_dialo.png",
      *    // width & height are mandatory for 9-slice sprites
      *    { width: this.width, height: this.height },
@@ -180,7 +180,7 @@ export class TextureAtlas {
      * );
      *
      * // create a new Animated Sprite
-     * var sprite = game.texture.createAnimationFromName([
+     * let sprite = game.texture.createAnimationFromName([
      *     "walk0001.png", "walk0002.png", "walk0003.png",
      *     "walk0004.png", "walk0005.png", "walk0006.png",
      *     "walk0007.png", "walk0008.png", "walk0009.png",

package/dist/types/video/texture/canvas_texture.d.ts

@@ -57,6 +57,46 @@ declare class CanvasTexture {
      * @return {ImageData} The ImageData extracted from this CanvasTexture.
      */
     getImageData(x: number, y: number, width: number, height: number): ImageData;
+    /**
+     * creates a Blob object representing the image contained in this canvas texture
+     * @param {Object} [options] - An object with the following properties:
+     * @param {String} [options.type="image/png"] - A string indicating the image format
+     * @param {Number} [options.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.
+     * @return {Promise} A Promise returning a Blob object representing the image contained in this canvas texture
+     * @example
+     * canvasTexture.convertToBlob().then((blob) => console.log(blob));
+     */
+    toBlob(options?: {
+        type?: string | undefined;
+        quality?: number | undefined;
+    } | undefined): Promise<any>;
+    /**
+     * creates an ImageBitmap object from the most recently rendered image of this canvas texture
+     * @param {Object} [options] - An object with the following properties:
+     * @param {String} [options.type="image/png"] - A string indicating the image format
+     * @param {Number} [options.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.
+     * @return {Promise} A Promise returning an ImageBitmap.
+     * @example
+     * canvasTexture.transferToImageBitmap().then((bitmap) => console.log(bitmap));
+     */
+    toImageBitmap(options?: {
+        type?: string | undefined;
+        quality?: number | undefined;
+    } | undefined): Promise<any>;
+    /**
+     * returns a data URL containing a representation of the most recently rendered image of this canvas texture
+     * (not supported by OffscreenCanvas)
+     * @param {Object} [options] - An object with the following properties:
+     * @param {String} [options.type="image/png"] - A string indicating the image format
+     * @param {Number} [options.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.
+     * @return {Promise} A Promise returning a string containing the requested data URL.
+     * @example
+     * renderer.toDataURL().then((dataURL) => console.log(dataURL));
+     */
+    toDataURL(options?: {
+        type?: string | undefined;
+        quality?: number | undefined;
+    } | undefined): Promise<any>;
     /**
      * @ignore
      */

package/dist/types/video/webgl/buffer/vertex.d.ts

@@ -5,9 +5,9 @@
  * @ignore
  */
 export default class VertexArrayBuffer {
-    constructor(vertex_size: any, vertex_per_quad: any);
+    constructor(vertex_size: any, vertex_per_obj: any);
     vertexSize: any;
-    quadSize: any;
+    objSize: any;
     maxVertex: number;
     vertexCount: number;
     buffer: ArrayBuffer;
@@ -27,7 +27,7 @@ export default class VertexArrayBuffer {
      * resize the vertex buffer, retaining its original contents
      * @ignore
      */
-    resize(): VertexArrayBuffer;
+    resize(vertexCount: any): VertexArrayBuffer;
     /**
      * push a new vertex to the buffer
      * @ignore

package/dist/types/video/webgl/compositors/compositor.d.ts

@@ -5,22 +5,37 @@
 export default class Compositor {
     /**
      * @param {WebGLRenderer} renderer - the current WebGL renderer session
+     * @param {Object} settings - additional settings to initialize this compositors
+     * @param {object[]} attribute - an array of attributes definition
+     * @param {string} attribute.name - name of the attribute in the vertex shader
+     * @param {number} attribute.size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
+     * @param {GLenum} attribute.type - data type of each component in the array
+     * @param {boolean} attribute.normalized - whether integer data values should be normalized into a certain range when being cast to a float
+     * @param {number} attribute.offset - offset in bytes of the first component in the vertex attribute array
+     * @param {object} shader - an array of attributes definition
+     * @param {string} shader.vertex - a string containing the GLSL source code to set
+     * @param {string} shader.fragment - a string containing the GLSL source code to set
      */
-    constructor(renderer: WebGLRenderer);
+    constructor(renderer: WebGLRenderer, settings: Object);
     /**
      * Initialize the compositor
      * @ignore
      */
-    init(renderer: any): void;
+    init(renderer: any, settings: any): void;
     renderer: any;
     gl: any;
     color: any;
     viewMatrix: any;
     /**
-     * a reference to the active WebGL shader
+     * the default shader created by this compositor
      * @type {GLShader}
      */
-    activeShader: any;
+    defaultShader: GLShader | undefined;
+    /**
+     * the shader currently used by this compositor
+     * @type {GLShader}
+     */
+    currentShader: GLShader | undefined;
     /**
      * primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)
      * @type {number}
@@ -47,11 +62,27 @@ export default class Compositor {
      * @type {number}
      */
     vertexSize: number | undefined;
+    /**
+     * the vertex data buffer used by this compositor
+     * @type {VertexArrayBuffer}
+     */
+    vertexData: VertexArrayBuffer | undefined;
     /**
      * Reset compositor internal state
      * @ignore
      */
     reset(): void;
+    /**
+     * @ignore
+     * called by the WebGL renderer when a compositor become the current one
+     */
+    bind(): void;
+    /**
+     * Select the shader to use for compositing
+     * @see GLShader
+     * @param {GLShader} shader - a reference to a GLShader instance
+     */
+    useShader(shader: GLShader): void;
     /**
      * add vertex attribute property definition to the compositor
      * @param {string} name - name of the attribute in the vertex shader
@@ -61,41 +92,16 @@ export default class Compositor {
      * @param {number} offset - offset in bytes of the first component in the vertex attribute array
      */
     addAttribute(name: string, size: number, type: GLenum, normalized: boolean, offset: number): void;
-    /**
-     * Sets the viewport
-     * @param {number} x - x position of viewport
-     * @param {number} y - y position of viewport
-     * @param {number} w - width of viewport
-     * @param {number} h - height of viewport
-     */
-    setViewport(x: number, y: number, w: number, h: number): void;
     /**
      * set/change the current projection matrix
      * @param {Matrix3d} matrix
      */
     setProjection(matrix: Matrix3d): void;
     /**
-     * Select the shader to use for compositing
-     * @see GLShader
-     * @param {GLShader} shader - a reference to a GLShader instance
-     */
-    useShader(shader: GLShader): void;
-    /**
-     * Flush batched texture operations to the GPU
+     * Flush batched vertex data to the GPU
      * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
      */
     flush(mode?: number | undefined): void;
-    /**
-     * Clear the frame buffer
-     * @param {number} [alpha = 0.0] - the alpha value used when clearing the framebuffer
-     */
-    clear(alpha?: number | undefined): void;
-    /**
-     * Specify the color values used when clearing color buffers. The values are clamped between 0 and 1.
-     * @param {number} [r = 0] - the red color value used when the color buffers are cleared
-     * @param {number} [g = 0] - the green color value used when the color buffers are cleared
-     * @param {number} [b = 0] - the blue color value used when the color buffers are cleared
-     * @param {number} [a = 0] - the alpha color value used when the color buffers are cleared
-     */
-    clearColor(r?: number | undefined, g?: number | undefined, b?: number | undefined, a?: number | undefined): void;
 }
+import GLShader from "../glshader.js";
+import VertexArrayBuffer from "../buffer/vertex.js";

package/dist/types/video/webgl/compositors/primitive_compositor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @classdesc
+ * 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
+ * @augments Compositor
+ */
+export default class PrimitiveCompositor extends Compositor {
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init(renderer: any): void;
+    /**
+     * 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)
+     * @param {Point[]} verts - an array of vertices
+     * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
+     */
+    drawVertices(mode: GLenum, verts: Point[], vertexCount?: number | undefined): void;
+    mode: any;
+}
+import Compositor from "./compositor.js";

package/dist/types/video/webgl/compositors/quad_compositor.d.ts

@@ -0,0 +1,72 @@
+/**
+ * @classdesc
+ * 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
+ * @augments Compositor
+ */
+export default class QuadCompositor extends Compositor {
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init(renderer: any): void;
+    currentTextureUnit: any;
+    boundTextures: any[] | undefined;
+    /**
+     * Create a WebGL texture from an image
+     * @param {number} unit - Destination texture unit
+     * @param {Image|HTMLCanvasElement|ImageData|Uint8Array[]|Float32Array[]} [pixels=null] - Source image
+     * @param {number} filter - gl.LINEAR or gl.NEAREST
+     * @param {string} [repeat="no-repeat"] - Image repeat behavior (see {@link ImageLayer#repeat})
+     * @param {number} [w=pixels.width] - Source image width (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [h=pixels.height] - Source image height (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {boolean} [premultipliedAlpha=true] - Multiplies the alpha channel into the other color channels
+     * @param {boolean} [mipmap=true] - Whether mipmap levels should be generated for this texture
+     * @returns {WebGLTexture} a WebGL texture
+     */
+    createTexture2D(unit: number, pixels?: HTMLCanvasElement | ImageData | (new (width?: number | undefined, height?: number | undefined) => HTMLImageElement) | Uint8Array[] | Float32Array[] | undefined, filter: number, repeat?: string | undefined, w?: number | undefined, h?: number | undefined, premultipliedAlpha?: boolean | undefined, mipmap?: boolean | undefined): WebGLTexture;
+    /**
+     * delete the given WebGL texture
+     * @param {WebGLTexture} [texture] - a WebGL texture to delete
+     * @param {number} [unit] - Texture unit to delete
+     */
+    deleteTexture2D(texture?: WebGLTexture | undefined): void;
+    /**
+     * returns the WebGL texture associated to the given texture unit
+     * @param {number} unit - Texture unit to which a texture is bound
+     * @returns {WebGLTexture} texture a WebGL texture
+     */
+    getTexture2D(unit: number): WebGLTexture;
+    /**
+     * assign the given WebGL texture to the current batch
+     * @param {WebGLTexture} texture - a WebGL texture
+     * @param {number} unit - Texture unit to which the given texture is bound
+     */
+    bindTexture2D(texture: WebGLTexture, unit: number): void;
+    /**
+     * unbind the given WebGL texture, forcing it to be reuploaded
+     * @param {WebGLTexture} [texture] - a WebGL texture
+     * @param {number} [unit] - a WebGL texture
+     * @returns {number} unit the unit number that was associated with the given texture
+     */
+    unbindTexture2D(texture?: WebGLTexture | undefined, unit?: number | undefined): number;
+    /**
+     * @ignore
+     */
+    uploadTexture(texture: any, w: any, h: any, force?: boolean): any;
+    /**
+     * Add a textured quad
+     * @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 to be applied to the texture in UINT32 (argb) format
+     */
+    addQuad(texture: TextureAtlas, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number): void;
+}
+import Compositor from "./compositor.js";

package/dist/types/video/webgl/glshader.d.ts

@@ -11,7 +11,7 @@ export default class GLShader {
      * @see https://developer.mozilla.org/en-US/docs/Games/Techniques/3D_on_the_web/GLSL_Shaders
      * @example
      * // create a basic shader
-     * var myShader = new me.GLShader(
+     * let myShader = new me.GLShader(
      *    // WebGL rendering context
      *    gl,
      *    // vertex shader

package/dist/types/video/webgl/webgl_renderer.d.ts

@@ -15,10 +15,11 @@ export default class WebGLRenderer extends Renderer {
      * @param {boolean} [options.premultipliedAlpha=true] - in WebGL, whether the renderer will assume that colors have premultiplied alpha when canvas transparency is enabled
      * @param {boolean} [options.subPixel=false] - Whether to enable subpixel renderering (performance hit when enabled)
      * @param {boolean} [options.preferWebGL1=false] - if true the renderer will only use WebGL 1
+     * @param {boolean} [options.depthTest="sorting"] - ~Experimental~ the default method to sort object on the z axis in WebGL ("sorting", "z-buffer")
      * @param {string} [options.powerPreference="default"] - a hint to the user agent indicating what configuration of GPU is suitable for the WebGL context ("default", "high-performance", "low-power"). To be noted that Safari and Chrome (since version 80) both default to "low-power" to save battery life and improve the user experience on these dual-GPU machines.
      * @param {number} [options.zoomX=width] - The actual width of the canvas with scaling applied
      * @param {number} [options.zoomY=height] - The actual height of the canvas with scaling applied
-     * @param {WebGLCompositor} [options.compositor] - A class that implements the compositor API
+     * @param {Compositor} [options.compositor] - A class that implements the compositor API for sprite rendering
      */
     constructor(options: {
         width: number;
@@ -30,10 +31,11 @@ export default class WebGLRenderer extends Renderer {
         premultipliedAlpha?: boolean | undefined;
         subPixel?: boolean | undefined;
         preferWebGL1?: boolean | undefined;
+        depthTest?: boolean | undefined;
         powerPreference?: string | undefined;
         zoomX?: number | undefined;
         zoomY?: number | undefined;
-        compositor?: WebGLCompositor | undefined;
+        compositor?: any;
     });
     /**
      * The WebGL version used by this renderer (1 or 2)
@@ -45,14 +47,14 @@ export default class WebGLRenderer extends Renderer {
     /**
      * The vendor string of the underlying graphics driver.
      * @type {string}
-     * @default null
+     * @default undefined
      * @readonly
      */
     readonly GPUVendor: string;
     /**
      * The renderer string of the underlying graphics driver.
      * @type {string}
-     * @default null
+     * @default undefined
      * @readonly
      */
     readonly GPURenderer: string;
@@ -63,6 +65,11 @@ export default class WebGLRenderer extends Renderer {
      */
     context: WebGLRenderingContext;
     gl: WebGLRenderingContext;
+    /**
+     * the vertex buffer used by this WebGL Renderer
+     * @type {WebGLBuffer}
+     */
+    vertexBuffer: WebGLBuffer;
     /**
      * Maximum number of texture unit supported under the current context
      * @type {number}
@@ -95,51 +102,63 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLCompositor}
      */
     currentCompositor: WebGLCompositor;
+    /**
+     * a reference to the current shader program used by the renderer
+     * @type {WebGLProgram}
+     */
+    currentProgram: WebGLProgram;
     /**
      * The list of active compositors
      * @type {Map<WebGLCompositor>}
      */
     compositors: Map<WebGLCompositor, any>;
+    depthTest: boolean | undefined;
+    customShader: any;
     cache: TextureCache;
+    /**
+     * 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
+     */
+    addCompositor(compositor: Compositor, name?: string, activate?: boolean | undefined): void;
     /**
      * set the active compositor for this renderer
-     * @param {WebGLCompositor|string} compositor - a compositor name or instance
+     * @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
+     * @return {Compositor} an instance to the current active compositor
      */
-    setCompositor(compositor?: WebGLCompositor | string): void;
+    setCompositor(name?: string, shader?: any): Compositor;
     /**
      * Reset the gl transform to identity
      */
     resetTransform(): void;
-    /**
-     * @ignore
-     */
-    createFontTexture(cache: any): void;
-    /**
-     * @ignore
-     */
-    fontContext2D: CanvasRenderingContext2D | undefined;
-    /**
-     * @ignore
-     */
-    fontTexture: TextureAtlas | undefined;
     /**
      * Create a pattern with the specified repetition
-     * @param {Image} image - Source image
+     * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame} image - Source image to be used as the pattern's image
      * @param {string} repeat - Define how the pattern should be repeated
      * @returns {TextureAtlas}
      * @see ImageLayer#repeat
      * @example
-     * var tileable   = renderer.createPattern(image, "repeat");
-     * var horizontal = renderer.createPattern(image, "repeat-x");
-     * var vertical   = renderer.createPattern(image, "repeat-y");
-     * var basic      = renderer.createPattern(image, "no-repeat");
+     * let tileable   = renderer.createPattern(image, "repeat");
+     * let horizontal = renderer.createPattern(image, "repeat-x");
+     * let vertical   = renderer.createPattern(image, "repeat-y");
+     * let basic      = renderer.createPattern(image, "no-repeat");
      */
-    createPattern(image: new (width?: number | undefined, height?: number | undefined) => HTMLImageElement, repeat: string): TextureAtlas;
+    createPattern(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame, repeat: string): TextureAtlas;
     /**
      * set/change the current projection matrix (WebGL only)
      * @param {Matrix3d} matrix
      */
     setProjection(matrix: Matrix3d): void;
+    /**
+     * Sets the WebGL viewport, which specifies the affine transformation of x and y from normalized device coordinates to window coordinates
+     * @param {number} [x = 0] - x the horizontal coordinate for the lower left corner of the viewport origin
+     * @param {number} [y = 0] - y the vertical coordinate for the lower left corner of the viewport origin
+     * @param {number} [w = width of the canvas] - the width of viewport
+     * @param {number} [h = height of the canvas] - the height of viewport
+     */
+    setViewport(x?: number | undefined, y?: number | undefined, w?: number | undefined, h?: number | undefined): void;
     /**
      * Clears the gl context with the given color.
      * @param {Color|string} [color="#000000"] - CSS color.
@@ -154,13 +173,9 @@ export default class WebGLRenderer extends Renderer {
      * @param {number} height - The rectangle's height.
      */
     clearRect(x: number, y: number, width: number, height: number): void;
-    /**
-     * @ignore
-     */
-    drawFont(bounds: any): void;
     /**
      * Draw an image to the gl context
-     * @param {Image} image - An element to draw into the context. The specification permits any canvas image source (CanvasImageSource), specifically, a CSSImageValue, an HTMLImageElement, an SVGImageElement, an HTMLVideoElement, an HTMLCanvasElement, an ImageBitmap, or an OffscreenCanvas.
+     * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame} 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 +192,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: new (width?: number | undefined, height?: number | undefined) => HTMLImageElement, 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, 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
@@ -192,9 +207,10 @@ export default class WebGLRenderer extends Renderer {
      * Returns the WebGL Context object of the given canvas element
      * @param {HTMLCanvasElement} canvas
      * @param {boolean} [transparent=false] - use true to enable transparency
+     * @param {boolean} [depth=false] - use true to enable depth buffer testing
      * @returns {WebGLRenderingContext}
      */
-    getContextGL(canvas: HTMLCanvasElement, transparent?: boolean | undefined): WebGLRenderingContext;
+    getContextGL(canvas: HTMLCanvasElement, transparent?: boolean | undefined, depth?: boolean | undefined): WebGLRenderingContext;
     /**
      * Returns the WebGLContext instance for the renderer
      * return a reference to the system 2d Context
@@ -218,11 +234,6 @@ export default class WebGLRenderer extends Renderer {
      */
     setBlendMode(mode?: string | undefined, gl?: WebGLRenderingContext | undefined): void;
     currentBlendMode: any;
-    /**
-     * return a reference to the font 2d Context
-     * @ignore
-     */
-    getFontContext(): CanvasRenderingContext2D | undefined;
     /**
      * restores the canvas context
      */
@@ -423,7 +434,6 @@ export default class WebGLRenderer extends Renderer {
 }
 import Renderer from "./../renderer.js";
 import Matrix2d from "./../../math/matrix2.js";
-import WebGLCompositor from "./compositors/webgl_compositor.js";
 import TextureCache from "./../texture/cache.js";
 import { TextureAtlas } from "./../texture/atlas.js";
 import Color from "./../../math/color.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "melonjs",
-  "version": "14.5.0",
+  "version": "15.1.0",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -52,39 +52,38 @@
     "CHANGELOG"
   ],
   "dependencies": {
-    "@teppeis/multimaps": "^2.0.0",
-    "core-js": "^3.27.2",
+    "@teppeis/multimaps": "^3.0.0",
+    "core-js": "^3.30.0",
     "earcut": "2.2.4",
     "eventemitter3": "^5.0.0",
     "howler": "2.2.3"
   },
   "devDependencies": {
-    "@babel/eslint-parser": "^7.19.1",
+    "@babel/eslint-parser": "^7.21.3",
     "@babel/plugin-syntax-import-assertions": "^7.20.0",
-    "@fastify/static": "^6.9.0",
+    "@fastify/static": "^6.10.0",
     "@melonjs/webdoc-theme": "^1.1.1",
     "@rollup/plugin-commonjs": "^24.0.1",
     "@rollup/plugin-image": "^3.0.2",
-    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-node-resolve": "^15.0.2",
     "@rollup/plugin-replace": "^5.0.2",
-    "@types/offscreencanvas": "^2019.7.0",
     "@webdoc/cli": "^2.2.0",
-    "chromedriver": "^110.0.0",
+    "chromedriver": "^112.0.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.34.0",
-    "eslint-plugin-jsdoc": "^40.0.0",
-    "expect": "^29.4.2",
-    "expect-mocha-image-snapshot": "^3.0.1",
-    "fastify": "^4.13.0",
+    "eslint": "^8.37.0",
+    "eslint-plugin-jsdoc": "^40.1.1",
+    "expect": "^29.5.0",
+    "expect-mocha-image-snapshot": "^3.0.8",
+    "fastify": "^4.15.0",
     "mocha": "^10.2.0",
     "npm-self-link": "^1.1.7",
-    "puppeteer": "^19.6.3",
-    "rollup": "^3.15.0",
+    "puppeteer": "^19.8.5",
+    "rollup": "^3.20.2",
     "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-string": "^3.0.0",
-    "terser": "^5.16.3",
-    "typescript": "^4.9.5"
+    "terser": "^5.16.8",
+    "typescript": "^5.0.3"
   },
   "scripts": {
     "build": "npm run lint && rollup -c --silent",