melonjs 14.1.2 → 14.3.0

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

@@ -0,0 +1,174 @@
+/**
+ * @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
+ */
+export default class WebGLCompositor {
+    /**
+     * @param {WebGLRenderer} renderer - the current WebGL renderer session
+     */
+    constructor(renderer: WebGLRenderer);
+    /**
+     * Initialize the compositor
+     * @ignore
+     */
+    init(renderer: any): void;
+    currentTextureUnit: any;
+    boundTextures: any[] | undefined;
+    renderer: any;
+    gl: any;
+    color: any;
+    viewMatrix: any;
+    /**
+     * a reference to the active WebGL shader
+     * @type {GLShader}
+     */
+    activeShader: 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}
+     * @default gl.TRIANGLES
+     */
+    mode: number | undefined;
+    /**
+     * an array of vertex attribute properties
+     * @see WebGLCompositor.addAttribute
+     * @type {Array}
+     */
+    attributes: any[] | undefined;
+    /**
+     * the size of a single vertex in bytes
+     * (will automatically be calculated as attributes definitions are added)
+     * @see WebGLCompositor.addAttribute
+     * @type {number}
+     */
+    vertexByteSize: number | undefined;
+    /**
+     * the size of a single vertex in floats
+     * (will automatically be calculated as attributes definitions are added)
+     * @see WebGLCompositor.addAttribute
+     * @type {number}
+     */
+    vertexSize: number | undefined;
+    primitiveShader: GLShader | undefined;
+    quadShader: GLShader | undefined;
+    vertexBuffer: VertexArrayBuffer | undefined;
+    /**
+     * Reset compositor internal state
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * add vertex attribute property definition to the compositor
+     * @param {string} name - name of the attribute in the vertex shader
+     * @param {number} size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
+     * @param {GLenum} type - data type of each component in the array
+     * @param {boolean} normalized - whether integer data values should be normalized into a certain range when being cast to a float
+     * @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;
+    /**
+     * Create a WebGL texture from an image
+     * @param {number} unit - Destination texture unit
+     * @param {Image|HTMLCanvasElement|ImageData|Uint8Array[]|Float32Array[]} image - 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] - Source image width (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [h] - Source image height (Only use with UInt8Array[] or Float32Array[] source image)
+     * @param {number} [b] - Source image border (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, image: (new (width?: number | undefined, height?: number | undefined) => HTMLImageElement) | HTMLCanvasElement | ImageData | Uint8Array[] | Float32Array[], filter: number, repeat?: string | undefined, w?: number | undefined, h?: number | undefined, b?: 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, b: any, force?: boolean): any;
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Flush batched texture operations to the GPU
+     * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
+     */
+    flush(mode?: number | undefined): 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 {Vector2d[]} verts - vertices
+     * @param {number} [vertexCount=verts.length] - amount of points defined in the points array
+     */
+    drawVertices(mode: GLenum, verts: Vector2d[], vertexCount?: 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";
+import Vector2d from "./../../math/vector2.js";

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

@@ -0,0 +1,429 @@
+/**
+ * @classdesc
+ * a WebGL renderer object
+ * @augments Renderer
+ */
+export default class WebGLRenderer extends Renderer {
+    /**
+     * @param {object} options - The renderer parameters
+     * @param {number} options.width - The width of the canvas without scaling
+     * @param {number} options.height - The height of the canvas without scaling
+     * @param {HTMLCanvasElement} [options.canvas] - The html canvas to draw to on screen
+     * @param {boolean} [options.antiAlias=false] - Whether to enable anti-aliasing
+     * @param {boolean} [options.failIfMajorPerformanceCaveat=true] - If true, the renderer will switch to CANVAS mode if the performances of a WebGL context would be dramatically lower than that of a native application making equivalent OpenGL calls.
+     * @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.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 {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
+     */
+    constructor(options: {
+        width: number;
+        height: number;
+        canvas?: HTMLCanvasElement | undefined;
+        antiAlias?: boolean | undefined;
+        failIfMajorPerformanceCaveat?: boolean | undefined;
+        transparent?: boolean | undefined;
+        premultipliedAlpha?: boolean | undefined;
+        subPixel?: boolean | undefined;
+        preferWebGL1?: boolean | undefined;
+        powerPreference?: string | undefined;
+        zoomX?: number | undefined;
+        zoomY?: number | undefined;
+        compositor?: WebGLCompositor | undefined;
+    });
+    /**
+     * The WebGL version used by this renderer (1 or 2)
+     * @type {number}
+     * @default 1
+     * @readonly
+     */
+    readonly WebGLVersion: number;
+    /**
+     * The vendor string of the underlying graphics driver.
+     * @type {string}
+     * @default null
+     * @readonly
+     */
+    readonly GPUVendor: string;
+    /**
+     * The renderer string of the underlying graphics driver.
+     * @type {string}
+     * @default null
+     * @readonly
+     */
+    readonly GPURenderer: string;
+    /**
+     * The WebGL context
+     * @name gl
+     * @type {WebGLRenderingContext}
+     */
+    context: WebGLRenderingContext;
+    gl: WebGLRenderingContext;
+    /**
+     * Maximum number of texture unit supported under the current context
+     * @type {number}
+     * @readonly
+     */
+    readonly maxTextures: number;
+    /**
+     * @ignore
+     */
+    _colorStack: any[];
+    /**
+     * @ignore
+     */
+    _matrixStack: any[];
+    /**
+     * @ignore
+     */
+    _scissorStack: any[];
+    /**
+     * @ignore
+     */
+    _blendStack: any[];
+    /**
+     * The current transformation matrix used for transformations on the overall scene
+     * @type {Matrix2d}
+     */
+    currentTransform: Matrix2d;
+    /**
+     * The current compositor used by the renderer
+     * @type {WebGLCompositor}
+     */
+    currentCompositor: WebGLCompositor;
+    /**
+     * The list of active compositors
+     * @type {Map<WebGLCompositor>}
+     */
+    compositors: Map<WebGLCompositor, any>;
+    cache: TextureCache;
+    /**
+     * set the active compositor for this renderer
+     * @param {WebGLCompositor|string} compositor - a compositor name or instance
+     */
+    setCompositor(compositor?: WebGLCompositor | string): void;
+    /**
+     * 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 {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");
+     */
+    createPattern(image: new (width?: number | undefined, height?: number | undefined) => HTMLImageElement, repeat: string): TextureAtlas;
+    /**
+     * set/change the current projection matrix (WebGL only)
+     * @param {Matrix3d} matrix
+     */
+    setProjection(matrix: Matrix3d): void;
+    /**
+     * Clears the gl context with the given color.
+     * @param {Color|string} [color="#000000"] - CSS color.
+     * @param {boolean} [opaque=false] - Allow transparency [default] or clear the surface completely [true]
+     */
+    clearColor(color?: string | Color | undefined, opaque?: boolean | undefined): void;
+    /**
+     * Erase the pixels in the given rectangular area by setting them to transparent black (rgba(0,0,0,0)).
+     * @param {number} x - x axis of the coordinate for the rectangle starting point.
+     * @param {number} y - y axis of the coordinate for the rectangle starting point.
+     * @param {number} width - The rectangle's width.
+     * @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 {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.
+     * @param {number} sh - The height of the sub-rectangle of the source image to draw into the destination context.
+     * @param {number} dx - The X coordinate in the destination canvas at which to place the top-left corner of the source image.
+     * @param {number} dy - The Y coordinate in the destination canvas at which to place the top-left corner of the source image.
+     * @param {number} dw - The width to draw the image in the destination canvas. This allows scaling of the drawn image. If not specified, the image is not scaled in width when drawn.
+     * @param {number} dh - The height to draw the image in the destination canvas. This allows scaling of the drawn image. If not specified, the image is not scaled in height when drawn.
+     * @example
+     * // Position the image on the canvas:
+     * renderer.drawImage(image, dx, dy);
+     * // Position the image on the canvas, and specify width and height of the image:
+     * renderer.drawImage(image, dx, dy, dWidth, dHeight);
+     * // 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;
+    /**
+     * Draw a pattern within the given rectangle.
+     * @param {TextureAtlas} pattern - Pattern object
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @see WebGLRenderer#createPattern
+     */
+    drawPattern(pattern: TextureAtlas, x: number, y: number, width: number, height: number): void;
+    /**
+     * Returns the WebGL Context object of the given canvas element
+     * @param {HTMLCanvasElement} canvas
+     * @param {boolean} [transparent=false] - use true to enable transparency
+     * @returns {WebGLRenderingContext}
+     */
+    getContextGL(canvas: HTMLCanvasElement, transparent?: boolean | undefined): WebGLRenderingContext;
+    /**
+     * Returns the WebGLContext instance for the renderer
+     * return a reference to the system 2d Context
+     * @returns {WebGLRenderingContext}
+     */
+    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>
+     * @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]
+     */
+    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
+     */
+    restore(): void;
+    /**
+     * saves the canvas context
+     */
+    save(): void;
+    /**
+     * rotates the uniform matrix
+     * @param {number} angle - in radians
+     */
+    rotate(angle: number): void;
+    /**
+     * scales the uniform matrix
+     * @param {number} x
+     * @param {number} y
+     */
+    scale(x: number, y: number): void;
+    /**
+     * not used by this renderer?
+     * @ignore
+     */
+    setAntiAlias(context: any, enable: any): void;
+    /**
+     * Set the global alpha
+     * @param {number} alpha - 0.0 to 1.0 values accepted.
+     */
+    setGlobalAlpha(alpha: number): void;
+    /**
+     * Return the global alpha
+     * @returns {number} global alpha value
+     */
+    getGlobalAlpha(): number;
+    /**
+     * Set the current fill & stroke style color.
+     * By default, or upon reset, the value is set to #000000.
+     * @param {Color|string} color - css color string.
+     */
+    setColor(color: Color | string): void;
+    /**
+     * Set the line width
+     * @param {number} width - Line width
+     */
+    setLineWidth(width: number): void;
+    /**
+     * Stroke an arc at the specified coordinates with given radius, start and end points
+     * @param {number} x - arc center point x-axis
+     * @param {number} y - arc center point y-axis
+     * @param {number} radius
+     * @param {number} start - start angle in radians
+     * @param {number} end - end angle in radians
+     * @param {boolean} [antiClockwise=false] - draw arc anti-clockwise
+     * @param {boolean} [fill=false]
+     */
+    strokeArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean | undefined, fill?: boolean | undefined): void;
+    /**
+     * Fill an arc at the specified coordinates with given radius, start and end points
+     * @param {number} x - arc center point x-axis
+     * @param {number} y - arc center point y-axis
+     * @param {number} radius
+     * @param {number} start - start angle in radians
+     * @param {number} end - end angle in radians
+     * @param {boolean} [antiClockwise=false] - draw arc anti-clockwise
+     */
+    fillArc(x: number, y: number, radius: number, start: number, end: number, antiClockwise?: boolean | undefined): void;
+    /**
+     * Stroke an ellipse at the specified coordinates with given radius
+     * @param {number} x - ellipse center point x-axis
+     * @param {number} y - ellipse center point y-axis
+     * @param {number} w - horizontal radius of the ellipse
+     * @param {number} h - vertical radius of the ellipse
+     * @param {boolean} [fill=false] - also fill the shape with the current color if true
+     */
+    strokeEllipse(x: number, y: number, w: number, h: number, fill?: boolean | undefined): void;
+    /**
+     * Fill an ellipse at the specified coordinates with given radius
+     * @param {number} x - ellipse center point x-axis
+     * @param {number} y - ellipse center point y-axis
+     * @param {number} w - horizontal radius of the ellipse
+     * @param {number} h - vertical radius of the ellipse
+     */
+    fillEllipse(x: number, y: number, w: number, h: number): void;
+    /**
+     * Stroke a line of the given two points
+     * @param {number} startX - the start x coordinate
+     * @param {number} startY - the start y coordinate
+     * @param {number} endX - the end x coordinate
+     * @param {number} endY - the end y coordinate
+     */
+    strokeLine(startX: number, startY: number, endX: number, endY: number): void;
+    /**
+     * Fill a line of the given two points
+     * @param {number} startX - the start x coordinate
+     * @param {number} startY - the start y coordinate
+     * @param {number} endX - the end x coordinate
+     * @param {number} endY - the end y coordinate
+     */
+    fillLine(startX: number, startY: number, endX: number, endY: number): void;
+    /**
+     * Stroke a me.Polygon on the screen with a specified color
+     * @param {Polygon} poly - the shape to draw
+     * @param {boolean} [fill=false] - also fill the shape with the current color if true
+     */
+    strokePolygon(poly: Polygon, fill?: boolean | undefined): void;
+    /**
+     * Fill a me.Polygon on the screen
+     * @param {Polygon} poly - the shape to draw
+     */
+    fillPolygon(poly: Polygon): void;
+    /**
+     * Draw a stroke rectangle at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {boolean} [fill=false] - also fill the shape with the current color if true
+     */
+    strokeRect(x: number, y: number, width: number, height: number, fill?: boolean | undefined): void;
+    /**
+     * Draw a filled rectangle at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    fillRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * Stroke a rounded rectangle at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number} radius
+     * @param {boolean} [fill=false] - also fill the shape with the current color if true
+     */
+    strokeRoundRect(x: number, y: number, width: number, height: number, radius: number, fill?: boolean | undefined): void;
+    /**
+     * Draw a rounded filled rectangle at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {number} radius
+     */
+    fillRoundRect(x: number, y: number, width: number, height: number, radius: number): void;
+    /**
+     * Stroke a Point at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     */
+    strokePoint(x: number, y: number): void;
+    /**
+     * Draw a a point at the specified coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    fillPoint(x: number, y: number): void;
+    /**
+     * Reset (overrides) the renderer transformation matrix to the
+     * identity one, and then apply the given transformation matrix.
+     * @param {Matrix2d} mat2d - Matrix to transform by
+     */
+    setTransform(mat2d: Matrix2d): void;
+    /**
+     * Multiply given matrix into the renderer tranformation matrix
+     * @param {Matrix2d} mat2d - Matrix to transform by
+     */
+    transform(mat2d: Matrix2d): void;
+    /**
+     * Translates the uniform matrix by the given coordinates
+     * @param {number} x
+     * @param {number} y
+     */
+    translate(x: number, y: number): void;
+    /**
+     * clip the given region from the original canvas. Once a region is clipped,
+     * all future drawing will be limited to the clipped region.
+     * You can however save the current region using the save(),
+     * and restore it (with the restore() method) any time in the future.
+     * (<u>this is an experimental feature !</u>)
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     */
+    clipRect(x: number, y: number, width: number, height: number): void;
+    /**
+     * A mask limits rendering elements to the shape and position of the given mask object.
+     * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
+     * Mask are not preserved through renderer context save and restore.
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - a 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?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean | undefined): void;
+}
+import Renderer from "./../renderer.js";
+import Matrix2d from "./../../math/matrix2.js";
+import WebGLCompositor from "./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.1.2",
+  "version": "14.3.0",
   "description": "melonJS Game Engine",
   "homepage": "http://www.melonjs.org/",
   "type": "module",
@@ -44,7 +44,7 @@
   "files": [
     "dist/melonjs.mjs",
     "dist/melonjs.module.js",
-    "dist/types/index.d.ts",
+    "dist/types",
     "src/",
     "package.json",
     "README.md",
@@ -53,7 +53,7 @@
   ],
   "dependencies": {
     "@teppeis/multimaps": "^2.0.0",
-    "core-js": "^3.26.1",
+    "core-js": "^3.27.1",
     "earcut": "2.2.4",
     "eventemitter3": "^5.0.0",
     "howler": "2.2.3"
@@ -61,30 +61,30 @@
   "devDependencies": {
     "@babel/eslint-parser": "^7.19.1",
     "@babel/plugin-syntax-import-assertions": "^7.20.0",
-    "@fastify/static": "^6.5.1",
+    "@fastify/static": "^6.6.0",
     "@melonjs/webdoc-theme": "^1.1.1",
-    "@rollup/plugin-commonjs": "^23.0.3",
+    "@rollup/plugin-commonjs": "^24.0.0",
     "@rollup/plugin-image": "^3.0.1",
     "@rollup/plugin-node-resolve": "^15.0.1",
-    "@rollup/plugin-replace": "^5.0.1",
+    "@rollup/plugin-replace": "^5.0.2",
     "@types/offscreencanvas": "^2019.7.0",
     "@webdoc/cli": "^2.2.0",
-    "chromedriver": "^107.0.3",
+    "chromedriver": "^108.0.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.28.0",
+    "eslint": "^8.30.0",
     "eslint-plugin-jsdoc": "^39.6.4",
     "expect": "^29.3.1",
     "expect-mocha-image-snapshot": "^2.0.14",
     "fastify": "^4.10.2",
-    "mocha": "^10.1.0",
+    "mocha": "^10.2.0",
     "npm-self-link": "^1.1.7",
-    "puppeteer": "^19.3.0",
-    "rollup": "^3.5.0",
+    "puppeteer": "^19.4.1",
+    "rollup": "^3.9.0",
     "rollup-plugin-bundle-size": "^1.0.3",
     "rollup-plugin-string": "^3.0.0",
-    "terser": "^5.16.0",
-    "typescript": "^4.9.3"
+    "terser": "^5.16.1",
+    "typescript": "^4.9.4"
   },
   "scripts": {
     "build": "npm run lint && rollup -c --silent",
@@ -99,6 +99,6 @@
     "serve": "python3 -m http.server",
     "prepublishOnly": "npm run dist && npm run test",
     "clean": "del-cli --force build/*.* dist/*.* docs",
-    "types": "tsc src/index.js --declaration --allowJs --emitDeclarationOnly --outdir dist/types"
+    "types": "tsc"
   }
 }