Create replay group for the tile's native resolution only

src/ol/renderer/canvas/canvasvectortilelayerrenderer.js

@@ -7,6 +7,7 @@ goog.require('goog.object');
 goog.require('goog.vec.Mat4');
 goog.require('ol.TileRange');
 goog.require('ol.TileState');
+goog.require('ol.VectorTile');
 goog.require('ol.ViewHint');
 goog.require('ol.dom');
 goog.require('ol.extent');
@@ -155,12 +156,10 @@ ol.renderer.canvas.VectorTileLayer.prototype.composeFrame =
 /**
  * @param {ol.VectorTile} tile Tile.
  * @param {ol.layer.VectorTile} layer Vector tile layer.
- * @param {number} resolution Resolution.
  * @param {number} pixelRatio Pixel ratio.
- * @return {boolean} Success.
  */
 ol.renderer.canvas.VectorTileLayer.prototype.createReplayGroup = function(tile,
-    layer, resolution, pixelRatio) {
+    layer, pixelRatio) {
   var revision = layer.getRevision();
   var renderOrder = layer.getRenderOrder();
   if (!goog.isDef(renderOrder)) {
@@ -168,33 +167,30 @@ ol.renderer.canvas.VectorTileLayer.prototype.createReplayGroup = function(tile,
   }
 
   var replayState = tile.getReplayState();
-  if (!replayState.dirty &&
+  if (replayState.renderedRevision == revision &&
-      replayState.renderedResolution == resolution &&
-      replayState.renderedRevision == revision &&
       replayState.renderedRenderOrder == renderOrder) {
-    return false;
+    return;
   }
 
   // FIXME dispose of old replayGroup in post render
   goog.dispose(replayState.replayGroup);
   replayState.replayGroup = null;
-  replayState.dirty = false;
 
   var source = layer.getSource();
   goog.asserts.assertInstanceof(source, ol.source.VectorTile,
       'Source is an ol.source.VectorTile');
   var tileGrid = source.getTileGrid();
+  var tileCoord = tile.getTileCoord();
+  var resolution = tileGrid.getTileCoordResolution(tileCoord);
   var pixelSpace = tile.getProjection().getUnits() == ol.proj.Units.TILE_PIXELS;
   var extent = pixelSpace ?
-      [0, 0].concat(source.getTilePixelSize(
+      [0, 0].concat(source.getTilePixelSize(tileCoord[0], pixelRatio,
-          tileGrid.getZForResolution(resolution), pixelRatio,
               tile.getProjection())) :
-      tileGrid.getTileCoordExtent(tile.getTileCoord());
+      tileGrid.getTileCoordExtent(tileCoord);
   var tileResolution = pixelSpace ? source.getTilePixelRatio() : resolution;
   var replayGroup = new ol.render.canvas.ReplayGroup(pixelSpace ? 0 :
       ol.renderer.vector.getTolerance(tileResolution, pixelRatio), extent,
-      tileResolution, layer.getRenderBuffer(),
+      tileResolution, layer.getRenderBuffer(), source.getRightHandedPolygons());
-      source.getRightHandedPolygons());
 
   /**
    * @param {ol.Feature} feature Feature.
@@ -212,8 +208,7 @@ ol.renderer.canvas.VectorTileLayer.prototype.createReplayGroup = function(tile,
     if (goog.isDefAndNotNull(styles)) {
       var dirty = this.renderFeature(feature, squaredTolerance, styles,
           replayGroup);
-      replayState.dirty = replayState.dirty || dirty;
+      this.dirty_ = this.dirty_ || dirty;
-      this.dirty_ = this.dirty_ || replayState.dirty;
     }
   }
 
@@ -226,12 +221,9 @@ ol.renderer.canvas.VectorTileLayer.prototype.createReplayGroup = function(tile,
 
   replayGroup.finish();
 
-  replayState.renderedResolution = resolution;
   replayState.renderedRevision = revision;
   replayState.renderedRenderOrder = renderOrder;
   replayState.replayGroup = replayGroup;
-
-  return true;
 };
 
 
@@ -248,13 +240,14 @@ ol.renderer.canvas.VectorTileLayer.prototype.forEachFeatureAtCoordinate =
   var features = {};
 
   var replayables = this.renderedTiles_;
+  var source = layer.getSource();
+  var tileGrid = source.getTileGrid();
   var found, tileSpaceCoordinate;
-  var i, ii, origin, replayGroup, source;
+  var i, ii, origin, replayGroup;
   var tile, tileCoord, tileExtent, tilePixelRatio, tileResolution, tileSize;
   for (i = 0, ii = replayables.length; i < ii; ++i) {
     tile = replayables[i];
     tileCoord = tile.getTileCoord();
-    source = layer.getSource();
     goog.asserts.assertInstanceof(source, ol.source.VectorTile,
         'Source is an ol.source.VectorTile');
     tileExtent = source.getTileGrid().getTileCoordExtent(tileCoord);
@@ -265,9 +258,8 @@ ol.renderer.canvas.VectorTileLayer.prototype.forEachFeatureAtCoordinate =
       origin = ol.extent.getTopLeft(
           source.getTileGrid().getTileCoordExtent(tileCoord));
       tilePixelRatio = source.getTilePixelRatio();
-      tileResolution = resolution / tilePixelRatio;
+      tileResolution = tileGrid.getResolution(tileCoord[0]) / tilePixelRatio;
-      tileSize = ol.size.toSize(
+      tileSize = ol.size.toSize(tileGrid.getTileSize(tileCoord[0]));
-          source.getTileGrid().getTileSize(tileCoord[0]));
       tileSpaceCoordinate = [
         (coordinate[0] - origin[0]) / tileResolution,
         (origin[1] - coordinate[1]) / tileResolution
@@ -358,7 +350,7 @@ ol.renderer.canvas.VectorTileLayer.prototype.prepareFrame =
   this.scheduleExpireCache(frameState, source);
 
   /**
-   * @type {Object.<number, Object.<string, ol.Tile>>}
+   * @type {Object.<number, Object.<string, ol.VectorTile>>}
    */
   var tilesToDrawByZ = {};
   tilesToDrawByZ[z] = {};
@@ -374,6 +366,8 @@ ol.renderer.canvas.VectorTileLayer.prototype.prepareFrame =
     for (y = tileRange.minY; y <= tileRange.maxY; ++y) {
 
       tile = source.getTile(z, x, y, pixelRatio, projection);
+      goog.asserts.assertInstanceof(tile, ol.VectorTile,
+          'Tile is an ol.VectorTile');
       tileState = tile.getState();
       if (tileState == ol.TileState.LOADED ||
           tileState == ol.TileState.EMPTY ||
@@ -407,16 +401,11 @@ ol.renderer.canvas.VectorTileLayer.prototype.prepareFrame =
       tile = tilesToDraw[tileCoordKey];
       if (tile.getState() == ol.TileState.LOADED) {
         replayables.push(tile);
+        this.createReplayGroup(tile, layer, pixelRatio);
       }
     }
   }
 
-  for (i = 0, ii = replayables.length; i < ii; ++i) {
-    tile = replayables[i];
-    this.dirty_ = this.createReplayGroup(tile, layer, resolution, pixelRatio) ||
-        this.dirty_;
-  }
-
   this.renderedTiles_ = replayables;
 
   return true;

src/ol/vectortile.js

@@ -7,10 +7,9 @@ goog.require('ol.TileState');
 
 
 /**
- * @typedef {{dirty: boolean,
+ * @typedef {{
  *     renderedRenderOrder: (null|function(ol.Feature, ol.Feature):number),
  *     renderedRevision: number,
- *     renderedResolution: number,
  *     replayGroup: ol.render.IReplayGroup}}
  */
 ol.TileReplayState;
@@ -59,10 +58,8 @@ ol.VectorTile = function(tileCoord, state, src, format, tileLoadFunction) {
    * @type {ol.TileReplayState}
    */
   this.replayState_ = {
-    dirty: true,
     renderedRenderOrder: null,
     renderedRevision: -1,
-    renderedResolution: NaN,
     replayGroup: null
   };