[core] Refactor RenderSource updates

* Eliminate updateBatch in favor of diffing layers and detecting changes to properties upon which layout depends.
* Replace RenderSource::{update,remove,invalidate,reload}Tiles with a single update method
* Replace TilePyramid::{update,remove,invalidate,reload}Tiles with a single update method
* Remove Style& dependency TODO from GeometryTile and TileParameters

15 files changed, 192 insertions, 220 deletions

diff --git a/src/mbgl/renderer/render_source.cpp b/src/mbgl/renderer/render_source.cpp
index c59f767d26..7723a1c7ca 100644
--- a/src/mbgl/renderer/render_source.cpp
+++ b/src/mbgl/renderer/render_source.cpp
@@ -3,6 +3,7 @@
 #include <mbgl/renderer/sources/render_geojson_source.hpp>
 #include <mbgl/renderer/sources/render_raster_source.hpp>
 #include <mbgl/renderer/sources/render_vector_source.hpp>
+#include <mbgl/renderer/tile_parameters.hpp>
 #include <mbgl/annotation/render_annotation_source.hpp>
 #include <mbgl/renderer/sources/render_image_source.hpp>
 #include <mbgl/tile/tile.hpp>
@@ -44,10 +45,6 @@ void RenderSource::setObserver(RenderSourceObserver* observer_) {
     observer = observer_;
 }
 
-void RenderSource::setImpl(Immutable<style::Source::Impl> impl) {
-    baseImpl = impl;
-}
-
 void RenderSource::onTileChanged(Tile& tile) {
     observer->onTileChanged(*this, tile.id);
 }
@@ -56,4 +53,8 @@ void RenderSource::onTileError(Tile& tile, std::exception_ptr error) {
     observer->onTileError(*this, tile.id, error);
 }
 
+bool RenderSource::isEnabled() const {
+    return enabled;
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index df44ea70fd..b229d8a0bd 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -6,6 +6,7 @@
 #include <mbgl/util/geo.hpp>
 #include <mbgl/util/feature.hpp>
 #include <mbgl/style/source_impl.hpp>
+#include <mbgl/style/layer_impl.hpp>
 
 #include <unordered_map>
 #include <vector>
@@ -17,6 +18,7 @@ namespace mbgl {
 class Painter;
 class TransformState;
 class RenderTile;
+class RenderLayer;
 class RenderedQueryOptions;
 class SourceQueryOptions;
 class Tile;
@@ -35,8 +37,6 @@ class RenderSource : protected TileObserver {
 public:
     static std::unique_ptr<RenderSource> create(Immutable<style::Source::Impl>);
 
-    ~RenderSource() override = default;
-
     // Check whether this source is of the given subtype.
     template <class T>
     bool is() const;
@@ -52,21 +52,14 @@ public:
         return is<T>() ? reinterpret_cast<const T*>(this) : nullptr;
     }
 
+    bool isEnabled() const;
     virtual bool isLoaded() const = 0;
 
-    // Called when the camera has changed. May load new tiles, unload obsolete tiles, or
-    // trigger re-placement of existing complete tiles.
-    virtual void updateTiles(const TileParameters&) = 0;
-
-    // Removes all tiles (by putting them into the cache).
-    virtual void removeTiles() = 0;
-
-    // Remove all tiles and clear the cache.
-    virtual void invalidateTiles() = 0;
-
-    // Request that all loaded tiles re-run the layout operation on the existing source
-    // data with fresh style information.
-    virtual void reloadTiles() = 0;
+    virtual void update(Immutable<style::Source::Impl>,
+                        const std::vector<Immutable<style::Layer::Impl>>&,
+                        bool needsRendering,
+                        bool needsRelayout,
+                        const TileParameters&) = 0;
 
     virtual void startRender(algorithm::ClipIDGenerator&,
                              const mat4& projMatrix,
@@ -93,14 +86,13 @@ public:
     void setObserver(RenderSourceObserver*);
 
     Immutable<style::Source::Impl> baseImpl;
-    void setImpl(Immutable<style::Source::Impl>);
-
-    bool enabled = false;
 
 protected:
     RenderSource(Immutable<style::Source::Impl>);
     RenderSourceObserver* observer;
 
+    bool enabled = false;
+
     void onTileChanged(Tile&) final;
     void onTileError(Tile&, std::exception_ptr) final;
 };
diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp
index ca0c6c5244..19e93ca2ba 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.cpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.cpp
@@ -22,24 +22,15 @@ bool RenderGeoJSONSource::isLoaded() const {
     return tilePyramid.isLoaded();
 }
 
-void RenderGeoJSONSource::invalidateTiles() {
-    tilePyramid.invalidateTiles();
-}
-
-void RenderGeoJSONSource::startRender(algorithm::ClipIDGenerator& generator, const mat4& projMatrix, const mat4& clipMatrix, const TransformState& transform) {
-    generator.update(tilePyramid.getRenderTiles());
-    tilePyramid.startRender(projMatrix, clipMatrix, transform);
-}
+void RenderGeoJSONSource::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_);
 
-void RenderGeoJSONSource::finishRender(Painter& painter) {
-    tilePyramid.finishRender(painter);
-}
-
-std::map<UnwrappedTileID, RenderTile>& RenderGeoJSONSource::getRenderTiles() {
-    return tilePyramid.getRenderTiles();
-}
+    enabled = needsRendering;
 
-void RenderGeoJSONSource::updateTiles(const TileParameters& parameters) {
     GeoJSONData* data_ = impl().getData();
 
     if (!data_) {
@@ -55,21 +46,29 @@ void RenderGeoJSONSource::updateTiles(const TileParameters& parameters) {
         }
     }
 
-    tilePyramid.updateTiles(parameters,
-                            SourceType::GeoJSON,
-                            util::tileSize,
-                            impl().getZoomRange(),
-                            [&] (const OverscaledTileID& tileID) {
-                                return std::make_unique<GeoJSONTile>(tileID, impl().id, parameters, data->getTile(tileID.canonical));
-                            });
+    tilePyramid.update(layers,
+                       needsRendering,
+                       needsRelayout,
+                       parameters,
+                       SourceType::GeoJSON,
+                       util::tileSize,
+                       impl().getZoomRange(),
+                       [&] (const OverscaledTileID& tileID) {
+                           return std::make_unique<GeoJSONTile>(tileID, impl().id, parameters, data->getTile(tileID.canonical));
+                       });
 }
 
-void RenderGeoJSONSource::removeTiles() {
-    tilePyramid.removeTiles();
+void RenderGeoJSONSource::startRender(algorithm::ClipIDGenerator& generator, const mat4& projMatrix, const mat4& clipMatrix, const TransformState& transform) {
+    generator.update(tilePyramid.getRenderTiles());
+    tilePyramid.startRender(projMatrix, clipMatrix, transform);
 }
 
-void RenderGeoJSONSource::reloadTiles() {
-    tilePyramid.reloadTiles();
+void RenderGeoJSONSource::finishRender(Painter& painter) {
+    tilePyramid.finishRender(painter);
+}
+
+std::map<UnwrappedTileID, RenderTile>& RenderGeoJSONSource::getRenderTiles() {
+    return tilePyramid.getRenderTiles();
 }
 
 std::unordered_map<std::string, std::vector<Feature>>
diff --git a/src/mbgl/renderer/sources/render_geojson_source.hpp b/src/mbgl/renderer/sources/render_geojson_source.hpp
index 6571750347..c3783af642 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.hpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.hpp
@@ -16,19 +16,11 @@ public:
 
     bool isLoaded() const final;
 
-    // Called when the camera has changed. May load new tiles, unload obsolete tiles, or
-    // trigger re-placement of existing complete tiles.
-    void updateTiles(const TileParameters&) final;
-
-    // Removes all tiles (by putting them into the cache).
-    void removeTiles() final;
-
-    // Remove all tiles and clear the cache.
-    void invalidateTiles() final;
-
-    // Request that all loaded tiles re-run the layout operation on the existing source
-    // data with fresh style information.
-    void reloadTiles() final;
+    void update(Immutable<style::Source::Impl>,
+                const std::vector<Immutable<style::Layer::Impl>>&,
+                bool needsRendering,
+                bool needsRelayout,
+                const TileParameters&) final;
 
     void startRender(algorithm::ClipIDGenerator&,
                      const mat4& projMatrix,
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index a55e97fd9c..5f9887cdb8 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -72,7 +72,14 @@ void RenderImageSource::upload(gl::Context& context) {
     }
 }
 
-void RenderImageSource::updateTiles(const TileParameters& parameters) {
+void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
+                               const std::vector<Immutable<Layer::Impl>>&,
+                               const bool needsRendering,
+                               const bool,
+                               const TileParameters& parameters) {
+    std::swap(baseImpl, baseImpl_);
+
+    enabled = needsRendering;
 
     auto transformState = parameters.transformState;
     auto size = transformState.getSize();
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index f8581f079a..dc5c32876b 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -30,13 +30,11 @@ public:
 
     void finishRender(Painter&) final;
 
-    void updateTiles(const TileParameters&) final;
-    void removeTiles() final {
-    }
-    void invalidateTiles() final {
-    }
-    void reloadTiles() final {
-    }
+    void update(Immutable<style::Source::Impl>,
+                const std::vector<Immutable<style::Layer::Impl>>&,
+                bool needsRendering,
+                bool needsRelayout,
+                const TileParameters&) final;
 
     std::map<UnwrappedTileID, RenderTile>& getRenderTiles() final {
         return tiles;
diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index 182fe47549..239bac9dd6 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -19,23 +19,15 @@ bool RenderRasterSource::isLoaded() const {
     return tilePyramid.isLoaded();
 }
 
-void RenderRasterSource::invalidateTiles() {
-    tilePyramid.invalidateTiles();
-}
+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_);
 
-void RenderRasterSource::startRender(algorithm::ClipIDGenerator&, const mat4& projMatrix, const mat4& clipMatrix, const TransformState& transform) {
-    tilePyramid.startRender(projMatrix, clipMatrix, transform);
-}
+    enabled = needsRendering;
 
-void RenderRasterSource::finishRender(Painter& painter) {
-    tilePyramid.finishRender(painter);
-}
-
-std::map<UnwrappedTileID, RenderTile>& RenderRasterSource::getRenderTiles() {
-    return tilePyramid.getRenderTiles();
-}
-
-void RenderRasterSource::updateTiles(const TileParameters& parameters) {
     optional<Tileset> tileset = impl().getTileset();
 
     if (!tileset) {
@@ -44,24 +36,36 @@ 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(algorithm::ClipIDGenerator&, const mat4& projMatrix, const mat4& clipMatrix, const TransformState& transform) {
+    tilePyramid.startRender(projMatrix, clipMatrix, transform);
 }
 
-void RenderRasterSource::removeTiles() {
-    tilePyramid.removeTiles();
+void RenderRasterSource::finishRender(Painter& painter) {
+    tilePyramid.finishRender(painter);
 }
 
-void RenderRasterSource::reloadTiles() {
-    tilePyramid.reloadTiles();
+std::map<UnwrappedTileID, RenderTile>& RenderRasterSource::getRenderTiles() {
+    return tilePyramid.getRenderTiles();
 }
 
 std::unordered_map<std::string, std::vector<Feature>>
diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp
index d68c6d5dd3..cbe16b967e 100644
--- a/src/mbgl/renderer/sources/render_raster_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_source.hpp
@@ -12,19 +12,11 @@ public:
 
     bool isLoaded() const final;
 
-    // Called when the camera has changed. May load new tiles, unload obsolete tiles, or
-    // trigger re-placement of existing complete tiles.
-    void updateTiles(const TileParameters&) final;
-
-    // Removes all tiles (by putting them into the cache).
-    void removeTiles() final;
-
-    // Remove all tiles and clear the cache.
-    void invalidateTiles() final;
-
-    // Request that all loaded tiles re-run the layout operation on the existing source
-    // data with fresh style information.
-    void reloadTiles() final;
+    void update(Immutable<style::Source::Impl>,
+                const std::vector<Immutable<style::Layer::Impl>>&,
+                bool needsRendering,
+                bool needsRelayout,
+                const TileParameters&) final;
 
     void startRender(algorithm::ClipIDGenerator&,
                      const mat4& projMatrix,
diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp
index 732969db64..869d87b0b7 100644
--- a/src/mbgl/renderer/sources/render_vector_source.cpp
+++ b/src/mbgl/renderer/sources/render_vector_source.cpp
@@ -22,24 +22,15 @@ bool RenderVectorSource::isLoaded() const {
     return tilePyramid.isLoaded();
 }
 
-void RenderVectorSource::invalidateTiles() {
-    tilePyramid.invalidateTiles();
-}
-
-void RenderVectorSource::startRender(algorithm::ClipIDGenerator& generator, const mat4& projMatrix, const mat4& clipMatrix, const TransformState& transform) {
-    generator.update(tilePyramid.getRenderTiles());
-    tilePyramid.startRender(projMatrix, clipMatrix, transform);
-}
+void RenderVectorSource::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_);
 
-void RenderVectorSource::finishRender(Painter& painter) {
-    tilePyramid.finishRender(painter);
-}
+    enabled = needsRendering;
 
-std::map<UnwrappedTileID, RenderTile>& RenderVectorSource::getRenderTiles() {
-    return tilePyramid.getRenderTiles();
-}
-
-void RenderVectorSource::updateTiles(const TileParameters& parameters) {
     optional<Tileset> tileset = impl().getTileset();
 
     if (!tileset) {
@@ -48,24 +39,37 @@ void RenderVectorSource::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::Vector,
-                            util::tileSize,
-                            tileset->zoomRange,
-                            [&] (const OverscaledTileID& tileID) {
-                                return std::make_unique<VectorTile>(tileID, impl().id, parameters, *tileset);
-                            });
+    tilePyramid.update(layers,
+                       needsRendering,
+                       needsRelayout,
+                       parameters,
+                       SourceType::Vector,
+                       util::tileSize,
+                       tileset->zoomRange,
+                       [&] (const OverscaledTileID& tileID) {
+                           return std::make_unique<VectorTile>(tileID, impl().id, parameters, *tileset);
+                       });
 }
 
-void RenderVectorSource::removeTiles() {
-    tilePyramid.removeTiles();
+void RenderVectorSource::startRender(algorithm::ClipIDGenerator& generator, const mat4& projMatrix, const mat4& clipMatrix, const TransformState& transform) {
+    generator.update(tilePyramid.getRenderTiles());
+    tilePyramid.startRender(projMatrix, clipMatrix, transform);
 }
 
-void RenderVectorSource::reloadTiles() {
-    tilePyramid.reloadTiles();
+void RenderVectorSource::finishRender(Painter& painter) {
+    tilePyramid.finishRender(painter);
+}
+
+std::map<UnwrappedTileID, RenderTile>& RenderVectorSource::getRenderTiles() {
+    return tilePyramid.getRenderTiles();
 }
 
 std::unordered_map<std::string, std::vector<Feature>>
diff --git a/src/mbgl/renderer/sources/render_vector_source.hpp b/src/mbgl/renderer/sources/render_vector_source.hpp
index d67df4ca2c..c1357141a6 100644
--- a/src/mbgl/renderer/sources/render_vector_source.hpp
+++ b/src/mbgl/renderer/sources/render_vector_source.hpp
@@ -12,19 +12,11 @@ public:
 
     bool isLoaded() const final;
 
-    // Called when the camera has changed. May load new tiles, unload obsolete tiles, or
-    // trigger re-placement of existing complete tiles.
-    void updateTiles(const TileParameters&) final;
-
-    // Removes all tiles (by putting them into the cache).
-    void removeTiles() final;
-
-    // Remove all tiles and clear the cache.
-    void invalidateTiles() final;
-
-    // Request that all loaded tiles re-run the layout operation on the existing source
-    // data with fresh style information.
-    void reloadTiles() final;
+    void update(Immutable<style::Source::Impl>,
+                const std::vector<Immutable<style::Layer::Impl>>&,
+                bool needsRendering,
+                bool needsRelayout,
+                const TileParameters&) final;
 
     void startRender(algorithm::ClipIDGenerator&,
                      const mat4& projMatrix,
diff --git a/src/mbgl/renderer/style_diff.cpp b/src/mbgl/renderer/style_diff.cpp
index e2be95432f..e250dfa8d5 100644
--- a/src/mbgl/renderer/style_diff.cpp
+++ b/src/mbgl/renderer/style_diff.cpp
@@ -27,7 +27,7 @@ StyleDifference<T> diff(const std::vector<T>& a, const std::vector<T>& b, const
             bIt++;
         } else {
             if (aIt->get() != bIt->get()) {
-                result.changed.emplace((*bIt)->id, *bIt);
+                result.changed.emplace((*bIt)->id, std::array<T, 2> {{ *aIt, *bIt }});
             }
             aIt++;
             bIt++;
@@ -61,4 +61,13 @@ LayerDifference diffLayers(const std::vector<ImmutableLayer>& a,
     });
 }
 
+bool hasLayoutDifference(const LayerDifference& layerDiff, const std::string& layerID) {
+    if (layerDiff.added.count(layerID))
+        return true;
+    const auto it = layerDiff.changed.find(layerID);
+    if (it == layerDiff.changed.end())
+        return false;
+    return it->second[0]->hasLayoutDifference(*it->second[1]);
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/renderer/style_diff.hpp b/src/mbgl/renderer/style_diff.hpp
index 0ebb1fbfd6..285d1e12ed 100644
--- a/src/mbgl/renderer/style_diff.hpp
+++ b/src/mbgl/renderer/style_diff.hpp
@@ -1,3 +1,5 @@
+#pragma once
+
 #include <mbgl/style/image_impl.hpp>
 #include <mbgl/style/source_impl.hpp>
 #include <mbgl/style/layer_impl.hpp>
@@ -13,7 +15,7 @@ class StyleDifference {
 public:
     std::unordered_map<std::string, T> added;
     std::unordered_map<std::string, T> removed;
-    std::unordered_map<std::string, T> changed;
+    std::unordered_map<std::string, std::array<T, 2>> changed;
 };
 
 using ImmutableImage = Immutable<style::Image::Impl>;
@@ -34,4 +36,6 @@ using LayerDifference = StyleDifference<ImmutableLayer>;
 LayerDifference diffLayers(const std::vector<ImmutableLayer>&,
                            const std::vector<ImmutableLayer>&);
 
+bool hasLayoutDifference(const LayerDifference&, const std::string& layerID);
+
 } // namespace mbgl
diff --git a/src/mbgl/renderer/tile_parameters.hpp b/src/mbgl/renderer/tile_parameters.hpp
index 8f04baaec5..b4a84ec6c8 100644
--- a/src/mbgl/renderer/tile_parameters.hpp
+++ b/src/mbgl/renderer/tile_parameters.hpp
@@ -8,30 +8,11 @@ class TransformState;
 class Scheduler;
 class FileSource;
 class AnnotationManager;
-
-namespace style {
-class Style;
-} // namespace style
+class SpriteAtlas;
+class GlyphAtlas;
 
 class TileParameters {
 public:
-    TileParameters(float pixelRatio_,
-                   MapDebugOptions debugOptions_,
-                   const TransformState& transformState_,
-                   Scheduler& workerScheduler_,
-                   FileSource& fileSource_,
-                   const MapMode mode_,
-                   AnnotationManager& annotationManager_,
-                   style::Style& style_)
-        : pixelRatio(pixelRatio_),
-          debugOptions(debugOptions_),
-          transformState(transformState_),
-          workerScheduler(workerScheduler_),
-          fileSource(fileSource_),
-          mode(mode_),
-          annotationManager(annotationManager_),
-          style(style_) {}
-
     float pixelRatio;
     MapDebugOptions debugOptions;
     const TransformState& transformState;
@@ -39,9 +20,8 @@ public:
     FileSource& fileSource;
     const MapMode mode;
     AnnotationManager& annotationManager;
-
-    // TODO: remove
-    style::Style& style;
+    SpriteAtlas& spriteAtlas;
+    GlyphAtlas& glyphAtlas;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index d55f7938dd..7d9d7c88ca 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -39,12 +39,6 @@ bool TilePyramid::isLoaded() const {
     return true;
 }
 
-void TilePyramid::invalidateTiles() {
-    tiles.clear();
-    renderTiles.clear();
-    cache.clear();
-}
-
 void TilePyramid::startRender(const mat4& projMatrix,
                               const mat4& clipMatrix,
                               const TransformState& transform) {
@@ -67,11 +61,34 @@ std::map<UnwrappedTileID, RenderTile>& TilePyramid::getRenderTiles() {
     return renderTiles;
 }
 
-void TilePyramid::updateTiles(const TileParameters& parameters,
-                              const SourceType type,
-                              const uint16_t tileSize,
-                              const Range<uint8_t> zoomRange,
-                              std::function<std::unique_ptr<Tile> (const OverscaledTileID&)> createTile) {
+void TilePyramid::update(const std::vector<Immutable<style::Layer::Impl>>& layers,
+                         const bool needsRendering,
+                         const bool needsRelayout,
+                         const TileParameters& parameters,
+                         const SourceType type,
+                         const uint16_t tileSize,
+                         const Range<uint8_t> zoomRange,
+                         std::function<std::unique_ptr<Tile> (const OverscaledTileID&)> createTile) {
+    // If we need a relayout, abandon any cached tiles; they're now stale.
+    if (needsRelayout) {
+        cache.clear();
+    }
+
+    // If we're not going to render anything, move our existing tiles into
+    // the cache (if they're not stale) or abandon them, and return.
+    if (!needsRendering) {
+        if (!needsRelayout) {
+            for (auto& entry : tiles) {
+                cache.add(entry.first, std::move(entry.second));
+            }
+        }
+
+        tiles.clear();
+        renderTiles.clear();
+
+        return;
+    }
+
     // Determine the overzooming/underzooming amounts and required tiles.
     int32_t overscaledZoom = util::coveringZoomLevel(parameters.transformState.getZoom(), type, tileSize);
     int32_t tileZoom = overscaledZoom;
@@ -97,6 +114,9 @@ void TilePyramid::updateTiles(const TileParameters& parameters,
     auto retainTileFn = [&](Tile& tile, Resource::Necessity necessity) -> void {
         retain.emplace(tile.id);
         tile.setNecessity(necessity);
+        if (needsRelayout) {
+            tile.setLayers(layers);
+        }
     };
     auto getTileFn = [&](const OverscaledTileID& tileID) -> Tile* {
         auto it = tiles.find(tileID);
@@ -108,6 +128,7 @@ void TilePyramid::updateTiles(const TileParameters& parameters,
             tile = createTile(tileID);
             if (tile) {
                 tile->setObserver(observer);
+                tile->setLayers(layers);
             }
         }
         if (!tile) {
@@ -163,21 +184,6 @@ void TilePyramid::removeStaleTiles(const std::set<OverscaledTileID>& retain) {
     }
 }
 
-void TilePyramid::removeTiles() {
-    renderTiles.clear();
-    if (!tiles.empty()) {
-        removeStaleTiles({});
-    }
-}
-
-void TilePyramid::reloadTiles() {
-    cache.clear();
-
-    for (auto& pair : tiles) {
-        pair.second->redoLayout();
-    }
-}
-
 std::unordered_map<std::string, std::vector<Feature>> TilePyramid::queryRenderedFeatures(const ScreenLineString& geometry,
                                            const TransformState& transformState,
                                            const style::Style& style,
diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp
index a2657c92f2..b99c94d065 100644
--- a/src/mbgl/renderer/tile_pyramid.hpp
+++ b/src/mbgl/renderer/tile_pyramid.hpp
@@ -5,6 +5,7 @@
 #include <mbgl/tile/tile.hpp>
 #include <mbgl/tile/tile_cache.hpp>
 #include <mbgl/style/types.hpp>
+#include <mbgl/style/layer_impl.hpp>
 
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/feature.hpp>
@@ -35,23 +36,14 @@ public:
 
     bool isLoaded() const;
 
-    // Called when the camera has changed. May load new tiles, unload obsolete tiles, or
-    // trigger re-placement of existing complete tiles.
-    void updateTiles(const TileParameters&,
-                     SourceType type,
-                     uint16_t tileSize,
-                     Range<uint8_t> zoomRange,
-                     std::function<std::unique_ptr<Tile> (const OverscaledTileID&)> createTile);
-
-    // Removes all tiles (by putting them into the cache).
-    void removeTiles();
-
-    // Remove all tiles and clear the cache.
-    void invalidateTiles();
-
-    // Request that all loaded tiles re-run the layout operation on the existing source
-    // data with fresh style information.
-    void reloadTiles();
+    void update(const std::vector<Immutable<style::Layer::Impl>>&,
+                bool needsRendering,
+                bool needsRelayout,
+                const TileParameters&,
+                SourceType type,
+                uint16_t tileSize,
+                Range<uint8_t> zoomRange,
+                std::function<std::unique_ptr<Tile> (const OverscaledTileID&)> createTile);
 
     void startRender(const mat4& projMatrix,
                      const mat4& clipMatrix,