melonjs 14.0.2 → 14.1.1

package/src/video/renderer.js

@@ -17,21 +17,21 @@ import Point from "../geometries/point.js";
  * @classdesc
  * a base renderer object
  */
-class Renderer {
+ 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.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 {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.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) {
         /**
@@ -155,7 +155,7 @@ class Renderer {
      * Returns the 2D Context object of the given Canvas<br>
      * Also configures anti-aliasing and blend modes based on constructor options.
      * @param {HTMLCanvasElement} canvas
-     * @param {boolean} [transparent=true] use false to disable transparency
+     * @param {boolean} [transparent=true] - use false to disable transparency
      * @returns {CanvasRenderingContext2D}
      */
     getContext2d(canvas, transparent) {
@@ -234,8 +234,8 @@ class Renderer {
 
     /**
      * resizes the system canvas
-     * @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) {
         var canvas = this.getCanvas();
@@ -288,8 +288,8 @@ class Renderer {
 
     /**
      * stroke the given shape
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape a shape object to stroke
-     * @param {boolean} [fill=false] fill the shape with the current color if true
+     * @param {Rect|RoundRect|Polygon|Line|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 RoundRect) {
@@ -325,7 +325,7 @@ class Renderer {
      * fill the given shape
      * @name fill
      * @memberof Renderer
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape a shape object to fill
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape - a shape object to fill
      */
     fill(shape) {
         this.stroke(shape, true);
@@ -333,9 +333,9 @@ class Renderer {
 
     /**
      * tint the given image or canvas using the given color
-     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} src the source image to be tinted
-     * @param {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
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas} src - the source image to be tinted
+     * @param {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) {
@@ -361,8 +361,8 @@ class Renderer {
      * 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] the shape defining the mask to be applied
-     * @param {boolean} [invert=false] either the given shape should define what is visible (default) or the opposite
+     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
+     * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
      */
     // eslint-disable-next-line no-unused-vars
     setMask(mask) {}
@@ -375,8 +375,8 @@ class Renderer {
 
     /**
      * set a coloring tint for sprite based renderables
-     * @param {Color} tint the tint color
-     * @param {number} [alpha] an alpha value to be applied to the tint
+     * @param {Color} tint - the tint color
+     * @param {number} [alpha] - an alpha value to be applied to the tint
      */
     setTint(tint, alpha = tint.alpha) {
         // global tint color
@@ -399,4 +399,3 @@ class Renderer {
     drawFont(/*bounds*/) {}
 
 }
-export default Renderer;

package/src/video/texture/atlas.js

@@ -38,9 +38,9 @@ export function createAtlas(width, height, name = "default", repeat = "no-repeat
  */
 export class TextureAtlas {
     /**
-     * @param {object|object[]} atlases atlas information. See {@link 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
+     * @param {object|object[]} atlases - atlas information. See {@link 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.TextureAtlas(
@@ -269,7 +269,7 @@ export class TextureAtlas {
 
     /**
      * return the default or specified atlas dictionnary
-     * @param {string} [name] atlas name in case of multipack textures
+     * @param {string} [name] - atlas name in case of multipack textures
      * @returns {object}
      */
     getAtlas(name) {
@@ -290,7 +290,7 @@ export class TextureAtlas {
 
     /**
      * return the source texture for the given region (or default one if none specified)
-     * @param {object} [region] region name in case of multipack textures
+     * @param {object} [region] - region name in case of multipack textures
      * @returns {HTMLImageElement|HTMLCanvasElement}
      */
     getTexture(region) {
@@ -303,11 +303,11 @@ export class TextureAtlas {
 
     /**
      * add a region to the atlas
-     * @param {string} name region mame
-     * @param {number} x x origin of the region
-     * @param {number} y y origin of the region
-     * @param {number} w width of the region
-     * @param {number} h height of the region
+     * @param {string} name - region mame
+     * @param {number} x - x origin of the region
+     * @param {number} y - y origin of the region
+     * @param {number} w - width of the region
+     * @param {number} h - height of the region
      * @returns {object} the created region
      */
     addRegion(name, x, y, w, h) {
@@ -336,8 +336,8 @@ export class TextureAtlas {
 
     /**
      * return a normalized region (or frame) information for the specified sprite name
-     * @param {string} name name of the sprite
-     * @param {string} [atlas] name of a specific atlas where to search for the region
+     * @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) {
@@ -358,7 +358,7 @@ export class TextureAtlas {
 
     /**
      * return the uvs mapping for the given region
-     * @param {object} name region (or frame) name
+     * @param {object} name - region (or frame) name
      * @returns {Float32Array} region Uvs
      */
     getUVs(name) {
@@ -379,10 +379,10 @@ export class TextureAtlas {
 
     /**
      * add uvs mapping for the given region
-     * @param {object} atlas the atlas dictionnary where the region is define
-     * @param {object} name region (or frame) name
-     * @param {number} w the width of the region
-     * @param {number} h the height of the region
+     * @param {object} atlas - the atlas dictionnary where the region is define
+     * @param {object} name - region (or frame) name
+     * @param {number} w - the width of the region
+     * @param {number} h - the height of the region
      * @returns {Float32Array} the created region UVs
      */
     addUVs(atlas, name, w, h) {
@@ -409,9 +409,9 @@ export class TextureAtlas {
 
     /**
      * Create a sprite object using the first region found using the specified name
-     * @param {string} name name of the sprite
-     * @param {object} [settings] Additional settings passed to the {@link Sprite} contructor
-     * @param {boolean} [nineSlice=false] if true returns a 9-slice sprite
+     * @param {string} name - name of the sprite
+     * @param {object} [settings] - Additional settings passed to the {@link Sprite} contructor
+     * @param {boolean} [nineSlice=false] - if true returns a 9-slice sprite
      * @returns {Sprite|NineSliceSprite}
      * @example
      * // create a new texture object under the `game` namespace
@@ -449,9 +449,9 @@ export class TextureAtlas {
 
     /**
      * Create an animation object using the first region found using all specified names
-     * @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 Sprite} contructor
+     * @param {object} [settings] - Additional settings passed to the {@link Sprite} contructor
      * @returns {Sprite}
      * @example
      * // create a new texture object under the `game` namespace

package/src/video/texture/canvas_texture.js

@@ -14,13 +14,13 @@ var defaultAttributes = {
  */
 class CanvasTexture {
     /**
-     * @param {number} width the desired width of the canvas
-     * @param {number} height the desired height of the canvas
-     * @param {object} attributes The attributes to create both the canvas and context
-     * @param {boolean} [attributes.context="2d"] the context type to be created ("2d", "webgl", "webgl2")
-     * @param {boolean} [attributes.offscreenCanvas=false] will create an offscreenCanvas if true instead of a standard canvas
-     * @param {boolean} [attributes.willReadFrequently=false] Indicates whether or not a lot of read-back operations are planned
-     * @param {boolean} [attributes.antiAlias=false] Whether to enable anti-aliasing, use false (default) for a pixelated effect.
+     * @param {number} width - the desired width of the canvas
+     * @param {number} height - the desired height of the canvas
+     * @param {object} attributes - The attributes to create both the canvas and context
+     * @param {boolean} [attributes.context="2d"] - the context type to be created ("2d", "webgl", "webgl2")
+     * @param {boolean} [attributes.offscreenCanvas=false] - will create an offscreenCanvas if true instead of a standard canvas
+     * @param {boolean} [attributes.willReadFrequently=false] - Indicates whether or not a lot of read-back operations are planned
+     * @param {boolean} [attributes.antiAlias=false] - Whether to enable anti-aliasing, use false (default) for a pixelated effect.
      */
     constructor(width, height, attributes = defaultAttributes) {
 
@@ -89,8 +89,8 @@ class CanvasTexture {
 
     /**
      * Resizes the canvas texture to the given width and height.
-     * @param {number} width the desired width
-     * @param {number} height the desired height
+     * @param {number} width - the desired width
+     * @param {number} height - the desired height
      */
     resize(width, height) {
         this.canvas.width = Math.round(width);

package/src/video/video.js

@@ -194,18 +194,18 @@ 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 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=video.AUTO] renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO)
- * @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 {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=video.AUTO] - renderer to use (me.video.CANVAS, me.video.WEBGL, me.video.AUTO)
+ * @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
@@ -381,9 +381,9 @@ export function init(width, height, options) {
 /**
  * Create and return a new Canvas element
  * @function video.createCanvas
- * @param {number} width width
- * @param {number} height height
- * @param {boolean} [returnOffscreenCanvas=false] will return an OffscreenCanvas if supported
+ * @param {number} width - width
+ * @param {number} height - height
+ * @param {boolean} [returnOffscreenCanvas=false] - will return an OffscreenCanvas if supported
  * @returns {HTMLCanvasElement|OffscreenCanvas}
  */
 export function createCanvas(width, height, returnOffscreenCanvas = false) {
@@ -425,8 +425,8 @@ export function getParent() {
  * Only use this if you are not using the automatic scaling feature.
  * @function video.scale
  * @see 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.getCanvas();

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

@@ -5,7 +5,7 @@
  * @ignore
  */
 
-class VertexArrayBuffer {
+ export default class VertexArrayBuffer {
 
     constructor(vertex_size, vertex_per_quad) {
         // the size of one vertex in float
@@ -131,4 +131,3 @@ class VertexArrayBuffer {
     }
 
 }
-export default VertexArrayBuffer;

package/src/video/webgl/glshader.js

@@ -10,12 +10,12 @@ import { minify } from "./utils/string.js";
  * @classdesc
  * a base GL Shader object
  */
-class GLShader {
+ export default class GLShader {
     /**
-     * @param {WebGLRenderingContext} gl the current WebGL rendering context
-     * @param {string} vertex a string containing the GLSL source code to set
-     * @param {string} fragment a string containing the GLSL source code to set
-     * @param {string} [precision=auto detected] float precision ('lowp', 'mediump' or 'highp').
+     * @param {WebGLRenderingContext} gl - the current WebGL rendering context
+     * @param {string} vertex - a string containing the GLSL source code to set
+     * @param {string} fragment - a string containing the GLSL source code to set
+     * @param {string} [precision=auto detected] - float precision ('lowp', 'mediump' or 'highp').
      * @see https://developer.mozilla.org/en-US/docs/Games/Techniques/3D_on_the_web/GLSL_Shaders
      * @example
      * // create a basic shader
@@ -90,7 +90,7 @@ class GLShader {
 
     /**
      * returns the location of an attribute variable in this shader program
-     * @param {string} name the name of the attribute variable whose location to get.
+     * @param {string} name - the name of the attribute variable whose location to get.
      * @returns {GLint} number indicating the location of the variable name if found. Returns -1 otherwise
      */
     getAttribLocation(name) {
@@ -104,8 +104,8 @@ class GLShader {
 
     /**
      * Set the uniform to the given value
-     * @param {string} name the uniform name
-     * @param {object|Float32Array} value the value to assign to that uniform
+     * @param {string} name - the uniform name
+     * @param {object|Float32Array} value - the value to assign to that uniform
      * @example
      * myShader.setUniform("uProjectionMatrix", this.projectionMatrix);
      */
@@ -124,9 +124,9 @@ class GLShader {
 
     /**
      * activate the given vertex attribute for this shader
-     * @param {WebGLRenderingContext} gl the current WebGL rendering context
-     * @param {object[]} attributes an array of vertex attributes
-     * @param {number} vertexByteSize the size of a single vertex in bytes
+     * @param {WebGLRenderingContext} gl - the current WebGL rendering context
+     * @param {object[]} attributes - an array of vertex attributes
+     * @param {number} vertexByteSize - the size of a single vertex in bytes
      */
     setVertexAttributes(gl, attributes, vertexByteSize) {
         // set the vertex attributes
@@ -156,4 +156,4 @@ class GLShader {
         this.fragment = null;
     }
 }
-export default GLShader;
+

package/src/video/webgl/webgl_compositor.js

@@ -22,9 +22,9 @@ var V_ARRAY = [
  * 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
  */
-class WebGLCompositor {
+ export default class WebGLCompositor {
     /**
-     * @param {WebGLRenderer} renderer the current WebGL renderer session
+     * @param {WebGLRenderer} renderer - the current WebGL renderer session
      */
     constructor (renderer) {
         this.init(renderer);
@@ -147,11 +147,11 @@ class WebGLCompositor {
 
     /**
      * 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
+     * @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, size, type, normalized, offset) {
         this.attributes.push({
@@ -192,10 +192,10 @@ class WebGLCompositor {
 
     /**
      * 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
+     * @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, y, w, h) {
         this.gl.viewport(x, y, w, h);
@@ -203,15 +203,15 @@ class WebGLCompositor {
 
     /**
      * 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
+     * @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, image, filter, repeat = "no-repeat", w, h, b, premultipliedAlpha = true, mipmap = true) {
@@ -245,8 +245,8 @@ class WebGLCompositor {
 
     /**
      * delete the given WebGL texture
-     * @param {WebGLTexture} [texture] a WebGL texture to delete
-     * @param {number} [unit] Texture unit to delete
+     * @param {WebGLTexture} [texture] - a WebGL texture to delete
+     * @param {number} [unit] - Texture unit to delete
      */
     deleteTexture2D(texture) {
         this.gl.deleteTexture(texture);
@@ -255,7 +255,7 @@ class WebGLCompositor {
 
     /**
      * returns the WebGL texture associated to the given texture unit
-     * @param {number} unit Texture unit to which a texture is bound
+     * @param {number} unit - Texture unit to which a texture is bound
      * @returns {WebGLTexture} texture a WebGL texture
      */
     getTexture2D(unit) {
@@ -264,8 +264,8 @@ class WebGLCompositor {
 
     /**
      * 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
+     * @param {WebGLTexture} texture - a WebGL texture
+     * @param {number} unit - Texture unit to which the given texture is bound
      */
     bindTexture2D(texture, unit) {
         var gl = this.gl;
@@ -289,8 +289,8 @@ class WebGLCompositor {
 
     /**
      * unbind the given WebGL texture, forcing it to be reuploaded
-     * @param {WebGLTexture} [texture] a WebGL texture
-     * @param {number} [unit] a WebGL texture
+     * @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, unit) {
@@ -342,7 +342,7 @@ class WebGLCompositor {
     /**
      * Select the shader to use for compositing
      * @see GLShader
-     * @param {GLShader} shader a reference to a GLShader instance
+     * @param {GLShader} shader - a reference to a GLShader instance
      */
     useShader(shader) {
         if (this.activeShader !== shader) {
@@ -356,16 +356,16 @@ class WebGLCompositor {
 
     /**
      * 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
+     * @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, x, y, w, h, u0, v0, u1, v1, tint) {
 
@@ -410,7 +410,7 @@ class WebGLCompositor {
 
     /**
      * Flush batched texture operations to the GPU
-     * @param {number} [mode=gl.TRIANGLES] the GL drawing mode
+     * @param {number} [mode=gl.TRIANGLES] - the GL drawing mode
      */
     flush(mode = this.mode) {
         var vertex = this.vertexBuffer;
@@ -436,9 +436,9 @@ class WebGLCompositor {
 
     /**
      * 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
+     * @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, verts, vertexCount = verts.length) {
         // use the primitive shader
@@ -484,4 +484,3 @@ class WebGLCompositor {
         gl.clear(gl.COLOR_BUFFER_BIT);
     }
 }
-export default WebGLCompositor;