littlejsengine 1.5.0 → 1.5.1

package/engine/engine.js

@@ -17,43 +17,71 @@
     - Call engineInit() to start it up!
 */
 
+/**
+ * LittleJS Engine Globals
+ * @namespace Engine
+ */
+
 'use strict';
 
-/** Name of engine */
+/** Name of engine
+ *  @type {String}
+ *  @default
+ *  @memberof Engine */
 const engineName = 'LittleJS';
 
-/** Version of engine */
-const engineVersion = '1.5.0';
+/** Version of engine
+ *  @type {String}
+ *  @default
+ *  @memberof Engine */
+const engineVersion = '1.5.1';
 
 /** Frames per second to update objects
- *  @default */
+ *  @type {Number}
+ *  @default
+ *  @memberof Engine */
 const frameRate = 60;
 
 /** How many seconds each frame lasts, engine uses a fixed time step
- *  @default 1/60 */
+ *  @type {Number}
+ *  @default 1/60
+ *  @memberof Engine */
 const timeDelta = 1/frameRate;
 
-/** Array containing all engine objects */
+/** Array containing all engine objects
+ *  @type {Array}
+ *  @memberof Engine */
 let engineObjects = [];
 
-/** Array containing only objects that are set to collide with other objects this frame (for optimization) */
+/** Array containing only objects that are set to collide with other objects this frame (for optimization)
+ *  @type {Array}
+ *  @memberof Engine */
 let engineObjectsCollide = [];
 
-/** Current update frame, used to calculate time */
+/** Current update frame, used to calculate time
+ *  @type {Number}
+ *  @memberof Engine */
 let frame = 0;
 
-/** Current engine time since start in seconds, derived from frame */
+/** Current engine time since start in seconds, derived from frame
+ *  @type {Number}
+ *  @memberof Engine */
 let time = 0;
 
-/** Actual clock time since start in seconds (not affected by pause or frame rate clamping) */
+/** Actual clock time since start in seconds (not affected by pause or frame rate clamping)
+ *  @type {Number}
+ *  @memberof Engine */
 let timeReal = 0;
 
-/** Is the game paused? Causes time and objects to not be updated */
+/** Is the game paused? Causes time and objects to not be updated
+ *  @type {Boolean}
+ *  @default 0
+ *  @memberof Engine */
 let paused = 0;
 
 /** Set if game is paused
  *  @param {Boolean} paused
- */
+ *  @memberof Engine */
 function setPaused(_paused) { paused = _paused; }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -65,7 +93,7 @@ function setPaused(_paused) { paused = _paused; }
  *  @param {Function} gameRender      - Called before objects are rendered, draw any background effects that appear behind objects
  *  @param {Function} gameRenderPost  - Called after objects are rendered, draw effects or hud that appear above all objects
  *  @param {String} [tileImageSource] - Tile image to use, everything starts when the image is finished loading
- */
+ *  @memberof Engine */
 function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, tileImageSource)
 {
     // init engine when tiles load or fail to load
@@ -229,7 +257,8 @@ function enginePreRender()
     glEnable && glPreRender();
 }
 
-/** Update each engine object, remove destroyed objects, and update time */
+/** Update each engine object, remove destroyed objects, and update time
+ *  @memberof Engine */
 function engineObjectsUpdate()
 {
     // get list of solid objects for physics optimzation
@@ -255,7 +284,8 @@ function engineObjectsUpdate()
     time = ++frame / frameRate;
 }
 
-/** Destroy and remove all objects */
+/** Destroy and remove all objects
+ *  @memberof Engine */
 function engineObjectsDestroy()
 {
     for (const o of engineObjects)
@@ -267,7 +297,8 @@ function engineObjectsDestroy()
  *  @param {Vector2} [pos]                 - Center of test area
  *  @param {Number} [size]                 - Radius of circle if float, rectangle size if Vector2
  *  @param {Function} [callbackFunction]   - Calls this function on every object that passes the test
- *  @param {Array} [objects=engineObjects] - List of objects to check */
+ *  @param {Array} [objects=engineObjects] - List of objects to check
+ *  @memberof Engine */
 function engineObjectsCallback(pos, size, callbackFunction, objects=engineObjects)
 {
     if (!pos) // all objects

package/engine/engineAudio.js

@@ -146,7 +146,7 @@ class Music
     {
         if (!soundEnable) return;
 
-        this.source = playSamples(this.cachedSamples, volume, 1, 0, loop);
+        return this.source = playSamples(this.cachedSamples, volume, 1, 0, loop);
     }
 
     /** Stop the music */

package/engine/engineDebug.js

@@ -16,26 +16,31 @@
 'use strict';
 
 /** True if debug is enabled
+ *  @type {Boolean}
  *  @default
  *  @memberof Debug */
 const debug = 1;
 
 /** True if asserts are enaled
+ *  @type {Boolean}
  *  @default
  *  @memberof Debug */
 const enableAsserts = 1;
 
 /** Size to render debug points by default
+ *  @type {Number}
  *  @default
  *  @memberof Debug */
 const debugPointSize = .5;
 
 /** True if watermark with FPS should be down, false in release builds
+ *  @type {Boolean}
  *  @default
  *  @memberof Debug */
 let showWatermark = 1;
 
 /** True if god mode is enabled, handle this however you want
+ *  @type {Boolean}
  *  @default
  *  @memberof Debug */
 let godMode = 0;
@@ -55,7 +60,7 @@ const ASSERT = enableAsserts ? (...assert)=> console.assert(...assert) : ()=>{};
 
 /** Draw a debug rectangle in world space
  *  @param {Vector2} pos
- *  @param {Vector2} [size=new Vector2()]
+ *  @param {Vector2} [size=Vector2()]
  *  @param {String}  [color='#fff']
  *  @param {Number}  [time=0]
  *  @param {Number}  [angle=0]

package/engine/engineDraw.js

@@ -78,15 +78,15 @@ const worldToScreen = (worldPos)=>
 }
 
 /** Draw textured tile centered in world space, with color applied if using WebGL
- *  @param {Vector2} pos                                - Center of the tile in world space
- *  @param {Vector2} [size=new Vector2(1,1)]            - Size of the tile in world space
- *  @param {Number}  [tileIndex=-1]                     - Tile index to use, negative is untextured
- *  @param {Vector2} [tileSize=tileSizeDefault]         - Tile size in source pixels
- *  @param {Color}   [color=new Color(1,1,1)]           - Color to modulate with
- *  @param {Number}  [angle=0]                          - Angle to rotate by
- *  @param {Boolean} [mirror=0]                         - If true image is flipped along the Y axis
- *  @param {Color}   [additiveColor=new Color(0,0,0,0)] - Additive color to be applied
- *  @param {Boolean} [useWebGL=glEnable]                - Use accelerated WebGL rendering
+ *  @param {Vector2} pos                            - Center of the tile in world space
+ *  @param {Vector2} [size=Vector2(1,1)]            - Size of the tile in world space
+ *  @param {Number}  [tileIndex=-1]                 - Tile index to use, negative is untextured
+ *  @param {Vector2} [tileSize=tileSizeDefault]     - Tile size in source pixels
+ *  @param {Color}   [color=Color()]                - Color to modulate with
+ *  @param {Number}  [angle=0]                      - Angle to rotate by
+ *  @param {Boolean} [mirror=0]                     - If true image is flipped along the Y axis
+ *  @param {Color}   [additiveColor=Color(0,0,0,0)] - Additive color to be applied
+ *  @param {Boolean} [useWebGL=glEnable]            - Use accelerated WebGL rendering
  *  @memberof Draw */
 function drawTile(pos, size=vec2(1), tileIndex=-1, tileSize=tileSizeDefault, color=new Color, angle=0, mirror, 
     additiveColor=new Color(0,0,0,0), useWebGL=glEnable)
@@ -141,8 +141,8 @@ function drawTile(pos, size=vec2(1), tileIndex=-1, tileSize=tileSizeDefault, col
 
 /** Draw colored rect centered on pos
  *  @param {Vector2} pos
- *  @param {Vector2} [size=new Vector2(1,1)]
- *  @param {Color}   [color=new Color(1,1,1)]
+ *  @param {Vector2} [size=Vector2(1,1)]
+ *  @param {Color}   [color=Color()]
  *  @param {Number}  [angle=0]
  *  @param {Boolean} [useWebGL=glEnable]
  *  @memberof Draw */
@@ -153,13 +153,13 @@ function drawRect(pos, size, color, angle, useWebGL)
 
 /** Draw textured tile centered on pos in screen space
  *  @param {Vector2} pos                        - Center of the tile
- *  @param {Vector2} [size=new Vector2(1,1)]    - Size of the tile
+ *  @param {Vector2} [size=Vector2(1,1)]    - Size of the tile
  *  @param {Number}  [tileIndex=-1]             - Tile index to use, negative is untextured
  *  @param {Vector2} [tileSize=tileSizeDefault] - Tile size in source pixels
- *  @param {Color}   [color=new Color]
+ *  @param {Color}   [color=Color()]
  *  @param {Number}  [angle=0]
  *  @param {Boolean} [mirror=0]
- *  @param {Color}   [additiveColor=new Color(0,0,0,0)]
+ *  @param {Color}   [additiveColor=Color(0,0,0,0)]
  *  @param {Boolean} [useWebGL=glEnable]
  *  @memberof Draw */
 function drawTileScreenSpace(pos, size=vec2(1), tileIndex, tileSize, color, angle, mirror, additiveColor, useWebGL)
@@ -169,8 +169,8 @@ function drawTileScreenSpace(pos, size=vec2(1), tileIndex, tileSize, color, angl
 
 /** Draw colored rectangle in screen space
  *  @param {Vector2} pos
- *  @param {Vector2} [size=new Vector2(1,1)]
- *  @param {Color}   [color=new Color(1,1,1)]
+ *  @param {Vector2} [size=Vector2(1,1)]
+ *  @param {Color}   [color=Color()]
  *  @param {Number}  [angle=0]
  *  @param {Boolean} [useWebGL=glEnable]
  *  @memberof Draw */
@@ -183,7 +183,7 @@ function drawRectScreenSpace(pos, size, color, angle, useWebGL)
  *  @param {Vector2} posA
  *  @param {Vector2} posB
  *  @param {Number}  [thickness=.1]
- *  @param {Color}   [color=new Color(1,1,1)]
+ *  @param {Color}   [color=Color()]
  *  @param {Boolean} [useWebGL=glEnable]
  *  @memberof Draw */
 function drawLine(posA, posB, thickness=.1, color, useWebGL)
@@ -231,9 +231,9 @@ function setBlendMode(additive, useWebGL=glEnable)
  *  @param {String}  text
  *  @param {Vector2} pos
  *  @param {Number}  [size=1]
- *  @param {Color}   [color=new Color(1,1,1)]
+ *  @param {Color}   [color=Color()]
  *  @param {Number}  [lineWidth=0]
- *  @param {Color}   [lineColor=new Color(0,0,0)]
+ *  @param {Color}   [lineColor=Color(0,0,0)]
  *  @param {String}  [textAlign='center']
  *  @memberof Draw */
 function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), textAlign='center', font=fontDefault, context=overlayContext)
@@ -260,18 +260,20 @@ function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineCol
  *  @param {String}  text
  *  @param {Vector2} pos
  *  @param {Number}  [size=1]
- *  @param {Color}   [color=new Color(1,1,1)]
+ *  @param {Color}   [color=Color()]
  *  @param {Number}  [lineWidth=0]
- *  @param {Color}   [lineColor=new Color(0,0,0)]
+ *  @param {Color}   [lineColor=Color(0,0,0)]
  *  @param {String}  [textAlign='center']
  *  @memberof Draw */
-function drawText(text, pos, size=1, color, lineWidth, lineColor, textAlign, font)
+function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font)
 {
     drawTextScreen(text, worldToScreen(pos), size*cameraScale, color, lineWidth*cameraScale, lineColor, textAlign, font, mainContext);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+let engineFontImage;
+
 /** 
  * Font Image Object - Draw text on a 2D canvas by using characters in an image
  * <br> - 96 characters (from space to tilde) are stored in an image
@@ -284,10 +286,6 @@ function drawText(text, pos, size=1, color, lineWidth, lineColor, textAlign, fon
  * // draw text
  * font.drawTextScreen("LittleJS\nHello World!", vec2(200, 50));
  */
-
-// default font image created by engine
-let engineFontImage;
-
 class FontImage
 {
     /** Create an image font

package/engine/engineExport.js

@@ -4,43 +4,187 @@
  */
 
 // Setters for all variables that devs will need to modify
-const setCameraPos =                    (v)=> cameraPos = v;
-const setCameraScale =                  (v)=> cameraScale = v;
-const setCanvasMaxSize =                (v)=> canvasMaxSize = v;
-const setCanvasFixedSize =              (v)=> canvasFixedSize = v;
-const setCavasPixelated =               (v)=> cavasPixelated = v;
-const setFontDefault =                  (v)=> fontDefault = v;
-const setGlEnable =                     (v)=> glEnable = v;
-const setGlOverlay =                    (v)=> glOverlay = v;
-const setTileSizeDefault =              (v)=> tileSizeDefault = v;
-const setTileFixBleedScale =            (v)=> tileFixBleedScale = v;
-const setObjectDefaultSize =            (v)=> objectDefaultSize = v;
-const setEnablePhysicsSolver =          (v)=> enablePhysicsSolver = v;
-const setObjectDefaultMass =            (v)=> objectDefaultMass = v;
-const setObjectDefaultDamping =         (v)=> objectDefaultDamping = v;
-const setObjectDefaultAngleDamping =    (v)=> objectDefaultAngleDamping = v;
-const setObjectDefaultElasticity =      (v)=> objectDefaultElasticity = v;
-const setObjectDefaultFriction =        (v)=> objectDefaultFriction = v;
-const setObjectMaxSpeed =               (v)=> objectMaxSpeed = v;
-const setGravity =                      (v)=> gravity = v;
-const setParticleEmitRateScale =        (v)=> particleEmitRateScale = v;
-const setGamepadsEnable =               (v)=> gamepadsEnable = v;
-const setGamepadDirectionEmulateStick = (v)=> gamepadDirectionEmulateStick = v;
-const setInputWASDEmulateDirection =    (v)=> inputWASDEmulateDirection = v;
-const setTouchGamepadEnable =           (v)=> touchGamepadEnable = v;
-const setTouchGamepadAnalog =           (v)=> touchGamepadAnalog = v;
-const setTouchGamepadSize =             (v)=> touchGamepadSize = v;
-const setTouchGamepadAlpha =            (v)=> touchGamepadAlpha = v;
-const setVibrateEnable =                (v)=> vibrateEnable = v;
-const setSoundEnable =                  (v)=> soundEnable = v;
-const setSoundVolume =                  (v)=> soundVolume = v;
-const setSoundDefaultRange =            (v)=> soundDefaultRange = v;
-const setSoundDefaultTaper =            (v)=> soundDefaultTaper = v;
-const setMedalDisplayTime =             (v)=> medalDisplayTime = v;
-const setMedalDisplaySlideTime =        (v)=> medalDisplaySlideTime = v;
-const setMedalDisplaySize =            	(v)=> medalDisplaySize = v;
-const setMedalDisplayIconSize =         (v)=> medalDisplayIconSize = v;
-const setMedalsPreventUnlock =          (v)=> medalsPreventUnlock = v;
+
+
+/** Set position of camera in world space
+ *  @param {Vector2} pos
+ *  @memberof Settings */
+const setCameraPos = (pos)=> cameraPos = pos;
+
+/** Set scale of camera in world space
+ *  @param {Number} scale
+ *  @memberof Settings */
+const setCameraScale = (scale)=> cameraScale = scale;
+
+/** Set max size of the canvas
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setCanvasMaxSize = (size)=> canvasMaxSize = size;
+
+/** Set fixed size of the canvas
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setCanvasFixedSize = (size)=> canvasFixedSize = size;
+
+/** Disables anti aliasing for pixel art if true
+ *  @param {Boolean} pixelated
+ *  @memberof Settings */
+const setCavasPixelated = (pixelated)=> cavasPixelated = pixelated;
+
+/** Set default font used for text rendering
+ *  @param {String} font
+ *  @memberof Settings */
+const setFontDefault = (font)=> fontDefault = font;
+
+/** Set if webgl rendering is enabled
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setGlEnable = (enable)=> glEnable = enable;
+
+/** Set to not composite the WebGL canvas
+ *  @param {Boolean} overlay
+ *  @memberof Settings */
+const setGlOverlay = (overlay)=> glOverlay = overlay;
+
+/** Set default size of tiles in pixels
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setTileSizeDefault = (size)=> tileSizeDefault = size;
+
+/** Set to prevent tile bleeding from neighbors in pixels
+ *  @param {Number} scale
+ *  @memberof Settings */
+const setTileFixBleedScale = (scale)=> tileFixBleedScale = scale;
+
+/** Set if collisions between objects are enabled
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setEnablePhysicsSolver = (enable)=> enablePhysicsSolver = enable;
+
+/** Set default object mass for collison calcuations
+ *  @param {Number} mass
+ *  @memberof Settings */
+const setObjectDefaultMass = (mass)=> objectDefaultMass = mass;
+
+/** Set how much to slow velocity by each frame
+ *  @param {Number} damping
+ *  @memberof Settings */
+const setObjectDefaultDamping = (damp)=> objectDefaultDamping = damp;
+
+/** Set how much to slow angular velocity each frame
+ *  @param {Number} damping
+ *  @memberof Settings */
+const setObjectDefaultAngleDamping = (damp)=> objectDefaultAngleDamping = damp;
+
+/** Set how much to bounce when a collision occur
+ *  @param {Number} elasticity
+ *  @memberof Settings */
+const setObjectDefaultElasticity = (elasticity)=> objectDefaultElasticity = elasticity;
+
+/** Set how much to slow when touching
+ *  @param {Number} friction
+ *  @memberof Settings */
+const setObjectDefaultFriction = (friction)=> objectDefaultFriction = friction;
+
+/** Set max speed to avoid fast objects missing collisions
+ *  @param {Number} speed
+ *  @memberof Settings */
+const setObjectMaxSpeed = (speed)=> objectMaxSpeed = speed;
+
+/** Set how much gravity to apply to objects along the Y axis
+ *  @param {Number} gravity
+ *  @memberof Settings */
+const setGravity = (g)=> gravity = g;
+
+/** Set to scales emit rate of particles
+ *  @param {Number} scale
+ *  @memberof Settings */
+const setParticleEmitRateScale = (scale)=> particleEmitRateScale = scale;
+
+/** Set if gamepads are enabled
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setGamepadsEnable = (enable)=> gamepadsEnable = enable;
+
+/** Set if the dpad input is also routed to the left analog stick
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setGamepadDirectionEmulateStick = (enable)=> gamepadDirectionEmulateStick = enable;
+
+/** Set if true the WASD keys are also routed to the direction keys
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setInputWASDEmulateDirection = (enable)=> inputWASDEmulateDirection = enable;
+
+/** Set if touch gamepad should appear on mobile devices
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setTouchGamepadEnable = (enable)=> touchGamepadEnable = enable;
+
+/** Set if touch gamepad should be analog stick or 8 way dpad
+ *  @param {Boolean} analog
+ *  @memberof Settings */
+const setTouchGamepadAnalog = (analog)=> touchGamepadAnalog = analog;
+
+/** Set size of virutal gamepad for touch devices in pixels
+ *  @param {Number} size
+ *  @memberof Settings */
+const setTouchGamepadSize = (size)=> touchGamepadSize = size;
+
+/** Set transparency of touch gamepad overlay
+ *  @param {Number} alpha
+ *  @memberof Settings */
+const setTouchGamepadAlpha = (alpha)=> touchGamepadAlpha = alpha;
+
+/** Set to allow vibration hardware if it exists
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setVibrateEnable = (enable)=> vibrateEnable = enable;
+
+/** Set to disable all audio code
+ *  @param {Boolean} enable
+ *  @memberof Settings */
+const setSoundEnable = (enable)=> soundEnable = enable;
+
+/** Set volume scale to apply to all sound, music and speech
+ *  @param {Number} volume
+ *  @memberof Settings */
+const setSoundVolume = (volume)=> soundVolume = volume;
+
+/** Set default range where sound no longer plays
+ *  @param {Number} range
+ *  @memberof Settings */
+const setSoundDefaultRange = (range)=> soundDefaultRange = range;
+
+/** Set default range percent to start tapering off sound
+ *  @param {Number} taper
+ *  @memberof Settings */
+const setSoundDefaultTaper = (taper)=> soundDefaultTaper = taper;
+
+/** Set how long to show medals for in seconds
+ *  @param {Number} time
+ *  @memberof Settings */
+const setMedalDisplayTime = (time)=> medalDisplayTime = time;
+
+/** Set how quickly to slide on/off medals in seconds
+ *  @param {Number} time
+ *  @memberof Settings */
+const setMedalDisplaySlideTime = (time)=> medalDisplaySlideTime = time;
+
+/** Set size of medal display
+ *  @param {Vector2} size
+ *  @memberof Settings */
+const setMedalDisplaySize = (size)=> medalDisplaySize = size;
+
+/** Set size of icon in medal display
+ *  @param {Number} size
+ *  @memberof Settings */
+const setMedalDisplayIconSize = (size)=> medalDisplayIconSize = size;
+
+/** Set to stop medals from being unlockable
+ *  @param {Boolean} preventUnlock
+ *  @memberof Settings */
+const setMedalsPreventUnlock = (prevent)=> medalsPreventUnlock = prevent;
 
 export {
 	// Setters for global variables
@@ -54,7 +198,6 @@ export {
 	setGlOverlay,
 	setTileSizeDefault,
 	setTileFixBleedScale,
-	setObjectDefaultSize,
 	setEnablePhysicsSolver,
 	setObjectDefaultMass,
 	setObjectDefaultDamping,
@@ -89,7 +232,6 @@ export {
 	fontDefault,
 	tileSizeDefault,
 	tileFixBleedScale,
-	objectDefaultSize,
 	enablePhysicsSolver,
 	objectDefaultMass,
 	objectDefaultDamping,
@@ -124,17 +266,9 @@ export {
 	debug,
 	showWatermark,
 	godMode,
+
 	// Debug
-	//debugPrimitives,
-	//debugOverlay,
-	//debugPhysics,
-	//debugRaycast,
-	//debugParticles,
-	//debugGamepads,
-	//debugMedals,
-	//debugTakeScreenshot,
-	//downloadLink,
-	//ASSERT,
+	ASSERT,
 	debugRect,
 	debugCircle,
 	debugPoint,
@@ -143,9 +277,6 @@ export {
 	debugText,
 	debugClear,
 	debugSaveCanvas,
-	//debugInit,
-	//debugUpdate,
-	//debugRender,
 
 	// Utilities
 	PI,
@@ -225,18 +356,6 @@ export {
 	gamepadWasPressed,
 	gamepadWasReleased,
 	gamepadStick,
-	//inputData,
-	//inputUpdate,
-	//inputUpdatePost,
-	// onkeydown,
-	// onkeyup,
-	//remapKeyCode,
-	// onmousedown,
-	// onmouseup,
-	// onmousemove,
-	// onwheel,
-	// oncontextmenu,
-	//stickData,
 	mouseToScreen,
 	gamepadsUpdate,
 	vibrate,
@@ -253,9 +372,6 @@ export {
 	audioContext,
 	playSamples,
 	zzfx,
-	//zzfxR,
-	//zzfxG,
-	//zzfxM,
 
 	// Tiles
 	tileCollision,
@@ -278,25 +394,17 @@ export {
 	medalsInit,
 	newgroundsInit,
 	Medal,
-	//medalsRender,
 	Newgrounds,
-	//CryptoJS,
 
 	// WebGL
 	glCanvas,
 	glContext,
-	//glInit,
 	glSetBlendMode,
 	glSetTexture,
 	glCompileShader,
 	glCreateProgram,
 	glCreateTexture,
-	//glPreRender,
-	//glFlush,
-	//glCopyToContext,
-	//glDraw,
 	glInitPostProcess,
-	//glRenderPostProcess,
 
 	// Engine
 	engineName,
@@ -304,7 +412,6 @@ export {
 	frameRate,
 	timeDelta,
 	engineObjects,
-	//engineObjectsCollide,
 	frame,
 	time,
 	timeReal,

package/engine/engineInput.js

@@ -35,18 +35,21 @@ const keyWasReleased = (key, device=0)=> inputData[device] && inputData[device][
 const clearInput = ()=> inputData = [[]];
 
 /** Returns true if mouse button is down
+ *  @function
  *  @param {Number} button
  *  @return {Boolean}
  *  @memberof Input */
 const mouseIsDown = keyIsDown;
 
 /** Returns true if mouse button was pressed
+ *  @function
  *  @param {Number} button
  *  @return {Boolean}
  *  @memberof Input */
 const mouseWasPressed = keyWasPressed;
 
 /** Returns true if mouse button was released
+ *  @function
  *  @param {Number} button
  *  @return {Boolean}
  *  @memberof Input */
@@ -63,14 +66,17 @@ let mousePos = vec2();
 let mousePosScreen = vec2();
 
 /** Mouse wheel delta this frame
+ *  @type {Number}
  *  @memberof Input */
 let mouseWheel = 0;
 
 /** Returns true if user is using gamepad (has more recently pressed a gamepad button)
+ *  @type {Boolean}
  *  @memberof Input */
 let isUsingGamepad = 0;
 
 /** Prevents input continuing to the default browser handling (false by default)
+ *  @type {Boolean}
  *  @memberof Input */
 let preventDefaultInput = 0;
 
@@ -246,7 +252,6 @@ const vibrateStop = ()=> vibrate(0);
 // Touch input
 
 /** True if a touch device has been detected
- *  @const {Boolean}
  *  @memberof Input */
 const isTouchDevice = window.ontouchstart !== undefined;
 

package/engine/engineMedals.js

@@ -9,6 +9,7 @@
 'use strict';
 
 /** List of all medals
+ *  @type {Array}
  *  @memberof Medals */
 const medals = [];