littlejsengine 1.4.91 → 1.5.1

package/engine/engineSettings.js

@@ -10,11 +10,12 @@
 
 /** Position of camera in world space
  *  @type {Vector2}
- *  @default
+ *  @default Vector2()
  *  @memberof Settings */
 let cameraPos = vec2();
 
 /** Scale of camera in world space
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let cameraScale = 32;
@@ -23,24 +24,26 @@ let cameraScale = 32;
 // Display settings
 
 /** The max size of the canvas, centered if window is larger
- *  @type {Vector2} 
- *  @default
+ *  @type {Vector2}
+ *  @default Vector2(1920,1200)
  *  @memberof Settings */
 let canvasMaxSize = vec2(1920, 1200);
 
 /** Fixed size of the canvas, if enabled canvas size never changes
  * - you may also need to set mainCanvasSize if using screen space coords in startup
- *  @type {Vector2} 
- *  @default
+ *  @type {Vector2}
+ *  @default Vector2()
  *  @memberof Settings */
 let canvasFixedSize = vec2();
 
 /** Disables anti aliasing for pixel art if true
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let cavasPixelated = 1;
 
 /** Default font used for text rendering
+ *  @type {String}
  *  @default
  *  @memberof Settings */
 let fontDefault = 'arial';
@@ -49,11 +52,13 @@ let fontDefault = 'arial';
 // WebGL settings
 
 /** Enable webgl rendering, webgl can be disabled and removed from build (with some features disabled)
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let glEnable = 1;
 
 /** Fixes slow rendering in some browsers by not compositing the WebGL canvas
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let glOverlay = 1;
@@ -62,12 +67,13 @@ let glOverlay = 1;
 // Tile sheet settings
 
 /** Default size of tiles in pixels
- *  @type {Vector2} 
- *  @default
+ *  @type {Vector2}
+ *  @default Vector2(16,16)
  *  @memberof Settings */
 let tileSizeDefault = vec2(16);
 
 /** Prevent tile bleeding from neighbors in pixels
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let tileFixBleedScale = .3;
@@ -75,53 +81,56 @@ let tileFixBleedScale = .3;
 ///////////////////////////////////////////////////////////////////////////////
 // Object settings
 
-/** Default size of objects
- *  @type {Vector2} 
- *  @default
- *  @memberof Settings */
-let objectDefaultSize = vec2(1);
-
 /** Enable physics solver for collisions between objects
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let enablePhysicsSolver = 1;
 
 /** Default object mass for collison calcuations (how heavy objects are)
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let objectDefaultMass = 1;
 
 /** How much to slow velocity by each frame (0-1)
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
-let objectDefaultDamping = .99;
+let objectDefaultDamping = 1;
 
 /** How much to slow angular velocity each frame (0-1)
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
-let objectDefaultAngleDamping = .99;
+let objectDefaultAngleDamping = 1;
 
 /** How much to bounce when a collision occurs (0-1)
- *  @default
+ *  @type {Number}
+ *  @default 0
  *  @memberof Settings */
 let objectDefaultElasticity = 0;
 
 /** How much to slow when touching (0-1)
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let objectDefaultFriction = .8;
 
 /** Clamp max speed to avoid fast objects missing collisions
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let objectMaxSpeed = 1;
 
 /** How much gravity to apply to objects along the Y axis, negative is down
- *  @default
+ *  @type {Number}
+ *  @default 0
  *  @memberof Settings */
 let gravity = 0;
 
 /** Scales emit rate of particles, useful for low graphics mode (0 disables particle emitters)
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let particleEmitRateScale = 1;
@@ -130,16 +139,19 @@ let particleEmitRateScale = 1;
 // Input settings
 
 /** Should gamepads be allowed
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let gamepadsEnable = 1;
 
 /** If true, the dpad input is also routed to the left analog stick (for better accessability)
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let gamepadDirectionEmulateStick = 1;
 
 /** If true the WASD keys are also routed to the direction keys (for better accessability)
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let inputWASDEmulateDirection = 1;
@@ -147,26 +159,31 @@ let inputWASDEmulateDirection = 1;
 /** True if touch gamepad should appear on mobile devices
  *  <br> - Supports left analog stick, 4 face buttons and start button (button 9)
  *  <br> - Must be set by end of gameInit to be activated
- *  @default
+ *  @type {Boolean}
+ *  @default 0
  *  @memberof Settings */
 let touchGamepadEnable = 0;
 
 /** True if touch gamepad should be analog stick or false to use if 8 way dpad
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let touchGamepadAnalog = 1;
 
 /** Size of virutal gamepad for touch devices in pixels
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let touchGamepadSize = 99;
 
 /** Transparency of touch gamepad overlay
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let touchGamepadAlpha = .3;
 
 /** Allow vibration hardware if it exists
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let vibrateEnable = 1;
@@ -175,21 +192,25 @@ let vibrateEnable = 1;
 // Audio settings
 
 /** All audio code can be disabled and removed from build
+ *  @type {Boolean}
  *  @default
  *  @memberof Settings */
 let soundEnable = 1;
 
 /** Volume scale to apply to all sound, music and speech
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let soundVolume = .5;
 
 /** Default range where sound no longer plays
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let soundDefaultRange = 40;
 
 /** Default range percent to start tapering off sound (0-1)
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let soundDefaultTaper = .7;
@@ -198,26 +219,31 @@ let soundDefaultTaper = .7;
 // Medals settings
 
 /** How long to show medals for in seconds
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let medalDisplayTime = 5;
 
 /** How quickly to slide on/off medals in seconds
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let medalDisplaySlideTime = .5;
 
 /** Size of medal display
- *  @default
+ *  @type {Vector2}
+ *  @default Vector2(640,80)
  *  @memberof Settings */
 let medalDisplaySize = vec2(640, 80);
 
 /** Size of icon in medal display
+ *  @type {Number}
  *  @default
  *  @memberof Settings */
 let medalDisplayIconSize = 50;
 
 /** Set to stop medals from being unlockable (like if cheats are enabled)
- *  @default
+ *  @type {Boolean}
+ *  @default 0
  *  @memberof Settings */
 let medalsPreventUnlock;

package/engine/engineTileLayer.js

@@ -13,6 +13,7 @@
 'use strict';
 
 /** The tile collision layer array, use setTileCollisionData and getTileCollisionData to access
+ *  @type {Array} 
  *  @memberof TileCollision */
 let tileCollision = [];
 
@@ -48,7 +49,7 @@ const getTileCollisionData = (pos)=>
 
 /** Check if collision with another object should occur
  *  @param {Vector2}      pos
- *  @param {Vector2}      [size=new Vector2(1,1)]
+ *  @param {Vector2}      [size=Vector2(1,1)]
  *  @param {EngineObject} [object]
  *  @return {Boolean}
  *  @memberof TileCollision */
@@ -116,11 +117,11 @@ function tileCollisionRaycast(posStart, posEnd, object)
 class TileLayerData
 {
     /** Create a tile layer data object, one for each tile in a TileLayer
-     *  @param {Number}  [tile]                   - The tile to use, untextured if undefined
-     *  @param {Number}  [direction=0]            - Integer direction of tile, in 90 degree increments
-     *  @param {Boolean} [mirror=0]               - If the tile should be mirrored along the x axis
-     *  @param {Color}   [color=new Color(1,1,1)] - Color of the tile */
-    constructor(tile, direction=0, mirror=0, color=new Color)
+     *  @param {Number}  [tile]          - The tile to use, untextured if undefined
+     *  @param {Number}  [direction=0]   - Integer direction of tile, in 90 degree increments
+     *  @param {Boolean} [mirror=0]      - If the tile should be mirrored along the x axis
+     *  @param {Color}   [color=Color()] - Color of the tile */
+    constructor(tile, direction=0, mirror=0, color=new Color())
     {
         /** @property {Number}  - The tile to use, untextured if undefined */
         this.tile      = tile;
@@ -151,10 +152,10 @@ class TileLayerData
 class TileLayer extends EngineObject
 {
 /** Create a tile layer object
-    *  @param {Vector2} [position=new Vector2()]   - World space position
+    *  @param {Vector2} [position=Vector2()]       - World space position
     *  @param {Vector2} [size=tileCollisionSize]   - World space size
     *  @param {Vector2} [tileSize=tileSizeDefault] - Size of tiles in source pixels
-    *  @param {Vector2} [scale=new Vector2(1,1)]   - How much to scale this layer when rendered
+    *  @param {Vector2} [scale=Vector2(1,1)]       - How much to scale this layer when rendered
     *  @param {Number}  [renderOrder=0]            - Objects sorted by renderOrder before being rendered
     */
 constructor(pos, size=tileCollisionSize, tileSize=tileSizeDefault, scale=vec2(1), renderOrder=0)
@@ -306,10 +307,10 @@ constructor(pos, size=tileCollisionSize, tileSize=tileSizeDefault, scale=vec2(1)
 
     /** Draw a tile directly onto the layer canvas
      *  @param {Vector2} pos
-     *  @param {Vector2} [size=new Vector2(1,1)]
+     *  @param {Vector2} [size=Vector2(1,1)]
      *  @param {Number}  [tileIndex=-1]
      *  @param {Vector2} [tileSize=tileSizeDefault]
-     *  @param {Color}   [color=new Color(1,1,1)]
+     *  @param {Color}   [color=Color()]
      *  @param {Number}  [angle=0]
      *  @param {Boolean} [mirror=0] */
     drawTile(pos, size=vec2(1), tileIndex=-1, tileSize=tileSizeDefault, color=new Color, angle, mirror)
@@ -335,8 +336,8 @@ constructor(pos, size=tileCollisionSize, tileSize=tileSizeDefault, scale=vec2(1)
 
     /** Draw a rectangle directly onto the layer canvas
      *  @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] */
     drawRect(pos, size, color, angle) 
     { this.drawTile(pos, size, -1, 0, color, angle); }

package/engine/engineUtilities.js

@@ -10,7 +10,8 @@
 'use strict';
 
 /** A shortcut to get Math.PI
- *  @const
+ *  @type {Number}
+ *  @default Math.PI
  *  @memberof Utilities */
 const PI = Math.PI;
 
@@ -144,8 +145,8 @@ const randInCircle = (radius=1, minRadius=0)=> radius > 0 ? randVector(radius *
 const randVector = (length=1)=> new Vector2().setAngle(rand(2*PI), length);
 
 /** Returns a random color between the two passed in colors, combine components if linear
- *  @param {Color}   [colorA=new Color(1,1,1,1)]
- *  @param {Color}   [colorB=new Color(0,0,0,1)]
+ *  @param {Color}   [colorA=Color()]
+ *  @param {Color}   [colorB=Color(0,0,0,1)]
  *  @param {Boolean} [linear]
  *  @return {Color}
  *  @memberof Random */
@@ -153,6 +154,8 @@ const randColor = (cA = new Color, cB = new Color(0,0,0,1), linear)=>
     linear ? cA.lerp(cB, rand()) : new Color(rand(cA.r,cB.r),rand(cA.g,cB.g),rand(cA.b,cB.b),rand(cA.a,cB.a));
 
 /** Seed used by the randSeeded function
+ *  @type {Number}
+ *  @default
  *  @memberof Random */
 let randSeed = 1;
 
@@ -291,7 +294,8 @@ class Vector2
 
     /** Sets this vector with angle and length passed in
      * @param {Number} [angle=0]
-     * @param {Number} [length=1] */
+     * @param {Number} [length=1]
+     * @return {Vector2} */
     setAngle(a=0, length=1) { this.x = length*Math.sin(a); this.y = length*Math.cos(a); return this; }
 
     /** Returns copy of this vector rotated by the angle passed in
@@ -360,9 +364,11 @@ const colorHSLA = (h, s, l, a)=> new Color().setHSLA(h, s, l, a);
 /** 
  * Color object (red, green, blue, alpha) with some helpful functions
  * @example
- * let a = new Color;             // white
- * let b = new Color(1, 0, 0);    // red
- * let c = new Color(0, 0, 0, 0); // transparent black
+ * let a = new Color;              // white
+ * let b = new Color(1, 0, 0);     // red
+ * let c = new Color(0, 0, 0, 0);  // transparent black
+ * let d = colorRGBA(0, 0, 1);     // blue using rgb color
+ * let e = colorHSLA(.3, 1, .5);   // green using hsl color
  */
 class Color
 {

package/engine/engineWebGL.js

@@ -263,12 +263,13 @@ function glDraw(x, y, sizeX, sizeY, angle, uv0X, uv0Y, uv1X, uv1Y, rgba, rgbaAdd
 ///////////////////////////////////////////////////////////////////////////////
 // post processing - can be enabled to pass other canvases through a final shader
 
-let glPostShader, glPostArrayBuffer, glPostTexture;
+let glPostShader, glPostArrayBuffer, glPostTexture, glPostIncludeOverlay;
 
 /** Set up a post processing shader
  *  @param {String} shaderCode
+ *  @param {Boolean} includeOverlay
  *  @memberof WebGL */
-function glInitPostProcess(shaderCode)
+function glInitPostProcess(shaderCode, includeOverlay)
 {
     ASSERT(!glPostShader); // can only have 1 post effects shader
 
@@ -297,6 +298,7 @@ function glInitPostProcess(shaderCode)
     // create buffer and texture
     glPostArrayBuffer = glContext.createBuffer();
     glPostTexture = glCreateTexture();
+    glPostIncludeOverlay = includeOverlay;
 
     // hide the original 2d canvas
     mainCanvas.style.visibility = 'hidden';
@@ -317,6 +319,13 @@ function glRenderPostProcess()
     else // set viewport
         glContext.viewport(0, 0, glCanvas.width = mainCanvas.width, glCanvas.height = mainCanvas.height);
 
+    if (glPostIncludeOverlay)
+    {
+        // copy overlay canvas so it will be included in post processing
+        mainContext.drawImage(overlayCanvas, 0, 0);
+        overlayCanvas.width |= 0;
+    }
+
     // setup shader program to draw one triangle
     glContext.useProgram(glPostShader);
     glContext.disable(gl_BLEND);