[core] RenderTile does not expose Tile

RenderTile and Tile will be split when ochestration movces to a separate thread.

This PR improves encapsulation of Tiles management: now performed within TilePyramid.

34 files changed, 189 insertions, 92 deletions

diff --git a/src/mbgl/annotation/render_annotation_source.cpp b/src/mbgl/annotation/render_annotation_source.cpp
index c90b73dad9..ada6ec5ea9 100644
--- a/src/mbgl/annotation/render_annotation_source.cpp
+++ b/src/mbgl/annotation/render_annotation_source.cpp
@@ -59,6 +59,14 @@ void RenderAnnotationSource::finishRender(PaintParameters& parameters) {
     tilePyramid.finishRender(parameters);
 }
 
+void RenderAnnotationSource::updateFadingTiles() {
+    tilePyramid.updateFadingTiles();
+}
+
+bool RenderAnnotationSource::hasFadingTiles() const {
+    return tilePyramid.hasFadingTiles();
+}
+
 std::vector<std::reference_wrapper<RenderTile>> RenderAnnotationSource::getRenderTiles() {
     return tilePyramid.getRenderTiles();
 }
diff --git a/src/mbgl/annotation/render_annotation_source.hpp b/src/mbgl/annotation/render_annotation_source.hpp
index 8267fea39e..c427da16d5 100644
--- a/src/mbgl/annotation/render_annotation_source.hpp
+++ b/src/mbgl/annotation/render_annotation_source.hpp
@@ -21,6 +21,8 @@ public:
     void upload(gfx::UploadPass&) final;
     void prepare(const SourcePrepareParameters&) final;
     void finishRender(PaintParameters&) final;
+    void updateFadingTiles() final;
+    bool hasFadingTiles() const final;
 
     std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
 
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index b5bbc4b22e..e7496df074 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -58,7 +58,7 @@ void RenderCircleLayer::render(PaintParameters& parameters) {
     }
 
     for (const RenderTile& tile : renderTiles) {
-        const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+        const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) {
             continue;
         }
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index a21f62c6a6..1a2e623dd5 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -115,7 +115,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
         // Draw solid color extrusions
         auto drawTiles = [&](const gfx::StencilMode& stencilMode_, const gfx::ColorMode& colorMode_) {
             for (const RenderTile& tile : renderTiles) {
-                const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+                const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
                 if (!renderData) {
                     continue;
                 }
@@ -160,15 +160,13 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
         const auto fillPatternValue = evaluated.get<FillExtrusionPattern>().constantOr(mbgl::Faded<std::basic_string<char> >{"", ""});
         auto drawTiles = [&](const gfx::StencilMode& stencilMode_, const gfx::ColorMode& colorMode_) {
             for (const RenderTile& tile : renderTiles) {
-                const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+                const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
                 if (!renderData) {
                     continue;
                 }
                 auto& bucket = static_cast<FillExtrusionBucket&>(*renderData->bucket);
-
-                auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
-                optional<ImagePosition> patternPosA = geometryTile.getPattern(fillPatternValue.from);
-                optional<ImagePosition> patternPosB = geometryTile.getPattern(fillPatternValue.to);
+                optional<ImagePosition> patternPosA = tile.getPattern(fillPatternValue.from);
+                optional<ImagePosition> patternPosB = tile.getPattern(fillPatternValue.to);
 
                 draw(
                     parameters.programs.getFillExtrusionLayerPrograms().fillExtrusionPattern,
@@ -181,7 +179,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
                         tile.translatedClipMatrix(evaluated.get<FillExtrusionTranslate>(),
                                                   evaluated.get<FillExtrusionTranslateAnchor>(),
                                                   parameters.state),
-                        geometryTile.iconAtlasTexture->size,
+                        tile.getIconAtlasTexture()->size,
                         crossfade,
                         tile.id,
                         parameters.state,
@@ -193,7 +191,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
                     patternPosA,
                     patternPosB,
                     FillExtrusionPatternProgram::TextureBindings{
-                        textures::image::Value{ geometryTile.iconAtlasTexture->getResource(), gfx::TextureFilterType::Linear },
+                        textures::image::Value{ tile.getIconAtlasTexture()->getResource(), gfx::TextureFilterType::Linear },
                     }
                 );
             }
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 73b6c3d596..64e0f0bba1 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -76,7 +76,7 @@ void RenderFillLayer::render(PaintParameters& parameters) {
     if (unevaluated.get<FillPattern>().isUndefined()) {
         parameters.renderTileClippingMasks(renderTiles);
         for (const RenderTile& tile : renderTiles) {
-            const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+            const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
             if (!renderData) {
                 continue;
             }
@@ -163,7 +163,7 @@ void RenderFillLayer::render(PaintParameters& parameters) {
         parameters.renderTileClippingMasks(renderTiles);
 
         for (const RenderTile& tile : renderTiles) {
-            const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+            const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
             if (!renderData) {
                 continue;
             }
@@ -172,9 +172,8 @@ void RenderFillLayer::render(PaintParameters& parameters) {
             const auto& crossfade = getCrossfade<FillLayerProperties>(renderData->layerProperties);
 
             const auto& fillPatternValue = evaluated.get<FillPattern>().constantOr(Faded<std::basic_string<char>>{"", ""});
-            auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
-            optional<ImagePosition> patternPosA = geometryTile.getPattern(fillPatternValue.from);
-            optional<ImagePosition> patternPosB = geometryTile.getPattern(fillPatternValue.to);
+            optional<ImagePosition> patternPosA = tile.getPattern(fillPatternValue.from);
+            optional<ImagePosition> patternPosB = tile.getPattern(fillPatternValue.to);
 
             auto draw = [&] (auto& programInstance,
                              const auto& drawMode,
@@ -191,7 +190,7 @@ void RenderFillLayer::render(PaintParameters& parameters) {
                                               evaluated.get<FillTranslateAnchor>(),
                                               parameters.state),
                         parameters.backend.getDefaultRenderable().getSize(),
-                        geometryTile.iconAtlasTexture->size,
+                        tile.getIconAtlasTexture()->size,
                         crossfade,
                         tile.id,
                         parameters.state,
@@ -233,7 +232,7 @@ void RenderFillLayer::render(PaintParameters& parameters) {
                      *bucket.triangleIndexBuffer,
                      bucket.triangleSegments,
                      FillPatternProgram::TextureBindings{
-                         textures::image::Value{ geometryTile.iconAtlasTexture->getResource(), gfx::TextureFilterType::Linear },
+                         textures::image::Value{ tile.getIconAtlasTexture()->getResource(), gfx::TextureFilterType::Linear },
                      });
             }
             if (evaluated.get<FillAntialias>() && unevaluated.get<FillOutlineColor>().isUndefined()) {
@@ -243,7 +242,7 @@ void RenderFillLayer::render(PaintParameters& parameters) {
                      *bucket.lineIndexBuffer,
                      bucket.lineSegments,
                      FillOutlinePatternProgram::TextureBindings{
-                         textures::image::Value{ geometryTile.iconAtlasTexture->getResource(), gfx::TextureFilterType::Linear },
+                         textures::image::Value{ tile.getIconAtlasTexture()->getResource(), gfx::TextureFilterType::Linear },
                      });
             }
         }
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 2c071d1fcf..ba6e6b7a26 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -94,7 +94,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters) {
             "heatmap texture", { *renderTexture, Color{ 0.0f, 0.0f, 0.0f, 1.0f }, {}, {} });
 
         for (const RenderTile& tile : renderTiles) {
-            const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+            const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
             if (!renderData) {
                 continue;
             }
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index b271cd478f..b3c01941b9 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -129,11 +129,11 @@ void RenderHillshadeLayer::render(PaintParameters& parameters) {
     matrix::translate(mat, mat, 0, -util::EXTENT, 0);
 
     for (const RenderTile& tile : renderTiles) {
-        auto bucket_ = tile.tile.getBucket<HillshadeBucket>(*baseImpl);
+        auto* bucket_ = tile.getBucket(*baseImpl);
         if (!bucket_) {
             continue;
         }
-        HillshadeBucket& bucket = *bucket_;
+        auto& bucket = static_cast<HillshadeBucket&>(*bucket_);
 
         if (!bucket.hasData()){
             continue;
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 5b98c75a3e..2520386df8 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -61,7 +61,7 @@ bool RenderLineLayer::hasCrossfade() const {
 
 void RenderLineLayer::upload(gfx::UploadPass& uploadPass, UploadParameters& uploadParameters) {
     for (const RenderTile& tile : renderTiles) {
-        const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+        const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) {
             continue;
         }
@@ -77,11 +77,10 @@ void RenderLineLayer::upload(gfx::UploadPass& uploadPass, UploadParameters& uplo
 
         } else if (!unevaluated.get<LinePattern>().isUndefined()) {
             const auto& linePatternValue = evaluated.get<LinePattern>().constantOr(Faded<std::basic_string<char>>{ "", ""});
-            auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
 
             // Ensures that the pattern gets added and uplodated to the atlas.
-            geometryTile.getPattern(linePatternValue.from);
-            geometryTile.getPattern(linePatternValue.to);
+            tile.getPattern(linePatternValue.from);
+            tile.getPattern(linePatternValue.to);
 
         } else if (!unevaluated.get<LineGradient>().getValue().isUndefined()) {
             if (!colorRampTexture) {
@@ -99,7 +98,7 @@ void RenderLineLayer::render(PaintParameters& parameters) {
     parameters.renderTileClippingMasks(renderTiles);
 
     for (const RenderTile& tile : renderTiles) {
-        const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+        const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) {
             continue;
         }
@@ -171,11 +170,10 @@ void RenderLineLayer::render(PaintParameters& parameters) {
 
         } else if (!unevaluated.get<LinePattern>().isUndefined()) {
             const auto& linePatternValue = evaluated.get<LinePattern>().constantOr(Faded<std::basic_string<char>>{ "", ""});
-            auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
-            const Size texsize = geometryTile.iconAtlasTexture->size;
+            const Size& texsize = tile.getIconAtlasTexture()->size;
 
-            optional<ImagePosition> posA = geometryTile.getPattern(linePatternValue.from);
-            optional<ImagePosition> posB = geometryTile.getPattern(linePatternValue.to);
+            optional<ImagePosition> posA = tile.getPattern(linePatternValue.from);
+            optional<ImagePosition> posB = tile.getPattern(linePatternValue.to);
 
             draw(parameters.programs.getLineLayerPrograms().linePattern,
                  LinePatternProgram::layoutUniformValues(
@@ -189,7 +187,7 @@ void RenderLineLayer::render(PaintParameters& parameters) {
                      posA,
                      posB,
                      LinePatternProgram::TextureBindings{
-                         textures::image::Value{ geometryTile.iconAtlasTexture->getResource(), gfx::TextureFilterType::Linear },
+                         textures::image::Value{ tile.getIconAtlasTexture()->getResource(), gfx::TextureFilterType::Linear },
                      });
         } else if (!unevaluated.get<LineGradient>().getValue().isUndefined()) {
             assert(colorRampTexture);
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index ade5cbb4e1..af9022189a 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -159,11 +159,11 @@ void RenderRasterLayer::render(PaintParameters& parameters) {
         }
     } else {
         for (const RenderTile& tile : renderTiles) {
-            auto bucket_ = tile.tile.getBucket<RasterBucket>(*baseImpl);
+            auto* bucket_ = tile.getBucket(*baseImpl);
             if (!bucket_) {
                 continue;
             }
-            RasterBucket& bucket = *bucket_;
+            auto& bucket = static_cast<RasterBucket&>(*bucket_);
 
             if (!bucket.hasData())
                 continue;
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index dc67dea7e3..235f0dfdfb 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -111,8 +111,6 @@ void drawIcon(const DrawFn& draw,
               SegmentsWrapper iconSegments,
               const SymbolBucket::PaintProperties& bucketPaintProperties,
               const PaintParameters& parameters) {
-    assert(tile.tile.kind == Tile::Kind::Geometry);
-    auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
     auto& bucket = static_cast<SymbolBucket&>(*renderData.bucket);
     const auto& evaluated = getEvaluated<SymbolLayerProperties>(renderData.layerProperties);
     const auto& layout = bucket.layout;
@@ -125,14 +123,14 @@ void drawIcon(const DrawFn& draw,
     const bool iconScaled = layout.get<IconSize>().constantOr(1.0) != 1.0 || bucket.iconsNeedLinear;
     const bool iconTransformed = values.rotationAlignment == AlignmentType::Map || parameters.state.getPitch() != 0;
 
-    const gfx::TextureBinding textureBinding{ geometryTile.iconAtlasTexture->getResource(),
+    const gfx::TextureBinding textureBinding{ tile.getIconAtlasTexture()->getResource(),
                                             bucket.sdfIcons ||
                                                     parameters.state.isChanging() ||
                                                     iconScaled || iconTransformed
                                                 ? gfx::TextureFilterType::Linear
                                                 : gfx::TextureFilterType::Nearest };
 
-    const Size iconSize = geometryTile.iconAtlasTexture->size;
+    const Size& iconSize = tile.getIconAtlasTexture()->size;
 
     if (bucket.sdfIcons) {
         if (values.hasHalo) {
@@ -187,13 +185,11 @@ void drawText(const DrawFn& draw,
               SegmentsWrapper textSegments,
               const SymbolBucket::PaintProperties& bucketPaintProperties,
               const PaintParameters& parameters) {
-    assert(tile.tile.kind == Tile::Kind::Geometry);
-    auto& geometryTile = static_cast<GeometryTile&>(tile.tile);
     auto& bucket = static_cast<SymbolBucket&>(*renderData.bucket);
     const auto& evaluated = getEvaluated<SymbolLayerProperties>(renderData.layerProperties);
     const auto& layout = bucket.layout;
 
-    const gfx::TextureBinding textureBinding{ geometryTile.glyphAtlasTexture->getResource(),
+    const gfx::TextureBinding textureBinding{ tile.getGlyphAtlasTexture()->getResource(),
                                               gfx::TextureFilterType::Linear };
 
     auto values = textPropertyValues(evaluated, layout);
@@ -202,7 +198,7 @@ void drawText(const DrawFn& draw,
     const bool alongLine = layout.get<SymbolPlacement>() != SymbolPlacementType::Point &&
         layout.get<TextRotationAlignment>() == AlignmentType::Map;
 
-    const Size texsize = geometryTile.glyphAtlasTexture->size;
+    const Size& texsize = tile.getGlyphAtlasTexture()->size;
 
     if (values.hasHalo) {
         draw(parameters.programs.getSymbolLayerPrograms().symbolGlyph,
@@ -363,7 +359,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
     };
 
     for (const RenderTile& tile : renderTiles) {
-        const LayerRenderData* renderData = tile.tile.getLayerRenderData(*baseImpl);
+        const LayerRenderData* renderData = tile.getLayerRenderData(*baseImpl);
         if (!renderData) {
             continue;
         }
@@ -399,7 +395,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
             static const CollisionBoxProgram::Binders paintAttributeData(properties, 0);
 
             auto pixelRatio = tile.id.pixelsToTileUnits(1, parameters.state.getZoom());
-            const float scale = std::pow(2, parameters.state.getZoom() - tile.tile.id.overscaledZ);
+            const float scale = std::pow(2, parameters.state.getZoom() - tile.getOverscaledTileID().overscaledZ);
             std::array<float,2> extrudeScale =
                 {{
                     parameters.pixelsToGLUnits[0] / (pixelRatio * scale),
@@ -435,7 +431,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
             static const CollisionBoxProgram::Binders paintAttributeData(properties, 0);
 
             auto pixelRatio = tile.id.pixelsToTileUnits(1, parameters.state.getZoom());
-            const float scale = std::pow(2, parameters.state.getZoom() - tile.tile.id.overscaledZ);
+            const float scale = std::pow(2, parameters.state.getZoom() - tile.getOverscaledTileID().overscaledZ);
             std::array<float,2> extrudeScale =
                 {{
                     parameters.pixelsToGLUnits[0] / (pixelRatio * scale),
@@ -453,7 +449,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
                 CollisionCircleProgram::LayoutUniformValues {
                     uniforms::matrix::Value( tile.matrix ),
                     uniforms::extrude_scale::Value( extrudeScale ),
-                    uniforms::overscale_factor::Value( float(tile.tile.id.overscaleFactor()) ),
+                    uniforms::overscale_factor::Value( float(tile.getOverscaledTileID().overscaleFactor()) ),
                     uniforms::camera_to_center_distance::Value( parameters.state.getCameraToCenterDistance() )
                 },
                 *bucket.collisionCircle.vertexBuffer,
@@ -523,7 +519,7 @@ void RenderSymbolLayer::prepare(const LayerPrepareParameters& params) {
 
     placementData.clear();
     for (RenderTile& renderTile : renderTiles) {
-        auto bucket = renderTile.tile.getBucket<SymbolBucket>(*baseImpl);
+        auto* bucket = static_cast<SymbolBucket*>(renderTile.getBucket(*baseImpl));
         if (bucket && bucket->bucketLeaderID == getID()) {
             auto& layout = bucket->layout;
             bool pitchWithMap = layout.get<style::TextPitchAlignment>() == style::AlignmentType::Map;
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index c4e7c9bf05..b3da821bb9 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -57,13 +57,11 @@ optional<Color> RenderLayer::getSolidBackground() const {
 RenderLayer::RenderTiles RenderLayer::filterRenderTiles(RenderTiles tiles) const {
     RenderTiles filtered;
 
-    for (auto& tileRef : tiles) {
-        auto& tile = tileRef.get().tile;
-        assert(tile.isRenderable());
+    for (RenderTile& tile : tiles) {
         if (tile.holdForFade()) {
             continue;
         }
-        filtered.emplace_back(tileRef);
+        filtered.emplace_back(tile);
     }
     return filtered;
 }
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index cea45cfaca..599c25b920 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -71,7 +71,8 @@ public:
     virtual void upload(gfx::UploadPass&) = 0;
     virtual void prepare(const SourcePrepareParameters&) = 0;
     virtual void finishRender(PaintParameters&) = 0;
-
+    virtual void updateFadingTiles() = 0;
+    virtual bool hasFadingTiles() const = 0;
     // Returns a list of RenderTiles, sorted by tile id.
     virtual std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() = 0;
 
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index 3a2c2de5e3..a640a96776 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -8,6 +8,7 @@
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
 #include <mbgl/tile/tile.hpp>
+#include <mbgl/tile/geometry_tile.hpp>
 #include <mbgl/util/math.hpp>
 
 namespace mbgl {
@@ -60,6 +61,37 @@ mat4 RenderTile::translatedClipMatrix(const std::array<float, 2>& translation,
     return translateVtxMatrix(nearClippedMatrix, translation, anchor, state, false);
 }
 
+const OverscaledTileID& RenderTile::getOverscaledTileID() const { return tile.id; }
+bool RenderTile::holdForFade() const { return tile.holdForFade(); }
+
+Bucket* RenderTile::getBucket(const style::Layer::Impl& impl) const {
+    return tile.getBucket(impl);
+}
+
+const LayerRenderData* RenderTile::getLayerRenderData(const style::Layer::Impl& impl) const {
+    return tile.getLayerRenderData(impl);
+}
+
+optional<ImagePosition> RenderTile::getPattern(const std::string& pattern) const {
+    assert(tile.kind == Tile::Kind::Geometry);
+    return static_cast<const GeometryTile&>(tile).getPattern(pattern);
+}
+
+const optional<gfx::Texture>& RenderTile::getGlyphAtlasTexture() const {
+    assert(tile.kind == Tile::Kind::Geometry);
+    return static_cast<const GeometryTile&>(tile).glyphAtlasTexture;
+}
+
+const optional<gfx::Texture>& RenderTile::getIconAtlasTexture() const {
+    assert(tile.kind == Tile::Kind::Geometry);
+    return static_cast<const GeometryTile&>(tile).iconAtlasTexture;
+}
+
+std::shared_ptr<FeatureIndex> RenderTile::getFeatureIndex() const {
+    assert(tile.kind == Tile::Kind::Geometry);
+    return static_cast<const GeometryTile&>(tile).getFeatureIndex();
+}
+
 void RenderTile::setMask(TileMask&& mask) {
     tile.setMask(std::move(mask));
 }
diff --git a/src/mbgl/renderer/render_tile.hpp b/src/mbgl/renderer/render_tile.hpp
index 552a093ab7..aaeef88db0 100644
--- a/src/mbgl/renderer/render_tile.hpp
+++ b/src/mbgl/renderer/render_tile.hpp
@@ -1,9 +1,12 @@
 #pragma once
 
 #include <mbgl/map/mode.hpp>
+#include <mbgl/gfx/texture.hpp>
 #include <mbgl/tile/tile_id.hpp>
 #include <mbgl/util/mat4.hpp>
+#include <mbgl/style/layer_impl.hpp>
 #include <mbgl/style/types.hpp>
+#include <mbgl/renderer/image_atlas.hpp>
 #include <mbgl/renderer/tile_mask.hpp>
 
 #include <array>
@@ -15,11 +18,14 @@ namespace gfx {
 class UploadPass;
 } // namespace gfx
 
+class Bucket;
+class LayerRenderData;
 class Tile;
 class TransformState;
 class PaintParameters;
 class DebugBucket;
 class SourcePrepareParameters;
+class FeatureIndex;
 
 class RenderTile final {
 public:
@@ -31,7 +37,6 @@ public:
     RenderTile& operator=(RenderTile&&) = default;
 
     UnwrappedTileID id;
-    Tile& tile;
     mat4 matrix;
     mat4 nearClippedMatrix;
     bool used = false;
@@ -46,6 +51,16 @@ public:
                               style::TranslateAnchorType anchor,
                               const TransformState&) const;
 
+    const OverscaledTileID& getOverscaledTileID() const;
+    bool holdForFade() const;
+
+    Bucket* getBucket(const style::Layer::Impl&) const;
+    const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const;
+    optional<ImagePosition> getPattern(const std::string& pattern) const;
+    const optional<gfx::Texture>& getGlyphAtlasTexture() const;
+    const optional<gfx::Texture>& getIconAtlasTexture() const;
+    std::shared_ptr<FeatureIndex> getFeatureIndex() const;
+
     void setMask(TileMask&&);
     void upload(gfx::UploadPass&);
     void prepare(const SourcePrepareParameters&);
@@ -56,6 +71,9 @@ public:
                             style::TranslateAnchorType anchor,
                             const TransformState& state,
                             const bool inViewportPixelUnits) const;
+private:
+    friend class TilePyramid;
+    Tile& tile;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index a809fd843a..483b534b5a 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -340,7 +340,9 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         if (placementChanged) {
             placement->commit(updateParameters.timePoint);
             crossTileSymbolIndex.pruneUnusedLayers(usedSymbolLayers);
-            updateFadingTiles();
+            for (const auto& entry : renderSources) {
+                entry.second->updateFadingTiles();
+            }
         } else {
             placement->setStale();
         }
@@ -699,25 +701,14 @@ bool Renderer::Impl::hasTransitions(TimePoint timePoint) const {
     if (placement->hasTransitions(timePoint)) {
         return true;
     }
-    
-    if (fadingTiles) {
-        return true;
-    }
-
-    return false;
-}
 
-void Renderer::Impl::updateFadingTiles() {
-    fadingTiles = false;
-    for (auto& source : renderSources) {
-        for (auto& renderTile : source.second->getRenderTiles()) {
-            Tile& tile = renderTile.get().tile;
-            if (tile.holdForFade()) {
-                fadingTiles = true;
-                tile.performedFadePlacement();
-            }
+    for (const auto& entry : renderSources) {
+        if (entry.second->hasFadingTiles()) {
+            return true;
         }
     }
+
+    return false;
 }
 
 bool Renderer::Impl::isLoaded() const {
diff --git a/src/mbgl/renderer/renderer_impl.hpp b/src/mbgl/renderer/renderer_impl.hpp
index 84191b85a6..7bcbdbbf7c 100644
--- a/src/mbgl/renderer/renderer_impl.hpp
+++ b/src/mbgl/renderer/renderer_impl.hpp
@@ -93,8 +93,6 @@ private:
     void onStyleImageMissing(const std::string&, std::function<void()>) override;
     void onRemoveUnusedStyleImages(const std::vector<std::string>&) final;
 
-    void updateFadingTiles();
-
     friend class Renderer;
 
     gfx::RendererBackend& backend;
@@ -132,7 +130,6 @@ private:
     std::unique_ptr<Placement> placement;
 
     bool contextLost = false;
-    bool fadingTiles = false;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
index 9746d84599..d0b8a70d8e 100644
--- a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
@@ -59,6 +59,14 @@ void RenderCustomGeometrySource::finishRender(PaintParameters& parameters) {
     tilePyramid.finishRender(parameters);
 }
 
+void RenderCustomGeometrySource::updateFadingTiles() {
+    tilePyramid.updateFadingTiles();
+}
+
+bool RenderCustomGeometrySource::hasFadingTiles() const {
+    return tilePyramid.hasFadingTiles();
+}
+
 std::vector<std::reference_wrapper<RenderTile>> RenderCustomGeometrySource::getRenderTiles() {
     return tilePyramid.getRenderTiles();
 }
diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
index aac6fe221b..b461d92e8b 100644
--- a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
@@ -21,6 +21,8 @@ public:
     void upload(gfx::UploadPass&) final;
     void prepare(const SourcePrepareParameters&) final;
     void finishRender(PaintParameters&) final;
+    void updateFadingTiles() final;
+    bool hasFadingTiles() const final;
 
     std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
 
diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp
index c43b44934e..44d3a3a2bb 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.cpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.cpp
@@ -135,6 +135,14 @@ void RenderGeoJSONSource::finishRender(PaintParameters& parameters) {
     tilePyramid.finishRender(parameters);
 }
 
+void RenderGeoJSONSource::updateFadingTiles() {
+    tilePyramid.updateFadingTiles();
+}
+
+bool RenderGeoJSONSource::hasFadingTiles() const {
+    return tilePyramid.hasFadingTiles();
+}
+
 std::vector<std::reference_wrapper<RenderTile>> RenderGeoJSONSource::getRenderTiles() {
     return tilePyramid.getRenderTiles();
 }
diff --git a/src/mbgl/renderer/sources/render_geojson_source.hpp b/src/mbgl/renderer/sources/render_geojson_source.hpp
index f2b0014ac4..1ebeb045d8 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.hpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.hpp
@@ -26,6 +26,8 @@ public:
     void upload(gfx::UploadPass&) final;
     void prepare(const SourcePrepareParameters&) final;
     void finishRender(PaintParameters&) final;
+    void updateFadingTiles() final;
+    bool hasFadingTiles() const final;
 
     std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
 
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index 07c3005dbc..f1d3a86db1 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -24,6 +24,8 @@ public:
     void upload(gfx::UploadPass&) final;
     void prepare(const SourcePrepareParameters&) final;
     void finishRender(PaintParameters&) final;
+    void updateFadingTiles() final {}
+    bool hasFadingTiles() const final { return false; }
 
     void update(Immutable<style::Source::Impl>,
                 const std::vector<Immutable<style::LayerProperties>>&,
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.cpp b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
index 9962e26337..afe8e060b2 100644
--- a/src/mbgl/renderer/sources/render_raster_dem_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
@@ -139,6 +139,14 @@ void RenderRasterDEMSource::finishRender(PaintParameters& parameters) {
     tilePyramid.finishRender(parameters);
 }
 
+void RenderRasterDEMSource::updateFadingTiles() {
+    tilePyramid.updateFadingTiles();
+}
+
+bool RenderRasterDEMSource::hasFadingTiles() const {
+    return tilePyramid.hasFadingTiles();
+}
+
 std::vector<std::reference_wrapper<RenderTile>> RenderRasterDEMSource::getRenderTiles() {
     return tilePyramid.getRenderTiles();
 }
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.hpp b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
index 712f4fefaa..9167fd1114 100644
--- a/src/mbgl/renderer/sources/render_raster_dem_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
@@ -21,6 +21,8 @@ public:
     void upload(gfx::UploadPass&) final;
     void prepare(const SourcePrepareParameters&) final;
     void finishRender(PaintParameters&) final;
+    void updateFadingTiles() final;
+    bool hasFadingTiles() const final;
 
     std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
 
diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index d7dec8ff17..db410a4e5c 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -70,6 +70,14 @@ void RenderRasterSource::finishRender(PaintParameters& parameters) {
     tilePyramid.finishRender(parameters);
 }
 
+void RenderRasterSource::updateFadingTiles() {
+    tilePyramid.updateFadingTiles();
+}
+
+bool RenderRasterSource::hasFadingTiles() const {
+    return tilePyramid.hasFadingTiles();
+}
+
 std::vector<std::reference_wrapper<RenderTile>> RenderRasterSource::getRenderTiles() {
     return tilePyramid.getRenderTiles();
 }
diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp
index 74f81a1397..bc3bc53d35 100644
--- a/src/mbgl/renderer/sources/render_raster_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_source.hpp
@@ -21,6 +21,8 @@ public:
     void upload(gfx::UploadPass&) final;
     void prepare(const SourcePrepareParameters&) final;
     void finishRender(PaintParameters&) final;
+    void updateFadingTiles() final;
+    bool hasFadingTiles() const final;
 
     std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
 
diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp
index 36fc69d988..0d5eb5c89f 100644
--- a/src/mbgl/renderer/sources/render_vector_source.cpp
+++ b/src/mbgl/renderer/sources/render_vector_source.cpp
@@ -69,6 +69,14 @@ void RenderVectorSource::finishRender(PaintParameters& parameters) {
     tilePyramid.finishRender(parameters);
 }
 
+void RenderVectorSource::updateFadingTiles() {
+    tilePyramid.updateFadingTiles();
+}
+
+bool RenderVectorSource::hasFadingTiles() const {
+    return tilePyramid.hasFadingTiles();
+}
+
 std::vector<std::reference_wrapper<RenderTile>> RenderVectorSource::getRenderTiles() {
     return tilePyramid.getRenderTiles();
 }
diff --git a/src/mbgl/renderer/sources/render_vector_source.hpp b/src/mbgl/renderer/sources/render_vector_source.hpp
index fd37e1e4fd..2eb33df91b 100644
--- a/src/mbgl/renderer/sources/render_vector_source.hpp
+++ b/src/mbgl/renderer/sources/render_vector_source.hpp
@@ -21,6 +21,8 @@ public:
     void upload(gfx::UploadPass&) final;
     void prepare(const SourcePrepareParameters&) final;
     void finishRender(PaintParameters&) final;
+    void updateFadingTiles() final;
+    bool hasFadingTiles() const final;
 
     std::vector<std::reference_wrapper<RenderTile>> getRenderTiles() final;
 
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index 51999c0aac..4f095ed97d 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -242,12 +242,15 @@ void TilePyramid::update(const std::vector<Immutable<style::LayerProperties>>& l
         pair.second->setShowCollisionBoxes(parameters.debugOptions & MapDebugOptions::Collision);
     }
 
+    fadingTiles = false;
+
     // Initialize render tiles fields and update the tile contained layer render data.
     for (RenderTile& renderTile : renderTiles) {
         Tile& tile = renderTile.tile;
         assert(tile.isRenderable());
 
         const bool holdForFade = tile.holdForFade();
+        fadingTiles = (fadingTiles || holdForFade);
         for (const auto& layerProperties : layers) {
             const auto* typeInfo = layerProperties->baseImpl->getTypeInfo();
             if (holdForFade && typeInfo->fadingTiles == LayerTypeInfo::FadingTiles::NotRequired) {
@@ -401,4 +404,13 @@ void TilePyramid::addRenderTile(const UnwrappedTileID& tileID, Tile& tile) {
     renderTiles.emplace(it, tileID, tile);
 }
 
+void TilePyramid::updateFadingTiles() {
+    for (auto& renderTile : renderTiles) {
+        Tile& tile = renderTile.tile;
+        if (tile.holdForFade()) {
+            tile.performedFadePlacement();
+        }
+    }
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp
index 5dbdae5d38..5f5492ede4 100644
--- a/src/mbgl/renderer/tile_pyramid.hpp
+++ b/src/mbgl/renderer/tile_pyramid.hpp
@@ -71,6 +71,9 @@ public:
     const std::map<OverscaledTileID, std::unique_ptr<Tile>>& getTiles() const { return tiles; }
     void clearAll();
 
+    void updateFadingTiles();
+    bool hasFadingTiles() const { return fadingTiles; }
+
 private:
     void addRenderTile(const UnwrappedTileID& tileID, Tile& tile);
 
@@ -82,6 +85,8 @@ private:
     TileObserver* observer = nullptr;
 
     float prevLng = 0;
+
+    bool fadingTiles = false;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/text/cross_tile_symbol_index.cpp b/src/mbgl/text/cross_tile_symbol_index.cpp
index 2ddb209878..b92bab861f 100644
--- a/src/mbgl/text/cross_tile_symbol_index.cpp
+++ b/src/mbgl/text/cross_tile_symbol_index.cpp
@@ -174,7 +174,7 @@ bool CrossTileSymbolIndex::addLayer(const RenderLayer& layer, float lng) {
     for (const auto& item : layer.getPlacementData()) {
         RenderTile& renderTile = item.tile;
         Bucket& bucket = item.bucket;
-        auto result = bucket.registerAtCrossTileIndex(layerIndex, renderTile.tile.id, maxCrossTileID);
+        auto result = bucket.registerAtCrossTileIndex(layerIndex, renderTile.getOverscaledTileID(), maxCrossTileID);
         assert(result.first != 0u);
         symbolBucketsChanged = symbolBucketsChanged || result.second;
         currentBucketIDs.insert(result.first);
diff --git a/src/mbgl/text/placement.cpp b/src/mbgl/text/placement.cpp
index 8dbb7fe346..dfe663a8a2 100644
--- a/src/mbgl/text/placement.cpp
+++ b/src/mbgl/text/placement.cpp
@@ -77,14 +77,12 @@ void Placement::placeLayer(const RenderLayer& layer, const mat4& projMatrix, boo
 
     for (const auto& item : layer.getPlacementData()) {
         RenderTile& renderTile = item.tile;
-        assert(renderTile.tile.kind == Tile::Kind::Geometry);
-        auto& geometryTile = static_cast<GeometryTile&>(renderTile.tile);
         Bucket& bucket = item.bucket;
 
         const float pixelsToTileUnits = renderTile.id.pixelsToTileUnits(1, state.getZoom());
-
-        const float scale = std::pow(2, state.getZoom() - geometryTile.id.overscaledZ);
-        const float textPixelRatio = (util::tileSize * geometryTile.id.overscaleFactor()) / util::EXTENT;
+        const OverscaledTileID& overscaledID = renderTile.getOverscaledTileID();
+        const float scale = std::pow(2, state.getZoom() - overscaledID.overscaledZ);
+        const float textPixelRatio = (util::tileSize * overscaledID.overscaleFactor()) / util::EXTENT;
 
         mat4 posMatrix;
         state.matrixFor(posMatrix, renderTile.id);
@@ -102,7 +100,7 @@ void Placement::placeLayer(const RenderLayer& layer, const mat4& projMatrix, boo
                 state,
                 pixelsToTileUnits);
 
-        const auto& collisionGroup = collisionGroups.get(geometryTile.sourceID);
+        const auto& collisionGroup = collisionGroups.get(layer.baseImpl->source);
         BucketPlacementParameters params{
                 posMatrix,
                 textLabelPlaneMatrix,
@@ -110,7 +108,7 @@ void Placement::placeLayer(const RenderLayer& layer, const mat4& projMatrix, boo
                 scale,
                 textPixelRatio,
                 showCollisionBoxes,
-                renderTile.tile.holdForFade(),
+                renderTile.holdForFade(),
                 collisionGroup};
         auto bucketInstanceId = bucket.place(*this, params, seenCrossTileIDs);
         assert(bucketInstanceId != 0u);
@@ -119,9 +117,7 @@ void Placement::placeLayer(const RenderLayer& layer, const mat4& projMatrix, boo
         // matching FeatureIndex/data for querying purposes
         retainedQueryData.emplace(std::piecewise_construct,
                                   std::forward_as_tuple(bucketInstanceId),
-                                  std::forward_as_tuple(bucketInstanceId, geometryTile.getFeatureIndex(), geometryTile.id));
-        
-
+                                  std::forward_as_tuple(bucketInstanceId, renderTile.getFeatureIndex(), overscaledID));
     }
 }
 
@@ -439,7 +435,7 @@ void Placement::updateBucketDynamicVertices(SymbolBucket& bucket, const RenderTi
         bucket.hasVariablePlacement = false;
 
         const auto partiallyEvaluatedSize = bucket.textSizeBinder->evaluateForZoom(state.getZoom());
-        const float tileScale = std::pow(2, state.getZoom() - tile.tile.id.overscaledZ);
+        const float tileScale = std::pow(2, state.getZoom() - tile.getOverscaledTileID().overscaledZ);
         const bool rotateWithMap = layout.get<TextRotationAlignment>() == AlignmentType::Map;
         const bool pitchWithMap = layout.get<TextPitchAlignment>() == AlignmentType::Map;
         const float pixelsToTileUnits = tile.id.pixelsToTileUnits(1.0, state.getZoom());
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 46ab9e713b..7a7b7cb770 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -168,12 +168,12 @@ void GeometryTile::getImages(ImageRequestPair pair) {
     imageManager.getImages(*this, std::move(pair));
 }
 
-const optional<ImagePosition> GeometryTile::getPattern(const std::string& pattern) {
+const optional<ImagePosition> GeometryTile::getPattern(const std::string& pattern) const {
     auto it = iconAtlas.patternPositions.find(pattern);
     if (it !=  iconAtlas.patternPositions.end()) {
         return it->second;
     }
-    return {};
+    return nullopt;
 }
 
 void GeometryTile::upload(gfx::UploadPass& uploadPass) {
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index c7a0d76363..768948a82d 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -87,7 +87,7 @@ public:
     void markRenderedIdeal() override;
     void markRenderedPreviously() override;
     void performedFadePlacement() override;
-    const optional<ImagePosition> getPattern(const std::string& pattern);
+    const optional<ImagePosition> getPattern(const std::string& pattern) const;
     const std::shared_ptr<FeatureIndex> getFeatureIndex() const { return latestFeatureIndex; }
     
     const std::string sourceID;
diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp
index e98d192efd..1bb38f5c96 100644
--- a/src/mbgl/tile/tile.hpp
+++ b/src/mbgl/tile/tile.hpp
@@ -62,12 +62,6 @@ public:
     // Returns `true` if the corresponding render layer data is present in this tile (and i.e. it
     // was succesfully updated); returns `false` otherwise.
     virtual bool updateLayerProperties(const Immutable<style::LayerProperties>&) { return true; }
-
-    template <class T>
-    T* getBucket(const style::Layer::Impl& layer) const {
-        return static_cast<T*>(getBucket(layer));
-    }
-
     virtual void setShowCollisionBoxes(const bool) {}
     virtual void setLayers(const std::vector<Immutable<style::LayerProperties>>&) {}
     virtual void setMask(TileMask&&) {}