Removed resolveTileset from TilemapLayerGL, added new task to task list.

Author: pjbaron

docs/_phaser_tilemap_GL_progress.txt

@@ -170,3 +170,13 @@ Made TilemapLayerGL grab the tile dimensions from the new tileset parameter inst
 First working demo with multiple webgl layers each batching tiles from separate tilesets which were all attached to one map layer in the Tiled program.
 Tiles are still turning off too soon at the map edges (exactly like the Canvas version) but that should be fixable with this 'internal layer' approach.
 
+Fixed tiles vanishing at the edge of the screen by using the difference between the original map tileWidth and the current tileset tileWidth when calculating the redraw region left and top.
+
+
+Removed resolveTileset from TilemapLayerGL as it is no longer needed.
+
+Task list updated:
+- Add alpha blending to the shader, calculate the 'final' alpha by multiplying the layer's worldAlpha with the tile.alpha
+- Add scaling to the shader, use the layer's worldScale.  (See if rotation can be easily supported too, while doing this)
+- Optimise the drawing to avoid degenerate triangles where possible, e.g. each row should be a single tri-strip without degenerates in it for faster drawing
+- larger tiles are top-left aligned but should be bottom-left aligned to match the way that Tiled places them

src/tilemap/TilemapLayerGL.js

@@ -171,7 +171,7 @@ Phaser.TilemapLayerGL = function (game, tilemap, index, width, height) {
     * @property {object} _mc
     * @private
     */
-    var tileset =  this.layer.tileset || this.map.tilesets[0];
+    var tileset = this.layer.tileset || this.map.tilesets[0];
     this._mc = {
 
         // Used to bypass rendering without reliance on `dirty` and detect changes.
@@ -580,44 +580,6 @@ Phaser.TilemapLayerGL.prototype.getTiles = function (x, y, width, height, collid
 
 };
 
-/**
-* Returns the appropriate tileset for the index, updating the internal cache as required.
-* This should only be called if `tilesets[index]` evaluates to undefined.
-*
-* @method Phaser.TilemapLayerGL#resolveTileset
-* @private
-* @param {integer} Tile index
-* @return {Phaser.Tileset|null} Returns the associated tileset or null if there is no such mapping.
-*/
-Phaser.TilemapLayerGL.prototype.resolveTileset = function (tileIndex) {
-
-    var tilesets = this._mc.tilesets;
-
-    //  Try for dense array if reasonable
-    if (tileIndex < 2000)
-    {
-        while (tilesets.length < tileIndex)
-        {
-            tilesets.push(undefined);
-        }
-    }
-
-    var setIndex = this.map.tiles[tileIndex] && this.map.tiles[tileIndex][2];
-
-    if (setIndex != null) // number: not null or undefined
-    {
-        var tileset = this.map.tilesets[setIndex];
-
-        if (tileset && tileset.containsTileIndex(tileIndex))
-        {
-            return (tilesets[tileIndex] = tileset);
-        }
-    }
-
-    return (tilesets[tileIndex] = null);
-
-};
-
 /**
 * The TilemapLayerGL caches tileset look-ups.
 *
@@ -739,36 +701,31 @@ Phaser.TilemapLayerGL.prototype.renderRegion = function (scrollX, scrollY, left,
 
             var index = tile.index;
 
-            var set = this.resolveTileset(index);
-
             if (tile.alpha !== lastAlpha && !this.debug)
             {
                 //context.globalAlpha = tile.alpha;
                 lastAlpha = tile.alpha;
             }
 
-            if (set)
+            if (tile.rotation || tile.flipped)
             {
-                if (tile.rotation || tile.flipped)
-                {
-                    //context.save();
-                    //context.translate(tx + tile.centerX, ty + tile.centerY);
-                    //context.rotate(tile.rotation);
+                //context.save();
+                //context.translate(tx + tile.centerX, ty + tile.centerY);
+                //context.rotate(tile.rotation);
 
-                    // if (tile.flipped)
-                    // {
-                    //     context.scale(-1, 1);
-                    // }
+                // if (tile.flipped)
+                // {
+                //     context.scale(-1, 1);
+                // }
 
-                    set.drawGl(this.glBatch, -tile.centerX, -tile.centerY, index);
-                    //context.restore();
-                }
-                else
-                {
-                    set.drawGl(this.glBatch, tx, ty, index);
-                }
+                this._mc.tileset.drawGl(this.glBatch, -tile.centerX, -tile.centerY, index);
+                //context.restore();
+            }
+            else
+            {
+                this._mc.tileset.drawGl(this.glBatch, tx, ty, index);
             }
-            // else if (this.debugSettings.missingImageFill)
+            // if (!this._mc.tileset && this.debugSettings.missingImageFill)
             // {
             //     context.fillStyle = this.debugSettings.missingImageFill;
             //     context.fillRect(tx, ty, tw, th);