littlejsengine 1.6.0 → 1.6.6

package/src/engineDraw.js

@@ -1,22 +1,22 @@
 /** 
  * LittleJS Drawing System
- * <br> - Hybrid with both Canvas2D and WebGL available
- * <br> - Super fast tile sheet rendering with WebGL
- * <br> - Can apply rotation, mirror, color and additive color
- * <br> - Many useful utility functions
- * <br>
- * <br>LittleJS uses a hybrid rendering solution with the best of both Canvas2D and WebGL.
- * <br>There are 3 canvas/contexts available to draw to...
- * <br> - mainCanvas - 2D background canvas, non WebGL stuff like tile layers are drawn here.
- * <br> - glCanvas - Used by the accelerated WebGL batch rendering system.
- * <br> - overlayCanvas - Another 2D canvas that appears on top of the other 2 canvases.
- * <br>
- * <br>The WebGL rendering system is very fast with some caveats...
- * <br> - The default setup supports only 1 tile sheet, to support more call glCreateTexture and glSetTexture
- * <br> - Switching blend modes (additive) or textures causes another draw call which is expensive in excess
- * <br> - Group additive rendering together using renderOrder to mitigate this issue
- * <br>
- * <br>The LittleJS rendering solution is intentionally simple, feel free to adjust it for your needs!
+ * - Hybrid with both Canvas2D and WebGL available
+ * - Super fast tile sheet rendering with WebGL
+ * - Can apply rotation, mirror, color and additive color
+ * - Many useful utility functions
+ * 
+ * LittleJS uses a hybrid rendering solution with the best of both Canvas2D and WebGL.
+ * There are 3 canvas/contexts available to draw to...
+ * mainCanvas - 2D background canvas, non WebGL stuff like tile layers are drawn here.
+ * glCanvas - Used by the accelerated WebGL batch rendering system.
+ * overlayCanvas - Another 2D canvas that appears on top of the other 2 canvases.
+ * 
+ * The WebGL rendering system is very fast with some caveats...
+ * - The default setup supports only 1 tile sheet, to support more call glCreateTexture and glSetTexture
+ * - Switching blend modes (additive) or textures causes another draw call which is expensive in excess
+ * - Group additive rendering together using renderOrder to mitigate this issue
+ * 
+ * The LittleJS rendering solution is intentionally simple, feel free to adjust it for your needs!
  * @namespace Draw
  */
 
@@ -60,7 +60,7 @@ let tileImageSize, tileImageFixBleed, drawCount;
  *  @param {Vector2} screenPos
  *  @return {Vector2}
  *  @memberof Draw */
-const screenToWorld = (screenPos)=>
+function screenToWorld(screenPos)
 {
     ASSERT(mainCanvasSize.x && mainCanvasSize.y, 'mainCanvasSize is invalid');
     return screenPos.add(vec2(.5)).subtract(mainCanvasSize.scale(.5)).multiply(vec2(1/cameraScale,-1/cameraScale)).add(cameraPos);
@@ -71,7 +71,7 @@ const screenToWorld = (screenPos)=>
  *  @param {Vector2} worldPos
  *  @return {Vector2}
  *  @memberof Draw */
-const worldToScreen = (worldPos)=>
+function worldToScreen(worldPos)
 {
     ASSERT(mainCanvasSize.x && mainCanvasSize.y, 'mainCanvasSize is invalid');
     return worldPos.subtract(cameraPos).multiply(vec2(cameraScale,-cameraScale)).add(mainCanvasSize.scale(.5)).subtract(vec2(.5));
@@ -226,6 +226,23 @@ function setBlendMode(additive, useWebGL=glEnable)
         mainContext.globalCompositeOperation = additive ? 'lighter' : 'source-over';
 }
 
+/** Draw text on overlay canvas in world space
+ *  Automatically splits new lines into rows
+ *  @param {String}  text
+ *  @param {Vector2} pos
+ *  @param {Number}  [size=1]
+ *  @param {Color}   [color=Color()]
+ *  @param {Number}  [lineWidth=0]
+ *  @param {Color}   [lineColor=Color(0,0,0)]
+ *  @param {String}  [textAlign='center']
+ *  @param {String}  [font=fontDefault]
+ *  @param {CanvasRenderingContext2D} [context=overlayContext]
+ *  @memberof Draw */
+function drawText(text, pos, size=1, color, lineWidth=0, lineColor, textAlign, font, context)
+{
+    drawTextScreen(text, worldToScreen(pos), size*cameraScale, color, lineWidth*cameraScale, lineColor, textAlign, font, context);
+}
+
 /** Draw text on overlay canvas in screen space
  *  Automatically splits new lines into rows
  *  @param {String}  text
@@ -235,6 +252,8 @@ function setBlendMode(additive, useWebGL=glEnable)
  *  @param {Number}  [lineWidth=0]
  *  @param {Color}   [lineColor=Color(0,0,0)]
  *  @param {String}  [textAlign='center']
+ *  @param {String}  [font=fontDefault]
+ *  @param {CanvasRenderingContext2D} [context=overlayContext]
  *  @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)
 {
@@ -255,30 +274,15 @@ function drawTextScreen(text, pos, size=1, color=new Color, lineWidth=0, lineCol
     });
 }
 
-/** Draw text on overlay canvas in world space
- *  Automatically splits new lines into rows
- *  @param {String}  text
- *  @param {Vector2} pos
- *  @param {Number}  [size=1]
- *  @param {Color}   [color=Color()]
- *  @param {Number}  [lineWidth=0]
- *  @param {Color}   [lineColor=Color(0,0,0)]
- *  @param {String}  [textAlign='center']
- *  @memberof Draw */
-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
- * <br> - Uses a default 8x8 font if none is supplied
- * <br> - You can also use fonts from the main tile sheet
+ * - 96 characters (from space to tilde) are stored in an image
+ * - Uses a default 8x8 font if none is supplied
+ * - You can also use fonts from the main tile sheet
  * @example
  * // use built in font
  * const font = new ImageFont;
@@ -318,7 +322,7 @@ class FontImage
     {
         const context = this.context;
         context.save();
-        context.imageSmoothingEnabled = !cavasPixelated;
+        context.imageSmoothingEnabled = !canvasPixelated;
 
         const size = this.tileSize;
         const drawSize = size.add(this.paddingSize).scale(scale);
@@ -364,7 +368,7 @@ class FontImage
 /** Returns true if fullscreen mode is active
  *  @return {Boolean}
  *  @memberof Draw */
-const isFullscreen = ()=> document.fullscreenElement;
+function isFullscreen() { return document.fullscreenElement; }
 
 /** Toggle fullsceen mode
  *  @memberof Draw */

package/src/engineExport.js

@@ -1,200 +1,202 @@
 /** 
  * LittleJS Module Export
- * <br> - Export engine as a module with extra functions where necessary
+ * - Export engine as a module with extra functions where necessary
  */
 
-// Setters for all variables that devs will need to modify
-
-
 /** Set position of camera in world space
  *  @param {Vector2} pos
  *  @memberof Settings */
-const setCameraPos = (pos)=> cameraPos = pos;
+function setCameraPos(pos) { cameraPos = pos; }
 
 /** Set scale of camera in world space
  *  @param {Number} scale
  *  @memberof Settings */
-const setCameraScale = (scale)=> cameraScale = scale;
+function setCameraScale(scale) { cameraScale = scale; }
 
 /** Set max size of the canvas
  *  @param {Vector2} size
  *  @memberof Settings */
-const setCanvasMaxSize = (size)=> canvasMaxSize = size;
+function setCanvasMaxSize(size) { canvasMaxSize = size; }
 
 /** Set fixed size of the canvas
  *  @param {Vector2} size
  *  @memberof Settings */
-const setCanvasFixedSize = (size)=> canvasFixedSize = size;
+function setCanvasFixedSize(size) { canvasFixedSize = size; }
 
 /** Disables anti aliasing for pixel art if true
  *  @param {Boolean} pixelated
  *  @memberof Settings */
-const setCavasPixelated = (pixelated)=> cavasPixelated = pixelated;
+function setCanvasPixelated(pixelated) { canvasPixelated = pixelated; }
 
 /** Set default font used for text rendering
  *  @param {String} font
  *  @memberof Settings */
-const setFontDefault = (font)=> fontDefault = font;
+function setFontDefault(font) { fontDefault = font; }
 
 /** Set if webgl rendering is enabled
  *  @param {Boolean} enable
  *  @memberof Settings */
-const setGlEnable = (enable)=> glEnable = enable;
+function setGlEnable(enable) { glEnable = enable; }
 
 /** Set to not composite the WebGL canvas
  *  @param {Boolean} overlay
  *  @memberof Settings */
-const setGlOverlay = (overlay)=> glOverlay = overlay;
+function setGlOverlay(overlay) { glOverlay = overlay; }
 
 /** Set default size of tiles in pixels
  *  @param {Vector2} size
  *  @memberof Settings */
-const setTileSizeDefault = (size)=> tileSizeDefault = size;
+function setTileSizeDefault(size) { tileSizeDefault = size; }
 
 /** Set to prevent tile bleeding from neighbors in pixels
  *  @param {Number} scale
  *  @memberof Settings */
-const setTileFixBleedScale = (scale)=> tileFixBleedScale = scale;
+function setTileFixBleedScale(scale) { tileFixBleedScale = scale; }
 
 /** Set if collisions between objects are enabled
  *  @param {Boolean} enable
  *  @memberof Settings */
-const setEnablePhysicsSolver = (enable)=> enablePhysicsSolver = enable;
+function setEnablePhysicsSolver(enable) { enablePhysicsSolver = enable; }
 
 /** Set default object mass for collison calcuations
  *  @param {Number} mass
  *  @memberof Settings */
-const setObjectDefaultMass = (mass)=> objectDefaultMass = mass;
+function setObjectDefaultMass(mass) { objectDefaultMass = mass; }
 
 /** Set how much to slow velocity by each frame
  *  @param {Number} damping
  *  @memberof Settings */
-const setObjectDefaultDamping = (damp)=> objectDefaultDamping = damp;
+function setObjectDefaultDamping(damp) { objectDefaultDamping = damp; }
 
 /** Set how much to slow angular velocity each frame
  *  @param {Number} damping
  *  @memberof Settings */
-const setObjectDefaultAngleDamping = (damp)=> objectDefaultAngleDamping = damp;
+function setObjectDefaultAngleDamping(damp) { objectDefaultAngleDamping = damp; }
 
 /** Set how much to bounce when a collision occur
  *  @param {Number} elasticity
  *  @memberof Settings */
-const setObjectDefaultElasticity = (elasticity)=> objectDefaultElasticity = elasticity;
+function setObjectDefaultElasticity(elasticity) { objectDefaultElasticity = elasticity; }
 
 /** Set how much to slow when touching
  *  @param {Number} friction
  *  @memberof Settings */
-const setObjectDefaultFriction = (friction)=> objectDefaultFriction = friction;
+function setObjectDefaultFriction(friction) { objectDefaultFriction = friction; }
 
 /** Set max speed to avoid fast objects missing collisions
  *  @param {Number} speed
  *  @memberof Settings */
-const setObjectMaxSpeed = (speed)=> objectMaxSpeed = speed;
+function 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;
+function setGravity(g) { gravity = g; }
 
 /** Set to scales emit rate of particles
  *  @param {Number} scale
  *  @memberof Settings */
-const setParticleEmitRateScale = (scale)=> particleEmitRateScale = scale;
+function setParticleEmitRateScale(scale) { particleEmitRateScale = scale; }
 
 /** Set if gamepads are enabled
  *  @param {Boolean} enable
  *  @memberof Settings */
-const setGamepadsEnable = (enable)=> gamepadsEnable = enable;
+function 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;
+function 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;
+function setInputWASDEmulateDirection(enable) { inputWASDEmulateDirection = enable; }
 
 /** Set if touch gamepad should appear on mobile devices
  *  @param {Boolean} enable
  *  @memberof Settings */
-const setTouchGamepadEnable = (enable)=> touchGamepadEnable = enable;
+function 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;
+function setTouchGamepadAnalog(analog) { touchGamepadAnalog = analog; }
 
 /** Set size of virutal gamepad for touch devices in pixels
  *  @param {Number} size
  *  @memberof Settings */
-const setTouchGamepadSize = (size)=> touchGamepadSize = size;
+function setTouchGamepadSize(size) { touchGamepadSize = size; }
 
 /** Set transparency of touch gamepad overlay
  *  @param {Number} alpha
  *  @memberof Settings */
-const setTouchGamepadAlpha = (alpha)=> touchGamepadAlpha = alpha;
+function setTouchGamepadAlpha(alpha) { touchGamepadAlpha = alpha; }
 
 /** Set to allow vibration hardware if it exists
  *  @param {Boolean} enable
  *  @memberof Settings */
-const setVibrateEnable = (enable)=> vibrateEnable = enable;
+function setVibrateEnable(enable) { vibrateEnable = enable; }
 
 /** Set to disable all audio code
  *  @param {Boolean} enable
  *  @memberof Settings */
-const setSoundEnable = (enable)=> soundEnable = enable;
+function 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;
+function setSoundVolume(volume) { soundVolume = volume; }
 
 /** Set default range where sound no longer plays
  *  @param {Number} range
  *  @memberof Settings */
-const setSoundDefaultRange = (range)=> soundDefaultRange = range;
+function setSoundDefaultRange(range) { soundDefaultRange = range; }
 
 /** Set default range percent to start tapering off sound
  *  @param {Number} taper
  *  @memberof Settings */
-const setSoundDefaultTaper = (taper)=> soundDefaultTaper = taper;
+function setSoundDefaultTaper(taper) { soundDefaultTaper = taper; }
 
 /** Set how long to show medals for in seconds
  *  @param {Number} time
  *  @memberof Settings */
-const setMedalDisplayTime = (time)=> medalDisplayTime = time;
+function setMedalDisplayTime(time) { medalDisplayTime = time; }
 
 /** Set how quickly to slide on/off medals in seconds
  *  @param {Number} time
  *  @memberof Settings */
-const setMedalDisplaySlideTime = (time)=> medalDisplaySlideTime = time;
+function setMedalDisplaySlideTime(time) { medalDisplaySlideTime = time; }
 
 /** Set size of medal display
  *  @param {Vector2} size
  *  @memberof Settings */
-const setMedalDisplaySize = (size)=> medalDisplaySize = size;
+function setMedalDisplaySize(size) { medalDisplaySize = size; }
 
 /** Set size of icon in medal display
  *  @param {Number} size
  *  @memberof Settings */
-const setMedalDisplayIconSize = (size)=> medalDisplayIconSize = size;
+function setMedalDisplayIconSize(size) { medalDisplayIconSize = size; }
 
 /** Set to stop medals from being unlockable
  *  @param {Boolean} preventUnlock
  *  @memberof Settings */
-const setMedalsPreventUnlock = (prevent)=> medalsPreventUnlock = prevent;
+function setMedalsPreventUnlock(prevent) { medalsPreventUnlock = prevent; }
 
 /** Set if watermark with FPS should be shown
  *  @param {Boolean} show
  *  @memberof Debug */
-const setShowWatermark = (show)=> showWatermark = show;
+function setShowWatermark(show) { showWatermark = show; }
 
 /** Set if god mode is enabled
  *  @param {Boolean} enable
  *  @memberof Debug */
-const setGodMode = (enable)=> godMode = enable;
+function setGodMode(enable) { godMode = enable; }
+
+/** Set key code used to toggle debug mode, Esc by default
+ *  @param {Number} key
+ *  @memberof Debug */
+function setDebugKey(key) { debugKey = key; }
 
 export {
 	// Setters for global variables
@@ -202,7 +204,7 @@ export {
 	setCameraScale,
 	setCanvasMaxSize,
 	setCanvasFixedSize,
-	setCavasPixelated,
+	setCanvasPixelated,
 	setFontDefault,
 	setGlEnable,
 	setGlOverlay,
@@ -236,11 +238,12 @@ export {
 	setMedalsPreventUnlock,
 	setShowWatermark,
 	setGodMode,
+	setDebugKey,
 
 	// Settings
 	canvasMaxSize,
 	canvasFixedSize,
-	cavasPixelated,
+	canvasPixelated,
 	fontDefault,
 	tileSizeDefault,
 	tileFixBleedScale,
@@ -322,8 +325,8 @@ export {
 	Color,
 	Timer,
 	vec2,
-	colorRGBA,
-	colorHSLA,
+	rgb,
+	hsl,
 
 	// Base
 	EngineObject,