melonjs 15.2.1 → 15.4.0

package/dist/types/renderable/text/textmetrics.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @classdesc
+ * a Text Metrics object that contains helper for text manipulation
+ * @augments Bounds
+ */
+export default class TextMetrics extends Bounds {
+    /**
+     * @param {Text|BitmapText} ancestor - the parent object that contains this TextMetrics object
+     */
+    constructor(ancestor: Text | BitmapText);
+    /**
+     * a reference to the parent object that contains this TextMetrics object
+     * @public
+     * @type {Renderable}
+     * @default undefined
+     */
+    public ancestor: Renderable;
+    /**
+     * Returns the height of a segment of inline text in CSS pixels.
+     * @returns {number} the height of a segment of inline text in CSS pixels.
+     */
+    lineHeight(): number;
+    /**
+     * Returns the width of the given segment of inline text in CSS pixels.
+     * @param {string} text - the text to be measured
+     * @param {CanvasRenderingContext2D} [context] - reference to an active 2d context for canvas rendering
+     * @returns {number} the width of the given segment of inline text in CSS pixels.
+     */
+    lineWidth(text: string, context?: CanvasRenderingContext2D | undefined): number;
+    /**
+     * measure the given text size in CSS pixels
+     * @param {string} text - the text to be measured
+     * @param {CanvasRenderingContext2D} [context] - reference to an active 2d context for canvas rendering
+     * @returns {TextMetrics} this
+     */
+    measureText(text: string, context?: CanvasRenderingContext2D | undefined): TextMetrics;
+    /**
+     * wrap the given text based on the given width
+     * @param {string|string[]} text - the text to be wrapped
+     * @param {number} width - maximum width of one segment of text in css pixel
+     * @param {CanvasRenderingContext2D} [context] - reference to an active 2d context for canvas rendering
+     * @returns {string[]} an array of string representing wrapped text
+     */
+    wordWrap(text: string | string[], width: number, context?: CanvasRenderingContext2D | undefined): string[];
+}
+import Bounds from "../../physics/bounds.js";
+import Text from "./text.js";

package/dist/types/renderable/text/textstyle.d.ts

@@ -0,0 +1,5 @@
+/**
+ * apply the current text style to the given context
+ * @ignore
+ */
+export default function setContextStyle(context: any, style: any): void;

package/dist/types/renderable/ui/uibaseelement.d.ts

@@ -55,7 +55,6 @@ export default class UIBaseElement extends Container {
      * @ignore
      */
     clicked(event: any): boolean | undefined;
-    dirty: boolean | undefined;
     /**
      * function called when the object is pressed (to be extended)
      * @param {Pointer} event - the event object

package/dist/types/renderable/ui/uispriteelement.d.ts

@@ -64,7 +64,6 @@ export default class UISpriteElement extends Sprite {
      * @ignore
      */
     clicked(event: any): boolean | undefined;
-    dirty: boolean | undefined;
     /**
      * function called when the object is pressed (to be extended)
      * @param {Pointer} event - the event object

package/dist/types/renderable/ui/uitextbutton.d.ts

@@ -49,11 +49,6 @@ export default class UITextButton extends UIBaseElement {
      * @type {string}
      */
     bindKey: string;
-    /**
-     * The css value of a background color
-     * @type {string}
-     */
-    backgroundColor: string;
     /**
      * The css value of a color to be used if the pointer hovers over the button
      * @type {string}
@@ -85,10 +80,10 @@ export default class UITextButton extends UIBaseElement {
      * @type {BitmapText}
      */
     bitmapText: BitmapText;
-    dimensions: import("../../text/textmetrics.js").default;
+    dimensions: import("../text/textmetrics.js").default;
     border: RoundRect;
     draw(renderer: any): void;
 }
 import UIBaseElement from "./uibaseelement.js";
-import BitmapText from "../../text/bitmaptext.js";
+import BitmapText from "../text/bitmaptext.js";
 import RoundRect from "../../geometries/roundrect.js";

package/dist/types/state/stage.d.ts

@@ -86,9 +86,10 @@ export default class Stage {
      * @name draw
      * @memberof Stage
      * @ignore
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer object
+     * @param {Renderer} renderer - the renderer object to draw with
+     * @param {World} world - the world object to draw
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+    draw(renderer: Renderer, world: World): void;
     /**
      * destroy function
      * @ignore

package/dist/types/state/state.d.ts

@@ -1,16 +1,16 @@
 export default state;
 declare namespace state {
-    const LOADING: number;
-    const MENU: number;
-    const READY: number;
-    const PLAY: number;
-    const GAMEOVER: number;
-    const GAME_END: number;
-    const SCORE: number;
-    const CREDITS: number;
-    const SETTINGS: number;
-    const DEFAULT: number;
-    const USER: number;
+    let LOADING: number;
+    let MENU: number;
+    let READY: number;
+    let PLAY: number;
+    let GAMEOVER: number;
+    let GAME_END: number;
+    let SCORE: number;
+    let CREDITS: number;
+    let SETTINGS: number;
+    let DEFAULT: number;
+    let USER: number;
     /**
      * Stop the current stage.
      * @name stop

package/dist/types/system/device.d.ts

@@ -1,5 +1,6 @@
 /**
  * used by [un]watchDeviceOrientation()
+ * @ignore
  */
 export function onDeviceRotate(e: any): void;
 /**
@@ -544,6 +545,8 @@ export let alpha: number;
  * Specify whether to pause the game when losing focus
  * @name pauseOnBlur
  * @memberof device
+ * @deprecated since 15.4.0
+ * @see Application.pauseOnBlur
  * @type {boolean}
  * @public
  * @default true
@@ -553,27 +556,31 @@ export let pauseOnBlur: boolean;
  * Specify whether to unpause the game when gaining focus
  * @name resumeOnFocus
  * @memberof device
+ * @deprecated since 15.4.0
+ * @see Application.resumeOnFocus
  * @type {boolean}
  * @public
  * @default true
  */
 export let resumeOnFocus: boolean;
-/**
- * Specify whether to automatically bring the window to the front
- * @name autoFocus
- * @memberof device
- * @type {boolean}
- * @public
- * @default true
- */
-export let autoFocus: boolean;
 /**
  * Specify whether to stop the game when losing focus or not.
  * The engine restarts on focus if this is enabled.
  * @name stopOnBlur
  * @memberof device
+ * @deprecated since 15.4.0
+ * @see Application.stopOnBlur
  * @type {boolean}
  * @public
  * @default false
  */
 export let stopOnBlur: boolean;
+/**
+ * Specify whether to automatically bring the window to the front
+ * @name autoFocus
+ * @memberof device
+ * @type {boolean}
+ * @public
+ * @default true
+ */
+export let autoFocus: boolean;

package/dist/types/system/event.d.ts

@@ -63,6 +63,36 @@ export const DOM_READY: string;
  * @see event.on
  */
 export const BOOT: string;
+/**
+ * event generated when the system update the engine and the renderer by one step
+ * @public
+ * @constant
+ * @type {string}
+ * @name TICK
+ * @memberof event
+ * @see event.on
+ */
+export const TICK: string;
+/**
+ * event generated when the main browser or window is losing focus
+ * @public
+ * @constant
+ * @type {string}
+ * @name BLUR
+ * @memberof event
+ * @see event.on
+ */
+export const BLUR: string;
+/**
+ * event generated when the main browser or window is gaining back focus
+ * @public
+ * @constant
+ * @type {string}
+ * @name FOCUS
+ * @memberof event
+ * @see event.on
+ */
+export const FOCUS: string;
 /**
  * event when the game is paused <br>
  * Data passed : none <br>
@@ -117,6 +147,16 @@ export const STATE_RESTART: string;
  * @see event.on
  */
 export const STATE_CHANGE: string;
+/**
+ * event for when a stage is resetted
+ * @public
+ * @constant
+ * @type {string}
+ * @name STAGE_RESET
+ * @memberof event
+ * @see event.on
+*/
+export const STAGE_RESET: string;
 /**
  * event for when the video is initialized<br>
  * Data passed : none <br>

package/dist/types/system/platform.d.ts

@@ -1,21 +1,21 @@
 /**
- * The device platform type
- * @namespace platform
- * @memberof device
- * @property {string} ua the user agent string for the current device
- * @property {boolean} iOS `true` if the device is an iOS platform
- * @property {boolean} android `true` if the device is an Android platform
- * @property {boolean} android2 `true` if the device is an Android 2.x platform
- * @property {boolean} linux `true` if the device is a Linux platform
- * @property {boolean} chromeOS `true` if the device is running on ChromeOS.
- * @property {boolean} wp `true` if the device is a Windows Phone platform
- * @property {boolean} BlackBerry`true` if the device is a BlackBerry platform
- * @property {boolean} Kindle`true` if the device is a Kindle platform
- * @property {boolean} ejecta `true` if running under Ejecta
- * @property {boolean} isWeixin `true` if running under Wechat
- * @property {boolean} nodeJS `true` if running under node.js
- * @property {boolean} isMobile `true` if a mobile device
- */
+* The device platform type
+* @namespace platform
+* @memberof device
+* @property {string} ua the user agent string for the current device
+* @property {boolean} iOS `true` if the device is an iOS platform
+* @property {boolean} android `true` if the device is an Android platform
+* @property {boolean} android2 `true` if the device is an Android 2.x platform
+* @property {boolean} linux `true` if the device is a Linux platform
+* @property {boolean} chromeOS `true` if the device is running on ChromeOS.
+* @property {boolean} wp `true` if the device is a Windows Phone platform
+* @property {boolean} BlackBerry`true` if the device is a BlackBerry platform
+* @property {boolean} Kindle`true` if the device is a Kindle platform
+* @property {boolean} ejecta `true` if running under Ejecta
+* @property {boolean} isWeixin `true` if running under Wechat
+* @property {boolean} nodeJS `true` if running under node.js
+* @property {boolean} isMobile `true` if a mobile device
+*/
 export const ua: string;
 export const iOS: boolean;
 export const android: boolean;

package/dist/types/utils/function.d.ts

@@ -19,8 +19,7 @@
  */
 export function defer(func: Function, thisArg: object, ...args: any[]): number;
 /**
- * returns a function that, when invoked will only be triggered at most
- * once during a given window of time
+ * returns a function that, when invoked will only be triggered at most once during a given window of time
  * @public
  * @memberof utils.function
  * @name throttle

package/dist/types/video/canvas/canvas_renderer.d.ts

@@ -4,29 +4,6 @@
  * @augments Renderer
  */
 export default class CanvasRenderer 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.transparent=false] - Whether to enable transparency on the canvas (performance hit when enabled)
-     * @param {boolean} [options.subPixel=false] - Whether to enable subpixel renderering (performance hit when enabled)
-     * @param {boolean} [options.textureSeamFix=true] - enable the texture seam fix when rendering Tile when antiAlias is off for the canvasRenderer
-     * @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
-     */
-    constructor(options: {
-        width: number;
-        height: number;
-        canvas?: HTMLCanvasElement | undefined;
-        antiAlias?: boolean | undefined;
-        transparent?: boolean | undefined;
-        subPixel?: boolean | undefined;
-        textureSeamFix?: boolean | undefined;
-        zoomX?: number | undefined;
-        zoomY?: number | undefined;
-    });
     context: CanvasRenderingContext2D;
     cache: TextureCache;
     /**

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

@@ -4,36 +4,9 @@
  */
 export default class 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, use false (default) for a pixelated effect.
-     * @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.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
-     * @param {number} [options.zoomY=height] - The actual height of the canvas with scaling applied
-     */
-    constructor(options: {
-        width: number;
-        height: number;
-        canvas?: HTMLCanvasElement | undefined;
-        antiAlias?: boolean | undefined;
-        failIfMajorPerformanceCaveat?: boolean | undefined;
-        transparent?: boolean | undefined;
-        premultipliedAlpha?: boolean | undefined;
-        blendMode?: boolean | undefined;
-        depthBuffer?: boolean | undefined;
-        subPixel?: boolean | undefined;
-        verbose?: boolean | undefined;
-        zoomX?: number | undefined;
-        zoomY?: number | undefined;
-    });
+     * @param {Application.Settings} [options] - optional parameters for the renderer
+     */
+    constructor(options?: any);
     /**
      * The given constructor options
      * @public
@@ -43,7 +16,7 @@ export default class Renderer {
     /**
      * the requested video size ratio
      * @public
-     * @type {Number}
+     * @type {number}
      */
     public designRatio: number;
     /**
@@ -215,10 +188,10 @@ export default class Renderer {
     clearTint(): 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
+     * @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.
+     * @returns {Promise} A Promise returning a Blob object representing the last rendered frame
      * @example
      * renderer.convertToBlob().then((blob) => console.log(blob));
      */
@@ -229,10 +202,10 @@ export default class Renderer {
     /**
      * 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.
+     * @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.
+     * @returns {Promise} A Promise returning an ImageBitmap.
      * @example
      * renderer.transferToImageBitmap().then((image) => console.log(image));
      */
@@ -242,10 +215,10 @@ export default class Renderer {
     } | 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.
+     * @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.
+     * @returns {Promise} A Promise returning a string containing the requested data URL.
      * @example
      * renderer.toDataURL().then((dataURL) => console.log(dataURL));
      */

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

@@ -38,7 +38,7 @@ declare class CanvasTexture {
     clear(): void;
     /**
      * enable/disable image smoothing (scaling interpolation)
-     * @param {boolean} [enable=false]
+     * @param {boolean} [enable=false] - whether to enable or not image smoothing (scaling interpolation)
      */
     setAntiAlias(enable?: boolean | undefined): void;
     /**
@@ -54,15 +54,15 @@ declare class CanvasTexture {
      * @param {number} y - The y-axis coordinate of the top-left corner of the rectangle from which the ImageData will be extracted
      * @param {number} width - The width of the rectangle from which the ImageData will be extracted. Positive values are to the right, and negative to the left
      * @param {number} height - The height of the rectangle from which the ImageData will be extracted. Positive values are down, and negative are up
-     * @return {ImageData} The ImageData extracted from this CanvasTexture.
+     * @returns {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
+     * @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.
+     * @returns {Promise} A Promise returning a Blob object representing the image contained in this canvas texture
      * @example
      * canvasTexture.convertToBlob().then((blob) => console.log(blob));
      */
@@ -72,10 +72,10 @@ declare class CanvasTexture {
     } | 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.
+     * @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.
+     * @returns {Promise} A Promise returning an ImageBitmap.
      * @example
      * canvasTexture.transferToImageBitmap().then((bitmap) => console.log(bitmap));
      */
@@ -86,10 +86,10 @@ declare class CanvasTexture {
     /**
      * 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.
+     * @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.
+     * @returns {Promise} A Promise returning a string containing the requested data URL.
      * @example
      * renderer.toDataURL().then((dataURL) => console.log(dataURL));
      */

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

@@ -1,33 +1,9 @@
 /**
  * Initialize the "video" system (create a canvas based on the given arguments, and the related renderer). <br>
- * melonJS support various scaling mode, that can be enabled <u>once the scale option is set to <b>`auto`</b></u> : <br>
- *  - <i><b>`fit`</b></i> : Letterboxed; content is scaled to design aspect ratio <br>
- * <center><img src="images/scale-fit.png"/></center><br>
- *  - <i><b>`fill-min`</b></i> : Canvas is resized to fit minimum design resolution; content is scaled to design aspect ratio <br>
- * <center><img src="images/scale-fill-min.png"/></center><br>
- *  - <i><b>`fill-max`</b></i> : Canvas is resized to fit maximum design resolution; content is scaled to design aspect ratio <br>
- * <center><img src="images/scale-fill-max.png"/></center><br>
- *  - <i><b>`flex`</b><</i> : Canvas width & height is resized to fit; content is scaled to design aspect ratio <br>
- * <center><img src="images/scale-flex.png"/></center><br>
- *  - <i><b>`flex-width`</b></i> : Canvas width is resized to fit; content is scaled to design aspect ratio <br>
- * <center><img src="images/scale-flex-width.png"/></center><br>
- *  - <i><b>`flex-height`</b></i> : Canvas height is resized to fit; content is scaled to design aspect ratio <br>
- * <center><img src="images/scale-flex-height.png"/></center><br>
- *  - <i><b>`stretch`</b></i> : Canvas is resized to fit; content is scaled to screen aspect ratio
- * <center><img src="images/scale-stretch.png"/></center><br>
  * @memberof video
  * @param {number} width - The width of the canvas viewport
  * @param {number} height - The height of the canvas viewport
- * @param {object} [options] - The optional video/renderer parameters.<br> (see Renderer(s) documentation for further specific options)
- * @param {string|HTMLElement} [options.parent=document.body] - the DOM parent element to hold the canvas in the HTML file
- * @param {number|Renderer} [options.renderer=video.AUTO] - renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO), or a custom renderer class
- * @param {number|string} [options.scale=1.0] - enable scaling of the canvas ('auto' for automatic scaling)
- * @param {string} [options.scaleMethod="fit"] - screen scaling modes ('fit','fill-min','fill-max','flex','flex-width','flex-height','stretch')
- * @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 {boolean} [options.transparent=false] - whether to allow transparent pixels in the front buffer (screen).
- * @param {boolean} [options.antiAlias=false] - whether to enable or not video scaling interpolation
- * @param {boolean} [options.consoleHeader=true] - whether to display melonJS version and basic device information in the console
+ * @param {Application.Settings} [options] - optional parameters for the renderer
  * @returns {boolean} false if initialization failed (canvas not supported)
  * @example
  * // init the video with a 640x480 canvas
@@ -38,30 +14,20 @@
  *     scaleMethod : "fit"
  * });
  */
-export function init(width: number, height: number, options?: {
-    parent?: string | HTMLElement | undefined;
-    renderer?: number | Renderer;
-    scale?: string | number | undefined;
-    scaleMethod?: string | undefined;
-    preferWebGL1?: boolean | undefined;
-    powerPreference?: string | undefined;
-    transparent?: boolean | undefined;
-    antiAlias?: boolean | undefined;
-    consoleHeader?: boolean | undefined;
-} | undefined): boolean;
+export function init(width: number, height: number, options?: any): boolean;
 /**
  * Create and return a new Canvas element
  * @memberof video
  * @param {number} width - width
  * @param {number} height - height
  * @param {boolean} [returnOffscreenCanvas=false] - will return an OffscreenCanvas if supported
- * @returns {HTMLCanvasElement|OffscreenCanvas}
+ * @returns {HTMLCanvasElement|OffscreenCanvas} a new Canvas element of the given size
  */
 export function createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean | undefined): HTMLCanvasElement | OffscreenCanvas;
 /**
  * return a reference to the parent DOM element holding the main canvas
  * @memberof video
- * @returns {HTMLElement}
+ * @returns {HTMLElement} the HTML parent element
  */
 export function getParent(): HTMLElement;
 /**

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

@@ -27,12 +27,12 @@ export default class VertexArrayBuffer {
      * resize the vertex buffer, retaining its original contents
      * @ignore
      */
-    resize(vertexCount: any): VertexArrayBuffer;
+    resize(vertexCount: any): this;
     /**
      * push a new vertex to the buffer
      * @ignore
      */
-    push(x: any, y: any, u: any, v: any, tint: any): VertexArrayBuffer;
+    push(x: any, y: any, u: any, v: any, tint: any): this;
     /**
      * return a reference to the data in Float32 format
      * @ignore

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

@@ -5,18 +5,30 @@
 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
+     * @param {object} settings - additional settings to initialize this compositors
+     * @param {object[]} settings.attribute - an array of attributes definition
+     * @param {string} settings.attribute.name - name of the attribute in the vertex shader
+     * @param {number} settings.attribute.size - number of components per vertex attribute. Must be 1, 2, 3, or 4.
+     * @param {GLenum} settings.attribute.type - data type of each component in the array
+     * @param {boolean} settings.attribute.normalized - whether integer data values should be normalized into a certain range when being cast to a float
+     * @param {number} settings.attribute.offset - offset in bytes of the first component in the vertex attribute array
+     * @param {object} settings.shader - an array of attributes definition
+     * @param {string} settings.shader.vertex - a string containing the GLSL source code to set
+     * @param {string} settings.shader.fragment - a string containing the GLSL source code to set
      */
-    constructor(renderer: WebGLRenderer, settings: Object);
+    constructor(renderer: WebGLRenderer, settings: {
+        attribute: {
+            name: string;
+            size: number;
+            type: GLenum;
+            normalized: boolean;
+            offset: number;
+        };
+        shader: {
+            vertex: string;
+            fragment: string;
+        };
+    });
     /**
      * Initialize the compositor
      * @ignore
@@ -73,7 +85,6 @@ export default class Compositor {
      */
     reset(): void;
     /**
-     * @ignore
      * called by the WebGL renderer when a compositor become the current one
      */
     bind(): void;
@@ -94,7 +105,7 @@ export default class Compositor {
     addAttribute(name: string, size: number, type: GLenum, normalized: boolean, offset: number): void;
     /**
      * set/change the current projection matrix
-     * @param {Matrix3d} matrix
+     * @param {Matrix3d} matrix - the new projection matrix
      */
     setProjection(matrix: Matrix3d): void;
     /**

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

@@ -17,6 +17,5 @@ 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 | undefined): void;
-    mode: any;
 }
 import Compositor from "./compositor.js";