littlejsengine 1.10.2 → 1.10.7

package/dist/littlejs.release.js

@@ -239,7 +239,8 @@ function formatTime(t) { return (t/60|0) + ':' + (t%60<10?'0':'') + (t%60|0); }
  *  @memberof Random */
 function rand(valueA=1, valueB=0) { return valueB + Math.random() * (valueA-valueB); }
 
-/** Returns a floored random value the two values passed in
+/** Returns a floored random value between the two values passed in
+ *  The upper bound is exclusive. (If 2 is passed in, result will be 0 or 1)
  *  @param {Number} valueA
  *  @param {Number} [valueB]
  *  @return {Number}
@@ -368,18 +369,24 @@ class Vector2
      *  @param {Number} [y] - Y axis location */
     constructor(x=0, y=0)
     {
-        ASSERT(typeof x == 'number' && typeof y == 'number');
         /** @property {Number} - X axis location */
         this.x = x;
         /** @property {Number} - Y axis location */
         this.y = y;
+        ASSERT(this.isValid());
     }
 
     /** Sets values of this vector and returns self
      *  @param {Number} [x] - X axis location
      *  @param {Number} [y] - Y axis location
      *  @return {Vector2} */
-    set(x=0, y=0) { this.x=x; this.y=y; return this; }
+    set(x=0, y=0)
+    {
+        this.x = x;
+        this.y = y;
+        ASSERT(this.isValid());
+        return this;
+    }
 
     /** Returns a new vector that is a copy of this
      *  @return {Vector2} */
@@ -521,6 +528,7 @@ class Vector2
      * @param {Number} [length] */
     setDirection(direction, length=1)
     {
+        direction = mod(direction, 4);
         ASSERT(direction==0 || direction==1 || direction==2 || direction==3);
         return vec2(direction%2 ? direction-1 ? -length : length : 0, 
             direction%2 ? 0 : direction ? -length : length);
@@ -570,6 +578,14 @@ class Vector2
         if (debug)
             return `(${(this.x<0?'':' ') + this.x.toFixed(digits)},${(this.y<0?'':' ') + this.y.toFixed(digits)} )`;
     }
+
+    /** Checks if this is a valid vector
+     * @return {Boolean} */
+    isValid()
+    {
+        return typeof this.x == 'number' && !isNaN(this.x)
+            && typeof this.y == 'number' && !isNaN(this.y);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -630,6 +646,7 @@ class Color
         this.b = b;
         /** @property {Number} - Alpha */
         this.a = a;
+        ASSERT(this.isValid());
     }
 
     /** Sets values of this color and returns self
@@ -639,7 +656,14 @@ class Color
      *  @param {Number} [a] - alpha
      *  @return {Color} */
     set(r=1, g=1, b=1, a=1)
-    { this.r=r; this.g=g; this.b=b; this.a=a; return this; }
+    {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+        ASSERT(this.isValid());
+        return this;
+    }
 
     /** Returns a new color that is a copy of this
      * @return {Color} */
@@ -722,6 +746,7 @@ class Color
         this.g = f(p, q, h);
         this.b = f(p, q, h - 1/3);
         this.a = a;
+        ASSERT(this.isValid());
         return this;
     }
 
@@ -749,7 +774,6 @@ class Color
             else if (b == max)
                 h =  (r - g) / d + 4;
         }
-
         return [h / 6, s, l, a];
     }
 
@@ -782,11 +806,27 @@ class Color
      * @return {Color} */
     setHex(hex)
     {
-        const fromHex = (c)=> clamp(parseInt(hex.slice(c,c+2),16)/255);
-        this.r = fromHex(1);
-        this.g = fromHex(3),
-        this.b = fromHex(5);
-        this.a = hex.length > 7 ? fromHex(7) : 1;
+        ASSERT(typeof hex == 'string' && hex[0] == '#');
+        ASSERT([4,5,7,9].includes(hex.length), 'Invalid hex');
+
+        if (hex.length < 6)
+        {
+            const fromHex = (c)=> clamp(parseInt(hex[c],16)/15);
+            this.r = fromHex(1);
+            this.g = fromHex(2),
+            this.b = fromHex(3);
+            this.a = hex.length == 5 ? fromHex(4) : 1;
+        }
+        else
+        {
+            const fromHex = (c)=> clamp(parseInt(hex.slice(c,c+2),16)/255);
+            this.r = fromHex(1);
+            this.g = fromHex(3),
+            this.b = fromHex(5);
+            this.a = hex.length == 9 ? fromHex(7) : 1;
+        }
+
+        ASSERT(this.isValid());
         return this;
     }
     
@@ -800,6 +840,16 @@ class Color
         const a = clamp(this.a)*255<<24;
         return r + g + b + a;
     }
+
+    /** Checks if this is a valid color
+     * @return {Boolean} */
+    isValid()
+    {
+        return typeof this.r == 'number' && !isNaN(this.r)
+            && typeof this.g == 'number' && !isNaN(this.g)
+            && typeof this.b == 'number' && !isNaN(this.b)
+            && typeof this.a == 'number' && !isNaN(this.a);
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1435,7 +1485,7 @@ class EngineObject
      *  @param {Color}    [color=(1,1,1,1)] - Color to apply to tile when rendered
      *  @param {Number}   [renderOrder]     - Objects sorted by renderOrder before being rendered
      */
-    constructor(pos=vec2(), size=vec2(1), tileInfo, angle=0, color, renderOrder=0)
+    constructor(pos=vec2(), size=vec2(1), tileInfo, angle=0, color=new Color, renderOrder=0)
     {
         // set passed in params
         ASSERT(isVector2(pos) && isVector2(size), 'ensure pos and size are vec2s');
@@ -1549,15 +1599,18 @@ class EngineObject
 
         // apply physics
         const oldPos = this.pos.copy();
-        this.pos.x += this.velocity.x *= this.damping;
-        this.pos.y += this.velocity.y = this.damping * this.velocity.y 
-            + gravity * this.gravityScale;
+        this.velocity.x *= this.damping;
+        this.velocity.y *= this.damping;
+        if (this.mass) // dont apply gravity to static objects
+            this.velocity.y += gravity * this.gravityScale;
+        this.pos.x += this.velocity.x;
+        this.pos.y += this.velocity.y;
         this.angle += this.angleVelocity *= this.angleDamping;
 
         // physics sanity checks
         ASSERT(this.angleDamping >= 0 && this.angleDamping <= 1);
         ASSERT(this.damping >= 0 && this.damping <= 1);
-        if (!enablePhysicsSolver || !this.mass) // dont do collision for fixed objects
+        if (!enablePhysicsSolver || !this.mass) // dont do collision for static objects
             return;
 
         const wasMovingDown = this.velocity.y < 0;
@@ -1703,6 +1756,7 @@ class EngineObject
                         this.pos.x = oldPos.x;
                         this.velocity.x *= -this.elasticity;
                     }
+                    debugOverlay && debugPhysics && debugRect(this.pos, this.size, '#f00');
                 }
             }
         }
@@ -1917,7 +1971,7 @@ let drawCount;
  * tile(2)                       // a tile at index 2 using the default tile size of 16
  * tile(5, 8)                    // a tile at index 5 using a tile size of 8
  * tile(1, 16, 3)                // a tile at index 1 of size 16 on texture 3
- * tile(vec2(4,8), vec2(30,10))  // a tile at pixel location (4,8) with a size of (30,10)
+ * tile(vec2(4,8), vec2(30,10))  // a tile at index (4,8) with a size of (30,10)
  * @memberof Draw
  */
 function tile(pos=vec2(), size=tileSizeDefault, textureIndex=0, padding=0)
@@ -2135,6 +2189,22 @@ function drawRect(pos, size, color, angle, useWebGL, screenSpace, context)
     drawTile(pos, size, undefined, color, angle, false, undefined, useWebGL, screenSpace, context); 
 }
 
+/** Draw colored line between two points
+ *  @param {Vector2} posA
+ *  @param {Vector2} posB
+ *  @param {Number}  [thickness]
+ *  @param {Color}   [color=(1,1,1,1)]
+ *  @param {Boolean} [useWebGL=glEnable]
+ *  @param {Boolean} [screenSpace=false]
+ *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
+ *  @memberof Draw */
+function drawLine(posA, posB, thickness=.1, color, useWebGL, screenSpace, context)
+{
+    const halfDelta = vec2((posB.x - posA.x)/2, (posB.y - posA.y)/2);
+    const size = vec2(thickness, halfDelta.length()*2);
+    drawRect(posA.add(halfDelta), size, color, halfDelta.angle(), useWebGL, screenSpace, context);
+}
+
 /** Draw colored polygon using passed in points
  *  @param {Array}   points - Array of Vector2 points
  *  @param {Color}   [color=(1,1,1,1)]
@@ -2203,22 +2273,6 @@ function drawEllipse(pos, width=1, height=1, angle=0, color=new Color, lineWidth
 function drawCircle(pos, radius=1, color=new Color, lineWidth=0, lineColor=new Color(0,0,0), screenSpace, context=mainContext)
 { drawEllipse(pos, radius, radius, 0, color, lineWidth, lineColor, screenSpace, context); }
 
-/** Draw colored line between two points
- *  @param {Vector2} posA
- *  @param {Vector2} posB
- *  @param {Number}  [thickness]
- *  @param {Color}   [color=(1,1,1,1)]
- *  @param {Boolean} [useWebGL=glEnable]
- *  @param {Boolean} [screenSpace=false]
- *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context]
- *  @memberof Draw */
-function drawLine(posA, posB, thickness=.1, color, useWebGL, screenSpace, context)
-{
-    const halfDelta = vec2((posB.x - posA.x)/2, (posB.y - posA.y)/2);
-    const size = vec2(thickness, halfDelta.length()*2);
-    drawRect(posA.add(halfDelta), size, color, halfDelta.angle(), useWebGL, screenSpace, context);
-}
-
 /** Draw directly to a 2d canvas context in world space
  *  @param {Vector2}  pos
  *  @param {Vector2}  size
@@ -2410,13 +2464,14 @@ function isFullscreen() { return !!document.fullscreenElement; }
  *  @memberof Draw */
 function toggleFullscreen()
 {
+    const rootElement = mainCanvas.parentElement;
     if (isFullscreen())
     {
         if (document.exitFullscreen)
             document.exitFullscreen();
     }
-    else if (engineRoot.requestFullscreen)
-        engineRoot.requestFullscreen();
+    else if (rootElement.requestFullscreen)
+        rootElement.requestFullscreen();
 }
 /** 
  * LittleJS Input System
@@ -2465,7 +2520,7 @@ function keyWasReleased(key, device=0)
 
 /** Clears all input
  *  @memberof Input */
-function clearInput() { inputData = [[]]; }
+function clearInput() { inputData = [[]]; touchGamepadButtons = []; }
 
 /** Returns true if mouse button is down
  *  @function
@@ -2587,7 +2642,6 @@ function inputInit()
 
     onkeydown = (e)=>
     {
-        if (debug && e.target != engineRoot) return;
         if (!e.repeat)
         {
             isUsingGamepad = false;
@@ -2600,7 +2654,6 @@ function inputInit()
 
     onkeyup = (e)=>
     {
-        if (debug && e.target != engineRoot) return;
         inputData[0][e.code] = 4;
         if (inputWASDEmulateDirection)
             inputData[0][remapKey(e.code)] = 4;
@@ -2632,6 +2685,7 @@ function inputInit()
     onmousemove   = (e)=> mousePosScreen = mouseToScreen(e);
     onwheel       = (e)=> mouseWheel = e.ctrlKey ? 0 : sign(e.deltaY);
     oncontextmenu = (e)=> false; // prevent right click menu
+    onblur        = (e) => clearInput(); // reset input when focus is lost
 
     // init touch input
     if (isTouchDevice && touchInputEnable)
@@ -2802,7 +2856,7 @@ function touchInputInit()
             // set event pos and pass it along
             const p = vec2(e.touches[0].clientX, e.touches[0].clientY);
             mousePosScreen = mouseToScreen(p);
-            wasTouching ? isUsingGamepad = false : inputData[0][button] = 3;
+            wasTouching ? isUsingGamepad = touchGamepadEnable : inputData[0][button] = 3;
         }
         else if (wasTouching)
             inputData[0][button] = inputData[0][button] & 2 | 4;
@@ -2830,10 +2884,13 @@ function touchInputInit()
         if (touching)
         {
             touchGamepadTimer.set();
-            if (paused)
+            if (paused && !wasTouching)
             {
                 // touch anywhere to press start when paused
                 touchGamepadButtons[9] = 1;
+
+                // call default touch handler so normal touch events still work
+                handleTouchDefault(e);
                 return;
             }
         }
@@ -2858,7 +2915,7 @@ function touchInputInit()
                 const button = touchPos.subtract(buttonCenter).direction();
                 touchGamepadButtons[button] = 1;
             }
-            else if (touchPos.distance(startCenter) < touchGamepadSize)
+            else if (touchPos.distance(startCenter) < touchGamepadSize && !wasTouching)
             {
                 // virtual start button in center
                 touchGamepadButtons[9] = 1;
@@ -2946,7 +3003,7 @@ function touchGamepadRender()
 /** Audio context used by the engine
  *  @type {AudioContext}
  *  @memberof Audio */
-let audioContext;
+let audioContext = new AudioContext;
 
 /** Master gain node for all audio to pass through
  *  @type {GainNode}
@@ -2957,14 +3014,10 @@ function audioInit()
 {
     if (!soundEnable || headlessMode) return;
     
-    // create audio context
-    audioContext = new AudioContext;
-
-    // create and connect gain node
     // (createGain is more widely spported then GainNode construtor)
     audioGainNode = audioContext.createGain();
     audioGainNode.connect(audioContext.destination);
-    setSoundVolume(soundVolume); // update gain volume
+    audioGainNode.gain.value = soundVolume; // set starting value
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2999,12 +3052,15 @@ class Sound
 
         /** @property {Number} - How much to randomize frequency each time sound plays */
         this.randomness = 0;
+        
+        /** @property {GainNode} - Gain node for this sound */
+        this.gainNode = audioContext.createGain();
 
         if (zzfxSound)
         {
             // generate zzfx sound now for fast playback
             const defaultRandomness = .05;
-            this.randomness = zzfxSound[1] || defaultRandomness;
+            this.randomness = zzfxSound[1] != undefined ? zzfxSound[1] : defaultRandomness;
             zzfxSound[1] = 0; // generate without randomness
             this.sampleChannels = [zzfxG(...zzfxSound)];
             this.sampleRate = zzfxR;
@@ -3045,18 +3101,13 @@ class Sound
 
         // play the sound
         const playbackRate = pitch + pitch * this.randomness*randomnessScale*rand(-1,1);
-        this.gainNode = audioContext.createGain();
         return this.source = playSamples(this.sampleChannels, volume, playbackRate, pan, loop, this.sampleRate, this.gainNode);
     }
 
     /** Set the sound volume
      *  @param {Number}  [volume] - How much to scale volume by
      */
-    setVolume(volume=1)
-    {
-        if (this.gainNode)
-            this.gainNode.gain.value = volume;
-    }
+    setVolume(volume=1) { this.gainNode.gain.value = volume; }
 
     /** Stop the last instance of this sound that was played */
     stop()
@@ -3540,18 +3591,18 @@ function zzfxM(instruments, patterns, sequence, BPM = 125)
 
 
 
-/** The tile collision layer array, use setTileCollisionData and getTileCollisionData to access
+/** The tile collision layer grid, use setTileCollisionData and getTileCollisionData to access
  *  @type {Array} 
  *  @memberof TileCollision */
 let tileCollision = [];
 
-/** Size of the tile collision layer
+/** Size of the tile collision layer 2d grid
  *  @type {Vector2} 
  *  @memberof TileCollision */
 let tileCollisionSize = vec2();
 
 /** Clear and initialize tile collision
- *  @param {Vector2} size
+ *  @param {Vector2} size - width and height of tile collision 2d grid
  *  @memberof TileCollision */
 function initTileCollision(size)
 {
@@ -3561,7 +3612,7 @@ function initTileCollision(size)
         tileCollision[i] = 0;
 }
 
-/** Set tile collision data
+/** Set tile collision data for a given cell in the grid
  *  @param {Vector2} pos
  *  @param {Number}  [data]
  *  @memberof TileCollision */
@@ -3570,7 +3621,7 @@ function setTileCollisionData(pos, data=0)
     pos.arrayCheck(tileCollisionSize) && (tileCollision[(pos.y|0)*tileCollisionSize.x+pos.x|0] = data);
 }
 
-/** Get tile collision data
+/** Get tile collision data for a given cell in the grid
  *  @param {Vector2} pos
  *  @return {Number}
  *  @memberof TileCollision */
@@ -3598,9 +3649,11 @@ function tileCollisionTest(pos, size=vec2(), object)
         if (tileData && (!object || object.collideWithTile(tileData, vec2(x, y))))
             return true;
     }
+    return false;
 }
 
-/** Return the center of first tile hit (does not return the exact intersection)
+/** Return the center of first tile hit, undefined if nothing was hit.
+ *  This does not return the exact intersection, but the center of the tile hit.
  *  @param {Vector2}      posStart
  *  @param {Vector2}      posEnd
  *  @param {EngineObject} [object]
@@ -3621,7 +3674,7 @@ function tileCollisionRaycast(posStart, posEnd, object)
     let xi = unit.x * (delta.x < 0 ? posStart.x - pos.x : pos.x - posStart.x + 1);
     let yi = unit.y * (delta.y < 0 ? posStart.y - pos.y : pos.y - posStart.y + 1);
 
-    while (1)
+    while (true)
     {
         // check for tile collision
         const tileData = getTileCollisionData(pos);
@@ -3845,8 +3898,8 @@ class TileLayer extends EngineObject
         const d = this.getData(layerPos);
         if (d.tile != undefined)
         {
-            const pos = this.pos.add(layerPos).add(vec2(.5));
             ASSERT(mainContext == this.context, 'must call redrawStart() before drawing tiles');
+            const pos = layerPos.add(vec2(.5));
             const tileInfo = tile(d.tile, s, this.tileInfo.textureIndex);
             drawTile(pos, vec2(1), tileInfo, d.color, d.direction*PI/2, d.mirror);
         }
@@ -4275,7 +4328,7 @@ function medalsInit(saveName)
     // check if medals are unlocked
     medalsSaveName = saveName;
     if (!debugMedals)
-        medalsForEach(medal=> medal.unlocked = (localStorage[medal.storageKey()] | 0));
+        medalsForEach(medal=> medal.unlocked = !!localStorage[medal.storageKey()]);
 
     // engine automatically renders medals
     engineAddPlugin(undefined, medalsRender);
@@ -4338,14 +4391,28 @@ class Medal
     constructor(id, name, description='', icon='🏆', src)
     {
         ASSERT(id >= 0 && !medals[id]);
-
-        // save attributes and add to list of medals
-        medals[this.id = id] = this;
+        
+        /** @property {Number} - The unique identifier of the medal */
+        this.id = id;
+        
+        /** @property {String} - Name of the medal */
         this.name = name;
+        
+        /** @property {String} - Description of the medal */
         this.description = description;
+        
+        /** @property {String} - Icon for the medal */
         this.icon = icon;
+        
+        /** @property {Boolean} - Is the medal unlocked? */
+        this.unlocked = false;
+
+        // load the source image if provided
         if (src)
             (this.image = new Image).src = src;
+
+        // add this to list of medals
+        medals[id] = this;
     }
 
     /** Unlocks a medal if not already unlocked */
@@ -4356,7 +4423,7 @@ class Medal
 
         // save the medal
         ASSERT(medalsSaveName, 'save name must be set');
-        localStorage[this.storageKey()] = this.unlocked = 1;
+        localStorage[this.storageKey()] = this.unlocked = true;
         medalsDisplayQueue.push(this);
     }
 
@@ -4430,6 +4497,11 @@ let glCanvas;
  *  @memberof WebGL */
 let glContext;
 
+/** Shoule webgl be setup with antialiasing, must be set before calling engineInit
+ *  @type {Boolean}
+ *  @memberof WebGL */
+let glAntialias = true;
+
 // WebGL internal variables not exposed to documentation
 let glShader, glActiveTexture, glArrayBuffer, glGeometryBuffer, glPositionData, glColorData, glInstanceCount, glAdditive, glBatchAdditive;
 
@@ -4442,10 +4514,11 @@ function glInit()
 
     // create the canvas and textures
     glCanvas = document.createElement('canvas');
-    glContext = glCanvas.getContext('webgl2', {antialias:!canvasPixelated});
+    glContext = glCanvas.getContext('webgl2', {antialias:glAntialias});
 
     // some browsers are much faster without copying the gl buffer so we just overlay it instead
-    glOverlay && engineRoot.appendChild(glCanvas);
+    const rootElement = mainCanvas.parentElement;
+    glOverlay && rootElement.appendChild(glCanvas);
 
     // setup vertex and fragment shaders
     glShader = glCreateProgram(
@@ -4649,6 +4722,15 @@ function glCopyToContext(context, forceDraw=false)
         context.drawImage(glCanvas, 0, 0);
 }
 
+/** Set antialiasing for webgl canvas
+ *  @param {Boolean} [antialias]
+ *  @memberof WebGL */
+function glSetAntialias(antialias=true)
+{
+    ASSERT(!glCanvas, 'must be called before engineInit');
+    glAntialias = antialias;
+}
+
 /** Add a sprite to the gl draw list, used by all gl draw functions
  *  @param {Number} x
  *  @param {Number} y
@@ -4749,7 +4831,7 @@ const engineName = 'LittleJS';
  *  @type {String}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.10.2';
+const engineVersion = '1.10.7';
 
 /** Frames per second to update
  *  @type {Number}
@@ -4793,13 +4875,6 @@ let timeReal = 0;
  *  @default false
  *  @memberof Engine */
 let paused = false;
-
-/** The root element that engine is attached to
- *  @type {HTMLElement}
- *  @default document.body
- *  @memberof Engine */
-let engineRoot;
-
 /** Set if game is paused
  *  @param {Boolean} isPaused
  *  @memberof Engine */
@@ -4819,6 +4894,8 @@ const pluginUpdateList = [], pluginRenderList = [];
  *  @memberof Engine */
 function engineAddPlugin(updateFunction, renderFunction)
 {
+    ASSERT(!pluginUpdateList.includes(updateFunction));
+    ASSERT(!pluginRenderList.includes(renderFunction));
     updateFunction && pluginUpdateList.push(updateFunction);
     renderFunction && pluginRenderList.push(renderFunction);
 }
@@ -4827,12 +4904,12 @@ function engineAddPlugin(updateFunction, renderFunction)
 // Main engine functions
 
 /** Startup LittleJS engine with your callback functions
- *  @param {Function} gameInit       - Called once after the engine starts up, setup the game
- *  @param {Function} gameUpdate     - Called every frame at 60 frames per second, handle input and update the game state
- *  @param {Function} gameUpdatePost - Called after physics and objects are updated, setup camera and prepare for render
- *  @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 {Array} [imageSources=['tiles.png']] - Image to load
+ *  @param {Function|function():Promise} gameInit - Called once after the engine starts up
+ *  @param {Function} gameUpdate - Called every frame before objects are updated
+ *  @param {Function} gameUpdatePost - Called after physics and objects are updated, even when paused
+ *  @param {Function} gameRender - Called before objects are rendered, for drawing the background
+ *  @param {Function} gameRenderPost - Called after objects are rendered, useful for drawing UI
+ *  @param {Array} [imageSources=[]] - List of images to load
  *  @param {HTMLElement} [rootElement] - Root element to attach to, the document body by default
  *  @memberof Engine */
 function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, imageSources=[], rootElement=document.body)
@@ -4982,8 +5059,7 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
 
     function startEngine()
     {
-        gameInit();
-        engineUpdate();
+        new Promise((resolve) => resolve(gameInit())).then(engineUpdate);
     }
 
     if (headlessMode)
@@ -4998,7 +5074,6 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         'width:100vw;height:100vh;' + // fill the window
         'display:flex;' +             // use flexbox
         'align-items:center;' +       // horizontal center
-        (canvasPixelated ? 'image-rendering:pixelated;' : '') + // pixel art
         'justify-content:center;' +   // vertical center
         'background:#000;' +          // set background color
         'user-select:none;' +         // prevent hold to select
@@ -5006,9 +5081,8 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
         (!touchInputEnable ? '' :     // no touch css setttings
         'touch-action:none;' +        // prevent mobile pinch to resize
         '-webkit-touch-callout:none');// compatibility for ios
-    engineRoot = rootElement;
-    engineRoot.style.cssText = styleRoot;
-    engineRoot.appendChild(mainCanvas = document.createElement('canvas'));
+    rootElement.style.cssText = styleRoot;
+    rootElement.appendChild(mainCanvas = document.createElement('canvas'));
     mainContext = mainCanvas.getContext('2d');
 
     // init stuff and start engine
@@ -5018,7 +5092,7 @@ function engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRender
     glInit();
 
     // create overlay canvas for hud to appear above gl canvas
-    engineRoot.appendChild(overlayCanvas = document.createElement('canvas'));
+    rootElement.appendChild(overlayCanvas = document.createElement('canvas'));
     overlayContext = overlayCanvas.getContext('2d');
 
     // set canvas style
@@ -5337,4 +5411,5 @@ function drawEngineSplashScreen(t)
     }
     
     x.restore();
-}
+}
+

package/examples/box2d/game.js

@@ -19,6 +19,7 @@ setShowSplashScreen(true);
 const maxScenes = 11;
 let scene = 0;
 let sceneName;
+let spriteAtlas;
 let groundObject;
 let mouseJoint;
 let car;
@@ -27,6 +28,19 @@ let repeatSpawnTimer = new Timer;
 ///////////////////////////////////////////////////////////////////////////////
 function gameInit()
 {
+    // create a table of all sprites
+    const gameTile = (i)=>  tile(i, 16, 0, 1);
+    spriteAtlas =
+    {
+        circle:         gameTile(0),
+        dot:            gameTile(1),
+        circleOutline:  gameTile(2),
+        squareOutline:  gameTile(3),
+        wheel:          gameTile(4),
+        gear:           gameTile(5),
+        squareOutline2: gameTile(6),
+    };
+
     loadScene(scene);
 }
 
@@ -125,7 +139,7 @@ function gameRenderPost()
     {
         // draw mouse joint
         const ab = vec2(mouseJoint.GetAnchorB());
-        drawTile(ab, vec2(.3), tile(0), BLACK);
+        drawTile(ab, vec2(.3), spriteAtlas.circle, BLACK);
         drawLine(mousePos, ab, .1, BLACK);
     }