Merge branch 'master' of github.com:openlayers/ol3 into vector

src/ol/renderer/canvas/canvasmaprenderer.js

@@ -2,6 +2,7 @@
 
 goog.provide('ol.renderer.canvas.Map');
 
+goog.require('goog.array');
 goog.require('goog.dom');
 goog.require('goog.style');
 goog.require('goog.vec.Mat4');
@@ -73,44 +74,8 @@ ol.renderer.canvas.Map.prototype.createLayerRenderer = function(layer) {
 /**
  * @inheritDoc
  */
-ol.renderer.canvas.Map.prototype.handleBackgroundColorChanged = function() {
-  this.getMap().render();
-};
-
-
-/**
- * @inheritDoc
- */
-ol.renderer.canvas.Map.prototype.handleViewPropertyChanged = function() {
-  goog.base(this, 'handleViewPropertyChanged');
-  this.getMap().render();
-};
-
-
-/**
- * @param {goog.events.Event} event Event.
- * @protected
- */
-ol.renderer.canvas.Map.prototype.handleLayerRendererChange = function(event) {
-  this.getMap().render();
-};
-
-
-/**
- * @inheritDoc
- */
-ol.renderer.canvas.Map.prototype.handleSizeChanged = function() {
-  goog.base(this, 'handleSizeChanged');
-  this.getMap().render();
-};
-
-
-/**
- * @inheritDoc
- */
-ol.renderer.canvas.Map.prototype.handleViewChanged = function() {
-  goog.base(this, 'handleViewChanged');
-  this.getMap().render();
+ol.renderer.canvas.Map.prototype.getCanvas = function() {
+  return this.canvas_;
 };
 
 

src/ol/renderer/canvas/canvastilelayerrenderer.js

@@ -4,6 +4,7 @@
 
 goog.provide('ol.renderer.canvas.TileLayer');
 
+goog.require('goog.array');
 goog.require('goog.dom');
 goog.require('goog.style');
 goog.require('goog.vec.Mat4');
@@ -87,6 +88,7 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
 
   var tileLayer = this.getTileLayer();
   var tileSource = tileLayer.getTileSource();
+  var tileSourceKey = goog.getUid(tileSource).toString();
   var tileGrid = tileSource.getTileGrid();
   var tileSize = tileGrid.getTileSize();
   var z = tileGrid.getZForResolution(view2DState.resolution);
@@ -165,7 +167,7 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
       tileState = tile.getState();
       if (tileState == ol.TileState.IDLE) {
         tileCenter = tileGrid.getTileCoordCenter(tileCoord);
-        frameState.tileQueue.enqueue(tile, tileCenter, tileResolution);
+        frameState.tileQueue.enqueue(tile, tileSourceKey, tileCenter);
       } else if (tileState == ol.TileState.LOADED) {
         tilesToDrawByZ[z][tileCoord.toString()] = tile;
         continue;
@@ -213,9 +215,11 @@ ol.renderer.canvas.TileLayer.prototype.renderFrame =
 
   if (!allTilesLoaded) {
     frameState.animate = true;
+    this.updateWantedTiles(frameState.wantedTiles, tileSource, z, tileRange);
   }
 
-  this.updateTileUsage(frameState.tileUsage, tileSource, z, tileRange);
+  this.updateUsedTiles(frameState.usedTiles, tileSource, z, tileRange);
+  this.scheduleExpireCache(frameState, tileSource);
 
   var transform = this.transform_;
   goog.vec.Mat4.makeIdentity(transform);

src/ol/renderer/dom/dommaprenderer.js

@@ -1,5 +1,6 @@
 goog.provide('ol.renderer.dom.Map');
 
+goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.dom');
 goog.require('goog.dom.TagName');

src/ol/renderer/dom/domtilelayerrenderer.js

@@ -83,6 +83,7 @@ ol.renderer.dom.TileLayer.prototype.renderFrame =
 
   var tileLayer = this.getTileLayer();
   var tileSource = tileLayer.getTileSource();
+  var tileSourceKey = goog.getUid(tileSource).toString();
   var tileGrid = tileSource.getTileGrid();
   var z = tileGrid.getZForResolution(view2DState.resolution);
   var tileResolution = tileGrid.getResolution(z);
@@ -132,7 +133,7 @@ ol.renderer.dom.TileLayer.prototype.renderFrame =
       tileState = tile.getState();
       if (tileState == ol.TileState.IDLE) {
         tileCenter = tileGrid.getTileCoordCenter(tileCoord);
-        frameState.tileQueue.enqueue(tile, tileCenter, tileResolution);
+        frameState.tileQueue.enqueue(tile, tileSourceKey, tileCenter);
       } else if (tileState == ol.TileState.LOADED) {
         tilesToDrawByZ[z][tileCoord.toString()] = tile;
         continue;
@@ -234,9 +235,11 @@ ol.renderer.dom.TileLayer.prototype.renderFrame =
 
   if (!allTilesLoaded) {
     frameState.animate = true;
+    this.updateWantedTiles(frameState.wantedTiles, tileSource, z, tileRange);
   }
 
-  this.updateTileUsage(frameState.tileUsage, tileSource, z, tileRange);
+  this.updateUsedTiles(frameState.usedTiles, tileSource, z, tileRange);
+  this.scheduleExpireCache(frameState, tileSource);
 
 };
 

src/ol/renderer/layerrenderer.js

@@ -2,10 +2,12 @@ goog.provide('ol.renderer.Layer');
 
 goog.require('goog.events');
 goog.require('goog.events.EventType');
+goog.require('ol.FrameState');
 goog.require('ol.Object');
 goog.require('ol.TileRange');
 goog.require('ol.layer.Layer');
 goog.require('ol.layer.LayerProperty');
+goog.require('ol.source.TileSource');
 
 
 
@@ -130,24 +132,66 @@ ol.renderer.Layer.prototype.handleLayerVisibleChange = goog.nullFunction;
 
 /**
  * @protected
- * @param {Object.<string, Object.<string, ol.TileRange>>} tileUsage Tile usage.
+ * @param {ol.FrameState} frameState Frame state.
+ * @param {ol.source.TileSource} tileSource Tile source.
+ */
+ol.renderer.Layer.prototype.scheduleExpireCache =
+    function(frameState, tileSource) {
+  if (tileSource.canExpireCache()) {
+    frameState.postRenderFunctions.push(
+        goog.partial(function(tileSource, map, frameState) {
+          var tileSourceKey = goog.getUid(tileSource).toString();
+          tileSource.expireCache(frameState.usedTiles[tileSourceKey]);
+        }, tileSource));
+  }
+};
+
+
+/**
+ * @protected
+ * @param {Object.<string, Object.<string, ol.TileRange>>} usedTiles Used tiles.
  * @param {ol.source.Source} source Source.
  * @param {number} z Z.
  * @param {ol.TileRange} tileRange Tile range.
  */
-ol.renderer.Layer.prototype.updateTileUsage =
-    function(tileUsage, source, z, tileRange) {
+ol.renderer.Layer.prototype.updateUsedTiles =
+    function(usedTiles, source, z, tileRange) {
   // FIXME should we use tilesToDrawByZ instead?
   var sourceKey = goog.getUid(source).toString();
   var zKey = z.toString();
-  if (sourceKey in tileUsage) {
-    if (z in tileUsage[sourceKey]) {
-      tileUsage[sourceKey][zKey].extend(tileRange);
+  if (sourceKey in usedTiles) {
+    if (zKey in usedTiles[sourceKey]) {
+      usedTiles[sourceKey][zKey].extend(tileRange);
     } else {
-      tileUsage[sourceKey][zKey] = tileRange;
+      usedTiles[sourceKey][zKey] = tileRange;
     }
   } else {
-    tileUsage[sourceKey] = {};
-    tileUsage[sourceKey][zKey] = tileRange;
+    usedTiles[sourceKey] = {};
+    usedTiles[sourceKey][zKey] = tileRange;
+  }
+};
+
+
+/**
+ * @protected
+ * @param {Object.<string, Object.<string, ol.TileRange>>} wantedTiles Wanted
+ *     tile ranges.
+ * @param {ol.source.Source} source Source.
+ * @param {number} z Z.
+ * @param {ol.TileRange} tileRange Tile range.
+ */
+ol.renderer.Layer.prototype.updateWantedTiles =
+    function(wantedTiles, source, z, tileRange) {
+  var sourceKey = goog.getUid(source).toString();
+  var zKey = z.toString();
+  if (sourceKey in wantedTiles) {
+    if (zKey in wantedTiles[sourceKey]) {
+      wantedTiles[sourceKey][zKey].extend(tileRange);
+    } else {
+      wantedTiles[sourceKey][zKey] = tileRange;
+    }
+  } else {
+    wantedTiles[sourceKey] = {};
+    wantedTiles[sourceKey][zKey] = tileRange;
   }
 };

src/ol/renderer/maprenderer.js

@@ -1,11 +1,10 @@
 goog.provide('ol.renderer.Map');
 
 goog.require('goog.Disposable');
+goog.require('goog.array');
 goog.require('goog.asserts');
 goog.require('goog.events');
 goog.require('goog.functions');
-goog.require('goog.fx.anim');
-goog.require('goog.fx.anim.Animated');
 goog.require('goog.vec.Mat4');
 goog.require('ol.FrameState');
 goog.require('ol.View2D');
@@ -41,40 +40,24 @@ ol.renderer.Map = function(container, map) {
    */
   this.layerRenderers = {};
 
-  /**
-   * @private
-   * @type {Array.<number>}
-   */
-  this.layersListenerKeys_ = null;
-
+  //
+  // We listen to layer add/remove to add/remove layer renderers.
+  //
 
   /**
    * @private
    * @type {?number}
    */
-  this.viewPropertyListenerKey_ = null;
+  this.mapLayersChangedListenerKey_ =
+      goog.events.listen(
+          map, ol.Object.getChangedEventType(ol.MapProperty.LAYERS),
+          this.handleLayersChanged, false, this);
 
   /**
    * @private
    * @type {Array.<number>}
    */
-  this.mapListenerKeys_ = [
-    goog.events.listen(
-        map, ol.Object.getChangedEventType(ol.MapProperty.BACKGROUND_COLOR),
-        this.handleBackgroundColorChanged, false, this),
-
-    goog.events.listen(
-        map, ol.Object.getChangedEventType(ol.MapProperty.LAYERS),
-        this.handleLayersChanged, false, this),
-
-    goog.events.listen(
-        map, ol.Object.getChangedEventType(ol.MapProperty.SIZE),
-        this.handleSizeChanged, false, this),
-
-    goog.events.listen(
-        map, ol.Object.getChangedEventType(ol.MapProperty.VIEW),
-        this.handleViewChanged, false, this)
-  ];
+  this.layersListenerKeys_ = null;
 
 };
 goog.inherits(ol.renderer.Map, goog.Disposable);
@@ -137,10 +120,7 @@ ol.renderer.Map.prototype.disposeInternal = function() {
   goog.object.forEach(this.layerRenderers, function(layerRenderer) {
     goog.dispose(layerRenderer);
   });
-  goog.array.forEach(this.mapListenerKeys_, goog.events.unlistenByKey);
-  if (!goog.isNull(this.viewPropertyListenerKey_)) {
-    goog.events.unlistenByKey(this.viewPropertyListenerKey_);
-  }
+  goog.events.unlistenByKey(this.mapLayersChangedListenerKey_);
   if (!goog.isNull(this.layersListenerKeys_)) {
     goog.array.forEach(this.layersListenerKeys_, goog.events.unlistenByKey);
   }
@@ -148,6 +128,12 @@ ol.renderer.Map.prototype.disposeInternal = function() {
 };
 
 
+/**
+ * @return {Element} Canvas.
+ */
+ol.renderer.Map.prototype.getCanvas = goog.functions.NULL;
+
+
 /**
  * @param {ol.layer.Layer} layer Layer.
  * @protected
@@ -169,12 +155,6 @@ ol.renderer.Map.prototype.getMap = function() {
 };
 
 
-/**
- * Handle background color changed.
- */
-ol.renderer.Map.prototype.handleBackgroundColorChanged = goog.nullFunction;
-
-
 /**
  * @param {ol.CollectionEvent} collectionEvent Collection event.
  * @protected
@@ -218,40 +198,6 @@ ol.renderer.Map.prototype.handleLayersRemove = function(collectionEvent) {
 };
 
 
-/**
- * @protected
- */
-ol.renderer.Map.prototype.handleViewPropertyChanged = function() {
-  this.getMap().render();
-};
-
-
-/**
- * @protected
- */
-ol.renderer.Map.prototype.handleSizeChanged = function() {
-  this.getMap().render();
-};
-
-
-/**
- * @protected
- */
-ol.renderer.Map.prototype.handleViewChanged = function() {
-  if (!goog.isNull(this.viewPropertyListenerKey_)) {
-    goog.events.unlistenByKey(this.viewPropertyListenerKey_);
-    this.viewPropertyListenerKey_ = null;
-  }
-  var view = this.getMap().getView();
-  if (goog.isDefAndNotNull(view)) {
-    this.viewPropertyListenerKey_ = goog.events.listen(
-        view, ol.ObjectEventType.CHANGED,
-        this.handleViewPropertyChanged, false, this);
-  }
-  this.getMap().render();
-};
-
-
 /**
  * @param {ol.layer.Layer} layer Layer.
  * @protected

src/ol/renderer/webgl/webglmaprenderer.js

@@ -1,10 +1,9 @@
-// FIXME clear textureCache
-// FIXME generational tile texture garbage collector newFrame/get
 // FIXME check against gl.getParameter(webgl.MAX_TEXTURE_SIZE)
 
 goog.provide('ol.renderer.webgl.Map');
 goog.provide('ol.renderer.webgl.map.shader');
 
+goog.require('goog.array');
 goog.require('goog.debug.Logger');
 goog.require('goog.dispose');
 goog.require('goog.dom');
@@ -17,13 +16,21 @@ goog.require('goog.webgl');
 goog.require('ol.Tile');
 goog.require('ol.layer.Layer');
 goog.require('ol.layer.TileLayer');
+goog.require('ol.renderer.Map');
 goog.require('ol.renderer.webgl.FragmentShader');
 goog.require('ol.renderer.webgl.TileLayer');
 goog.require('ol.renderer.webgl.VertexShader');
+goog.require('ol.structs.LinkedMap');
 goog.require('ol.webgl');
 goog.require('ol.webgl.WebGLContextEventType');
 
 
+/**
+ * @define {number} Texture cache high water mark.
+ */
+ol.WEBGL_TEXTURE_CACHE_HIGH_WATER_MARK = 1024;
+
+
 /**
  * @typedef {{magFilter: number, minFilter: number, texture: WebGLTexture}}
  */
@@ -177,9 +184,15 @@ ol.renderer.webgl.Map = function(container, map) {
 
   /**
    * @private
-   * @type {Object.<string, ol.renderer.webgl.TextureCacheEntry>}
+   * @type {ol.structs.LinkedMap}
    */
-  this.textureCache_ = {};
+  this.textureCache_ = new ol.structs.LinkedMap(undefined, true);
+
+  /**
+   * @private
+   * @type {number}
+   */
+  this.textureCacheFrameMarkerCount_ = 0;
 
   /**
    * @private
@@ -225,8 +238,8 @@ ol.renderer.webgl.Map.prototype.bindTileTexture =
     function(tile, magFilter, minFilter) {
   var gl = this.getGL();
   var tileKey = tile.getKey();
-  var textureCacheEntry = this.textureCache_[tileKey];
-  if (goog.isDef(textureCacheEntry)) {
+  if (this.textureCache_.containsKey(tileKey)) {
+    var textureCacheEntry = this.textureCache_.get(tileKey);
     gl.bindTexture(goog.webgl.TEXTURE_2D, textureCacheEntry.texture);
     if (textureCacheEntry.magFilter != magFilter) {
       gl.texParameteri(
@@ -251,11 +264,11 @@ ol.renderer.webgl.Map.prototype.bindTileTexture =
         goog.webgl.CLAMP_TO_EDGE);
     gl.texParameteri(goog.webgl.TEXTURE_2D, goog.webgl.TEXTURE_WRAP_T,
         goog.webgl.CLAMP_TO_EDGE);
-    this.textureCache_[tileKey] = {
+    this.textureCache_.set(tileKey, {
       texture: texture,
       magFilter: magFilter,
       minFilter: minFilter
-    };
+    });
   }
 };
 
@@ -285,14 +298,50 @@ ol.renderer.webgl.Map.prototype.disposeInternal = function() {
     goog.object.forEach(this.shaderCache_, function(shader) {
       gl.deleteShader(shader);
     });
-    goog.object.forEach(this.textureCache_, function(textureCacheEntry) {
-      gl.deleteTexture(textureCacheEntry.texture);
+    this.textureCache_.forEach(function(textureCacheEntry) {
+      if (!goog.isNull(textureCacheEntry)) {
+        gl.deleteTexture(textureCacheEntry.texture);
+      }
     });
   }
   goog.base(this, 'disposeInternal');
 };
 
 
+/**
+ * @param {ol.Map} map Map.
+ * @param {ol.FrameState} frameState Frame state.
+ * @private
+ */
+ol.renderer.webgl.Map.prototype.expireCache_ = function(map, frameState) {
+  var gl = this.getGL();
+  var key, textureCacheEntry;
+  while (this.textureCache_.getCount() - this.textureCacheFrameMarkerCount_ >
+      ol.WEBGL_TEXTURE_CACHE_HIGH_WATER_MARK) {
+    textureCacheEntry = /** @type {?ol.renderer.webgl.TextureCacheEntry} */
+        (this.textureCache_.peekLast());
+    if (goog.isNull(textureCacheEntry)) {
+      if (+this.textureCache_.peekLastKey() == frameState.time) {
+        break;
+      } else {
+        --this.textureCacheFrameMarkerCount_;
+      }
+    } else {
+      gl.deleteTexture(textureCacheEntry.texture);
+    }
+    this.textureCache_.pop();
+  }
+};
+
+
+/**
+ * @inheritDoc
+ */
+ol.renderer.webgl.Map.prototype.getCanvas = function() {
+  return this.canvas_;
+};
+
+
 /**
  * @return {WebGLRenderingContext} GL.
  */
@@ -360,14 +409,6 @@ ol.renderer.webgl.Map.prototype.getShader = function(shaderObject) {
 };
 
 
-/**
- * @inheritDoc
- */
-ol.renderer.webgl.Map.prototype.handleBackgroundColorChanged = function() {
-  this.getMap().render();
-};
-
-
 /**
  * @param {goog.events.Event} event Event.
  * @protected
@@ -390,7 +431,8 @@ ol.renderer.webgl.Map.prototype.handleWebGLContextLost = function(event) {
   this.arrayBuffer_ = null;
   this.shaderCache_ = {};
   this.programCache_ = {};
-  this.textureCache_ = {};
+  this.textureCache_.clear();
+  this.textureCacheFrameMarkerCount_ = 0;
   goog.object.forEach(this.layerRenderers, function(layerRenderer) {
     layerRenderer.handleWebGLContextLost();
   });
@@ -427,7 +469,7 @@ ol.renderer.webgl.Map.prototype.initializeGL_ = function() {
  * @return {boolean} Is tile texture loaded.
  */
 ol.renderer.webgl.Map.prototype.isTileTextureLoaded = function(tile) {
-  return tile.getKey() in this.textureCache_;
+  return this.textureCache_.containsKey(tile.getKey());
 };
 
 
@@ -471,6 +513,9 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
     return false;
   }
 
+  this.textureCache_.set(frameState.time.toString(), null);
+  ++this.textureCacheFrameMarkerCount_;
+
   goog.array.forEach(frameState.layersArray, function(layer) {
     var layerState = frameState.layerStates[goog.getUid(layer)];
     if (!layerState.visible || !layerState.ready) {
@@ -553,6 +598,11 @@ ol.renderer.webgl.Map.prototype.renderFrame = function(frameState) {
 
   this.calculateMatrices2D(frameState);
 
+  if (this.textureCache_.getCount() - this.textureCacheFrameMarkerCount_ >
+      ol.WEBGL_TEXTURE_CACHE_HIGH_WATER_MARK) {
+    frameState.postRenderFunctions.push(goog.bind(this.expireCache_, this));
+  }
+
 };
 
 

src/ol/renderer/webgl/webgltilelayerrenderer.js

@@ -270,6 +270,7 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
 
   var tileLayer = this.getTileLayer();
   var tileSource = tileLayer.getTileSource();
+  var tileSourceKey = goog.getUid(tileSource).toString();
   var tileGrid = tileSource.getTileGrid();
   var z = tileGrid.getZForResolution(view2DState.resolution);
   var tileResolution = tileGrid.getResolution(z);
@@ -392,7 +393,7 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
         tileState = tile.getState();
         if (tileState == ol.TileState.IDLE) {
           tileCenter = tileGrid.getTileCoordCenter(tileCoord);
-          frameState.tileQueue.enqueue(tile, tileCenter, tileResolution);
+          frameState.tileQueue.enqueue(tile, tileSourceKey, tileCenter);
         } else if (tileState == ol.TileState.LOADED) {
           if (mapRenderer.isTileTextureLoaded(tile)) {
             tilesToDrawByZ[z][tileCoord.toString()] = tile;
@@ -455,11 +456,13 @@ ol.renderer.webgl.TileLayer.prototype.renderFrame =
       this.renderedTileRange_ = null;
       this.renderedFramebufferExtent_ = null;
       frameState.animate = true;
+      this.updateWantedTiles(frameState.wantedTiles, tileSource, z, tileRange);
     }
 
   }
 
-  this.updateTileUsage(frameState.tileUsage, tileSource, z, tileRange);
+  this.updateUsedTiles(frameState.usedTiles, tileSource, z, tileRange);
+  this.scheduleExpireCache(frameState, tileSource);
 
   goog.vec.Mat4.makeIdentity(this.matrix_);
   goog.vec.Mat4.translate(this.matrix_,