melonjs 15.2.0 → 15.3.0

package/src/application/resize.js

@@ -43,6 +43,7 @@ export function onresize(game) {
     let renderer = game.renderer;
     let settings = renderer.settings;
     let scaleX = 1, scaleY = 1;
+    let nodeBounds;
 
     if (settings.autoScale) {
 
@@ -56,8 +57,13 @@ export function onresize(game) {
             canvasMaxHeight = parseInt(style.maxHeight, 10) || Infinity;
         }
 
-        // get the maximum canvas size within the parent div containing the canvas container
-        let nodeBounds = device.getParentBounds(game.getParentElement());
+        if (typeof game.settings.scaleTarget !== "undefined") {
+            // get the bounds of the given scale target
+            nodeBounds = device.getElementBounds(game.settings.scaleTarget);
+        } else {
+            // get the maximum canvas size within the parent div containing the canvas container
+            nodeBounds = device.getParentBounds(game.getParentElement());
+        }
 
         let _max_width = Math.min(canvasMaxWidth, nodeBounds.width);
         let _max_height = Math.min(canvasMaxHeight, nodeBounds.height);

package/src/application/settings.js

@@ -5,6 +5,7 @@ export const defaultSettings = {
     autoScale : false,
     scale : 1.0,
     scaleMethod : "manual",
+    scaleTarget : undefined,
     transparent : false,
     premultipliedAlpha: true,
     blendMode : "normal",
@@ -17,3 +18,38 @@ export const defaultSettings = {
     consoleHeader : true,
     legacy : false
 };
+
+/**
+ * Application & Renderer Settings definition.
+ * @typedef {Object} Settings
+ * @property {string|HTMLElement} [parent=document.body] - the DOM parent element to hold the canvas in the HTML file
+ * @property {number|Renderer} [renderer=AUTO] - renderer to use (CANVAS, WEBGL, AUTO), or a custom renderer class
+ * @property {number|string} [scale=1.0] - enable scaling of the canvas ('auto' for automatic scaling)
+ * @property {string} [scaleMethod="fit"] - screen scaling modes ('fit','fill-min','fill-max','flex','flex-width','flex-height','stretch') : <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 <br>
+ * <center><img src="images/scale-stretch.png"/></center>
+ * @property {string|HTMLElement} [scaleTarget] - the HTML Element to be used as the reference target when using automatic scaling (by default melonJS will use the parent container of the div element containing the canvas)
+ * @property {boolean} [preferWebGL1=false] - if true the renderer will only use WebGL 1
+ * @property {boolean} [depthTest="sorting"] - ~Experimental~ the default method to sort object on the z axis in WebGL ("sorting", "z-buffer")
+ * @property {string} [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.
+ * @property {boolean} [transparent=false] - whether to allow transparent pixels in the front buffer (screen).
+ * @property {boolean} [antiAlias=false] - whether to enable or not video scaling interpolation
+ * @property {boolean} [consoleHeader=true] - whether to display melonJS version and basic device information in the console
+ * @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 {Compositor} [options.compositor] - a custom compositor class (WebGL only)
+ * @see Application
+ * @memberof Application
+ */

package/src/index.js

@@ -54,6 +54,7 @@ import TMXTileset from "./level/tiled/TMXTileset.js";
 import TMXTilesetGroup from "./level/tiled/TMXTilesetGroup.js";
 import TMXTileMap from "./level/tiled/TMXTileMap.js";
 import TMXLayer from "./level/tiled/TMXLayer.js";
+import * as TMXUtils from "./level/tiled/TMXUtils.js";
 import Pointer from "./input/pointer.js";
 import Stage from "./state/stage.js";
 import Camera2d from "./camera/camera2d.js";
@@ -167,6 +168,7 @@ export {
     TMXTilesetGroup,
     TMXTileMap,
     TMXLayer,
+    TMXUtils,
     Pointer,
     Stage,
     Camera2d,

package/src/level/tiled/TMXUtils.js

@@ -1,5 +1,10 @@
 import { isBoolean, isNumeric } from "../../utils/string.js";
-import * as utils from "../../utils/utils.js";
+
+/**
+ * the function used to decompress zlib/gzip data
+ * @ignore
+ */
+let inflateFunction;
 
 /**
  * set and interpret a TMX property value
@@ -96,99 +101,11 @@ function parseAttributes(obj, elt) {
     }
 }
 
-/**
- * decompress and decode zlib/gzip data
- * @ignore
- * @name decompress
- * @param {string} input - Base64 encoded and compressed data
- * @param {string} format - compressed data format ("gzip","zlib", "zstd")
- * @returns {Uint32Array} Decoded and decompress data
- */
-export function decompress(data, format) {
-    if (typeof utils.inflateb64 === "function") {
-        return utils.inflateb64(data, format);
-    } else {
-        throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!");
-    }
-}
-
-/**
- * Decode a CSV encoded array into a binary array
- * @ignore
- * @name decodeCSV
- * @param  {string} input- -  CSV formatted data (only numbers, everything else will be converted to NaN)
- * @returns {number[]} Decoded data
- */
-export function decodeCSV(input) {
-    let entries = input.replace("\n", "").trim().split(",");
-
-    let result = [];
-    for (let i = 0; i < entries.length; i++) {
-        result.push(+entries[i]);
-    }
-    return result;
-}
-
-/**
- * Decode a base64 encoded string into a byte array
- * @ignore
- * @name decodeBase64AsArray
- * @param {string} input - Base64 encoded data
- * @param {number} [bytes] - number of bytes per array entry
- * @returns {Uint32Array} Decoded data
- */
-export function decodeBase64AsArray(input, bytes) {
-    bytes = bytes || 1;
-
-    let i, j, len;
-    let dec = globalThis.atob(input.replace(/[^A-Za-z0-9\+\/\=]/g, ""));
-    let ar = new Uint32Array(dec.length / bytes);
-
-    for (i = 0, len = dec.length / bytes; i < len; i++) {
-        ar[i] = 0;
-        for (j = bytes - 1; j >= 0; --j) {
-            ar[i] += dec.charCodeAt((i * bytes) + j) << (j << 3);
-        }
-    }
-    return ar;
-}
-
-/**
- * Decode the given data
- * @ignore
- */
-export function decode(data, encoding, compression) {
-    compression = compression || "none";
-    encoding = encoding || "none";
-
-    switch (encoding) {
-        case "csv":
-            return decodeCSV(data);
-
-        case "base64":
-            if (compression !== "none") {
-                data = decompress(data, compression);
-            } else {
-                data = decodeBase64AsArray(data, 4);
-            }
-            return data;
-
-        case "none":
-            return data;
-
-        case "xml":
-            throw new Error("XML encoding is deprecated, use base64 instead");
-
-        default:
-            throw new Error("Unknown layer encoding: " + encoding);
-    }
-}
-
 /**
  * Normalize TMX format to Tiled JSON format
  * @ignore
  */
-export function normalize(obj, item) {
+function normalize(obj, item) {
     let nodeName = item.nodeName;
 
     switch (nodeName) {
@@ -316,9 +233,113 @@ export function normalize(obj, item) {
     }
 }
 
+/**
+ * a collection of utility functions for parsing TMX maps
+ * @namespace TMXUtils
+ */
+
+/**
+ * decompress and decode zlib/gzip data
+ * @memberof TMXUtils
+ * @param {string} input - Base64 encoded and compressed data
+ * @param {string} format - compressed data format ("gzip","zlib", "zstd")
+ * @returns {Uint32Array} Decoded and decompress data
+ */
+function decompress(data, format) {
+    if (typeof inflateFunction === "function") {
+        return inflateFunction(data, format);
+    } else {
+        throw new Error("GZIP/ZLIB compressed TMX Tile Map not supported!");
+    }
+}
+
+/**
+ * Decode a CSV encoded array into a binary array
+ * @memberof TMXUtils
+ * @param  {string} input- -  CSV formatted data (only numbers, everything else will be converted to NaN)
+ * @returns {number[]} Decoded data
+ */
+function decodeCSV(input) {
+    let entries = input.replace("\n", "").trim().split(",");
+
+    let result = [];
+    for (let i = 0; i < entries.length; i++) {
+        result.push(+entries[i]);
+    }
+    return result;
+}
+
+/**
+ * Decode a base64 encoded string into a byte array
+ * @memberof TMXUtils
+ * @param {string} input - Base64 encoded data
+ * @param {number} [bytes] - number of bytes per array entry
+ * @returns {Uint32Array} Decoded data
+ */
+function decodeBase64AsArray(input, bytes) {
+    bytes = bytes || 1;
+
+    let i, j, len;
+    let dec = globalThis.atob(input.replace(/[^A-Za-z0-9\+\/\=]/g, ""));
+    let ar = new Uint32Array(dec.length / bytes);
+
+    for (i = 0, len = dec.length / bytes; i < len; i++) {
+        ar[i] = 0;
+        for (j = bytes - 1; j >= 0; --j) {
+            ar[i] += dec.charCodeAt((i * bytes) + j) << (j << 3);
+        }
+    }
+    return ar;
+}
+
+/**
+ * set the function used to inflate gzip/zlib data
+ * @memberof TMXUtils
+ * @param {Func} fn - inflate function
+ */
+export function setInflateFunction(fn) {
+    inflateFunction = fn;
+}
+
+/**
+ * Decode a encoded array into a binary array
+ * @memberof TMXUtils
+ * @param {string} data - data to be decoded
+ * @param {string} [encoding="none"] - data encoding ("csv", "base64", "xml")
+ * @returns {number[]} Decoded data
+ */
+export function decode(data, encoding, compression) {
+    compression = compression || "none";
+    encoding = encoding || "none";
+
+    switch (encoding) {
+        case "csv":
+            return decodeCSV(data);
+
+        case "base64":
+            if (compression !== "none") {
+                data = decompress(data, compression);
+            } else {
+                data = decodeBase64AsArray(data, 4);
+            }
+            return data;
+
+        case "none":
+            return data;
+
+        case "xml":
+            throw new Error("XML encoding is deprecated, use base64 instead");
+
+        default:
+            throw new Error("Unknown layer encoding: " + encoding);
+    }
+}
+
 /**
  * Parse a XML TMX object and returns the corresponding javascript object
- * @ignore
+ * @memberof TMXUtils
+ * @param {Document} xml - XML TMX object
+ * @returns {object} Javascript object
  */
 export function parse(xml) {
     // Create the return object
@@ -356,7 +377,10 @@ export function parse(xml) {
 
 /**
  * Apply TMX Properties to the given object
- * @ignore
+ * @memberof TMXUtils
+ * @param {object} obj - object to apply the properties to
+ * @param {object} data - TMX data object
+ * @returns {object} obj
  */
 export function applyTMXProperties(obj, data) {
     let properties = data.properties;

package/src/math/color.js

@@ -336,12 +336,12 @@ let cssToRGB = new Map();
      * @returns {Color} Reference to this object for method chaining
      */
     copy(color) {
-        if (color instanceof Color) {
+        if (typeof color === "string") {
+            return this.parseCSS(color);
+        } else {
             this.glArray.set(color.glArray);
             return this;
         }
-
-        return this.parseCSS(color);
     }
 
     /**

package/src/renderable/renderable.js

@@ -4,7 +4,6 @@ import Rect from "./../geometries/rectangle.js";
 import pool from "./../system/pooling.js";
 import { releaseAllPointerEvents } from "./../input/input.js";
 import { clamp } from "./../math/math.js";
-import Color from "./../math/color.js";
 
 /**
  * @classdesc
@@ -258,6 +257,9 @@ import Color from "./../math/color.js";
         // viewport flag
         this._inViewport = false;
 
+        // renderable cache tint value used by the getter/setter
+        this._tint = pool.pull("Color", 255, 255, 255, 1.0);
+
         // ensure it's fully opaque by default
         this.setOpacity(1.0);
     }
@@ -282,21 +284,11 @@ import Color from "./../math/color.js";
      * this.tint.setColor(255, 255, 255);
      */
     get tint() {
-        if (typeof this._tint === "undefined") {
-            this._tint = pool.pull("Color", 255, 255, 255, 1.0);
-        }
         return this._tint;
     }
     set tint(value) {
-        if (typeof this._tint === "undefined") {
-            this._tint = pool.pull("Color", 255, 255, 255, 1.0);
-        }
-        if (value instanceof Color) {
-            this._tint.copy(value);
-        } else {
-            // string (#RGB, #ARGB, #RRGGBB, #AARRGGBB)
-            this._tint.parseCSS(value);
-        }
+        this._tint.copy(value);
+        this.isDirty = true;
     }
 
     /**

package/src/state/stage.js

@@ -1,5 +1,5 @@
 import { renderer } from "./../video/video.js";
-import { game } from "../index.js";
+import * as event from "./../system/event.js";
 import Camera2d from "./../camera/camera2d.js";
 import Color from "./../math/color.js";
 
@@ -87,7 +87,6 @@ let default_settings = {
      * @ignore
      */
     reset() {
-
         // add all defined cameras
         this.settings.cameras.forEach((camera) => {
             this.cameras.set(camera.name, camera);
@@ -105,7 +104,7 @@ let default_settings = {
         }
 
         // reset the game
-        game.reset();
+        event.emit(event.STAGE_RESET, this);
 
         // call the onReset Function
         this.onResetEvent.apply(this, arguments);
@@ -120,8 +119,7 @@ let default_settings = {
      * @returns {boolean}
      */
     update(dt) {
-        // update all objects (and pass the elapsed time since last frame)
-        let isDirty = game.world.update(dt);
+        let isDirty = false;
 
         // update the camera/viewport
         // iterate through all cameras
@@ -146,13 +144,15 @@ let default_settings = {
      * @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) {
+    draw(renderer, world) {
+
         // iterate through all cameras
         this.cameras.forEach((camera) => {
             // render the root container
-            camera.draw(renderer, game.world);
+            camera.draw(renderer, world);
 
             // render the ambient light
             if (this.ambientLight.alpha !== 0) {
@@ -172,9 +172,9 @@ let default_settings = {
 
             // render all lights
             this.lights.forEach((light) => {
-                light.preDraw(renderer, game.world);
-                light.draw(renderer, game.world);
-                light.postDraw(renderer, game.world);
+                light.preDraw(renderer, world);
+                light.draw(renderer, world);
+                light.postDraw(renderer, world);
             });
         });
     }
@@ -209,7 +209,6 @@ let default_settings = {
         if (typeof this.settings.onResetEvent === "function") {
             this.settings.onResetEvent.apply(this, arguments);
         }
-
     }
 
     /**

package/src/state/state.js

@@ -72,11 +72,7 @@ function _pauseRunLoop() {
  * @ignore
  */
 function _renderFrame(time) {
-    let stage = _stages[_state].stage;
-    // update all game objects
-    game.update(time, stage);
-    // render all game objects
-    game.draw(stage);
+    event.emit(event.TICK, time);
     // schedule the next frame update
     if (_animFrameId !== -1) {
         _animFrameId = globalThis.requestAnimationFrame(_renderFrame);
@@ -125,9 +121,6 @@ function _switchState(state) {
         if (_onSwitchComplete) {
             _onSwitchComplete();
         }
-
-        // force repaint
-        game.repaint();
     }
 }
 
@@ -273,7 +266,7 @@ let state = {
      * default state ID for the default Stage
      * (the default stage is the one running as soon as melonJS is started)
      * @constant
-     * @name SETTINGS
+     * @name DEFAULT
      * @memberof state
      */
     DEFAULT : 9,
@@ -361,9 +354,6 @@ let state = {
             // calculate the elpased time
             _pauseTime = globalThis.performance.now() - _pauseTime;
 
-            // force repaint
-            game.repaint();
-
             // publish the restart notification
             event.emit(event.STATE_RESTART, _pauseTime);
         }

package/src/system/device.js

@@ -45,6 +45,7 @@ function hasOffscreenCanvas() {
 
 /**
  * used by [un]watchAccelerometer()
+ * @ignore
  */
 function onDeviceMotion(e) {
     // Accelerometer information
@@ -55,6 +56,7 @@ function onDeviceMotion(e) {
 
 /**
  * used by [un]watchDeviceOrientation()
+ * @ignore
  */
 export function onDeviceRotate(e) {
     gamma = e.gamma;

package/src/system/event.js

@@ -30,6 +30,17 @@ export const DOM_READY = "dom_ready";
  */
 export const BOOT = "me.boot";
 
+/**
+ * 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 = "me.tick";
+
 /**
  * event when the game is paused <br>
  * Data passed : none <br>
@@ -89,6 +100,17 @@ export const STATE_RESTART = "me.state.onRestart";
  */
 export const STATE_CHANGE = "me.state.onChange";
 
+/**
+ * event for when a stage is resetted
+ * @public
+ * @constant
+ * @type {string}
+ * @name STAGE_RESET
+ * @memberof event
+ * @see event.on
+*/
+export const STAGE_RESET = "me.stage.onReset";
+
 /**
  * event for when the video is initialized<br>
  * Data passed : none <br>

package/src/video/canvas/canvas_renderer.js

@@ -14,16 +14,7 @@ import * as event from "./../../system/event.js";
  */
  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
+     * @param {Application.Settings} [options] - optional parameters for the renderer
      */
     constructor(options) {
         // parent constructor

package/src/video/renderer.js

@@ -20,20 +20,7 @@ import Point from "../geometries/point.js";
  */
  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
+     * @param {Application.Settings} [options] - optional parameters for the renderer
      */
     constructor(options) {
         /**

package/src/video/video.js

@@ -2,33 +2,34 @@ import * as event from "./../system/event.js";
 import { initialized, game } from "./../index.js";
 import * as device from "./../system/device.js";
 import { throttle } from "../utils/function.js";
-import * as vc from "../const";
 
 /**
  * @namespace video
  */
 
-
 /**
  * Select the HTML5 Canvas renderer
  * @memberof video
+ * @name CANVAS
  * @static
  */
-export const CANVAS = vc.CANVAS;
+export { CANVAS } from "../const";
 
 /**
  * Select the WebGL renderer
  * @memberof video
+ * @name WEBGL
  * @static
  */
-export const WEBGL = vc.WEBGL;
+export { WEBGL } from "../const";
 
 /**
  * Auto-select the renderer (Attempt WebGL first, with fallback to Canvas)
  * @memberof video
+ * @name AUTO
  * @static
  */
-export const AUTO = vc.AUTO;
+export { AUTO } from "../const";
 
 /**
  * A reference to the active Canvas or WebGL active renderer renderer
@@ -39,34 +40,10 @@ export let renderer = null;
 
 /**
  * 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