melonjs 10.2.1 → 10.2.2

package/src/video/renderer.js

@@ -17,19 +17,19 @@ import Bounds from "./../physics/bounds.js";
  * @class Renderer
  * @memberOf me
  * @constructor
- * @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 {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.doubleBuffering=false] Whether to enable double buffering
- * @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 (performance hit when enabled)
- * @param {Boolean} [options.blendMode="normal"] the default blend mode to use ("normal", "multiply")
- * @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 {boolean} [options.doubleBuffering=false] Whether to enable double buffering
+ * @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 (performance hit when enabled)
+ * @param {boolean} [options.blendMode="normal"] the default blend mode to use ("normal", "multiply")
+ * @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
  */
 class Renderer {
 
@@ -39,7 +39,7 @@ class Renderer {
          * @public
          * @name settings
          * @memberOf me.Renderer#
-         * @enum {Object}
+         * @enum {object}
          */
         this.settings = options;
 
@@ -48,7 +48,7 @@ class Renderer {
          * @name isContextValid
          * @memberOf me.Renderer
          * @default true
-         * type {Boolean}
+         * type {boolean}
          */
         this.isContextValid = true;
 
@@ -132,7 +132,7 @@ class Renderer {
      * @name getCanvas
      * @memberOf me.Renderer.prototype
      * @function
-     * @return {HTMLCanvasElement}
+     * @returns {HTMLCanvasElement}
      */
     getCanvas() {
         return this.backBufferCanvas;
@@ -143,7 +143,7 @@ class Renderer {
      * @name getScreenCanvas
      * @memberOf me.Renderer.prototype
      * @function
-     * @return {HTMLCanvasElement}
+     * @returns {HTMLCanvasElement}
      */
     getScreenCanvas() {
         return this.canvas;
@@ -155,7 +155,7 @@ class Renderer {
      * @name getScreenContext
      * @memberOf me.Renderer.prototype
      * @function
-     * @return {Context2d}
+     * @returns {CanvasRenderingContext2D}
      */
     getScreenContext() {
         return this.context;
@@ -166,7 +166,7 @@ class Renderer {
      * @name getBlendMode
      * @memberOf me.Renderer.prototype
      * @function
-     * @return {String} blend mode
+     * @returns {string} blend mode
      */
     getBlendMode() {
         return this.currentBlendMode;
@@ -179,18 +179,18 @@ class Renderer {
      * @memberOf me.Renderer.prototype
      * @function
      * @param {HTMLCanvasElement} canvas
-     * @param {Boolean} [transparent=true] use false to disable transparency
-     * @return {CanvasRenderingContext2D}
+     * @param {boolean} [transparent=true] use false to disable transparency
+     * @returns {CanvasRenderingContext2D}
      */
-    getContext2d(c, transparent) {
-        if (typeof c === "undefined" || c === null) {
+    getContext2d(canvas, transparent) {
+        if (typeof canvas === "undefined" || canvas === null) {
             throw new Error(
                 "You must pass a canvas element in order to create " +
                 "a 2d context"
             );
         }
 
-        if (typeof c.getContext === "undefined") {
+        if (typeof canvas.getContext === "undefined") {
             throw new Error(
                 "Your browser does not support HTML5 canvas."
             );
@@ -200,12 +200,12 @@ class Renderer {
             transparent = true;
         }
 
-        var _context = c.getContext("2d", {
+        var _context = canvas.getContext("2d", {
                 "alpha" : transparent
         });
 
         if (!_context.canvas) {
-            _context.canvas = c;
+            _context.canvas = canvas;
         }
         this.setAntiAlias(_context, this.settings.antiAlias);
         return _context;
@@ -216,7 +216,7 @@ class Renderer {
      * @name getWidth
      * @memberOf me.Renderer.prototype
      * @function
-     * @return {Number}
+     * @returns {number}
      */
     getWidth() {
         return this.backBufferCanvas.width;
@@ -227,7 +227,7 @@ class Renderer {
      * @name getHeight
      * @memberOf me.Renderer.prototype
      * @function
-     * @return {Number}
+     * @returns {number} height of the system Canvas
      */
     getHeight() {
         return this.backBufferCanvas.height;
@@ -238,7 +238,7 @@ class Renderer {
      * @name getColor
      * @memberOf me.Renderer.prototype
      * @function
-     * @param {me.Color} current global color
+     * @returns {me.Color} current global color
      */
     getColor() {
         return this.currentColor;
@@ -249,7 +249,7 @@ class Renderer {
      * @name globalAlpha
      * @memberOf me.Renderer.prototype
      * @function
-     * @return {Number}
+     * @returns {number}
      */
     globalAlpha() {
         return this.currentColor.glArray[3];
@@ -261,7 +261,7 @@ class Renderer {
      * @memberOf me.Renderer.prototype
      * @function
      * @param  {me.Rect|me.Bounds} bounds
-     * @return {boolean} true if overlaps
+     * @returns {boolean} true if overlaps
      */
     overlaps(bounds) {
         return (
@@ -276,8 +276,8 @@ class Renderer {
      * @name resize
      * @memberOf me.Renderer.prototype
      * @function
-     * @param {Number} width new width of the canvas
-     * @param {Number} height new height of the canvas
+     * @param {number} width new width of the canvas
+     * @param {number} height new height of the canvas
      */
     resize(width, height) {
         if (width !== this.backBufferCanvas.width || height !== this.backBufferCanvas.height) {
@@ -297,8 +297,8 @@ class Renderer {
      * @name setAntiAlias
      * @memberOf me.Renderer.prototype
      * @function
-     * @param {Context2d} context
-     * @param {Boolean} [enable=false]
+     * @param {CanvasRenderingContext2D} context
+     * @param {boolean} [enable=false]
      */
     setAntiAlias(context, enable) {
         var canvas = context.canvas;
@@ -339,6 +339,7 @@ class Renderer {
      * @memberOf me.Renderer.prototype
      * @function
      * @param {me.Rect|me.Polygon|me.Line|me.Ellipse} shape a shape object to stroke
+     * @param {boolean} [fill=false] fill the shape with the current color if true
      */
     stroke(shape, fill) {
         if (shape instanceof Rect || shape instanceof Bounds) {
@@ -361,10 +362,10 @@ class Renderer {
      * @name tint
      * @memberOf me.Renderer.prototype
      * @function
-     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} image the source image to be tinted
-     * @param {me.Color|String} color the color that will be used to tint the image
-     * @param {String} [mode="multiply"] the composition mode used to tint the image
-     * @return {HTMLCanvasElement|OffscreenCanvas} a new canvas element representing the tinted image
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} src the source image to be tinted
+     * @param {me.Color|string} color the color that will be used to tint the image
+     * @param {string} [mode="multiply"] the composition mode used to tint the image
+     * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas element representing the tinted image
      */
     tint(src, color, mode) {
         var canvas = createCanvas(src.width, src.height, true);
@@ -423,7 +424,7 @@ class Renderer {
      * @memberOf me.Renderer.prototype
      * @function
      * @param {me.Color} tint the tint color
-     * @param {Number} [alpha] an alpha value to be applied to the tint
+     * @param {number} [alpha] an alpha value to be applied to the tint
      */
     setTint(tint, alpha = tint.alpha) {
         // global tint color

package/src/video/texture.js

@@ -8,62 +8,61 @@ import loader from "./../loader/loader.js";
 import { ETA } from "./../math/math.js";
 
 /**
-  * @classdesc
-  * A Texture atlas object, currently supports : <br>
-  * - [TexturePacker]{@link http://www.codeandweb.com/texturepacker/} : through JSON export (standard and multipack texture atlas) <br>
-  * - [ShoeBox]{@link http://renderhjs.net/shoebox/} : through JSON export using the
-  * melonJS setting [file]{@link https://github.com/melonjs/melonJS/raw/master/media/shoebox_JSON_export.sbx} <br>
-  * - [Free Texture Packer]{@link http://free-tex-packer.com/app/} : through JSON export (standard and multipack texture atlas) <br>
-  * - Standard (fixed cell size) spritesheet : through a {framewidth:xx, frameheight:xx, anchorPoint:me.Vector2d} object
-  * @class Texture
-  * @memberOf me.Renderer
-  * @constructor
-  * @param {Object|Object[]} atlas atlas information. See {@link me.loader.getJSON}
-  * @param {HTMLImageElement|HTMLCanvasElement|String|HTMLImageElement[]|HTMLCanvasElement[]|String[]} [source=atlas.meta.image] Image source
-  * @param {Boolean} [cached=false] Use true to skip caching this Texture
-  * @example
-  * // create a texture atlas from a JSON Object
-  * game.texture = new me.video.renderer.Texture(
-  *     me.loader.getJSON("texture")
-  * );
-  *
-  * // create a texture atlas from a multipack JSON Object
-  * game.texture = new me.video.renderer.Texture([
-  *     me.loader.getJSON("texture-0"),
-  *     me.loader.getJSON("texture-1"),
-  *     me.loader.getJSON("texture-2")
-  * ]);
-  *
-  * // create a texture atlas for a spritesheet with an anchorPoint in the center of each frame
-  * game.texture = new me.video.renderer.Texture(
-  *     {
-  *         framewidth : 32,
-  *         frameheight : 32,
-  *         anchorPoint : new me.Vector2d(0.5, 0.5)
-  *     },
-  *     me.loader.getImage("spritesheet")
-  * );
-  */
-
-  /**
-   * create a simple 1 frame texture atlas based on the given parameters
-   * @ignore
-   */
+ * create a simple 1 frame texture atlas based on the given parameters
+ * @ignore
+ */
 export function createAtlas(width, height, name = "default", repeat = "no-repeat") {
-    return {
-        "meta" : {
-            "app" : "melonJS",
-            "size" : { "w" : width, "h" : height },
-            "repeat" : repeat,
-            "image" : "default"
-        },
-        "frames" : [{
-            "filename" : name,
-            "frame" : { "x" : 0, "y" : 0, "w" : width, "h" : height }
-        }]
-    };
+   return {
+       "meta" : {
+           "app" : "melonJS",
+           "size" : { "w" : width, "h" : height },
+           "repeat" : repeat,
+           "image" : "default"
+       },
+       "frames" : [{
+           "filename" : name,
+           "frame" : { "x" : 0, "y" : 0, "w" : width, "h" : height }
+       }]
+   };
 }
 
+/**
+ * @classdesc
+ * A Texture atlas object, currently supports : <br>
+ * - [TexturePacker]{@link http://www.codeandweb.com/texturepacker/} : through JSON export (standard and multipack texture atlas) <br>
+ * - [ShoeBox]{@link http://renderhjs.net/shoebox/} : through JSON export using the
+ * melonJS setting [file]{@link https://github.com/melonjs/melonJS/raw/master/media/shoebox_JSON_export.sbx} <br>
+ * - [Free Texture Packer]{@link http://free-tex-packer.com/app/} : through JSON export (standard and multipack texture atlas) <br>
+ * - Standard (fixed cell size) spritesheet : through a {framewidth:xx, frameheight:xx, anchorPoint:me.Vector2d} object
+ * @class Texture
+ * @memberOf me.Renderer
+ * @constructor
+ * @param {object|object[]} atlases atlas information. See {@link me.loader.getJSON}
+ * @param {HTMLImageElement|HTMLCanvasElement|string|HTMLImageElement[]|HTMLCanvasElement[]|string[]} [src=atlas.meta.image] Image source
+ * @param {boolean} [cache=false] Use true to skip caching this Texture
+ * @example
+ * // create a texture atlas from a JSON Object
+ * game.texture = new me.video.renderer.Texture(
+ *     me.loader.getJSON("texture")
+ * );
+ *
+ * // create a texture atlas from a multipack JSON Object
+ * game.texture = new me.video.renderer.Texture([
+ *     me.loader.getJSON("texture-0"),
+ *     me.loader.getJSON("texture-1"),
+ *     me.loader.getJSON("texture-2")
+ * ]);
+ *
+ * // create a texture atlas for a spritesheet with an anchorPoint in the center of each frame
+ * game.texture = new me.video.renderer.Texture(
+ *     {
+ *         framewidth : 32,
+ *         frameheight : 32,
+ *         anchorPoint : new me.Vector2d(0.5, 0.5)
+ *     },
+ *     me.loader.getImage("spritesheet")
+ * );
+ */
 export class Texture {
 
     constructor (atlases, src, cache) {
@@ -75,14 +74,14 @@ export class Texture {
 
         /**
          * the texture source(s) itself
-         * @type Map
+         * @type {Map}
          * @ignore
          */
         this.sources = new Map();
 
         /**
          * the atlas dictionnaries
-         * @type Map
+         * @type {Map}
          * @ignore
          */
         this.atlases = new Map();
@@ -327,12 +326,12 @@ export class Texture {
      * @name getAtlas
      * @memberOf me.Renderer.Texture
      * @function
-     * @param {String} [name] atlas name in case of multipack textures
-     * @return {Object}
+     * @param {string} [name] atlas name in case of multipack textures
+     * @returns {object}
      */
-    getAtlas(key) {
-        if (typeof key === "string") {
-            return this.atlases.get(key);
+    getAtlas(name) {
+        if (typeof name === "string") {
+            return this.atlases.get(name);
         } else {
             return this.atlases.values().next().value;
         }
@@ -343,7 +342,7 @@ export class Texture {
      * @name getFormat
      * @memberOf me.Renderer.Texture
      * @function
-     * @return {String} will return "texturepacker", or "ShoeBox", or "melonJS", or "Spritesheet (fixed cell size)"
+     * @returns {string} will return "texturepacker", or "ShoeBox", or "melonJS", or "Spritesheet (fixed cell size)"
      */
     getFormat() {
         return this.format;
@@ -354,8 +353,8 @@ export class Texture {
      * @name getTexture
      * @memberOf me.Renderer.Texture
      * @function
-     * @param {Object} [region] region name in case of multipack textures
-     * @return {HTMLImageElement|HTMLCanvasElement}
+     * @param {object} [region] region name in case of multipack textures
+     * @returns {HTMLImageElement|HTMLCanvasElement}
      */
     getTexture(region) {
         if ((typeof region === "object") && (typeof region.texture === "string")) {
@@ -370,9 +369,9 @@ export class Texture {
      * @name getRegion
      * @memberOf me.Renderer.Texture
      * @function
-     * @param {String} name name of the sprite
-     * @param {String} [atlas] name of a specific atlas where to search for the region
-     * @return {Object}
+     * @param {string} name name of the sprite
+     * @param {string} [atlas] name of a specific atlas where to search for the region
+     * @returns {object}
      */
     getRegion(name, atlas) {
         var region;
@@ -395,8 +394,8 @@ export class Texture {
      * @name getUVs
      * @memberOf me.Renderer.Texture
      * @function
-     * @param {Object} region region (or frame) name
-     * @return {Float32Array} region Uvs
+     * @param {object} name region (or frame) name
+     * @returns {Float32Array} region Uvs
      */
     getUVs(name) {
         // Get the source texture region
@@ -419,10 +418,10 @@ export class Texture {
      * @name createSpriteFromName
      * @memberOf me.Renderer.Texture
      * @function
-     * @param {String} name name of the sprite
-     * @param {Object} [settings] Additional settings passed to the {@link me.Sprite} contructor
-     * @param {Boolean} [nineSlice=false] if true returns a 9-slice sprite
-     * @return {me.Sprite|me.NineSliceSprite}
+     * @param {string} name name of the sprite
+     * @param {object} [settings] Additional settings passed to the {@link me.Sprite} contructor
+     * @param {boolean} [nineSlice=false] if true returns a 9-slice sprite
+     * @returns {me.Sprite|me.NineSliceSprite}
      * @example
      * // create a new texture object under the `game` namespace
      * game.texture = new me.video.renderer.Texture(
@@ -462,10 +461,10 @@ export class Texture {
      * @name createAnimationFromName
      * @memberOf me.Renderer.Texture
      * @function
-     * @param {String[]|Number[]} names list of names for each sprite
+     * @param {string[]|number[]} names list of names for each sprite
      * (when manually creating a Texture out of a spritesheet, only numeric values are authorized)
-     * @param {Object} [settings] Additional settings passed to the {@link me.Sprite} contructor
-     * @return {me.Sprite}
+     * @param {object} [settings] Additional settings passed to the {@link me.Sprite} contructor
+     * @returns {me.Sprite}
      * @example
      * // create a new texture object under the `game` namespace
      * game.texture = new me.video.renderer.Texture(

package/src/video/video.js

@@ -192,20 +192,20 @@ export let renderer = null;
  *  - <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>
  * @function me.video.init
- * @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} [options.renderer=me.video.AUTO] renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO)
- * @param {Boolean} [options.doubleBuffering=false] enable/disable double buffering
- * @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
- * @return {Boolean} false if initialization failed (canvas not supported)
+ * @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} [options.renderer=me.video.AUTO] renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO)
+ * @param {boolean} [options.doubleBuffering=false] enable/disable double buffering
+ * @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
+ * @returns {boolean} false if initialization failed (canvas not supported)
  * @example
  * // init the video with a 640x480 canvas
  * me.video.init(640, 480, {
@@ -216,7 +216,7 @@ export let renderer = null;
  *     doubleBuffering : true
  * });
  */
-export function init(game_width, game_height, options) {
+export function init(width, height, options) {
 
     // ensure melonjs has been properly initialized
     if (!initialized) {
@@ -227,8 +227,8 @@ export function init(game_width, game_height, options) {
     settings = Object.assign(settings, options || {});
 
     // sanitize potential given parameters
-    settings.width = game_width;
-    settings.height = game_height;
+    settings.width = width;
+    settings.height = height;
     settings.doubleBuffering = !!(settings.doubleBuffering);
     settings.transparent = !!(settings.transparent);
     settings.antiAlias = !!(settings.antiAlias);
@@ -268,13 +268,13 @@ export function init(game_width, game_height, options) {
     }
 
     // hold the requested video size ratio
-    designRatio = game_width / game_height;
-    designWidth = game_width;
-    designHeight = game_height;
+    designRatio = width / height;
+    designWidth = width;
+    designHeight = height;
 
     // default scaled size value
-    settings.zoomX = game_width * scaleRatio.x;
-    settings.zoomY = game_height * scaleRatio.y;
+    settings.zoomX = width * scaleRatio.x;
+    settings.zoomY = width * scaleRatio.y;
 
     //add a channel for the onresize/onorientationchange event
     window.addEventListener(
@@ -367,7 +367,7 @@ export function init(game_width, game_height, options) {
             device.getScreenOrientation() + " | " +
             device.language
         );
-        console.log( "resolution: " + "requested " + game_width + "x" + game_height +
+        console.log( "resolution: " + "requested " + width + "x" + height +
             ", got " + renderer.getWidth() + "x" + renderer.getHeight()
         );
     }
@@ -381,10 +381,10 @@ export function init(game_width, game_height, options) {
 /**
  * Create and return a new Canvas element
  * @function me.video.createCanvas
- * @param {Number} width width
- * @param {Number} height height
- * @param {Boolean} [offscreen=false] will returns an OffscreenCanvas if supported
- * @return {HTMLCanvasElement|OffscreenCanvas}
+ * @param {number} width width
+ * @param {number} height height
+ * @param {boolean} [offscreen=false] will returns an OffscreenCanvas if supported
+ * @returns {HTMLCanvasElement|OffscreenCanvas}
  */
 export function createCanvas(width, height, offscreen) {
     var _canvas;
@@ -413,7 +413,7 @@ export function createCanvas(width, height, offscreen) {
 /**
  * return a reference to the parent DOM element holding the main canvas
  * @function me.video.getParent
- * @return {HTMLElement}
+ * @returns {HTMLElement}
  */
 export function getParent() {
     return parent;
@@ -425,8 +425,8 @@ export function getParent() {
  * Only use this if you are not using the automatic scaling feature.
  * @function me.video.scale
  * @see me.video.init
- * @param {Number} x x scaling multiplier
- * @param {Number} y y scaling multiplier
+ * @param {number} x x scaling multiplier
+ * @param {number} y y scaling multiplier
  */
 export function scale(x, y) {
     var canvas = renderer.getScreenCanvas();

package/src/video/webgl/buffer/vertex.js

@@ -2,7 +2,7 @@
  * @classdesc
  * a Vertex Buffer object
  * @class VertexArrayBuffer
- * @private
+ * @ignore
  */
 
 class VertexArrayBuffer {
@@ -29,6 +29,7 @@ class VertexArrayBuffer {
 
     /**
      * clear the vertex array buffer
+     * @ignore
      */
     clear() {
         this.vertexCount = 0;
@@ -37,6 +38,7 @@ class VertexArrayBuffer {
 
     /**
      * return true if full
+     * @ignore
      */
     isFull(vertex = 0) {
          return (this.vertexCount + vertex >= this.maxVertex);
@@ -44,6 +46,7 @@ class VertexArrayBuffer {
 
     /**
      * resize the vertex buffer, retaining its original contents
+     * @ignore
      */
     resize() {
         // double the vertex size
@@ -64,6 +67,7 @@ class VertexArrayBuffer {
 
     /**
      * push a new vertex to the buffer
+     * @ignore
      */
     push(x, y, u, v, tint) {
         var offset = this.vertexCount * this.vertexSize;
@@ -91,6 +95,7 @@ class VertexArrayBuffer {
 
     /**
      * return a reference to the data in Float32 format
+     * @ignore
      */
     toFloat32(begin, end) {
         if (typeof end !== "undefined") {
@@ -102,6 +107,7 @@ class VertexArrayBuffer {
 
     /**
      * return a reference to the data in Uint32 format
+     * @ignore
      */
     toUint32(begin, end) {
         if (typeof end !== "undefined") {
@@ -113,6 +119,7 @@ class VertexArrayBuffer {
 
     /**
      * return the size of the vertex in vertex
+     * @ignore
      */
     length() {
         return this.vertexCount;
@@ -120,6 +127,7 @@ class VertexArrayBuffer {
 
     /**
      * return true if empty
+     * @ignore
      */
     isEmpty() {
         return this.vertexCount === 0;