phaser-rails 2.4.2.0 → 2.4.3.0

data/vendor/assets/javascripts/phaser.js

@@ -7,7 +7,7 @@
 *
 * Phaser - http://phaser.io
 *
-* v2.4.2 "Altara" - Built: Wed Jul 29 2015 14:59:16
+* v2.4.3 "Coramen" - Built: Mon Aug 24 2015 13:54:08
 *
 * By Richard Davey http://www.photonstorm.com @photonstorm
 *
@@ -14090,8 +14090,13 @@ Object.defineProperty(PIXI.DisplayObject.prototype, 'mask', {
 
 /**
  * Sets the filters for the displayObject.
- * * IMPORTANT: This is a webGL only feature and will be ignored by the canvas renderer.
- * To remove filters simply set this property to 'null'
+ * IMPORTANT: This is a webGL only feature and will be ignored by the Canvas renderer.
+ * 
+ * To remove filters simply set this property to 'null'.
+ * 
+ * You cannot have a filter and a multiply blend mode active at the same time. Setting a filter will reset
+ * this objects blend mode to NORMAL.
+ * 
  * @property filters
  * @type Array(Filter)
  */
@@ -14123,6 +14128,11 @@ Object.defineProperty(PIXI.DisplayObject.prototype, 'filters', {
         }
 
         this._filters = value;
+
+        if (this.blendMode && this.blendMode === PIXI.blendModes.MULTIPLY)
+        {
+            this.blendMode = PIXI.blendModes.NORMAL;
+        }
     }
 });
 
@@ -14141,7 +14151,10 @@ Object.defineProperty(PIXI.DisplayObject.prototype, 'cacheAsBitmap', {
 
     set: function(value) {
 
-        if (this._cacheAsBitmap === value) return;
+        if (this._cacheAsBitmap === value)
+        {
+            return;
+        }
 
         if (value)
         {
@@ -14154,6 +14167,7 @@ Object.defineProperty(PIXI.DisplayObject.prototype, 'cacheAsBitmap', {
 
         this._cacheAsBitmap = value;
     }
+
 });
 
 /*
@@ -14411,29 +14425,29 @@ PIXI.DisplayObject.prototype._generateCachedSprite = function()
 
     var bounds = this.getLocalBounds();
 
+    this.updateTransform();
+
     if (!this._cachedSprite)
     {
-        var renderTexture = new PIXI.RenderTexture(bounds.width | 0, bounds.height | 0);//, renderSession.renderer);
-
+        var renderTexture = new PIXI.RenderTexture(bounds.width | 1, bounds.height | 1);
         this._cachedSprite = new PIXI.Sprite(renderTexture);
         this._cachedSprite.worldTransform = this.worldTransform;
     }
     else
     {
-        this._cachedSprite.texture.resize(bounds.width | 0, bounds.height | 0);
+        this._cachedSprite.texture.resize(bounds.width | 1, bounds.height | 1);
     }
 
-    //REMOVE filter!
+    //  Remove filters
     var tempFilters = this._filters;
     this._filters = null;
-
     this._cachedSprite.filters = tempFilters;
 
+    // PIXI.DisplayObject._tempMatrix.identity();
     PIXI.DisplayObject._tempMatrix.tx = -bounds.x;
     PIXI.DisplayObject._tempMatrix.ty = -bounds.y;
-    
-    this._cachedSprite.texture.render(this, PIXI.DisplayObject._tempMatrix, true);
 
+    this._cachedSprite.texture.render(this, PIXI.DisplayObject._tempMatrix, true);
     this._cachedSprite.anchor.x = -( bounds.x / bounds.width );
     this._cachedSprite.anchor.y = -( bounds.y / bounds.height );
 
@@ -15123,6 +15137,8 @@ PIXI.Sprite = function(texture)
     /**
      * The blend mode to be applied to the sprite. Set to PIXI.blendModes.NORMAL to remove any blend mode.
      *
+     * Warning: You cannot have a blend mode and a filter active on the same Sprite. Doing so will render the sprite invisible.
+     *
      * @property blendMode
      * @type Number
      * @default PIXI.blendModes.NORMAL;
@@ -15190,13 +15206,20 @@ Object.defineProperty(PIXI.Sprite.prototype, 'height', {
 });
 
 /**
- * Sets the texture of the sprite
+ * Sets the texture of the sprite. Be warned that this doesn't remove or destroy the previous
+ * texture this Sprite was using.
  *
  * @method setTexture
  * @param texture {Texture} The PIXI texture that is displayed by the sprite
+ * @param [destroy=false] {boolean} Call Texture.destroy on the current texture before replacing it with the new one?
  */
-PIXI.Sprite.prototype.setTexture = function(texture)
+PIXI.Sprite.prototype.setTexture = function(texture, destroyBase)
 {
+    if (destroyBase !== undefined)
+    {
+        this.texture.baseTexture.destroy();
+    }
+
     this.texture = texture;
     this.texture.valid = true;
 };
@@ -15437,8 +15460,8 @@ PIXI.Sprite.prototype._renderCanvas = function(renderSession, matrix)
         if (renderSession.roundPixels)
         {
             renderSession.context.setTransform(wt.a, wt.b, wt.c, wt.d, (wt.tx * renderSession.resolution) | 0, (wt.ty * renderSession.resolution) | 0);
-            dx = dx | 0;
-            dy = dy | 0;
+            dx |= 0;
+            dy |= 0;
         }
         else
         {
@@ -15818,9 +15841,7 @@ PIXI.canUseNewCanvasBlendModes = function()
     var yellow = new Image();
     yellow.src = pngHead + '/wCKxvRF' + pngEnd;
 
-    var canvas = document.createElement('canvas');
-    canvas.width = 6;
-    canvas.height = 1;
+    var canvas = PIXI.CanvasPool.create(this, 6, 1);
     var context = canvas.getContext('2d');
     context.globalCompositeOperation = 'multiply';
     context.drawImage(magenta, 0, 0);
@@ -15833,7 +15854,10 @@ PIXI.canUseNewCanvasBlendModes = function()
 
     var data = context.getImageData(2,0,1,1).data;
 
+    PIXI.CanvasPool.remove(this);
+
     return (data[0] === 255 && data[1] === 0 && data[2] === 0);
+
 };
 
 /**
@@ -16038,6 +16062,151 @@ PIXI.PolyK._convex = function(ax, ay, bx, by, cx, cy, sign)
     return ((ay-by)*(cx-bx) + (bx-ax)*(cy-by) >= 0) === sign;
 };
 
+/**
+* @author       Richard Davey <rich@photonstorm.com>
+* @copyright    2015 Photon Storm Ltd.
+* @license      {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
+*/
+
+/**
+* The CanvasPool is a global static object that allows Pixi and Phaser to pool
+*
+* @class PIXI.CanvasPool
+* @static
+*/
+PIXI.CanvasPool = {
+
+    /**
+    * 
+    * 
+    * @method PIXI.CanvasPool.create
+    * @static
+    * @param {any} parent - The parent of the canvas element.
+    * @param {number} width - The width of the canvas element.
+    * @param {number} height - The height of the canvas element.
+    * @return {HTMLCanvasElement} The canvas element.
+    */
+    create: function (parent, width, height) {
+
+        var idx = PIXI.CanvasPool.getFirst();
+        var canvas;
+
+        if (idx === -1)
+        {
+            var container = {
+                parent: parent,
+                canvas: document.createElement('canvas')
+            }
+
+            PIXI.CanvasPool.pool.push(container);
+
+            canvas = container.canvas;
+
+            // console.log('CanvasPool created', PIXI.CanvasPool.pool.length);
+        }
+        else
+        {
+            PIXI.CanvasPool.pool[idx].parent = parent;
+
+            canvas = PIXI.CanvasPool.pool[idx].canvas;
+
+            // console.log('CanvasPool recycled', idx);
+        }
+
+        if (width !== undefined)
+        {
+            canvas.width = width;
+            canvas.height = height;
+        }
+
+        return canvas;
+
+    },
+
+    getFirst: function () {
+
+        var pool = PIXI.CanvasPool.pool;
+
+        for (var i = 0; i < pool.length; i++)
+        {
+            if (pool[i].parent === null)
+            {
+                return i;
+            }
+        }
+
+        return -1;
+
+    },
+
+    remove: function (parent) {
+
+        var pool = PIXI.CanvasPool.pool;
+
+        for (var i = 0; i < pool.length; i++)
+        {
+            if (pool[i].parent === parent)
+            {
+                pool[i].parent = null;
+
+                // console.log('CanvasPool removed', i);
+            }
+        }
+
+    },
+
+    removeByCanvas: function (canvas) {
+
+        var pool = PIXI.CanvasPool.pool;
+
+        for (var i = 0; i < pool.length; i++)
+        {
+            if (pool[i].canvas === canvas)
+            {
+                pool[i].parent = null;
+            }
+        }
+
+    },
+
+    getTotal: function () {
+
+        var pool = PIXI.CanvasPool.pool;
+        var c = 0;
+
+        for (var i = 0; i < pool.length; i++)
+        {
+            if (pool[i].parent !== null)
+            {
+                c++;
+            }
+        }
+
+        return c;
+
+    },
+
+    getFree: function () {
+
+        var pool = PIXI.CanvasPool.pool;
+        var c = 0;
+
+        for (var i = 0; i < pool.length; i++)
+        {
+            if (pool[i].parent === null)
+            {
+                c++;
+            }
+        }
+
+        return c;
+
+    }
+
+};
+
+PIXI.CanvasPool.pool = [];
+
 /**
  * @author Mat Groves http://matgroves.com/ @Doormat23
  */
@@ -18071,8 +18240,8 @@ PIXI.WebGLRenderer = function(width, height, options)
     this._contextOptions = {
         alpha: this.transparent,
         antialias: options.antialias, // SPEED UP??
-        premultipliedAlpha:this.transparent && this.transparent !== 'notMultiplied',
-        stencil:true,
+        premultipliedAlpha: this.transparent && this.transparent !== 'notMultiplied',
+        stencil: true,
         preserveDrawingBuffer: options.preserveDrawingBuffer
     };
 
@@ -18387,6 +18556,8 @@ PIXI.WebGLRenderer.prototype.destroy = function()
     this.gl = null;
     this.renderSession = null;
 
+    PIXI.CanvasPool.remove(this);
+
     PIXI.instances[this.glContextId] = null;
 
     PIXI.WebGLRenderer.glContextId--;
@@ -20708,7 +20879,7 @@ PIXI.CanvasBuffer = function(width, height)
      * @property canvas
      * @type HTMLCanvasElement
      */
-    this.canvas = document.createElement("canvas");
+    this.canvas = PIXI.CanvasPool.create(this, this.width, this.height);
 
     /**
      * A CanvasRenderingContext2D object representing a two-dimensional rendering context.
@@ -20749,6 +20920,16 @@ PIXI.CanvasBuffer.prototype.resize = function(width, height)
     this.height = this.canvas.height = height;
 };
 
+/**
+ * Frees the canvas up for use again.
+ *
+ * @method destroy
+ */
+PIXI.CanvasBuffer.prototype.destroy = function()
+{
+    PIXI.CanvasPool.remove(this);
+};
+
 /**
  * @author Mat Groves http://matgroves.com/ @Doormat23
  */
@@ -20831,7 +21012,7 @@ PIXI.CanvasTinter = function() {};
  */
 PIXI.CanvasTinter.getTintedTexture = function(sprite, color)
 {
-    var canvas = sprite.tintedTexture || document.createElement("canvas");
+    var canvas = sprite.tintedTexture || PIXI.CanvasPool.create(this);
     
     PIXI.CanvasTinter.tintMethod(sprite.texture, color, canvas);
 
@@ -21089,14 +21270,14 @@ PIXI.CanvasRenderer = function(width, height, options)
      * @property view
      * @type HTMLCanvasElement
      */
-    this.view = options.view || document.createElement( "canvas" );
+    this.view = options.view || PIXI.CanvasPool.create(this, this.width, this.height);
 
     /**
      * The canvas 2d context that everything is drawn with
      * @property context
      * @type CanvasRenderingContext2D
      */
-    this.context = this.view.getContext( "2d", { alpha: this.transparent } );
+    this.context = this.view.getContext("2d", { alpha: this.transparent } );
 
     /**
      * Boolean flag controlling canvas refresh.
@@ -21841,6 +22022,8 @@ PIXI.BaseTexture.prototype.destroy = function()
     }
     else if (this.source && this.source._pixiId)
     {
+        PIXI.CanvasPool.removeByCanvas(this.source);
+
         delete PIXI.BaseTextureCache[this.source._pixiId];
     }
 
@@ -21924,7 +22107,7 @@ PIXI.BaseTexture.fromImage = function(imageUrl, crossorigin, scaleMode)
     {
         // new Image() breaks tex loading in some versions of Chrome.
         // See https://code.google.com/p/chromium/issues/detail?id=238071
-        var image = new Image();//document.createElement('img');
+        var image = new Image();
 
         if (crossorigin)
         {
@@ -21957,7 +22140,7 @@ PIXI.BaseTexture.fromImage = function(imageUrl, crossorigin, scaleMode)
  */
 PIXI.BaseTexture.fromCanvas = function(canvas, scaleMode)
 {
-    if(!canvas._pixiId)
+    if (!canvas._pixiId)
     {
         canvas._pixiId = 'canvas_' + PIXI.TextureCacheIdGenerator++;
     }
@@ -21974,7 +22157,7 @@ PIXI.BaseTexture.fromCanvas = function(canvas, scaleMode)
 
     var baseTexture = PIXI.BaseTextureCache[canvas._pixiId];
 
-    if(!baseTexture)
+    if (!baseTexture)
     {
         baseTexture = new PIXI.BaseTexture(canvas, scaleMode);
         PIXI.BaseTextureCache[canvas._pixiId] = baseTexture;
@@ -22290,7 +22473,6 @@ PIXI.Texture.fromCanvas = function(canvas, scaleMode)
     var baseTexture = PIXI.BaseTexture.fromCanvas(canvas, scaleMode);
 
     return new PIXI.Texture(baseTexture);
-
 };
 
 /**
@@ -22602,6 +22784,16 @@ PIXI.RenderTexture.prototype.renderCanvas = function(displayObject, matrix, clea
         return;
     }
 
+    //  Let's create a nice matrix to apply to our display object.
+    //  Frame buffers come in upside down so we need to flip the matrix.
+    var wt = displayObject.worldTransform;
+    wt.identity();
+
+    if (matrix)
+    {
+        wt.append(matrix);
+    }
+
     // Time to update all the children of the displayObject with the new matrix (what new matrix? there isn't one!)
     for (var i = 0; i < displayObject.children.length; i++)
     {
@@ -23644,12 +23836,7 @@ PIXI.TilingSprite.prototype._renderCanvas = function(renderSession)
     var wt = this.worldTransform;
     var resolution = renderSession.resolution;
 
-    context.setTransform(wt.a * resolution,
-                         wt.b * resolution,
-                         wt.c * resolution,
-                         wt.d * resolution,
-                         wt.tx * resolution,
-                         wt.ty * resolution);
+    context.setTransform(wt.a * resolution, wt.b * resolution, wt.c * resolution, wt.d * resolution, wt.tx * resolution, wt.ty * resolution);
 
     if (this.refreshTexture)
     {
@@ -23694,10 +23881,10 @@ PIXI.TilingSprite.prototype._renderCanvas = function(renderSession)
     //  Allow for pixel rounding
     if (renderSession.roundPixels)
     {
-        tx | 0;
-        ty | 0;
-        tw | 0;
-        th | 0;
+        tx |= 0;
+        ty |= 0;
+        tw |= 0;
+        th |= 0;
     }
 
     context.fillRect(tx, ty, tw, th);
@@ -23902,6 +24089,8 @@ PIXI.TilingSprite.prototype.getBounds = function()
 
 PIXI.TilingSprite.prototype.destroy = function () {
 
+    this.canvasBuffer.destroy();
+
     PIXI.Sprite.prototype.destroy.call(this);
 
     this.tileScale = null;
@@ -23996,7 +24185,7 @@ var Phaser = Phaser || {
     * @constant
     * @type {string}
     */
-    VERSION: '2.4.2',
+    VERSION: '2.4.3',
 
     /**
     * An array of Phaser game instances.
@@ -25909,8 +26098,9 @@ Phaser.Line.prototype = {
     * Rotates the line by the amount specified in `angle`.
     * 
     * Rotation takes place from the center of the line.
+    * If you wish to rotate around a different point see Line.rotateAround.
     * 
-    * If you wish to rotate from either end see Line.start.rotate or Line.end.rotate.
+    * If you wish to rotate the ends of the Line then see Line.start.rotate or Line.end.rotate.
     * 
     * @method Phaser.Line#rotate
     * @param {number} angle - The angle in radians (unless asDegrees is true) to rotate the line by.
@@ -25919,11 +26109,30 @@ Phaser.Line.prototype = {
     */
     rotate: function (angle, asDegrees) {
 
-        var x = this.start.x;
-        var y = this.start.y;
+        var cx = (this.start.x + this.end.x) / 2;
+        var cy = (this.start.y + this.end.y) / 2;
+
+        this.start.rotate(cx, cy, angle, asDegrees);
+        this.end.rotate(cx, cy, angle, asDegrees);
+
+        return this;
+
+    },
+
+    /**
+    * Rotates the line by the amount specified in `angle`.
+    * 
+    * Rotation takes place around the coordinates given.
+    * 
+    * @method Phaser.Line#rotateAround
+    * @param {number} angle - The angle in radians (unless asDegrees is true) to rotate the line by.
+    * @param {boolean} [asDegrees=false] - Is the given angle in radians (false) or degrees (true)?
+    * @return {Phaser.Line} This line object
+    */
+    rotateAround: function (x, y, angle, asDegrees) {
 
-        this.start.rotate(this.end.x, this.end.y, angle, asDegrees, this.length);
-        this.end.rotate(x, y, angle, asDegrees, this.length);
+        this.start.rotate(x, y, angle, asDegrees);
+        this.end.rotate(x, y, angle, asDegrees);
 
         return this;
 
@@ -25960,6 +26169,48 @@ Phaser.Line.prototype = {
 
     },
 
+    /**
+    * Returns a Point object where the x and y values correspond to the center (or midpoint) of the Line segment.
+    * 
+    * @method Phaser.Line#midPoint
+    * @param {Phaser.Point} [out] - A Phaser.Point object into which the result will be populated. If not given a new Point object is created.
+    * @return {Phaser.Point} A Phaser.Point object with the x and y values set to the center of the line segment.
+    */
+    midPoint: function (out) {
+
+        if (out === undefined) { out = new Phaser.Point(); }
+
+        out.x = (this.start.x + this.end.x) / 2;
+        out.y = (this.start.y + this.end.y) / 2;
+
+        return out;
+
+    },
+
+    /**
+    * Centers this Line on the given coordinates.
+    * 
+    * The line is centered by positioning the start and end points so that the lines midpoint matches
+    * the coordinates given.
+    * 
+    * @method Phaser.Line#centerOn
+    * @param {number} x - The x position to center the line on.
+    * @param {number} y - The y position to center the line on.
+    * @return {Phaser.Line} This line object
+    */
+    centerOn: function (x, y) {
+
+        var cx = (this.start.x + this.end.x) / 2;
+        var cy = (this.start.y + this.end.y) / 2;
+
+        var tx = x - cx;
+        var ty = y - cy;
+
+        this.start.add(tx, ty);
+        this.end.add(tx, ty);
+
+    },
+
     /**
     * Tests if the given coordinates fall on this line. See pointOnSegment to test against just the line segment.
     * 
@@ -27576,24 +27827,27 @@ Phaser.Point.normalize = function (a, out) {
 */
 Phaser.Point.rotate = function (a, x, y, angle, asDegrees, distance) {
 
-    if (asDegrees === undefined) { asDegrees = false; }
-    if (distance === undefined) { distance = null; }
+    if (asDegrees) { angle = Phaser.Math.degToRad(angle); }
 
-    if (asDegrees)
+    if (distance === undefined)
     {
-        angle = Phaser.Math.degToRad(angle);
-    }
+        a.subtract(x, y);
 
-    if (distance === null)
-    {
-        //  Get distance from origin (cx/cy) to this point
-        distance = Math.sqrt(((x - a.x) * (x - a.x)) + ((y - a.y) * (y - a.y)));
-    }
+        var s = Math.sin(angle);
+        var c = Math.cos(angle);
 
-    var t = angle + Math.atan2(a.y - y, a.x - x);
+        var tx = c * a.x - s * a.y;
+        var ty = s * a.x + c * a.y;
 
-    a.x = x + distance * Math.cos(t);
-    a.y = y + distance * Math.sin(t);
+        a.x = tx + x;
+        a.y = ty + y;
+    }
+    else
+    {
+        var t = angle + Math.atan2(a.y - y, a.x - x);
+        a.x = x + distance * Math.cos(t);
+        a.y = y + distance * Math.sin(t);
+    }
 
     return a;
 
@@ -30809,7 +31063,7 @@ Object.defineProperty(Phaser.StateManager.prototype, "created", {
 */
 
 /**
-* A Signal is an event dispatch mechansim that supports broadcasting to multiple listeners.
+* A Signal is an event dispatch mechanism that supports broadcasting to multiple listeners.
 *
 * Event listeners are uniquely identified by the listener/callback function and the context.
 * 
@@ -37407,8 +37661,6 @@ Phaser.ScaleManager.prototype = {
 
             this.updateLayout();
             this.queueUpdate(true);
-
-            this.enterFullScreen.dispatch(this.width, this.height);
         }
         else
         {
@@ -37418,11 +37670,9 @@ Phaser.ScaleManager.prototype = {
 
             this.updateLayout();
             this.queueUpdate(true);
-
-            this.leaveFullScreen.dispatch(this.width, this.height);
         }
 
-        this.onFullScreenChange.dispatch(this);
+        this.onFullScreenChange.dispatch(this, this.width, this.height);
 
     },
 
@@ -38526,14 +38776,7 @@ Phaser.Game.prototype = {
     */
     setUpRenderer: function () {
 
-        if (this.config['canvasID'])
-        {
-            this.canvas = Phaser.Canvas.create(this.width, this.height, this.config['canvasID']);
-        }
-        else
-        {
-            this.canvas = Phaser.Canvas.create(this.width, this.height);
-        }
+        this.canvas = Phaser.Canvas.create(this, this.width, this.height, this.config['canvasID'], true);
 
         if (this.config['canvasStyle'])
         {
@@ -39437,9 +39680,7 @@ Phaser.Input.prototype = {
 
         this.activePointer = this.mousePointer;
 
-        this.hitCanvas = document.createElement('canvas');
-        this.hitCanvas.width = 1;
-        this.hitCanvas.height = 1;
+        this.hitCanvas = PIXI.CanvasPool.create(this, 1, 1);
         this.hitContext = this.hitCanvas.getContext('2d');
 
         this.mouse.start();
@@ -39485,6 +39726,8 @@ Phaser.Input.prototype = {
 
         this.moveCallbacks = [];
 
+        PIXI.CanvasPool.remove(this);
+
         this.game.canvas.removeEventListener('click', this._onClickTrampoline);
 
     },
@@ -40556,16 +40799,12 @@ Phaser.Mouse.prototype = {
     },
 
     /**
-     * The internal method that handles the mouse wheel event from the browser.
-     *
-     * @method Phaser.Mouse#onMouseWheel
-     * @param {MouseEvent} event - The native event from the browser.
-     */
-    onMouseWheel: function (event) {
-
-        if (this._wheelEvent) {
-            event = this._wheelEvent.bindEvent(event);
-        }
+    * The internal method that handles the mouse over event from the browser.
+    *
+    * @method Phaser.Mouse#onMouseOver
+    * @param {MouseEvent} event - The native event from the browser. This gets stored in Mouse.event.
+    */
+    onMouseOver: function (event) {
 
         this.event = event;
 
@@ -40574,23 +40813,26 @@ Phaser.Mouse.prototype = {
             event.preventDefault();
         }
 
-        // reverse detail for firefox
-        this.wheelDelta = Phaser.Math.clamp(-event.deltaY, -1, 1);
+        this.input.mousePointer.withinGame = true;
 
-        if (this.mouseWheelCallback)
+        if (this.mouseOverCallback)
         {
-            this.mouseWheelCallback.call(this.callbackContext, event);
+            this.mouseOverCallback.call(this.callbackContext, event);
         }
 
     },
 
     /**
-    * The internal method that handles the mouse over event from the browser.
-    *
-    * @method Phaser.Mouse#onMouseOver
-    * @param {MouseEvent} event - The native event from the browser. This gets stored in Mouse.event.
-    */
-    onMouseOver: function (event) {
+     * The internal method that handles the mouse wheel event from the browser.
+     *
+     * @method Phaser.Mouse#onMouseWheel
+     * @param {MouseEvent} event - The native event from the browser.
+     */
+    onMouseWheel: function (event) {
+
+        if (this._wheelEvent) {
+            event = this._wheelEvent.bindEvent(event);
+        }
 
         this.event = event;
 
@@ -40599,16 +40841,12 @@ Phaser.Mouse.prototype = {
             event.preventDefault();
         }
 
-        this.input.mousePointer.withinGame = true;
-
-        if (this.mouseOverCallback)
-        {
-            this.mouseOverCallback.call(this.callbackContext, event);
-        }
+        // reverse detail for firefox
+        this.wheelDelta = Phaser.Math.clamp(-event.deltaY, -1, 1);
 
-        if (!this.input.enabled || !this.enabled)
+        if (this.mouseWheelCallback)
         {
-            return;
+            this.mouseWheelCallback.call(this.callbackContext, event);
         }
 
     },
@@ -40901,6 +41139,24 @@ Phaser.MSPointer = function (game) {
     */
     this._onMSPointerUp = null;
 
+    /**
+    * @property {function} _onMSPointerUpGlobal - Internal function to handle MSPointer events.
+    * @private
+    */
+    this._onMSPointerUpGlobal = null;
+
+    /**
+    * @property {function} _onMSPointerOut - Internal function to handle MSPointer events.
+    * @private
+    */
+    this._onMSPointerOut = null;
+
+    /**
+    * @property {function} _onMSPointerOver - Internal function to handle MSPointer events.
+    * @private
+    */
+    this._onMSPointerOver = null;
+
 };
 
 Phaser.MSPointer.prototype = {
@@ -40933,6 +41189,18 @@ Phaser.MSPointer.prototype = {
                 return _this.onPointerUp(event);
             };
 
+            this._onMSPointerUpGlobal = function (event) {
+                return _this.onPointerUpGlobal(event);
+            };
+
+            this._onMSPointerOut = function (event) {
+                return _this.onPointerOut(event);
+            };
+
+            this._onMSPointerOver = function (event) {
+                return _this.onPointerOver(event);
+            };
+
             var canvas = this.game.canvas;
 
             canvas.addEventListener('MSPointerDown', this._onMSPointerDown, false);
@@ -40940,12 +41208,24 @@ Phaser.MSPointer.prototype = {
             canvas.addEventListener('MSPointerUp', this._onMSPointerUp, false);
 
             //  IE11+ uses non-prefix events
-            canvas.addEventListener('pointerDown', this._onMSPointerDown, false);
-            canvas.addEventListener('pointerMove', this._onMSPointerMove, false);
-            canvas.addEventListener('pointerUp', this._onMSPointerUp, false);
+            canvas.addEventListener('pointerdown', this._onMSPointerDown, false);
+            canvas.addEventListener('pointermove', this._onMSPointerMove, false);
+            canvas.addEventListener('pointerup', this._onMSPointerUp, false);
 
             canvas.style['-ms-content-zooming'] = 'none';
             canvas.style['-ms-touch-action'] = 'none';
+
+            if (!this.game.device.cocoonJS)
+            {
+                window.addEventListener('MSPointerUp', this._onMSPointerUpGlobal, true);
+                canvas.addEventListener('MSPointerOver', this._onMSPointerOver, true);
+                canvas.addEventListener('MSPointerOut', this._onMSPointerOut, true);
+
+                //  IE11+ uses non-prefix events
+                window.addEventListener('pointerup', this._onMSPointerUpGlobal, true);
+                canvas.addEventListener('pointerover', this._onMSPointerOver, true);
+                canvas.addEventListener('pointerout', this._onMSPointerOut, true);
+            }
         }
 
     },
@@ -41062,6 +41342,121 @@ Phaser.MSPointer.prototype = {
 
     },
 
+    /**
+    * The internal method that handles the mouse up event from the window.
+    * 
+    * @method Phaser.MSPointer#onPointerUpGlobal
+    * @param {PointerEvent} event - The native event from the browser. This gets stored in MSPointer.event.
+    */
+    onPointerUpGlobal: function (event) {
+
+        if ((event.pointerType === 'mouse' || event.pointerType === 0x00000004) && !this.input.mousePointer.withinGame)
+        {
+            this.onPointerUp(event);
+        }
+        else
+        {
+            var pointer = this.input.getPointerFromIdentifier(event.identifier);
+
+            if (pointer && pointer.withinGame)
+            {
+                this.onPointerUp(event);
+            }
+        }
+
+    },
+
+    /**
+    * The internal method that handles the pointer out event from the browser.
+    *
+    * @method Phaser.MSPointer#onPointerOut
+    * @param {PointerEvent} event - The native event from the browser. This gets stored in MSPointer.event.
+    */
+    onPointerOut: function (event) {
+
+        this.event = event;
+
+        if (this.capture)
+        {
+            event.preventDefault();
+        }
+
+        if (event.pointerType === 'mouse' || event.pointerType === 0x00000004)
+        {
+            this.input.mousePointer.withinGame = false;
+        }
+        else
+        {
+            var pointer = this.input.getPointerFromIdentifier(event.identifier);
+
+            if (pointer)
+            {
+                pointer.withinGame = false;
+            }
+        }
+
+        if (this.input.mouse.mouseOutCallback)
+        {
+            this.input.mouse.mouseOutCallback.call(this.input.mouse.callbackContext, event);
+        }
+
+        if (!this.input.enabled || !this.enabled)
+        {
+            return;
+        }
+
+        if (this.input.mouse.stopOnGameOut)
+        {
+            event['identifier'] = 0;
+
+            if (pointer)
+            {
+                pointer.stop(event);
+            }
+            else
+            {
+                this.input.mousePointer.stop(event);
+            }
+        }
+
+    },
+
+    /**
+    * The internal method that handles the pointer out event from the browser.
+    *
+    * @method Phaser.MSPointer#onPointerOut
+    * @param {PointerEvent} event - The native event from the browser. This gets stored in MSPointer.event.
+    */
+    onPointerOver: function (event) {
+
+        this.event = event;
+
+        if (this.capture)
+        {
+            event.preventDefault();
+        }
+
+        if (event.pointerType === 'mouse' || event.pointerType === 0x00000004)
+        {
+            this.input.mousePointer.withinGame = true;
+        }
+        else
+        {
+            var pointer = this.input.getPointerFromIdentifier(event.identifier);
+
+            if (pointer)
+            {
+                pointer.withinGame = true;
+            }
+        }
+
+        if (this.input.mouse.mouseOverCallback)
+        {
+            this.input.mouse.mouseOverCallback.call(this.input.mouse.callbackContext, event);
+        }
+
+    },
+
     /**
     * Stop the event listeners.
     * @method Phaser.MSPointer#stop
@@ -41073,10 +41468,17 @@ Phaser.MSPointer.prototype = {
         canvas.removeEventListener('MSPointerDown', this._onMSPointerDown);
         canvas.removeEventListener('MSPointerMove', this._onMSPointerMove);
         canvas.removeEventListener('MSPointerUp', this._onMSPointerUp);
+        canvas.removeEventListener('MSPointerOver', this._onMSPointerOver);
+        canvas.removeEventListener('MSPointerOut', this._onMSPointerOut);
 
-        canvas.removeEventListener('pointerDown', this._onMSPointerDown);
-        canvas.removeEventListener('pointerMove', this._onMSPointerMove);
-        canvas.removeEventListener('pointerUp', this._onMSPointerUp);
+        canvas.removeEventListener('pointerdown', this._onMSPointerDown);
+        canvas.removeEventListener('pointermove', this._onMSPointerMove);
+        canvas.removeEventListener('pointerup', this._onMSPointerUp);
+        canvas.removeEventListener('pointerover', this._onMSPointerOver);
+        canvas.removeEventListener('pointerout', this._onMSPointerOut);
+
+        window.removeEventListener('MSPointerUp', this._onMSPointerUpGlobal);
+        window.removeEventListener('pointerup', this._onMSPointerUpGlobal);
 
     }
 
@@ -41991,8 +42393,6 @@ Phaser.Pointer.prototype = {
     */
     start: function (event) {
 
-        // console.log(event);
-
         if (event['pointerId'])
         {
             this.pointerId = event.pointerId;
@@ -42011,10 +42411,11 @@ Phaser.Pointer.prototype = {
             this.isUp = false;
         }
 
-        this._history = [];
         this.active = true;
         this.withinGame = true;
         this.dirty = false;
+
+        this._history = [];
         this._clickTrampolines = null;
         this._trampolineTargetObject = null;
 
@@ -42111,7 +42512,9 @@ Phaser.Pointer.prototype = {
     */
     move: function (event, fromClick) {
 
-        if (this.game.input.pollLocked)
+        var input = this.game.input;
+
+        if (input.pollLocked)
         {
             return;
         }
@@ -42137,7 +42540,7 @@ Phaser.Pointer.prototype = {
         this.screenX = event.screenX;
         this.screenY = event.screenY;
 
-        if (this.isMouse && this.game.input.mouse.locked && !fromClick)
+        if (this.isMouse && input.mouse.locked && !fromClick)
         {
             this.rawMovementX = event.movementX || event.mozMovementX || event.webkitMovementX || 0;
             this.rawMovementY = event.movementY || event.mozMovementY || event.webkitMovementY || 0;
@@ -42146,23 +42549,23 @@ Phaser.Pointer.prototype = {
             this.movementY += this.rawMovementY;
         }
 
-        this.x = (this.pageX - this.game.scale.offset.x) * this.game.input.scale.x;
-        this.y = (this.pageY - this.game.scale.offset.y) * this.game.input.scale.y;
+        this.x = (this.pageX - this.game.scale.offset.x) * input.scale.x;
+        this.y = (this.pageY - this.game.scale.offset.y) * input.scale.y;
 
         this.position.setTo(this.x, this.y);
         this.circle.x = this.x;
         this.circle.y = this.y;
 
-        if (this.game.input.multiInputOverride === Phaser.Input.MOUSE_OVERRIDES_TOUCH ||
-            this.game.input.multiInputOverride === Phaser.Input.MOUSE_TOUCH_COMBINE ||
-            (this.game.input.multiInputOverride === Phaser.Input.TOUCH_OVERRIDES_MOUSE && this.game.input.totalActivePointers === 0))
+        if (input.multiInputOverride === Phaser.Input.MOUSE_OVERRIDES_TOUCH ||
+            input.multiInputOverride === Phaser.Input.MOUSE_TOUCH_COMBINE ||
+            (input.multiInputOverride === Phaser.Input.TOUCH_OVERRIDES_MOUSE && input.totalActivePointers === 0))
         {
-            this.game.input.activePointer = this;
-            this.game.input.x = this.x;
-            this.game.input.y = this.y;
-            this.game.input.position.setTo(this.game.input.x, this.game.input.y);
-            this.game.input.circle.x = this.game.input.x;
-            this.game.input.circle.y = this.game.input.y;
+            input.activePointer = this;
+            input.x = this.x;
+            input.y = this.y;
+            input.position.setTo(input.x, input.y);
+            input.circle.x = input.x;
+            input.circle.y = input.y;
         }
 
         this.withinGame = this.game.scale.bounds.contains(this.pageX, this.pageY);
@@ -42173,11 +42576,11 @@ Phaser.Pointer.prototype = {
             return this;
         }
 
-        var i = this.game.input.moveCallbacks.length;
+        var i = input.moveCallbacks.length;
 
         while (i--)
         {
-            this.game.input.moveCallbacks[i].callback.call(this.game.input.moveCallbacks[i].context, this, this.x, this.y, fromClick);
+            input.moveCallbacks[i].callback.call(input.moveCallbacks[i].context, this, this.x, this.y, fromClick);
         }
 
         //  Easy out if we're dragging something and it still exists
@@ -42188,7 +42591,7 @@ Phaser.Pointer.prototype = {
                 this.targetObject = null;
             }
         }
-        else if (this.game.input.interactiveItems.total > 0)
+        else if (input.interactiveItems.total > 0)
         {
             this.processInteractiveObjects(fromClick);
         }
@@ -42334,16 +42737,6 @@ Phaser.Pointer.prototype = {
             return;
         }
 
-        if (this.isMouse)
-        {
-            this.updateButtons(event);
-        }
-        else
-        {
-            this.isDown = false;
-            this.isUp = true;
-        }
-
         this.timeUp = this.game.time.time;
 
         if (this.game.input.multiInputOverride === Phaser.Input.MOUSE_OVERRIDES_TOUCH ||
@@ -42371,13 +42764,23 @@ Phaser.Pointer.prototype = {
             }
         }
 
+        if (this.isMouse)
+        {
+            this.updateButtons(event);
+        }
+        else
+        {
+            this.isDown = false;
+            this.isUp = true;
+        }
+
         //  Mouse is always active
         if (this.id > 0)
         {
             this.active = false;
         }
 
-        this.withinGame = false;
+        this.withinGame = this.game.scale.bounds.contains(event.pageX, event.pageY);
         this.pointerId = null;
         this.identifier = null;
         
@@ -43740,7 +44143,10 @@ Phaser.InputHandler.prototype = {
         //  Need to pass it a temp point, in case we need it again for the pixel check
         if (this.game.input.hitTest(this.sprite, pointer, this._tempPoint))
         {
-            if (fastTest === undefined) { fastTest = false; }
+            if (fastTest === undefined)
+            {
+                fastTest = false;
+            }
 
             if (!fastTest && this.pixelPerfectClick)
             {
@@ -43775,7 +44181,10 @@ Phaser.InputHandler.prototype = {
         //  Need to pass it a temp point, in case we need it again for the pixel check
         if (this.game.input.hitTest(this.sprite, pointer, this._tempPoint))
         {
-            if (fastTest === undefined) { fastTest = false; }
+            if (fastTest === undefined)
+            {
+                fastTest = false;
+            }
 
             if (!fastTest && this.pixelPerfectOver)
             {
@@ -43915,15 +44324,17 @@ Phaser.InputHandler.prototype = {
             return;
         }
 
-        if (this._pointerData[pointer.id].isOver === false || pointer.dirty)
+        var data = this._pointerData[pointer.id];
+
+        if (data.isOver === false || pointer.dirty)
         {
-            this._pointerData[pointer.id].isOver = true;
-            this._pointerData[pointer.id].isOut = false;
-            this._pointerData[pointer.id].timeOver = this.game.time.time;
-            this._pointerData[pointer.id].x = pointer.x - this.sprite.x;
-            this._pointerData[pointer.id].y = pointer.y - this.sprite.y;
+            data.isOver = true;
+            data.isOut = false;
+            data.timeOver = this.game.time.time;
+            data.x = pointer.x - this.sprite.x;
+            data.y = pointer.y - this.sprite.y;
 
-            if (this.useHandCursor && this._pointerData[pointer.id].isDragged === false)
+            if (this.useHandCursor && data.isDragged === false)
             {
                 this.game.canvas.style.cursor = "pointer";
                 this._setHandCursor = true;
@@ -43952,11 +44363,13 @@ Phaser.InputHandler.prototype = {
             return;
         }
 
-        this._pointerData[pointer.id].isOver = false;
-        this._pointerData[pointer.id].isOut = true;
-        this._pointerData[pointer.id].timeOut = this.game.time.time;
+        var data = this._pointerData[pointer.id];
 
-        if (this.useHandCursor && this._pointerData[pointer.id].isDragged === false)
+        data.isOver = false;
+        data.isOut = true;
+        data.timeOut = this.game.time.time;
+
+        if (this.useHandCursor && data.isDragged === false)
         {
             this.game.canvas.style.cursor = "default";
             this._setHandCursor = false;
@@ -43984,16 +44397,18 @@ Phaser.InputHandler.prototype = {
             return;
         }
 
-        if (!this._pointerData[pointer.id].isDown && this._pointerData[pointer.id].isOver)
+        var data = this._pointerData[pointer.id];
+
+        if (!data.isDown && data.isOver)
         {
             if (this.pixelPerfectClick && !this.checkPixel(null, null, pointer))
             {
                 return;
             }
 
-            this._pointerData[pointer.id].isDown = true;
-            this._pointerData[pointer.id].isUp = false;
-            this._pointerData[pointer.id].timeDown = this.game.time.time;
+            data.isDown = true;
+            data.isUp = false;
+            data.timeDown = this.game.time.time;
 
             if (this.sprite && this.sprite.events)
             {
@@ -44034,40 +44449,39 @@ Phaser.InputHandler.prototype = {
             return;
         }
 
+        var data = this._pointerData[pointer.id];
+
         //  If was previously touched by this Pointer, check if still is AND still over this item
-        if (this._pointerData[pointer.id].isDown && pointer.isUp)
+        if (data.isDown && pointer.isUp)
         {
-            this._pointerData[pointer.id].isDown = false;
-            this._pointerData[pointer.id].isUp = true;
-            this._pointerData[pointer.id].timeUp = this.game.time.time;
-            this._pointerData[pointer.id].downDuration = this._pointerData[pointer.id].timeUp - this._pointerData[pointer.id].timeDown;
+            data.isDown = false;
+            data.isUp = true;
+            data.timeUp = this.game.time.time;
+            data.downDuration = data.timeUp - data.timeDown;
 
             //  Only release the InputUp signal if the pointer is still over this sprite
-            if (this.checkPointerOver(pointer))
+            var isOver = this.checkPointerOver(pointer);
+
+            if (this.sprite && this.sprite.events)
             {
-                //  Release the inputUp signal and provide optional parameter if pointer is still over the sprite or not
-                if (this.sprite && this.sprite.events)
+                this.sprite.events.onInputUp$dispatch(this.sprite, pointer, isOver);
+
+                //  The onInputUp event may have changed the sprite so that checkPointerOver is no longer true, so update it.
+                if (isOver)
                 {
-                    this.sprite.events.onInputUp$dispatch(this.sprite, pointer, true);
+                    isOver = this.checkPointerOver(pointer);
                 }
             }
-            else
-            {
-                //  Release the inputUp signal and provide optional parameter if pointer is still over the sprite or not
-                if (this.sprite && this.sprite.events)
-                {
-                    this.sprite.events.onInputUp$dispatch(this.sprite, pointer, false);
-                }
+            
+            data.isOver = isOver;
 
-                //  Pointer outside the sprite? Reset the cursor
-                if (this.useHandCursor)
-                {
-                    this.game.canvas.style.cursor = "default";
-                    this._setHandCursor = false;
-                }
+            if (!isOver && this.useHandCursor)
+            {
+                this.game.canvas.style.cursor = "default";
+                this._setHandCursor = false;
             }
 
-            //  It's possible the onInputUp event created a new Sprite that is on-top of this one, so we ought to force a Pointer update
+            //  It's possible the onInputUp event created a new Sprite that is on-top of this one, so force a Pointer update
             pointer.dirty = true;
 
             //  Stop drag
@@ -45954,7 +46368,7 @@ Phaser.Key = function (game, keycode) {
     this.onHoldContext = null;
 
     /**
-    * @property {Phaser.Signal} onUp - This Signal is dispatched every time this Key is pressed down. It is only dispatched once (until the key is released again).
+    * @property {Phaser.Signal} onUp - This Signal is dispatched every time this Key is released. It is only dispatched once (until the key is pressed and released again).
     */
     this.onUp = new Phaser.Signal();
 
@@ -47937,6 +48351,8 @@ Phaser.Component.Destroy.prototype = {
         this._currentBounds = null;
         this._mask = null;
 
+
+
         this._destroyCachedSprite();
 
         this.destroyPhase = false;
@@ -51877,7 +52293,8 @@ Phaser.BitmapData = function (game, key, width, height) {
     * @property {HTMLCanvasElement} canvas - The canvas to which this BitmapData draws.
     * @default
     */
-    this.canvas = Phaser.Canvas.create(width, height, '', true);
+    // this.canvas = Phaser.Canvas.create(width, height, '', true);
+    this.canvas = PIXI.CanvasPool.create(this, width, height);
 
     /**
     * @property {CanvasRenderingContext2D} context - The 2d context of the canvas.
@@ -51892,6 +52309,8 @@ Phaser.BitmapData = function (game, key, width, height) {
 
     /**
     * @property {ImageData} imageData - The context image data.
+    * Please note that a call to BitmapData.draw() or BitmapData.copy() does not update immediately this property for performance reason. Use BitmapData.update() to do so.
+    * This property is updated automatically after the first game loop, according to the dirty flag property.
     */
     this.imageData = this.context.getImageData(0, 0, width, height);
 
@@ -52045,7 +52464,7 @@ Phaser.BitmapData = function (game, key, width, height) {
     * @property {HTMLCanvasElement} _swapCanvas - A swap canvas.
     * @private
     */
-    this._swapCanvas = Phaser.Canvas.create(width, height, '', true);
+    this._swapCanvas = PIXI.CanvasPool.create(this, width, height);
 
 };
 
@@ -52748,7 +53167,6 @@ Phaser.BitmapData.prototype = {
     * @param {number} red - The red color value, between 0 and 0xFF (255).
     * @param {number} green - The green color value, between 0 and 0xFF (255).
     * @param {number} blue - The blue color value, between 0 and 0xFF (255).
-    * @param {number} alpha - The alpha color value, between 0 and 0xFF (255).
     * @param {boolean} [immediate=true] - If `true` the context.putImageData will be called and the dirty flag set.
     * @return {Phaser.BitmapData} This BitmapData object for method chaining.
     */
@@ -53013,7 +53431,7 @@ Phaser.BitmapData.prototype = {
 
         this._image = source;
 
-        if (source instanceof Phaser.Sprite || source instanceof Phaser.Image || source instanceof Phaser.Text)
+        if (source instanceof Phaser.Sprite || source instanceof Phaser.Image || source instanceof Phaser.Text || source instanceof PIXI.Sprite)
         {
             //  Copy over sprite values
             this._pos.set(source.texture.crop.x, source.texture.crop.y);
@@ -53139,15 +53557,17 @@ Phaser.BitmapData.prototype = {
             return;
         }
 
-        this._alpha.prev = this.context.globalAlpha;
+        var ctx = this.context;
 
-        this.context.save();
+        this._alpha.prev = ctx.globalAlpha;
 
-        this.context.globalAlpha = this._alpha.current;
+        ctx.save();
+
+        ctx.globalAlpha = this._alpha.current;
 
         if (blendMode)
         {
-            this.context.globalCompositeOperation = blendMode;
+            this.op = blendMode;
         }
 
         if (roundPx)
@@ -53156,17 +53576,17 @@ Phaser.BitmapData.prototype = {
             ty |= 0;
         }
 
-        this.context.translate(tx, ty);
+        ctx.translate(tx, ty);
 
-        this.context.scale(this._scale.x, this._scale.y);
+        ctx.scale(this._scale.x, this._scale.y);
 
-        this.context.rotate(this._rotate);
+        ctx.rotate(this._rotate);
 
-        this.context.drawImage(this._image, this._pos.x + x, this._pos.y + y, this._size.x, this._size.y, -newWidth * this._anchor.x, -newHeight * this._anchor.y, newWidth, newHeight);
+        ctx.drawImage(this._image, this._pos.x + x, this._pos.y + y, this._size.x, this._size.y, -newWidth * this._anchor.x, -newHeight * this._anchor.y, newWidth, newHeight);
 
-        this.context.restore();
+        ctx.restore();
 
-        this.context.globalAlpha = this._alpha.prev;
+        ctx.globalAlpha = this._alpha.prev;
 
         this.dirty = true;
 
@@ -53239,6 +53659,64 @@ Phaser.BitmapData.prototype = {
 
     },
 
+    /**
+    * Draws the Game Object or Group to this BitmapData and then recursively iterates through all of its children.
+    * 
+    * If a child has an `exists` property then it (and its children) will be only be drawn if exists is `true`.
+    * 
+    * The children will be drawn at their `x` and `y` world space coordinates. If this is outside the bounds of the BitmapData 
+    * they won't be drawn. Depending on your requirements you may need to resize the BitmapData in advance to match the 
+    * bounds of the top-level Game Object.
+    * 
+    * When drawing it will take into account the child's world rotation, scale and alpha values.
+    *
+    * It's perfectly valid to pass in `game.world` as the parent object, and it will iterate through the entire display list.
+    * 
+    * Note: If you are trying to grab your entire game at the start of a State then you should ensure that at least 1 full update
+    * has taken place before doing so, otherwise all of the objects will render with incorrect positions and scales. You can 
+    * trigger an update yourself by calling `stage.updateTransform()` before calling `drawFull`.
+    *
+    * @method Phaser.BitmapData#drawFull
+    * @param {Phaser.World|Phaser.Group|Phaser.Sprite|Phaser.Image|Phaser.Text|Phaser.BitmapText} parent - The Game Object to draw onto this BitmapData and then recursively draw all of its children.
+    * @param {string} [blendMode=null] - The composite blend mode that will be used when drawing. The default is no blend mode at all. This is a Canvas globalCompositeOperation value such as 'lighter' or 'xor'.
+    * @param {boolean} [roundPx=false] - Should the x and y values be rounded to integers before drawing? This prevents anti-aliasing in some instances.
+    * @return {Phaser.BitmapData} This BitmapData object for method chaining.
+    */
+    drawFull: function (parent, blendMode, roundPx) {
+
+        if (parent.worldVisible === false || parent.worldAlpha === 0 || (parent.hasOwnProperty('exists') && parent.exists === false))
+        {
+            return this;
+        }
+
+        if (parent.type !== Phaser.GROUP && parent.type !== Phaser.EMITTER && parent.type !== Phaser.BITMAPTEXT)
+        {
+            if (parent.type === Phaser.GRAPHICS)
+            {
+                var bounds = parent.getBounds();
+                this.ctx.save();
+                this.ctx.translate(bounds.x, bounds.y);
+                PIXI.CanvasGraphics.renderGraphics(parent, this.ctx);
+                this.ctx.restore();
+            }
+            else
+            {
+                this.copy(parent, null, null, null, null, parent.worldPosition.x, parent.worldPosition.y, null, null, parent.worldRotation, null, null, parent.worldScale.x, parent.worldScale.y, parent.worldAlpha, blendMode, roundPx);
+            }
+        }
+
+        if (parent.children)
+        {
+            for (var i = 0; i < parent.children.length; i++)
+            {
+                this.drawFull(parent.children[i], blendMode, roundPx);
+            }
+        }
+
+        return this;
+
+    },
+
     /**
     * Sets the shadow properties of this BitmapDatas context which will affect all draw operations made to it.
     * You can cancel an existing shadow by calling this method and passing no parameters.
@@ -53253,16 +53731,18 @@ Phaser.BitmapData.prototype = {
     */
     shadow: function (color, blur, x, y) {
 
+        var ctx = this.context;
+
         if (color === undefined || color === null)
         {
-            this.context.shadowColor = 'rgba(0,0,0,0)';
+            ctx.shadowColor = 'rgba(0,0,0,0)';
         }
         else
         {
-            this.context.shadowColor = color;
-            this.context.shadowBlur = blur || 5;
-            this.context.shadowOffsetX = x || 10;
-            this.context.shadowOffsetY = y || 10;
+            ctx.shadowColor = color;
+            ctx.shadowBlur = blur || 5;
+            ctx.shadowOffsetX = x || 10;
+            ctx.shadowOffsetY = y || 10;
         }
 
     },
@@ -53400,20 +53880,21 @@ Phaser.BitmapData.prototype = {
         if (color === undefined) { color = 'rgb(255,255,255)'; }
         if (shadow === undefined) { shadow = true; }
 
-        var prevFont = this.context.font;
+        var ctx = this.context;
+        var prevFont = ctx.font;
 
-        this.context.font = font;
+        ctx.font = font;
 
         if (shadow)
         {
-            this.context.fillStyle = 'rgb(0,0,0)';
-            this.context.fillText(text, x + 1, y + 1);
+            ctx.fillStyle = 'rgb(0,0,0)';
+            ctx.fillText(text, x + 1, y + 1);
         }
         
-        this.context.fillStyle = color;
-        this.context.fillText(text, x, y);
+        ctx.fillStyle = color;
+        ctx.fillText(text, x, y);
 
-        this.context.font = prevFont;
+        ctx.font = prevFont;
 
     },
 
@@ -53429,16 +53910,52 @@ Phaser.BitmapData.prototype = {
     */
     circle: function (x, y, radius, fillStyle) {
 
-        if (typeof fillStyle !== 'undefined')
+        var ctx = this.context;
+
+        if (fillStyle !== undefined)
         {
-            this.context.fillStyle = fillStyle;
+            ctx.fillStyle = fillStyle;
         }
 
-        this.context.beginPath();
-        this.context.arc(x, y, radius, 0, Math.PI * 2, false);
-        this.context.closePath();
+        ctx.beginPath();
+        ctx.arc(x, y, radius, 0, Math.PI * 2, false);
+        ctx.closePath();
 
-        this.context.fill();
+        ctx.fill();
+
+        return this;
+
+    },
+
+    /**
+    * Draws a line between the coordinates given in the color and thickness specified.
+    *
+    * @method Phaser.BitmapData#line
+    * @param {number} x1 - The x coordinate to start the line from.
+    * @param {number} y1 - The y coordinate to start the line from.
+    * @param {number} x2 - The x coordinate to draw the line to.
+    * @param {number} y2 - The y coordinate to draw the line to.
+    * @param {string} [color='#fff'] - The stroke color that the line will be drawn in.
+    * @param {number} [width=1] - The line thickness.
+    * @return {Phaser.BitmapData} This BitmapData object for method chaining.
+    */
+    line: function (x1, y1, x2, y2, color, width) {
+
+        if (color === undefined) { color = '#fff'; }
+        if (width === undefined) { width = 1; }
+
+        var ctx = this.context;
+
+        ctx.beginPath();
+
+        ctx.moveTo(x1, y1);
+        ctx.lineTo(x2, y2);
+
+        ctx.lineWidth = width;
+        ctx.strokeStyle = color;
+        ctx.stroke();
+
+        ctx.closePath();
 
         return this;
 
@@ -53474,17 +53991,19 @@ Phaser.BitmapData.prototype = {
             width = image.width;
         }
 
-        this.context.fillStyle = this.context.createPattern(image, repeat);
+        var ctx = this.context;
+
+        ctx.fillStyle = ctx.createPattern(image, repeat);
 
         this._circle = new Phaser.Circle(line.start.x, line.start.y, image.height);
 
         this._circle.circumferencePoint(line.angle - 1.5707963267948966, false, this._pos);
 
-        this.context.save();
-        this.context.translate(this._pos.x, this._pos.y);
-        this.context.rotate(line.angle);
-        this.context.fillRect(0, 0, width, image.height);
-        this.context.restore();
+        ctx.save();
+        ctx.translate(this._pos.x, this._pos.y);
+        ctx.rotate(line.angle);
+        ctx.fillRect(0, 0, width, image.height);
+        ctx.restore();
 
         this.dirty = true;
 
@@ -53512,6 +54031,17 @@ Phaser.BitmapData.prototype = {
 
     },
 
+    /**
+    * Destroys this BitmapData and puts the canvas it was using back into the canvas pool for re-use.
+    *
+    * @method Phaser.BitmapData#destroy
+    */
+    destroy: function () {
+
+        PIXI.CanvasPool.remove(this);
+
+    },
+
     /**
     * Resets the blend mode (effectively sets it to 'source-over')
     *
@@ -53520,7 +54050,7 @@ Phaser.BitmapData.prototype = {
     */
     blendReset: function () {
 
-        this.context.globalCompositeOperation = 'source-over';
+        this.op = 'source-over';
         return this;
 
     },
@@ -53533,7 +54063,7 @@ Phaser.BitmapData.prototype = {
     */
     blendSourceOver: function () {
 
-        this.context.globalCompositeOperation = 'source-over';
+        this.op = 'source-over';
         return this;
 
     },
@@ -53546,7 +54076,7 @@ Phaser.BitmapData.prototype = {
     */
     blendSourceIn: function () {
 
-        this.context.globalCompositeOperation = 'source-in';
+        this.op = 'source-in';
         return this;
 
     },
@@ -53559,7 +54089,7 @@ Phaser.BitmapData.prototype = {
     */
     blendSourceOut: function () {
 
-        this.context.globalCompositeOperation = 'source-out';
+        this.op = 'source-out';
         return this;
 
     },
@@ -53572,7 +54102,7 @@ Phaser.BitmapData.prototype = {
     */
     blendSourceAtop: function () {
 
-        this.context.globalCompositeOperation = 'source-atop';
+        this.op = 'source-atop';
         return this;
 
     },
@@ -53585,7 +54115,7 @@ Phaser.BitmapData.prototype = {
     */
     blendDestinationOver: function () {
 
-        this.context.globalCompositeOperation = 'destination-over';
+        this.op = 'destination-over';
         return this;
 
     },
@@ -53598,7 +54128,7 @@ Phaser.BitmapData.prototype = {
     */
     blendDestinationIn: function () {
 
-        this.context.globalCompositeOperation = 'destination-in';
+        this.op = 'destination-in';
         return this;
 
     },
@@ -53611,7 +54141,7 @@ Phaser.BitmapData.prototype = {
     */
     blendDestinationOut: function () {
 
-        this.context.globalCompositeOperation = 'destination-out';
+        this.op = 'destination-out';
         return this;
 
     },
@@ -53624,7 +54154,7 @@ Phaser.BitmapData.prototype = {
     */
     blendDestinationAtop: function () {
 
-        this.context.globalCompositeOperation = 'destination-atop';
+        this.op = 'destination-atop';
         return this;
 
     },
@@ -53637,7 +54167,7 @@ Phaser.BitmapData.prototype = {
     */
     blendXor: function () {
 
-        this.context.globalCompositeOperation = 'xor';
+        this.op = 'xor';
         return this;
 
     },
@@ -53650,7 +54180,7 @@ Phaser.BitmapData.prototype = {
     */
     blendAdd: function () {
 
-        this.context.globalCompositeOperation = 'lighter';
+        this.op = 'lighter';
         return this;
 
     },
@@ -53663,7 +54193,7 @@ Phaser.BitmapData.prototype = {
     */
     blendMultiply: function () {
 
-        this.context.globalCompositeOperation = 'multiply';
+        this.op = 'multiply';
         return this;
 
     },
@@ -53676,7 +54206,7 @@ Phaser.BitmapData.prototype = {
     */
     blendScreen: function () {
 
-        this.context.globalCompositeOperation = 'screen';
+        this.op = 'screen';
         return this;
 
     },
@@ -53689,7 +54219,7 @@ Phaser.BitmapData.prototype = {
     */
     blendOverlay: function () {
 
-        this.context.globalCompositeOperation = 'overlay';
+        this.op = 'overlay';
         return this;
 
     },
@@ -53702,7 +54232,7 @@ Phaser.BitmapData.prototype = {
     */
     blendDarken: function () {
 
-        this.context.globalCompositeOperation = 'darken';
+        this.op = 'darken';
         return this;
 
     },
@@ -53715,7 +54245,7 @@ Phaser.BitmapData.prototype = {
     */
     blendLighten: function () {
 
-        this.context.globalCompositeOperation = 'lighten';
+        this.op = 'lighten';
         return this;
 
     },
@@ -53728,7 +54258,7 @@ Phaser.BitmapData.prototype = {
     */
     blendColorDodge: function () {
 
-        this.context.globalCompositeOperation = 'color-dodge';
+        this.op = 'color-dodge';
         return this;
 
     },
@@ -53741,7 +54271,7 @@ Phaser.BitmapData.prototype = {
     */
     blendColorBurn: function () {
 
-        this.context.globalCompositeOperation = 'color-burn';
+        this.op = 'color-burn';
         return this;
 
     },
@@ -53754,7 +54284,7 @@ Phaser.BitmapData.prototype = {
     */
     blendHardLight: function () {
 
-        this.context.globalCompositeOperation = 'hard-light';
+        this.op = 'hard-light';
         return this;
 
     },
@@ -53767,7 +54297,7 @@ Phaser.BitmapData.prototype = {
     */
     blendSoftLight: function () {
 
-        this.context.globalCompositeOperation = 'soft-light';
+        this.op = 'soft-light';
         return this;
 
     },
@@ -53780,7 +54310,7 @@ Phaser.BitmapData.prototype = {
     */
     blendDifference: function () {
 
-        this.context.globalCompositeOperation = 'difference';
+        this.op = 'difference';
         return this;
 
     },
@@ -53793,7 +54323,7 @@ Phaser.BitmapData.prototype = {
     */
     blendExclusion: function () {
 
-        this.context.globalCompositeOperation = 'exclusion';
+        this.op = 'exclusion';
         return this;
 
     },
@@ -53806,7 +54336,7 @@ Phaser.BitmapData.prototype = {
     */
     blendHue: function () {
 
-        this.context.globalCompositeOperation = 'hue';
+        this.op = 'hue';
         return this;
 
     },
@@ -53819,7 +54349,7 @@ Phaser.BitmapData.prototype = {
     */
     blendSaturation: function () {
 
-        this.context.globalCompositeOperation = 'saturation';
+        this.op = 'saturation';
         return this;
 
     },
@@ -53832,7 +54362,7 @@ Phaser.BitmapData.prototype = {
     */
     blendColor: function () {
 
-        this.context.globalCompositeOperation = 'color';
+        this.op = 'color';
         return this;
 
     },
@@ -53845,7 +54375,7 @@ Phaser.BitmapData.prototype = {
     */
     blendLuminosity: function () {
 
-        this.context.globalCompositeOperation = 'luminosity';
+        this.op = 'luminosity';
         return this;
 
     }
@@ -53872,6 +54402,26 @@ Object.defineProperty(Phaser.BitmapData.prototype, "smoothed", {
 
 });
 
+/**
+* @memberof Phaser.BitmapData
+* @property {string} op - A short-hand code to get or set the global composite operation of the BitmapDatas canvas.
+*/
+Object.defineProperty(Phaser.BitmapData.prototype, "op", {
+
+    get: function () {
+
+        return this.context.globalCompositeOperation;
+
+    },
+
+    set: function (value) {
+
+        this.context.globalCompositeOperation = value;
+
+    }
+
+});
+
 /**
  * Gets a JavaScript object that has 6 properties set that are used by BitmapData in a transform.
  *
@@ -54554,7 +55104,7 @@ PIXI.Graphics.prototype.generateTexture = function(resolution, scaleMode)
 
     canvasBuffer.context.scale(resolution, resolution);
 
-    canvasBuffer.context.translate(-bounds.x,-bounds.y);
+    canvasBuffer.context.translate(-bounds.x, -bounds.y);
     
     PIXI.CanvasGraphics.renderGraphics(this, canvasBuffer.context);
 
@@ -54724,84 +55274,84 @@ PIXI.Graphics.prototype._renderCanvas = function(renderSession)
  */
 PIXI.Graphics.prototype.getBounds = function(matrix)
 {
-    if(!this._currentBounds)
+    if (!this._currentBounds)
     {
-
-        // return an empty object if the item is a mask!
+        //  Return an empty object if the item is a mask!
         if (!this.renderable)
         {
             return PIXI.EmptyRectangle;
         }
 
-    if (this.dirty)
-    {
-        this.updateLocalBounds();
-        this.webGLDirty = true;
-        this.cachedSpriteDirty = true;
-        this.dirty = false;
-    }
+        if (this.dirty)
+        {
+            this.updateLocalBounds();
+            this.webGLDirty = true;
+            this.cachedSpriteDirty = true;
+            this.dirty = false;
+        }
 
-    var bounds = this._localBounds;
+        var bounds = this._localBounds;
 
-    var w0 = bounds.x;
-    var w1 = bounds.width + bounds.x;
+        var w0 = bounds.x;
+        var w1 = bounds.width + bounds.x;
 
-    var h0 = bounds.y;
-    var h1 = bounds.height + bounds.y;
+        var h0 = bounds.y;
+        var h1 = bounds.height + bounds.y;
 
-    var worldTransform = matrix || this.worldTransform;
+        var worldTransform = matrix || this.worldTransform;
 
-    var a = worldTransform.a;
-    var b = worldTransform.b;
-    var c = worldTransform.c;
-    var d = worldTransform.d;
-    var tx = worldTransform.tx;
-    var ty = worldTransform.ty;
+        var a = worldTransform.a;
+        var b = worldTransform.b;
+        var c = worldTransform.c;
+        var d = worldTransform.d;
+        var tx = worldTransform.tx;
+        var ty = worldTransform.ty;
 
-    var x1 = a * w1 + c * h1 + tx;
-    var y1 = d * h1 + b * w1 + ty;
+        var x1 = a * w1 + c * h1 + tx;
+        var y1 = d * h1 + b * w1 + ty;
 
-    var x2 = a * w0 + c * h1 + tx;
-    var y2 = d * h1 + b * w0 + ty;
+        var x2 = a * w0 + c * h1 + tx;
+        var y2 = d * h1 + b * w0 + ty;
 
-    var x3 = a * w0 + c * h0 + tx;
-    var y3 = d * h0 + b * w0 + ty;
+        var x3 = a * w0 + c * h0 + tx;
+        var y3 = d * h0 + b * w0 + ty;
 
-    var x4 =  a * w1 + c * h0 + tx;
-    var y4 =  d * h0 + b * w1 + ty;
+        var x4 =  a * w1 + c * h0 + tx;
+        var y4 =  d * h0 + b * w1 + ty;
 
-    var maxX = x1;
-    var maxY = y1;
+        var maxX = x1;
+        var maxY = y1;
 
-    var minX = x1;
-    var minY = y1;
+        var minX = x1;
+        var minY = y1;
 
-    minX = x2 < minX ? x2 : minX;
-    minX = x3 < minX ? x3 : minX;
-    minX = x4 < minX ? x4 : minX;
+        minX = x2 < minX ? x2 : minX;
+        minX = x3 < minX ? x3 : minX;
+        minX = x4 < minX ? x4 : minX;
 
-    minY = y2 < minY ? y2 : minY;
-    minY = y3 < minY ? y3 : minY;
-    minY = y4 < minY ? y4 : minY;
+        minY = y2 < minY ? y2 : minY;
+        minY = y3 < minY ? y3 : minY;
+        minY = y4 < minY ? y4 : minY;
 
-    maxX = x2 > maxX ? x2 : maxX;
-    maxX = x3 > maxX ? x3 : maxX;
-    maxX = x4 > maxX ? x4 : maxX;
+        maxX = x2 > maxX ? x2 : maxX;
+        maxX = x3 > maxX ? x3 : maxX;
+        maxX = x4 > maxX ? x4 : maxX;
 
-    maxY = y2 > maxY ? y2 : maxY;
-    maxY = y3 > maxY ? y3 : maxY;
-    maxY = y4 > maxY ? y4 : maxY;
+        maxY = y2 > maxY ? y2 : maxY;
+        maxY = y3 > maxY ? y3 : maxY;
+        maxY = y4 > maxY ? y4 : maxY;
 
-    this._bounds.x = minX;
-    this._bounds.width = maxX - minX;
+        this._bounds.x = minX;
+        this._bounds.width = maxX - minX;
 
-    this._bounds.y = minY;
-    this._bounds.height = maxY - minY;
+        this._bounds.y = minY;
+        this._bounds.height = maxY - minY;
 
         this._currentBounds = this._bounds;
     }
 
     return this._currentBounds;
+
 };
 
 /**
@@ -54828,7 +55378,7 @@ PIXI.Graphics.prototype.containsPoint = function( point )
         // only deal with fills..
         if (data.shape)
         {
-            if ( data.shape.contains( tempPoint.x, tempPoint.y ) )
+            if (data.shape.contains(tempPoint.x, tempPoint.y))
             {
                 return true;
             }
@@ -54836,6 +55386,7 @@ PIXI.Graphics.prototype.containsPoint = function( point )
     }
 
     return false;
+
 };
 
 /**
@@ -55617,7 +56168,16 @@ Phaser.Text = function (game, x, y, text, style) {
 
     x = x || 0;
     y = y || 0;
-    text = text.toString() || '';
+
+    if (text === undefined || text === null)
+    {
+        text = '';
+    }
+    else
+    {
+        text = text.toString();
+    }
+
     style = style || {};
 
     /**
@@ -55650,7 +56210,7 @@ Phaser.Text = function (game, x, y, text, style) {
     /**
      * @property {HTMLCanvasElement} canvas - The canvas element that the text is rendered.
      */
-    this.canvas = document.createElement('canvas');
+    this.canvas = PIXI.CanvasPool.create(this);
 
     /**
      * @property {HTMLCanvasElement} context - The context of the canvas element that the text is rendered to.
@@ -55667,6 +56227,16 @@ Phaser.Text = function (game, x, y, text, style) {
     */
     this.strokeColors = [];
 
+    /**
+    * @property {array} fontStyles - An array of the font styles values as specified by {@link Phaser.Text#addFontStyle addFontStyle}.
+    */
+    this.fontStyles = [];
+
+    /**
+    * @property {array} fontWeights - An array of the font weights values as specified by {@link Phaser.Text#addFontWeight addFontWeight}.
+    */
+    this.fontWeights = [];
+
     /**
     * Should the linePositionX and Y values be automatically rounded before rendering the Text?
     * You may wish to enable this if you want to remove the effect of sub-pixel aliasing from text.
@@ -55768,15 +56338,17 @@ Phaser.Text.prototype.destroy = function (destroyChildren) {
 
     this.texture.destroy(true);
 
-    if (this.canvas && this.canvas.parentNode)
-    {
-        this.canvas.parentNode.removeChild(this.canvas);
-    }
-    else
-    {
-        this.canvas = null;
-        this.context = null;
-    }
+    PIXI.CanvasPool.remove(this);
+
+    // if (this.canvas && this.canvas.parentNode)
+    // {
+    //     this.canvas.parentNode.removeChild(this.canvas);
+    // }
+    // else
+    // {
+    //     this.canvas = null;
+    //     this.context = null;
+    // }
 
     Phaser.Component.Destroy.prototype.destroy.call(this, destroyChildren);
 
@@ -56049,7 +56621,7 @@ Phaser.Text.prototype.updateText = function () {
             linePositionY = Math.round(linePositionY);
         }
 
-        if (this.colors.length > 0 || this.strokeColors.length > 0)
+        if (this.colors.length > 0 || this.strokeColors.length > 0 || this.fontWeights.length > 0 || this.fontStyles.length > 0)
         {
             this.updateLine(lines[i], linePositionX, linePositionY);
         }
@@ -56180,7 +56752,7 @@ Phaser.Text.prototype.updateShadow = function (state) {
 };
 
 /**
-* Updates a line of text, applying fill and stroke per-character colors if applicable.
+* Updates a line of text, applying fill and stroke per-character colors or style and weight per-character font if applicable.
 *
 * @method Phaser.Text#updateLine
 * @private
@@ -56191,6 +56763,23 @@ Phaser.Text.prototype.updateLine = function (line, x, y) {
     {
         var letter = line[i];
 
+        if (this.fontWeights.length > 0 || this.fontStyles.length > 0)
+        {
+            var components = this.fontToComponents(this.context.font);
+
+            if (this.fontStyles[this._charCount])
+            {
+                components.fontStyle = this.fontStyles[this._charCount];
+            }
+        
+            if (this.fontWeights[this._charCount])
+            {
+                components.fontWeight = this.fontWeights[this._charCount];
+            }
+      
+            this.context.font = this.componentsToFont(components);
+        }
+
         if (this.style.stroke && this.style.strokeThickness)
         {
             if (this.strokeColors[this._charCount])
@@ -56236,6 +56825,22 @@ Phaser.Text.prototype.clearColors = function () {
 
 };
 
+/**
+* Clears any text styles or weights font that were set by `addFontStyle` or `addFontWeight`.
+*
+* @method Phaser.Text#clearFontValues
+* @return {Phaser.Text} This Text instance.
+*/
+Phaser.Text.prototype.clearFontValues = function () {
+
+    this.fontStyles = [];
+    this.fontWeights = [];
+    this.dirty = true;
+
+    return this;
+
+};
+
 /**
 * Set specific colors for certain characters within the Text.
 *
@@ -56286,6 +56891,54 @@ Phaser.Text.prototype.addStrokeColor = function (color, position) {
 
 };
 
+/**
+* Set specific font styles for certain characters within the Text.
+*
+* It works by taking a font style value, which is a typical string such as `normal`, `italic` or `oblique`.
+* The position value is the index of the character in the Text string to start applying this font style to.
+* Once set the font style remains in use until either another font style or the end of the string is encountered.
+* For example if the Text was `Photon Storm` and you did `Text.addFontStyle('italic', 6)` it would font style in the word `Storm` in italic.
+*
+* If you wish to change the text font weight see addFontWeight instead.
+*
+* @method Phaser.Text#addFontStyle
+* @param {string} style - A canvas font-style that will be used on the text style eg `normal`, `italic`, `oblique`.
+* @param {number} position - The index of the character in the string to start applying this font style value from.
+* @return {Phaser.Text} This Text instance.
+*/
+Phaser.Text.prototype.addFontStyle = function (style, position) {
+
+    this.fontStyles[position] = style;
+    this.dirty = true;
+
+    return this;
+
+};
+
+/**
+* Set specific font weights for certain characters within the Text.
+*
+* It works by taking a font weight value, which is a typical string such as `normal`, `bold`, `bolder`, etc.
+* The position value is the index of the character in the Text string to start applying this font weight to.
+* Once set the font weight remains in use until either another font weight or the end of the string is encountered.
+* For example if the Text was `Photon Storm` and you did `Text.addFontWeight('bold', 6)` it would font weight in the word `Storm` in bold.
+*
+* If you wish to change the text font style see addFontStyle instead.
+*
+* @method Phaser.Text#addFontWeight
+* @param {string} style - A canvas font-weight that will be used on the text weight eg `normal`, `bold`, `bolder`, `lighter`, etc.
+* @param {number} position - The index of the character in the string to start applying this font weight value from.
+* @return {Phaser.Text} This Text instance.
+*/
+Phaser.Text.prototype.addFontWeight = function (weight, position) {
+
+    this.fontWeights[position] = weight;
+    this.dirty = true;
+
+    return this;
+
+};
+
 /**
 * Greedy wrapping algorithm that will wrap words as the line grows longer than its horizontal bounds.
 *
@@ -56613,20 +57266,20 @@ Phaser.Text.prototype.updateTexture = function () {
         //  Align the canvas based on the bounds
         if (this.style.boundsAlignH === 'right')
         {
-            x = this.textBounds.width - this.canvas.width;
+            x += this.textBounds.width - this.canvas.width;
         }
         else if (this.style.boundsAlignH === 'center')
         {
-            x = this.textBounds.halfWidth - (this.canvas.width / 2);
+            x += this.textBounds.halfWidth - (this.canvas.width / 2);
         }
 
         if (this.style.boundsAlignV === 'bottom')
         {
-            y = this.textBounds.height - this.canvas.height;
+            y += this.textBounds.height - this.canvas.height;
         }
         else if (this.style.boundsAlignV === 'middle')
         {
-            y = this.textBounds.halfHeight - (this.canvas.height / 2);
+            y += this.textBounds.halfHeight - (this.canvas.height / 2);
         }
 
         this.pivot.x = -x;
@@ -56636,6 +57289,8 @@ Phaser.Text.prototype.updateTexture = function () {
     //  Can't render something with a zero sized dimension
     this.renderable = (w !== 0 && h !== 0);
 
+    this.texture.requiresReTint = true;
+
     this.texture.baseTexture.dirty();
 
 };
@@ -57457,7 +58112,7 @@ Object.defineProperty(Phaser.Text.prototype, 'height', {
 
 Phaser.Text.fontPropertiesCache = {};
 
-Phaser.Text.fontPropertiesCanvas = document.createElement('canvas');
+Phaser.Text.fontPropertiesCanvas = PIXI.CanvasPool.create(Phaser.Text.fontPropertiesCanvas);
 Phaser.Text.fontPropertiesContext = Phaser.Text.fontPropertiesCanvas.getContext('2d');
 
 /**
@@ -57837,8 +58492,6 @@ Phaser.BitmapText.prototype.updateText = function () {
             {
                 //  Sprite already exists in the glyphs pool, so we'll reuse it for this letter
                 g.texture = charData.texture;
-                // g.name = line.text[c];
-                // console.log('reusing', g.name, 'as', line.text[c]);
             }
             else
             {
@@ -57846,7 +58499,6 @@ Phaser.BitmapText.prototype.updateText = function () {
                 g = new PIXI.Sprite(charData.texture);
                 g.name = line.text[c];
                 this._glyphs.push(g);
-                // console.log('new', line.text[c]);
             }
 
             g.position.x = (line.chars[c] + align) - ax;
@@ -57854,6 +58506,7 @@ Phaser.BitmapText.prototype.updateText = function () {
 
             g.scale.set(scale);
             g.tint = this.tint;
+            g.texture.requiresReTint = true;
 
             if (!g.parent)
             {
@@ -57990,6 +58643,7 @@ Object.defineProperty(Phaser.BitmapText.prototype, 'font', {
         if (value !== this._font)
         {
             this._font = value.trim();
+            this._data = this.game.cache.getBitmapFont(this._font);
             this.updateText();
         }
 
@@ -58076,6 +58730,39 @@ Object.defineProperty(Phaser.BitmapText.prototype, 'maxWidth', {
 
 });
 
+/**
+* Enable or disable texture smoothing for this BitmapText.
+*
+* The smoothing is applied to the BaseTexture of this font, which all letters of the text reference.
+* 
+* Smoothing is enabled by default.
+* 
+* @name Phaser.BitmapText#smoothed
+* @property {boolean} smoothed
+*/
+Object.defineProperty(Phaser.BitmapText.prototype, 'smoothed', {
+
+    get: function() {
+
+        return !this._data.base.scaleMode;
+
+    },
+
+    set: function(value) {
+
+        if (value)
+        {
+            this._data.base.scaleMode = 0;
+        }
+        else
+        {
+            this._data.base.scaleMode = 1;
+        }
+
+    }
+
+});
+
 /**
 * @author       Richard Davey <rich@photonstorm.com>
 * @copyright    2015 Photon Storm Ltd.
@@ -60257,7 +60944,7 @@ Phaser.Device._initialize = function () {
             return false;
         }
 
-        var elem = document.createElement('canvas');
+        var elem = PIXI.CanvasPool.create(this, 1, 1);
         var ctx = elem.getContext('2d');
 
         if (!ctx)
@@ -60267,6 +60954,8 @@ Phaser.Device._initialize = function () {
 
         var image = ctx.createImageData(1, 1);
 
+        PIXI.CanvasPool.remove(this);
+
         return image.data instanceof Uint8ClampedArray;
 
     }
@@ -60880,7 +61569,8 @@ Phaser.Device.whenReady(function (device) {
 */
 
 /**
-* The Canvas class handles everything related to creating the `canvas` DOM tag that Phaser will use, including styles, offset and aspect ratio.
+* The Canvas class handles everything related to creating the `canvas` DOM tag that Phaser will use, 
+* including styles, offset and aspect ratio.
 *
 * @class Phaser.Canvas
 * @static
@@ -60891,17 +61581,26 @@ Phaser.Canvas = {
     * Creates a `canvas` DOM element. The element is not automatically added to the document.
     *
     * @method Phaser.Canvas.create
+    * @param {object} parent - The object that will own the canvas that is created.
     * @param {number} [width=256] - The width of the canvas element.
     * @param {number} [height=256] - The height of the canvas element..
     * @param {string} [id=(none)] - If specified, and not the empty string, this will be set as the ID of the canvas element. Otherwise no ID will be set.
+    * @param {boolean} [skipPool=false] - If `true` the canvas will not be placed in the CanvasPool global.
     * @return {HTMLCanvasElement} The newly created canvas element.
     */
-    create: function (width, height, id) {
+    create: function (parent, width, height, id, skipPool) {
 
         width = width || 256;
         height = height || 256;
 
-        var canvas = document.createElement('canvas');
+        if (skipPool === undefined)
+        {
+            var canvas = PIXI.CanvasPool.create(parent, width, height);
+        }
+        else
+        {
+            var canvas = document.createElement('canvas');
+        }
 
         if (typeof id === 'string' && id !== '')
         {
@@ -60910,7 +61609,6 @@ Phaser.Canvas = {
 
         canvas.width = width;
         canvas.height = height;
-
         canvas.style.display = 'block';
 
         return canvas;
@@ -63197,6 +63895,19 @@ Phaser.TweenManager = function (game) {
     */
     this.game = game;
 
+    /**
+    * Are all newly created Tweens frame or time based? A frame based tween will use the physics elapsed timer when updating. This means
+    * it will retain the same consistent frame rate, regardless of the speed of the device. The duration value given should
+    * be given in frames.
+    * 
+    * If the Tween uses a time based update (which is the default) then the duration is given in milliseconds.
+    * In this situation a 2000ms tween will last exactly 2 seconds, regardless of the device and how many visual updates the tween
+    * has actually been through. For very short tweens you may wish to experiment with a frame based update instead.
+    * @property {boolean} frameBased
+    * @default
+    */
+    this.frameBased = false;
+
     /**
     * @property {array<Phaser.Tween>} _tweens - All of the currently running tweens.
     * @private
@@ -63655,6 +64366,22 @@ Phaser.Tween = function (target, game, manager) {
     */
     this.isPaused = false;
 
+    /**
+    * Is this Tween frame or time based? A frame based tween will use the physics elapsed timer when updating. This means
+    * it will retain the same consistent frame rate, regardless of the speed of the device. The duration value given should
+    * be given in frames.
+    * 
+    * If the Tween uses a time based update (which is the default) then the duration is given in milliseconds.
+    * In this situation a 2000ms tween will last exactly 2 seconds, regardless of the device and how many visual updates the tween
+    * has actually been through. For very short tweens you may wish to experiment with a frame based update instead.
+    *
+    * The default value is whatever you've set in TweenManager.frameBased.
+    * 
+    * @property {boolean} frameBased
+    * @default
+    */
+    this.frameBased = manager.frameBased;
+
     /**
     * @property {function} _onUpdateCallback - An onUpdate callback.
     * @private
@@ -63699,7 +64426,7 @@ Phaser.Tween.prototype = {
     *
     * @method Phaser.Tween#to
     * @param {object} properties - An object containing the properties you want to tween, such as `Sprite.x` or `Sound.volume`. Given as a JavaScript object.
-    * @param {number} [duration=1000] - Duration of this tween in ms.
+    * @param {number} [duration=1000] - Duration of this tween in ms. Or if `Tween.frameBased` is true this represents the number of frames that should elapse.
     * @param {function|string} [ease=null] - Easing function. If not set it will default to Phaser.Easing.Default, which is Phaser.Easing.Linear.None by default but can be over-ridden.
     * @param {boolean} [autoStart=false] - Set to `true` to allow this tween to start automatically. Otherwise call Tween.start().
     * @param {number} [delay=0] - Delay before this tween will start in milliseconds. Defaults to 0, no delay.
@@ -63746,7 +64473,7 @@ Phaser.Tween.prototype = {
     *
     * @method Phaser.Tween#from
     * @param {object} properties - An object containing the properties you want to tween., such as `Sprite.x` or `Sound.volume`. Given as a JavaScript object.
-    * @param {number} [duration=1000] - Duration of this tween in ms.
+    * @param {number} [duration=1000] - Duration of this tween in ms. Or if `Tween.frameBased` is true this represents the number of frames that should elapse.
     * @param {function|string} [ease=null] - Easing function. If not set it will default to Phaser.Easing.Default, which is Phaser.Easing.Linear.None by default but can be over-ridden.
     * @param {boolean} [autoStart=false] - Set to `true` to allow this tween to start automatically. Otherwise call Tween.start().
     * @param {number} [delay=0] - Delay before this tween will start in milliseconds. Defaults to 0, no delay.
@@ -64781,14 +65508,16 @@ Phaser.TweenData.prototype = {
             }
         }
 
+        var ms = (this.parent.frameBased) ? this.game.time.physicsElapsedMS : this.game.time.elapsedMS;
+
         if (this.parent.reverse)
         {
-            this.dt -= this.game.time.elapsedMS * this.parent.timeScale;
+            this.dt -= ms * this.parent.timeScale;
             this.dt = Math.max(this.dt, 0);
         }
         else
         {
-            this.dt += this.game.time.elapsedMS * this.parent.timeScale;
+            this.dt += ms * this.parent.timeScale;
             this.dt = Math.min(this.dt, this.duration);
         }
 
@@ -69726,6 +70455,10 @@ Phaser.Cache.prototype = {
     */
     addSpriteSheet: function (key, url, data, frameWidth, frameHeight, frameMax, margin, spacing) {
 
+        if (frameMax === undefined) { frameMax = -1; }
+        if (margin === undefined) { margin = 0; }
+        if (spacing === undefined) { spacing = 0; }
+
         var obj = {
             key: key,
             url: url,
@@ -70538,7 +71271,7 @@ Phaser.Cache.prototype = {
     *
     * @method Phaser.Cache#getRenderTexture
     * @param {string} key - The key of the asset to retrieve from the cache.
-    * @return {Phaser.RenderTexture} The RenderTexture object.
+    * @return {Object} The object with Phaser.RenderTexture and Phaser.Frame.
     */
     getRenderTexture: function (key) {
 
@@ -71864,6 +72597,51 @@ Phaser.Loader.prototype = {
 
     },
 
+    /**
+    * Adds an array of images to the current load queue.
+    *
+    * It works by passing each element of the array to the Loader.image method.
+    * 
+    * The files are **not** loaded immediately after calling this method. The files are added to the queue ready to be loaded when the loader starts.
+    * 
+    * Phaser can load all common image types: png, jpg, gif and any other format the browser can natively handle.
+    * 
+    * The keys must be unique Strings. They are used to add the files to the Phaser.Cache upon successful load.
+    *
+    * Retrieve the images via `Cache.getImage(key)`
+    * 
+    * The URL can be relative or absolute. If the URL is relative the `Loader.baseURL` and `Loader.path` values will be prepended to it.
+    * 
+    * If the URL isn't specified the Loader will take the key and create a filename from that. For example if the key is "alien"
+    * and no URL is given then the Loader will set the URL to be "alien.png". It will always add `.png` as the extension.
+    * If you do not desire this action then provide a URL.
+    *
+    * @method Phaser.Loader#images
+    * @param {array} keys - An array of unique asset keys of the image files.
+    * @param {array} [urls] - Optional array of URLs. If undefined or `null` the url will be set to `<key>.png`, i.e. if `key` was "alien" then the URL will be "alien.png". If provided the URLs array length must match the keys array length.
+    * @return {Phaser.Loader} This Loader instance.
+     */
+    images: function (keys, urls) {
+
+        if (Array.isArray(urls))
+        {
+            for (var i = 0; i < keys.length; i++)
+            {
+                this.image(keys[i], urls[i]);
+            }
+        }
+        else
+        {
+            for (var i = 0; i < keys.length; i++)
+            {
+                this.image(keys[i]);
+            }
+        }
+
+        return this;
+
+    },
+
     /**
     * Adds a Text file to the current load queue.
     * 
@@ -72422,6 +73200,7 @@ Phaser.Loader.prototype = {
     * @return {Phaser.Loader} This Loader instance.
     */
     bitmapFont: function (key, textureURL, atlasURL, atlasData, xSpacing, ySpacing) {
+
         if (textureURL === undefined || textureURL === null)
         {
             textureURL = key + '.png';
@@ -73289,6 +74068,7 @@ Phaser.Loader.prototype = {
                 _this.fileComplete(file);
             }
         };
+
         file.data.onerror = function () {
             if (file.data.onload)
             {
@@ -76492,7 +77272,7 @@ Phaser.Utils.Debug.prototype = {
             this.sprite = this.game.make.image(0, 0, this.bmd);
             this.game.stage.addChild(this.sprite);
 
-            this.canvas = Phaser.Canvas.create(this.game.width, this.game.height, '', true);
+            this.canvas = PIXI.CanvasPool.create(this, this.game.width, this.game.height);
             this.context = this.canvas.getContext('2d');
         }
 
@@ -76738,7 +77518,7 @@ Phaser.Utils.Debug.prototype = {
         //  Render the text
         this.line('ID: ' + pointer.id + " Active: " + pointer.active);
         this.line('World X: ' + pointer.worldX + " World Y: " + pointer.worldY);
-        this.line('Screen X: ' + pointer.x + " Screen Y: " + pointer.y);
+        this.line('Screen X: ' + pointer.x + " Screen Y: " + pointer.y + " In: " + pointer.withinGame);
         this.line('Duration: ' + pointer.duration + " ms");
         this.line('is Down: ' + pointer.isDown + " is Up: " + pointer.isUp);
         this.stop();
@@ -77196,6 +77976,17 @@ Phaser.Utils.Debug.prototype = {
         Phaser.Physics.Box2D.renderBody(this.context, body, color);
         this.stop();
 
+    },
+
+    /**
+    * Destroy this object.
+    *
+    * @method Phaser.Utils.Debug#destroy
+    */
+    destroy: function () {
+    
+        PIXI.CanvasPool.remove(this);
+
     }
 
 };
@@ -77502,7 +78293,7 @@ Phaser.ArrayUtils = {
     * Fetch a random entry from the given array.
     *
     * Will return null if there are no array items that fall within the specified range
-    * or if there is no item for the randomly choosen index.
+    * or if there is no item for the randomly chosen index.
     *
     * @method
     * @param {any[]} objects - An array of objects.
@@ -77512,14 +78303,12 @@ Phaser.ArrayUtils = {
     */
     getRandomItem: function (objects, startIndex, length) {
 
-        if (objects == null) { // undefined or null
-            return null;
-        }
-
+        if (objects === null) { return null; }
         if (startIndex === undefined) { startIndex = 0; }
         if (length === undefined) { length = objects.length; }
 
         var randomIndex = startIndex + Math.floor(Math.random() * length);
+
         return objects[randomIndex] === undefined ? null : objects[randomIndex];
 
     },
@@ -77528,7 +78317,7 @@ Phaser.ArrayUtils = {
     * Removes a random object from the given array and returns it.
     *
     * Will return null if there are no array items that fall within the specified range
-    * or if there is no item for the randomly choosen index.
+    * or if there is no item for the randomly chosen index.
     *
     * @method
     * @param {any[]} objects - An array of objects.
@@ -77614,7 +78403,7 @@ Phaser.ArrayUtils = {
     *
     * @method
     * @param {Array<any[]>} matrix - The array to rotate; this matrix _may_ be altered.
-    * @param {number|string} direction - The amount to rotate: the roation in degrees (90, -90, 270, -270, 180) or a string command ('rotateLeft', 'rotateRight' or 'rotate180').
+    * @param {number|string} direction - The amount to rotate: the rotation in degrees (90, -90, 270, -270, 180) or a string command ('rotateLeft', 'rotateRight' or 'rotate180').
     * @return {Array<any[]>} The rotated matrix. The source matrix should be discarded for the returned matrix.
     */
     rotateMatrix: function (matrix, direction) {
@@ -77723,14 +78512,14 @@ Phaser.ArrayUtils = {
     * Create an array of numbers (positive and/or negative) progressing from `start`
     * up to but not including `end` by advancing by `step`.
     *
-    * If `start` is less than `stop` a zero-length range is created unless a negative `step` is specified.
+    * If `start` is less than `end` a zero-length range is created unless a negative `step` is specified.
     *
     * Certain values for `start` and `end` (eg. NaN/undefined/null) are currently coerced to 0;
     * for forward compatibility make sure to pass in actual numbers.
     *
     * @method Phaser.ArrayUtils#numberArrayStep
     * @param {number} start - The start of the range.
-    * @param {number} end - The end of the range.
+    * @param {number} [end] - The end of the range.
     * @param {number} [step=1] - The value to increment or decrement by.
     * @returns {Array} Returns the new array of numbers.
     * @example
@@ -77752,39 +78541,24 @@ Phaser.ArrayUtils = {
     * Phaser.ArrayUtils.numberArrayStep(0);
     * // => []
     */
-    numberArrayStep: function(start, end, step) {
-
-        start = +start || 0;
+    numberArrayStep: function (start, end, step) {
 
-        // enables use as a callback for functions like `_.map`
-        var type = typeof end;
+        if (start === undefined || start === null) { start = 0; }
 
-        if ((type === 'number' || type === 'string') && step && step[end] === start)
-        {
-            end = step = null;
-        }
-
-        step = step == null ? 1 : (+step || 0);
-
-        if (end === null)
+        if (end === undefined || end === null)
         {
             end = start;
             start = 0;
         }
-        else
-        {
-            end = +end || 0;
-        }
 
-        // use `Array(length)` so engines like Chakra and V8 avoid slower modes
-        // http://youtu.be/XAqIpGU8ZZk#t=17m25s
-        var index = -1;
-        var length = Math.max(Phaser.Math.roundAwayFromZero((end - start) / (step || 1)), 0);
-        var result = new Array(length);
+        if (step === undefined) { step = 1; }
+
+        var result = [];
+        var total = Math.max(Phaser.Math.roundAwayFromZero((end - start) / (step || 1)), 0);
 
-        while (++index < length)
+        for (var i = 0; i < total; i++)
         {
-            result[index] = start;
+            result.push(start);
             start += step;
         }
 
@@ -80079,8 +80853,8 @@ Phaser.Physics.Arcade.prototype = {
     * @method Phaser.Physics.Arcade#overlap
     * @param {Phaser.Sprite|Phaser.Group|Phaser.Particles.Emitter|array} object1 - The first object or array of objects to check. Can be Phaser.Sprite, Phaser.Group or Phaser.Particles.Emitter.
     * @param {Phaser.Sprite|Phaser.Group|Phaser.Particles.Emitter|array} object2 - The second object or array of objects to check. Can be Phaser.Sprite, Phaser.Group or Phaser.Particles.Emitter.
-    * @param {function} [overlapCallback=null] - An optional callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you specified them.  The two objects will be passed to this function in the same order in which you specified them, unless you are checking Group vs. Sprite, in which case Sprite will always be the first parameter.
-    * @param {function} [processCallback=null] - A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then overlapCallback will only be called if processCallback returns true.
+    * @param {function} [overlapCallback=null] - An optional callback function that is called if the objects overlap. The two objects will be passed to this function in the same order in which you specified them, unless you are checking Group vs. Sprite, in which case Sprite will always be the first parameter.
+    * @param {function} [processCallback=null] - A callback function that lets you perform additional checks against the two objects if they overlap. If this is set then `overlapCallback` will only be called if this callback returns `true`.
     * @param {object} [callbackContext] - The context in which to run the callbacks.
     * @return {boolean} True if an overlap occurred otherwise false.
     */
@@ -85730,6 +86504,7 @@ Phaser.Physics.P2.Body.prototype = {
 
     /**
     * Apply impulse to a point local to the body.
+    * 
     * This could for example be a point on the Body surface. An impulse is a force added to a body during a short 
     * period of time (impulse = force * time). Impulses will be added to Body.velocity and Body.angularVelocity.
     *
@@ -85738,14 +86513,17 @@ Phaser.Physics.P2.Body.prototype = {
     * @param {number} localX - A local point on the body.
     * @param {number} localY - A local point on the body.
     */
-    applyImpulseLocal: function (force, localX, localY) {
+    applyImpulseLocal: function (impulse, localX, localY) {
 
-        this.data.applyImpulseLocal(force, [this.world.pxmi(localX), this.world.pxmi(localY)]);
+        this.data.applyImpulseLocal(impulse, [this.world.pxmi(localX), this.world.pxmi(localY)]);
 
     },
 
     /**
-    * Apply force to a world point. This could for example be a point on the RigidBody surface. Applying force this way will add to Body.force and Body.angularForce.
+    * Apply force to a world point.
+    * 
+    * This could for example be a point on the RigidBody surface. Applying force 
+    * this way will add to Body.force and Body.angularForce.
     *
     * @method Phaser.Physics.P2.Body#applyForce
     * @param {Float32Array|Array} force - The force vector to add.
@@ -86681,11 +87459,7 @@ Object.defineProperty(Phaser.Physics.P2.Body.prototype, "static", {
         else if (!value && this.data.type === Phaser.Physics.P2.Body.STATIC)
         {
             this.data.type = Phaser.Physics.P2.Body.DYNAMIC;
-
-            if (this.mass === 0)
-            {
-                this.mass = 1;
-            }
+            this.mass = 1;
         }
 
     }
@@ -86709,11 +87483,7 @@ Object.defineProperty(Phaser.Physics.P2.Body.prototype, "dynamic", {
         if (value && this.data.type !== Phaser.Physics.P2.Body.DYNAMIC)
         {
             this.data.type = Phaser.Physics.P2.Body.DYNAMIC;
-
-            if (this.mass === 0)
-            {
-                this.mass = 1;
-            }
+            this.mass = 1;
         }
         else if (!value && this.data.type === Phaser.Physics.P2.Body.DYNAMIC)
         {
@@ -87166,7 +87936,7 @@ Phaser.Physics.P2.BodyDebug = function(game, body, settings) {
     * @private
     */
     var defaultSettings = {
-        pixelsPerLengthUnit: 20,
+        pixelsPerLengthUnit: game.physics.p2.mpx(1),
         debugPolygons: false,
         lineWidth: 1,
         alpha: 0.5
@@ -89033,50 +89803,46 @@ Phaser.Tilemap.prototype = {
             return;
         }
 
-        var sprite;
-        var found = false;
-
-        for (var i = 0, len = this.objects[name].length; i < len; i++)
+        for (var i = 0; i < this.objects[name].length; i++)
         {
-            if (typeof this.objects[name][i].gid !== 'undefined' && typeof gid === 'number')
+            var found = false;
+            var obj = this.objects[name][i];
+
+            if (obj.gid !== undefined && typeof gid === 'number' && obj.gid === gid)
             {
-                if (this.objects[name][i].gid === gid)
-                {
-                    found = true;
-                }
+                found = true;
             }
-
-            if (typeof this.objects[name][i].id !== 'undefined' && typeof gid === 'number')
+            else if (obj.id !== undefined && typeof gid === 'number' && obj.id === gid)
             {
-                if (this.objects[name][i].id === gid)
-                {
-                    found = true;
-                }
+                found = true;
             }
-
-            if (typeof this.objects[name][i].name !== 'undefined' && typeof gid === 'string')
+            else if (obj.name !== undefined && typeof gid === 'string' && obj.name === gid)
             {
-                if (this.objects[name][i].name === gid)
-                {
-                    found = true;
-                }
+                found = true;
             }
 
             if (found)
             {
-                sprite = new CustomClass(this.game, this.objects[name][i].x, this.objects[name][i].y, key, frame);
+                var sprite = new CustomClass(this.game, parseFloat(obj.x, 10), parseFloat(obj.y, 10), key, frame);
 
-                sprite.name = this.objects[name][i].name;
-                sprite.visible = this.objects[name][i].visible;
+                sprite.name = obj.name;
+                sprite.visible = obj.visible;
                 sprite.autoCull = autoCull;
                 sprite.exists = exists;
 
-                sprite.width = this.objects[name][i].width;
-                sprite.height = this.objects[name][i].height;
+                if (obj.width)
+                {
+                    sprite.width = obj.width;
+                }
+
+                if (obj.height)
+                {
+                    sprite.height = obj.height;
+                }
 
-                if (this.objects[name][i].rotation)
+                if (obj.rotation)
                 {
-                    sprite.angle = this.objects[name][i].rotation;
+                    sprite.angle = obj.rotation;
                 }
 
                 if (adjustY)
@@ -89086,9 +89852,9 @@ Phaser.Tilemap.prototype = {
 
                 group.add(sprite);
 
-                for (var property in this.objects[name][i].properties)
+                for (var property in obj.properties)
                 {
-                    group.set(sprite, property, this.objects[name][i].properties[property], false, false, 0, true);
+                    group.set(sprite, property, obj.properties[property], false, false, 0, true);
                 }
             }
         }
@@ -90435,7 +91201,7 @@ Phaser.Tilemap.prototype = {
             }
         }
 
-        Phaser.Utils.shuffle(indexes);
+        Phaser.ArrayUtils.shuffle(indexes);
 
         for (var i = 1; i < this._results.length; i++)
         {
@@ -90629,7 +91395,7 @@ Phaser.TilemapLayer = function (game, tilemap, index, width, height) {
     * @property {HTMLCanvasElement} canvas
     * @protected
     */
-    this.canvas = Phaser.Canvas.create(width, height);
+    this.canvas = PIXI.CanvasPool.create(this, width, height);
 
     /**
     * The 2d context of the canvas.
@@ -90828,6 +91594,7 @@ Phaser.TilemapLayer.sharedCopyCanvas = null;
 *
 * Code that uses the canvas is responsible to ensure the dimensions and save/restore state as appropriate.
 *
+* @method Phaser.TilemapLayer#ensureSharedCopyCanvas
 * @protected
 * @static
 */
@@ -90845,8 +91612,7 @@ Phaser.TilemapLayer.ensureSharedCopyCanvas = function () {
 /**
 * Automatically called by World.preUpdate.
 *
-* @method Phaser.Image#preUpdate
-* @memberof Phaser.Image
+* @method Phaser.TilemapLayer#preUpdate
 */
 Phaser.TilemapLayer.prototype.preUpdate = function() {
 
@@ -90874,6 +91640,19 @@ Phaser.TilemapLayer.prototype.postUpdate = function () {
 
 };
 
+/**
+* Destroys this TilemapLayer.
+*
+* @method Phaser.TilemapLayer#destroy
+*/
+Phaser.TilemapLayer.prototype.destroy = function() {
+
+    PIXI.CanvasPool.remove(this);
+
+    Phaser.Component.Destroy.prototype.destroy.call(this);
+
+};
+
 /**
 * Resizes the internal canvas and texture frame used by this TilemapLayer.
 *
@@ -91856,9 +92635,22 @@ Object.defineProperty(Phaser.TilemapLayer.prototype, "collisionHeight", {
 * Phaser.TilemapParser parses data objects from Phaser.Loader that need more preparation before they can be inserted into a Tilemap.
 *
 * @class Phaser.TilemapParser
+* @static
 */
 Phaser.TilemapParser = {
 
+    /**
+     * When scanning the Tiled map data the TilemapParser can either insert a null value (true) or 
+     * a Phaser.Tile instance with an index of -1 (false, the default). Depending on your game type
+     * depends how this should be configured. If you've a large sparsely populated map and the tile
+     * data doesn't need to change then setting this value to `true` will help with memory consumption.
+     * However if your map is small, or you need to update the tiles (perhaps the map dynamically changes
+     * during the game) then leave the default value set.
+     *
+     * @type {boolean}
+     */
+    INSERT_NULL: false,
+
     /**
     * Parse tilemap data from the cache and creates a Tilemap object.
     *
@@ -92065,17 +92857,19 @@ Phaser.TilemapParser = {
                 continue;
             }
 
+            var curl = json.layers[i];
+
             var layer = {
 
-                name: json.layers[i].name,
-                x: json.layers[i].x,
-                y: json.layers[i].y,
-                width: json.layers[i].width,
-                height: json.layers[i].height,
-                widthInPixels: json.layers[i].width * json.tilewidth,
-                heightInPixels: json.layers[i].height * json.tileheight,
-                alpha: json.layers[i].opacity,
-                visible: json.layers[i].visible,
+                name: curl.name,
+                x: curl.x,
+                y: curl.y,
+                width: curl.width,
+                height: curl.height,
+                widthInPixels: curl.width * json.tilewidth,
+                heightInPixels: curl.height * json.tileheight,
+                alpha: curl.opacity,
+                visible: curl.visible,
                 properties: {},
                 indexes: [],
                 callbacks: [],
@@ -92083,9 +92877,9 @@ Phaser.TilemapParser = {
 
             };
 
-            if (json.layers[i].properties)
+            if (curl.properties)
             {
-                layer.properties = json.layers[i].properties;
+                layer.properties = curl.properties;
             }
 
             var x = 0;
@@ -92099,11 +92893,11 @@ Phaser.TilemapParser = {
             //  If the map contains multiple tilesets then the indexes are relative to that which the set starts from.
             //  Need to set which tileset in the cache = which tileset in the JSON, if you do this manually it means you can use the same map data but a new tileset.
 
-            for (var t = 0, len = json.layers[i].data.length; t < len; t++)
+            for (var t = 0, len = curl.data.length; t < len; t++)
             {
                 rotation = 0;
                 flipped = false;
-                gid = json.layers[i].data[t];
+                gid = curl.data[t];
 
                 //  If true the current tile is flipped or rotated (Tiled TMX format) 
                 if (gid > 0x20000000)
@@ -92170,12 +92964,19 @@ Phaser.TilemapParser = {
                 }
                 else
                 {
-                    row.push(new Phaser.Tile(layer, -1, x, output.length, json.tilewidth, json.tileheight));
+                    if (Phaser.TilemapParser.INSERT_NULL)
+                    {
+                        row.push(null);
+                    }
+                    else
+                    {
+                        row.push(new Phaser.Tile(layer, -1, x, output.length, json.tilewidth, json.tileheight));
+                    }
                 }
 
                 x++;
 
-                if (x === json.layers[i].width)
+                if (x === curl.width)
                 {
                     output.push(row);
                     x = 0;
@@ -92201,21 +93002,23 @@ Phaser.TilemapParser = {
                 continue;
             }
 
+            var curi = json.layers[i];
+
             var image = {
 
-                name: json.layers[i].name,
-                image: json.layers[i].image,
-                x: json.layers[i].x,
-                y: json.layers[i].y,
-                alpha: json.layers[i].opacity,
-                visible: json.layers[i].visible,
+                name: curi.name,
+                image: curi.image,
+                x: curi.x,
+                y: curi.y,
+                alpha: curi.opacity,
+                visible: curi.visible,
                 properties: {}
 
             };
 
-            if (json.layers[i].properties)
+            if (curi.properties)
             {
-                image.properties = json.layers[i].properties;
+                image.properties = curi.properties;
             }
 
             images.push(image);
@@ -92294,95 +93097,97 @@ Phaser.TilemapParser = {
                 continue;
             }
 
-            objects[json.layers[i].name] = [];
-            collision[json.layers[i].name] = [];
+            var curo = json.layers[i];
 
-            for (var v = 0, len = json.layers[i].objects.length; v < len; v++)
+            objects[curo.name] = [];
+            collision[curo.name] = [];
+
+            for (var v = 0, len = curo.objects.length; v < len; v++)
             {
                 //  Object Tiles
-                if (json.layers[i].objects[v].gid)
+                if (curo.objects[v].gid)
                 {
                     var object = {
 
-                        gid: json.layers[i].objects[v].gid,
-                        name: json.layers[i].objects[v].name,
-                        type: json.layers[i].objects[v].hasOwnProperty("type") ? json.layers[i].objects[v].type : "",
-                        x: json.layers[i].objects[v].x,
-                        y: json.layers[i].objects[v].y,
-                        visible: json.layers[i].objects[v].visible,
-                        properties: json.layers[i].objects[v].properties
+                        gid: curo.objects[v].gid,
+                        name: curo.objects[v].name,
+                        type: curo.objects[v].hasOwnProperty("type") ? curo.objects[v].type : "",
+                        x: curo.objects[v].x,
+                        y: curo.objects[v].y,
+                        visible: curo.objects[v].visible,
+                        properties: curo.objects[v].properties
 
                     };
 
-                    if (json.layers[i].objects[v].rotation)
+                    if (curo.objects[v].rotation)
                     {
-                        object.rotation = json.layers[i].objects[v].rotation;
+                        object.rotation = curo.objects[v].rotation;
                     }
 
-                    objects[json.layers[i].name].push(object);
+                    objects[curo.name].push(object);
                 }
-                else if (json.layers[i].objects[v].polyline)
+                else if (curo.objects[v].polyline)
                 {
                     var object = {
 
-                        name: json.layers[i].objects[v].name,
-                        type: json.layers[i].objects[v].type,
-                        x: json.layers[i].objects[v].x,
-                        y: json.layers[i].objects[v].y,
-                        width: json.layers[i].objects[v].width,
-                        height: json.layers[i].objects[v].height,
-                        visible: json.layers[i].objects[v].visible,
-                        properties: json.layers[i].objects[v].properties
+                        name: curo.objects[v].name,
+                        type: curo.objects[v].type,
+                        x: curo.objects[v].x,
+                        y: curo.objects[v].y,
+                        width: curo.objects[v].width,
+                        height: curo.objects[v].height,
+                        visible: curo.objects[v].visible,
+                        properties: curo.objects[v].properties
 
                     };
 
-                    if (json.layers[i].objects[v].rotation)
+                    if (curo.objects[v].rotation)
                     {
-                        object.rotation = json.layers[i].objects[v].rotation;
+                        object.rotation = curo.objects[v].rotation;
                     }
 
                     object.polyline = [];
 
                     //  Parse the polyline into an array
-                    for (var p = 0; p < json.layers[i].objects[v].polyline.length; p++)
+                    for (var p = 0; p < curo.objects[v].polyline.length; p++)
                     {
-                        object.polyline.push([ json.layers[i].objects[v].polyline[p].x, json.layers[i].objects[v].polyline[p].y ]);
+                        object.polyline.push([ curo.objects[v].polyline[p].x, curo.objects[v].polyline[p].y ]);
                     }
 
-                    collision[json.layers[i].name].push(object);
-                    objects[json.layers[i].name].push(object);
+                    collision[curo.name].push(object);
+                    objects[curo.name].push(object);
                 }
                 // polygon
-                else if (json.layers[i].objects[v].polygon)
+                else if (curo.objects[v].polygon)
                 {
-                    var object = slice(json.layers[i].objects[v],
+                    var object = slice(curo.objects[v],
                                        ["name", "type", "x", "y", "visible", "rotation", "properties" ]);
 
                     //  Parse the polygon into an array
                     object.polygon = [];
 
-                    for (var p = 0; p < json.layers[i].objects[v].polygon.length; p++)
+                    for (var p = 0; p < curo.objects[v].polygon.length; p++)
                     {
-                        object.polygon.push([ json.layers[i].objects[v].polygon[p].x, json.layers[i].objects[v].polygon[p].y ]);
+                        object.polygon.push([ curo.objects[v].polygon[p].x, curo.objects[v].polygon[p].y ]);
                     }
 
-                    objects[json.layers[i].name].push(object);
+                    objects[curo.name].push(object);
 
                 }
                 // ellipse
-                else if (json.layers[i].objects[v].ellipse)
+                else if (curo.objects[v].ellipse)
                 {
-                    var object = slice(json.layers[i].objects[v],
+                    var object = slice(curo.objects[v],
                                        ["name", "type", "ellipse", "x", "y", "width", "height", "visible", "rotation", "properties" ]);
-                    objects[json.layers[i].name].push(object);
+                    objects[curo.name].push(object);
                 }
                 // otherwise it's a rectangle
                 else
                 {
-                    var object = slice(json.layers[i].objects[v],
+                    var object = slice(curo.objects[v],
                                        ["name", "type", "x", "y", "width", "height", "visible", "rotation", "properties" ]);
                     object.rectangle = true;
-                    objects[json.layers[i].name].push(object);
+                    objects[curo.name].push(object);
                 }
             }
         }
@@ -92459,7 +93264,7 @@ Phaser.TilemapParser = {
                 {
                     tile = row[k];
 
-                    if (tile.index < 0)
+                    if (tile === null || tile.index < 0)
                     {
                         continue;
                     }
@@ -94121,7 +94926,14 @@ Phaser.Video.prototype = {
 
         if (this.videoStream !== null)
         {
-            this.videoStream.stop();
+            if (this.videoStream['active'])
+            {
+                this.videoStream.active = false;
+            }
+            else
+            {
+                this.videoStream.stop();
+            }
         }
 
         this.removeVideoElement();
@@ -94500,7 +95312,15 @@ Phaser.Video.prototype = {
             else
             {
                 this.video.src = "";
-                this.videoStream.stop();
+
+                if (this.videoStream['active'])
+                {
+                    this.videoStream.active = false;
+                }
+                else
+                {
+                    this.videoStream.stop();
+                }
             }
 
             this.videoStream = null;
@@ -94508,7 +95328,8 @@ Phaser.Video.prototype = {
         }
         else
         {
-            this.video.removeEventListener('ended', this.complete.bind(this));
+            this.video.removeEventListener('ended', this.complete.bind(this), true);
+            this.video.removeEventListener('playing', this.playHandler.bind(this), true);
 
             if (this.touchLocked)
             {