TileSprites now emit outOfBounds and enterBounds events accordingly.

TileSprites working with physics bodies again.

Author: photonstorm

README.md

@@ -121,6 +121,7 @@ Updated
 * Emitters now bring the particle they are about to emit to the top of the Group before doing so. Avoids particles hidden behind others.
 * ArcadePhysics.Body.setSize corrected to take the parameters as positive, not negative values.
 * ArcadePhysics.World.seperate will now check gravity totals to determine separation order. You can set World.forceX to true to always separate on X first and skip this check.
+* TileSprites now emit outOfBounds and enterBounds events accordingly.
 
 
 New Features

src/gameobjects/BitmapData.js

@@ -101,7 +101,10 @@ Phaser.BitmapData = function (game, key, width, height) {
     */
     this.type = Phaser.BITMAPDATA;
 
-    this._dirty = false;
+    /**
+    * @property {boolean} dirty - If dirty this BitmapData will be re-rendered.
+    */
+    this.dirty = false;
 
 }
 
@@ -140,7 +143,7 @@ Phaser.BitmapData.prototype = {
 
         this.context.clearRect(0, 0, this.width, this.height);
 
-        this._dirty = true;
+        this.dirty = true;
 
     },
 
@@ -161,7 +164,7 @@ Phaser.BitmapData.prototype = {
             this.imageData = this.context.getImageData(0, 0, width, height);
         }
 
-        this._dirty = true;
+        this.dirty = true;
 
     },
 
@@ -209,7 +212,7 @@ Phaser.BitmapData.prototype = {
 
             this.context.putImageData(this.imageData, 0, 0);
 
-            this._dirty = true;
+            this.dirty = true;
         }
 
     },
@@ -361,16 +364,14 @@ Phaser.BitmapData.prototype = {
     */
     render: function () {
 
-        if (this._dirty)
+console.log('bmd dity');
+        if (this.game.renderType === Phaser.WEBGL && this.dirty)
         {
             //  Only needed if running in WebGL, otherwise this array will never get cleared down
-            if (this.game.renderType === Phaser.WEBGL)
-            {
-                //  should use the rendersession
-                PIXI.updateWebGLTexture(this.baseTexture, this.game.renderer.gl);
-            }
+            //  should use the rendersession
+            PIXI.updateWebGLTexture(this.baseTexture, this.game.renderer.gl);
 
-            this._dirty = false;
+            this.dirty = false;
         }
 
     }

src/gameobjects/Image.js

@@ -184,7 +184,7 @@ Phaser.Image.prototype.update = function() {
 */
 Phaser.Image.prototype.postUpdate = function() {
 
-    if (this.key instanceof Phaser.BitmapData && this.key._dirty)
+    if (this.key instanceof Phaser.BitmapData)
     {
         this.key.render();
     }

src/gameobjects/Sprite.js

@@ -308,7 +308,7 @@ Phaser.Sprite.prototype.update = function() {
 */
 Phaser.Sprite.prototype.postUpdate = function() {
 
-    if (this.key instanceof Phaser.BitmapData && this.key._dirty)
+    if (this.key instanceof Phaser.BitmapData)
     {
         this.key.render();
     }

src/gameobjects/TileSprite.js

@@ -98,6 +98,25 @@ Phaser.TileSprite = function (game, x, y, width, height, key, frame) {
     */
     this.world = new Phaser.Point(x, y);
 
+    /**
+    * Should this Sprite be automatically culled if out of range of the camera?
+    * A culled sprite has its renderable property set to 'false'.
+    * Be advised this is quite an expensive operation, as it has to calculate the bounds of the object every frame, so only enable it if you really need it.
+    *
+    * @property {boolean} autoCull - A flag indicating if the Sprite should be automatically camera culled or not.
+    * @default
+    */
+    this.autoCull = false;
+
+    /**
+    * If true the Sprite checks if it is still within the world each frame, when it leaves the world it dispatches Sprite.events.onOutOfBounds
+    * and optionally kills the sprite (if Sprite.outOfBoundsKill is true). By default this is disabled because the Sprite has to calculate its
+    * bounds every frame to support it, and not all games need it. Enable it by setting the value to true.
+    * @property {boolean} checkWorldBounds
+    * @default
+    */
+    this.checkWorldBounds = false;
+
     /**
     * @property {Phaser.Point} cameraOffset - If this object is fixedToCamera then this stores the x/y offset that its drawn at, from the top-left of the camera view.
     */
@@ -163,26 +182,65 @@ Phaser.TileSprite.prototype.preUpdate = function() {
         return false;
     }
 
-    this.world.setTo(this.game.camera.x + this.worldTransform[2], this.game.camera.y + this.worldTransform[5]);
+    this._cache[0] = this.world.x;
+    this._cache[1] = this.world.y;
+    this._cache[2] = this.rotation;
 
-    this.animations.update();
+    if (!this.exists || !this.parent.exists)
+    {
+        //  Reset the renderOrderID
+        this._cache[3] = -1;
+        return false;
+    }
 
-    if (this._scroll.x !== 0)
+    //  Cache the bounds if we need it
+    if (this.autoCull || this.checkWorldBounds)
     {
-        this.tilePosition.x += this._scroll.x * this.game.time.physicsElapsed;
+        this._bounds.copyFrom(this.getBounds());
     }
 
-    if (this._scroll.y !== 0)
+    if (this.autoCull)
     {
-        this.tilePosition.y += this._scroll.y * this.game.time.physicsElapsed;
+        //  Won't get rendered but will still get its transform updated
+        this.renderable = this.game.world.camera.screenView.intersects(this._bounds);
     }
 
+    if (this.checkWorldBounds)
+    {
+        //  The Sprite is already out of the world bounds, so let's check to see if it has come back again
+        if (this._cache[5] === 1 && this.game.world.bounds.intersects(this._bounds))
+        {
+            this._cache[5] = 0;
+            this.events.onEnterBounds.dispatch(this);
+        }
+        else if (this._cache[5] === 0 && !this.game.world.bounds.intersects(this._bounds))
+        {
+            //  The Sprite WAS in the screen, but has now left.
+            this._cache[5] = 1;
+            this.events.onOutOfBounds.dispatch(this);
+        }
+    }
+
+    this.world.setTo(this.game.camera.x + this.worldTransform.tx, this.game.camera.y + this.worldTransform.ty);
+
     if (this.visible)
     {
         this._cache[3] = this.game.stage.currentRenderOrderID++;
     }
 
-    if (this.exists && this.body)
+    this.animations.update();
+
+    if (this._scroll.x !== 0)
+    {
+        this.tilePosition.x += this._scroll.x * this.game.time.physicsElapsed;
+    }
+
+    if (this._scroll.y !== 0)
+    {
+        this.tilePosition.y += this._scroll.y * this.game.time.physicsElapsed;
+    }
+
+    if (this.body)
     {
         this.body.preUpdate();
     }

src/tilemap/Tilemap.js

@@ -190,44 +190,6 @@ Phaser.Tilemap.prototype = {
 
         return this.createBlankLayer(name, width, height, tileWidth, tileHeight, group);
 
-        /*
-        var row;
-        var output = [];
-
-        for (var y = 0; y < height; y++)
-        {
-            row = [];
-
-            for (var x = 0; x < width; x++)
-            {
-                row.push(null);
-            }
-
-            output.push(row);
-        }
-
-        this.layers.push({
-
-            name: name,
-            x: 0,
-            y: 0,
-            width: width,
-            height: height,
-            widthInPixels: this.widthInPixels,
-            heightInPixels: this.heightInPixels,
-            alpha: 1,
-            visible: true,
-            properties: {},
-            indexes: [],
-            callbacks: [],
-            bodies: [],
-            data: output
-
-        });
-
-        this.currentLayer = this.layers.length - 1;
-        */
-
     },
 
     /**
@@ -258,6 +220,7 @@ Phaser.Tilemap.prototype = {
     * @param {number} [tileMargin=0] - The width of the tiles in the Tileset Image. If not given it will default to the map.tileWidth value.
     * @param {number} [tileSpacing=0] - The height of the tiles in the Tileset Image. If not given it will default to the map.tileHeight value.
     * @param {number} [gid=0] - If adding multiple tilesets to a blank/dynamic map, specify the starting GID the set will use here.
+    * @return {Phaser.Tileset} Returns the Tileset object that was created or updated, or null if it failed.
     */
     addTilesetImage: function (tileset, key, tileWidth, tileHeight, tileMargin, tileSpacing, gid) {
 
@@ -275,7 +238,7 @@ Phaser.Tilemap.prototype = {
             }
             else
             {
-                return false;
+                return null;
             }
         }
 
@@ -287,7 +250,7 @@ Phaser.Tilemap.prototype = {
         if (this.tilesets[tileset])
         {
             this.tilesets[tileset].setImage(this.game.cache.getImage(key));
-            return true;
+            return this.tilesets[tileset];
         }
         else
         {
@@ -335,9 +298,11 @@ Phaser.Tilemap.prototype = {
                 }
             }
 
+            return newSet;
+
         }
 
-        return false;
+        return null;
 
     },
 
@@ -475,7 +440,7 @@ Phaser.Tilemap.prototype = {
             output.push(row);
         }
 
-        this.layers.push({
+        var layer = {
 
             name: name,
             x: 0,
@@ -492,11 +457,13 @@ Phaser.Tilemap.prototype = {
             bodies: [],
             data: output
 
-        });
+        };
+
+        this.layers.push(layer);
 
         this.currentLayer = this.layers.length - 1;
 
-        return group.add(new Phaser.TilemapLayer(this.game, this, this.layers.length - 1, width, height));
+        return group.add(new Phaser.TilemapLayer(this.game, this, this.layers.length - 1, layer.widthInPixels, layer.heightInPixels));
 
     },
 
@@ -1013,12 +980,11 @@ Phaser.Tilemap.prototype = {
     * @param {number} x - X position to place the tile (given in tile units, not pixels)
     * @param {number} y - Y position to place the tile (given in tile units, not pixels)
     * @param {number|string|Phaser.TilemapLayer} [layer] - The layer to modify.
+    * @return {Phaser.Tile} The Tile object that was created or added to this map.
     */
     putTile: function (tile, x, y, layer) {
 
-        console.log('putTile' ,layer);
         layer = this.getLayer(layer);
-        console.log('putTile2', layer);
 
         if (x >= 0 && x < this.layers[layer].width && y >= 0 && y < this.layers[layer].height)
         {
@@ -1061,11 +1027,14 @@ Phaser.Tilemap.prototype = {
             }
 
             this.layers[layer].dirty = true;
-			console.log(this.layers[layer]);
 
             this.calculateFaces(layer);
+            
+            return this.layers[layer].data[y][x];
         }
 
+        return null;
+
     },
 
     /**

src/tilemap/TilemapLayer.js

@@ -41,7 +41,7 @@ Phaser.TilemapLayer = function (game, tilemap, index, width, height) {
     * @property {HTMLCanvasElement} canvas - The canvas to which this TilemapLayer draws.
     */
     this.canvas = Phaser.Canvas.create(width, height, '', true);
-    
+
     /**
     * @property {CanvasRenderingContext2D} context - The 2d context of the canvas.
     */
@@ -62,7 +62,6 @@ Phaser.TilemapLayer = function (game, tilemap, index, width, height) {
     */
     this.textureFrame = new Phaser.Frame(0, 0, 0, width, height, 'tilemapLayer', game.rnd.uuid());
 
-    // Phaser.Sprite.call(this, this.game, 0, 0, this.texture, this.textureFrame);
     Phaser.Image.call(this, this.game, 0, 0, this.texture, this.textureFrame);
 
     /**
@@ -288,7 +287,6 @@ Phaser.TilemapLayer = function (game, tilemap, index, width, height) {
 };
 
 Phaser.TilemapLayer.prototype = Object.create(Phaser.Image.prototype);
-// Phaser.TilemapLayer.prototype = Phaser.Utils.extend(true, Phaser.TilemapLayer.prototype, Phaser.Sprite.prototype, PIXI.Sprite.prototype);
 Phaser.TilemapLayer.prototype.constructor = Phaser.TilemapLayer;
 
 /**
@@ -299,15 +297,27 @@ Phaser.TilemapLayer.prototype.constructor = Phaser.TilemapLayer;
 */
 Phaser.TilemapLayer.prototype.postUpdate = function () {
 
-    // Phaser.Sprite.prototype.postUpdate.call(this);
-	Phaser.Image.prototype.postUpdate.call(this);
+	// Phaser.Image.prototype.postUpdate.call(this);
 
     //  Stops you being able to auto-scroll the camera if it's not following a sprite
     this.scrollX = this.game.camera.x * this.scrollFactorX;
     this.scrollY = this.game.camera.y * this.scrollFactorY;
 
     this.render();
 
+    //  Fixed to Camera?
+    // if (this._cache[7] === 1)
+    // {
+        this.position.x = (this.game.camera.view.x + this.cameraOffset.x) / this.game.camera.scale.x;
+        this.position.y = (this.game.camera.view.y + this.cameraOffset.y) / this.game.camera.scale.y;
+    // }
+
+    //  Update any Children
+    // for (var i = 0, len = this.children.length; i < len; i++)
+    // {
+        // this.children[i].postUpdate();
+    // }
+
 }
 
 /**
@@ -640,7 +650,7 @@ Phaser.TilemapLayer.prototype.render = function () {
             {
                 tile = this._column[x];
 
-                set = this.map.tilesets[this.map.tiles[tile.index][2]]
+                set = this.map.tilesets[this.map.tiles[tile.index][2]];
 
                 if (this.debug === false && tile.alpha !== this.context.globalAlpha)
                 {