Use a loop rather than tileRange.forEachTileCoord

src/ol/renderer/dom/domtilelayerrenderer.js

@@ -96,52 +96,55 @@ ol.renderer.dom.TileLayer.prototype.renderFrame =
   var allTilesLoaded = true;
 
   tilesToDrawByZ[z] = {};
-  tileRange.forEachTileCoord(z, function(tileCoord) {
+  var tile, tileCenter, tileCoord, tileState, x, y;
+  for (x = tileRange.minX; x <= tileRange.maxX; ++x) {
+    for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
 
-    var tile = tileSource.getTile(tileCoord);
+      tileCoord = new ol.TileCoord(z, x, y);
+      tile = tileSource.getTile(tileCoord);
+      if (goog.isNull(tile)) {
+        continue;
+      }
 
-    if (goog.isNull(tile)) {
+      tileState = tile.getState();
-      return;
+      if (tileState == ol.TileState.IDLE) {
-    }
+        tileCenter = tileGrid.getTileCoordCenter(tileCoord);
+        frameState.tileQueue.enqueue(tile, tileCenter, tileResolution);
+      } else if (tileState == ol.TileState.LOADED) {
+        tilesToDrawByZ[z][tileCoord.toString()] = tile;
+        continue;
+      } else if (tileState == ol.TileState.ERROR) {
+        continue;
+      }
 
-    var tileState = tile.getState();
+      allTilesLoaded = false;
-    if (tileState == ol.TileState.IDLE) {
-      var tileCenter = tileGrid.getTileCoordCenter(tileCoord);
-      frameState.tileQueue.enqueue(tile, tileCenter, tileResolution);
-    } else if (tileState == ol.TileState.LOADED) {
-      tilesToDrawByZ[z][tile.tileCoord.toString()] = tile;
-      return;
-    } else if (tileState == ol.TileState.ERROR) {
-      return;
-    }
 
-    allTilesLoaded = false;
+      // FIXME this could be more efficient about filling partial holes
-
+      tileGrid.forEachTileCoordParentTileRange(
-    // FIXME this could be more efficient about filling partial holes
+          tileCoord,
-    tileGrid.forEachTileCoordParentTileRange(
+          function(z, tileRange) {
-        tileCoord,
+            var fullyCovered = true;
-        function(z, tileRange) {
+            tileRange.forEachTileCoord(z, function(tileCoord) {
-          var fullyCovered = true;
+              var tileCoordKey = tileCoord.toString();
-          tileRange.forEachTileCoord(z, function(tileCoord) {
+              if (tilesToDrawByZ[z] && tilesToDrawByZ[z][tileCoordKey]) {
-            var tileCoordKey = tileCoord.toString();
+                return;
-            if (tilesToDrawByZ[z] && tilesToDrawByZ[z][tileCoordKey]) {
-              return;
-            }
-            var tile = tileSource.getTile(tileCoord);
-            if (!goog.isNull(tile) &&
-                tile.getState() == ol.TileState.LOADED) {
-              if (!tilesToDrawByZ[z]) {
-                tilesToDrawByZ[z] = {};
               }
-              tilesToDrawByZ[z][tileCoordKey] = tile;
+              var tile = tileSource.getTile(tileCoord);
-            } else {
+              if (!goog.isNull(tile) &&
-              fullyCovered = false;
+                  tile.getState() == ol.TileState.LOADED) {
-            }
+                if (!tilesToDrawByZ[z]) {
+                  tilesToDrawByZ[z] = {};
+                }
+                tilesToDrawByZ[z][tileCoordKey] = tile;
+              } else {
+                fullyCovered = false;
+              }
+            });
+            return fullyCovered;
           });
-          return fullyCovered;
+    }
-        });
 
-  }, this);
+  }
 
   /** @type {Array.<number>} */
   var zs = goog.array.map(goog.object.getKeys(tilesToDrawByZ), Number);

src/ol/renderer/webgl/webgltilelayerrenderer.js

@@ -354,60 +354,65 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
     var allTilesLoaded = true;
 
     tilesToDrawByZ[z] = {};
-    tileRange.forEachTileCoord(z, function(tileCoord) {
+    var deltaX, deltaY, priority, tile, tileCenter, tileCoord, tileState, x, y;
+    for (x = tileRange.minX; x <= tileRange.maxX; ++x) {
+      for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
 
-      var tile = tileSource.getTile(tileCoord);
+        tileCoord = new ol.TileCoord(z, x, y);
-
+        tile = tileSource.getTile(tileCoord);
-      if (goog.isNull(tile)) {
+        if (goog.isNull(tile)) {
-        return;
+          continue;
-      }
-
-      var tileState = tile.getState();
-      if (tileState == ol.TileState.IDLE) {
-        var tileCenter = tileGrid.getTileCoordCenter(tileCoord);
-        frameState.tileQueue.enqueue(tile, tileCenter, tileResolution);
-      } else if (tileState == ol.TileState.LOADED) {
-        if (mapRenderer.isTileTextureLoaded(tile)) {
-          tilesToDrawByZ[z][tileCoord.toString()] = tile;
-          return;
-        } else {
-          var tileCenter = tileGrid.getTileCoordCenter(tileCoord);
-          var deltaX = tileCenter.x - center.x;
-          var deltaY = tileCenter.y - center.y;
-          var priority = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
-          tilesToLoad.enqueue(priority, tile);
         }
-      } else if (tileState == ol.TileState.ERROR) {
+
-        return;
+        tileState = tile.getState();
+        if (tileState == ol.TileState.IDLE) {
+          tileCenter = tileGrid.getTileCoordCenter(tileCoord);
+          frameState.tileQueue.enqueue(tile, tileCenter, tileResolution);
+        } else if (tileState == ol.TileState.LOADED) {
+          if (mapRenderer.isTileTextureLoaded(tile)) {
+            tilesToDrawByZ[z][tileCoord.toString()] = tile;
+            continue;
+          } else {
+            tileCenter = tileGrid.getTileCoordCenter(tileCoord);
+            deltaX = tileCenter.x - center.x;
+            deltaY = tileCenter.y - center.y;
+            priority = Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+            tilesToLoad.enqueue(priority, tile);
+          }
+        } else if (tileState == ol.TileState.ERROR) {
+          continue;
+        }
+
+        allTilesLoaded = false;
+
+        // FIXME this could be more efficient about filling partial holes
+        tileGrid.forEachTileCoordParentTileRange(
+            tileCoord,
+            function(z, tileRange) {
+              var fullyCovered = true;
+              tileRange.forEachTileCoord(z, function(tileCoord) {
+                var tileCoordKey = tileCoord.toString();
+                if (tilesToDrawByZ[z] && tilesToDrawByZ[z][tileCoordKey]) {
+                  return;
+                }
+                var tile = tileSource.getTile(tileCoord);
+                if (!goog.isNull(tile) &&
+                    tile.getState() == ol.TileState.LOADED &&
+                    mapRenderer.isTileTextureLoaded(tile)) {
+                  if (!tilesToDrawByZ[z]) {
+                    tilesToDrawByZ[z] = {};
+                  }
+                  tilesToDrawByZ[z][tileCoordKey] = tile;
+                } else {
+                  fullyCovered = false;
+                }
+              });
+              return fullyCovered;
+            });
+
       }
 
-      allTilesLoaded = false;
+    }
-
-      // FIXME this could be more efficient about filling partial holes
-      tileGrid.forEachTileCoordParentTileRange(
-          tileCoord,
-          function(z, tileRange) {
-            var fullyCovered = true;
-            tileRange.forEachTileCoord(z, function(tileCoord) {
-              var tileCoordKey = tileCoord.toString();
-              if (tilesToDrawByZ[z] && tilesToDrawByZ[z][tileCoordKey]) {
-                return;
-              }
-              var tile = tileSource.getTile(tileCoord);
-              if (!goog.isNull(tile) &&
-                  tile.getState() == ol.TileState.LOADED) {
-                if (!tilesToDrawByZ[z]) {
-                  tilesToDrawByZ[z] = {};
-                }
-                tilesToDrawByZ[z][tileCoordKey] = tile;
-              } else {
-                fullyCovered = false;
-              }
-            });
-            return fullyCovered;
-          });
-
-    }, this);
 
     /** @type {Array.<number>} */
     var zs = goog.array.map(goog.object.getKeys(tilesToDrawByZ), Number);