1 files changed, 42 insertions, 36 deletions

diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index c5a29eebf5..bcd719365d 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -1,39 +1,35 @@
 #include <mbgl/renderer/sources/render_raster_source.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/tile/raster_tile.hpp>
+#include <mbgl/algorithm/update_tile_masks.hpp>
 
 namespace mbgl {
 
 using namespace style;
 
-RenderRasterSource::RenderRasterSource(const style::RasterSource::Impl& impl_)
-    : RenderSource(impl_),
-      impl(impl_) {
+RenderRasterSource::RenderRasterSource(Immutable<style::RasterSource::Impl> impl_)
+    : RenderSource(impl_) {
     tilePyramid.setObserver(this);
 }
 
-bool RenderRasterSource::isLoaded() const {
-    return tilePyramid.isLoaded();
-}
-
-void RenderRasterSource::invalidateTiles() {
-    tilePyramid.invalidateTiles();
+const style::RasterSource::Impl& RenderRasterSource::impl() const {
+    return static_cast<const style::RasterSource::Impl&>(*baseImpl);
 }
 
-void RenderRasterSource::startRender(algorithm::ClipIDGenerator&, const mat4& projMatrix, const mat4& clipMatrix, const TransformState& transform) {
-    tilePyramid.startRender(projMatrix, clipMatrix, transform);
+bool RenderRasterSource::isLoaded() const {
+    return tilePyramid.isLoaded();
 }
 
-void RenderRasterSource::finishRender(Painter& painter) {
-    tilePyramid.finishRender(painter);
-}
+void RenderRasterSource::update(Immutable<style::Source::Impl> baseImpl_,
+                                const std::vector<Immutable<Layer::Impl>>& layers,
+                                const bool needsRendering,
+                                const bool needsRelayout,
+                                const TileParameters& parameters) {
+    std::swap(baseImpl, baseImpl_);
 
-std::map<UnwrappedTileID, RenderTile>& RenderRasterSource::getRenderTiles() {
-    return tilePyramid.getRenderTiles();
-}
+    enabled = needsRendering;
 
-void RenderRasterSource::updateTiles(const TileParameters& parameters) {
-    optional<Tileset> tileset = impl.getTileset();
+    optional<Tileset> tileset = impl().getTileset();
 
     if (!tileset) {
         return;
@@ -41,41 +37,51 @@ void RenderRasterSource::updateTiles(const TileParameters& parameters) {
 
     if (tileURLTemplates != tileset->tiles) {
         tileURLTemplates = tileset->tiles;
-        tilePyramid.invalidateTiles();
+
+        // TODO: this removes existing buckets, and will cause flickering.
+        // Should instead refresh tile data in place.
+        tilePyramid.tiles.clear();
+        tilePyramid.renderTiles.clear();
+        tilePyramid.cache.clear();
     }
 
-    tilePyramid.updateTiles(parameters,
-                            SourceType::Raster,
-                            impl.getTileSize(),
-                            tileset->zoomRange,
-                            [&] (const OverscaledTileID& tileID) {
-                                return std::make_unique<RasterTile>(tileID, parameters, *tileset);
-                            });
+    tilePyramid.update(layers,
+                       needsRendering,
+                       needsRelayout,
+                       parameters,
+                       SourceType::Raster,
+                       impl().getTileSize(),
+                       tileset->zoomRange,
+                       [&] (const OverscaledTileID& tileID) {
+                           return std::make_unique<RasterTile>(tileID, parameters, *tileset);
+                       });
+}
+
+void RenderRasterSource::startRender(PaintParameters& parameters) {
+    algorithm::updateTileMasks(tilePyramid.getRenderTiles());
+    tilePyramid.startRender(parameters);
 }
 
-void RenderRasterSource::removeTiles() {
-    tilePyramid.removeTiles();
+void RenderRasterSource::finishRender(PaintParameters& parameters) {
+    tilePyramid.finishRender(parameters);
 }
 
-void RenderRasterSource::reloadTiles() {
-    tilePyramid.reloadTiles();
+std::vector<std::reference_wrapper<RenderTile>> RenderRasterSource::getRenderTiles() {
+    return tilePyramid.getRenderTiles();
 }
 
 std::unordered_map<std::string, std::vector<Feature>>
 RenderRasterSource::queryRenderedFeatures(const ScreenLineString&,
                                           const TransformState&,
+                                          const std::vector<const RenderLayer*>&,
                                           const RenderedQueryOptions&) const {
-    return {};
+    return std::unordered_map<std::string, std::vector<Feature>> {};
 }
 
 std::vector<Feature> RenderRasterSource::querySourceFeatures(const SourceQueryOptions&) const {
     return {};
 }
 
-void RenderRasterSource::setCacheSize(size_t size) {
-    tilePyramid.setCacheSize(size);
-}
-
 void RenderRasterSource::onLowMemory() {
     tilePyramid.onLowMemory();
 }