5 files changed, 127 insertions, 15 deletions
diff --git a/src/mbgl/renderer/render_tile.cpp b/src/mbgl/renderer/render_tile.cpp
index 74fc945ac1..a0230a6511 100644
--- a/src/mbgl/renderer/render_tile.cpp
+++ b/src/mbgl/renderer/render_tile.cpp
@@ -4,6 +4,7 @@
 #include <mbgl/renderer/buckets/debug_bucket.hpp>
 #include <mbgl/renderer/render_source.hpp>
 #include <mbgl/renderer/render_static_data.hpp>
+#include <mbgl/renderer/tile_render_data.hpp>
 #include <mbgl/programs/programs.hpp>
 #include <mbgl/map/transform_state.hpp>
 #include <mbgl/gfx/cull_face_mode.hpp>
@@ -15,7 +16,8 @@ namespace mbgl {
 
 using namespace style;
 
-RenderTile::RenderTile(UnwrappedTileID id_, Tile& tile_) : id(std::move(id_)), tile(tile_) {
+RenderTile::RenderTile(UnwrappedTileID id_, Tile& tile_) 
+    : id(std::move(id_)), tile(tile_) {
 }
 
 RenderTile::~RenderTile() = default;
@@ -65,32 +67,33 @@ 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);
+    assert(renderData);
+    return renderData->getBucket(impl);
 }
 
 const LayerRenderData* RenderTile::getLayerRenderData(const style::Layer::Impl& impl) const {
-    return tile.getLayerRenderData(impl);
+    assert(renderData);
+    return renderData->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);
+    assert(renderData);
+    return renderData->getPattern(pattern);
 }
 
 const gfx::Texture& RenderTile::getGlyphAtlasTexture() const {
-    assert(tile.kind == Tile::Kind::Geometry);
-    assert(static_cast<const GeometryTile&>(tile).glyphAtlasTexture);
-    return *(static_cast<const GeometryTile&>(tile).glyphAtlasTexture);
+    assert(renderData);
+    return renderData->getGlyphAtlasTexture();
 }
 
 const gfx::Texture& RenderTile::getIconAtlasTexture() const {
-    assert(tile.kind == Tile::Kind::Geometry);
-    assert(static_cast<const GeometryTile&>(tile).iconAtlasTexture);
-    return *(static_cast<const GeometryTile&>(tile).iconAtlasTexture);
+    assert(renderData);
+    return renderData->getIconAtlasTexture();
 }
 
 void RenderTile::upload(gfx::UploadPass& uploadPass) {
-    tile.upload(uploadPass);
+    assert(renderData);
+    renderData->upload(uploadPass);
 
     if (debugBucket) {
         debugBucket->upload(uploadPass);
@@ -98,6 +101,10 @@ void RenderTile::upload(gfx::UploadPass& uploadPass) {
 }
 
 void RenderTile::prepare(const SourcePrepareParameters& parameters) {
+    renderData = tile.createRenderData();
+    assert(renderData);
+    needsRendering = tile.usedByRenderedLayers;
+
     if (parameters.debugOptions != MapDebugOptions::NoDebug &&
         (!debugBucket || debugBucket->renderable != tile.isRenderable() ||
          debugBucket->complete != tile.isComplete() ||
@@ -121,7 +128,7 @@ void RenderTile::prepare(const SourcePrepareParameters& parameters) {
 }
 
 void RenderTile::finishRender(PaintParameters& parameters) {
-    if (!tile.usedByRenderedLayers || parameters.debugOptions == MapDebugOptions::NoDebug)
+    if (!needsRendering || parameters.debugOptions == MapDebugOptions::NoDebug)
         return;
 
     static const style::Properties<>::PossiblyEvaluated properties {};
diff --git a/src/mbgl/renderer/render_tile.hpp b/src/mbgl/renderer/render_tile.hpp
index c863c5970e..a532bf8dd8 100644
--- a/src/mbgl/renderer/render_tile.hpp
+++ b/src/mbgl/renderer/render_tile.hpp
@@ -4,10 +4,9 @@
 #include <mbgl/gfx/texture.hpp>
 #include <mbgl/tile/tile_id.hpp>
 #include <mbgl/util/mat4.hpp>
+#include <mbgl/renderer/image_atlas.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>
 #include <memory>
@@ -26,6 +25,7 @@ class PaintParameters;
 class DebugBucket;
 class SourcePrepareParameters;
 class FeatureIndex;
+class TileRenderData;
 
 class RenderTile final {
 public:
@@ -70,6 +70,9 @@ public:
                             const bool inViewportPixelUnits) const;
 private:
     Tile& tile;
+    // The following members are reset at placement stage.
+    std::unique_ptr<TileRenderData> renderData;
+    bool needsRendering = false;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp
index 2d82603dd5..3af3b92e77 100644
--- a/src/mbgl/renderer/sources/render_tile_source.cpp
+++ b/src/mbgl/renderer/sources/render_tile_source.cpp
@@ -3,6 +3,7 @@
 #include <mbgl/renderer/buckets/debug_bucket.hpp>
 #include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/paint_parameters.hpp>
+#include <mbgl/renderer/tile_render_data.hpp>
 #include <mbgl/tile/vector_tile.hpp>
 
 namespace mbgl {
diff --git a/src/mbgl/renderer/tile_render_data.cpp b/src/mbgl/renderer/tile_render_data.cpp
new file mode 100644
index 0000000000..300e8d8488
--- /dev/null
+++ b/src/mbgl/renderer/tile_render_data.cpp
@@ -0,0 +1,40 @@
+#include <mbgl/renderer/tile_render_data.hpp>
+
+namespace mbgl {
+
+TileRenderData::TileRenderData() = default;
+
+TileRenderData::TileRenderData(std::shared_ptr<TileAtlasTextures> atlasTextures_)
+    : atlasTextures(std::move(atlasTextures_)) {
+}
+
+TileRenderData::~TileRenderData() = default;
+
+const gfx::Texture& TileRenderData::getGlyphAtlasTexture() const {
+    assert(atlasTextures);
+    assert(atlasTextures->glyph);
+    return *atlasTextures->glyph;
+}
+
+const gfx::Texture& TileRenderData::getIconAtlasTexture() const {
+    assert(atlasTextures);
+    assert(atlasTextures->icon);
+    return *atlasTextures->icon;
+}
+
+optional<ImagePosition> TileRenderData::getPattern(const std::string&) const {
+    assert(false);
+    return nullopt;
+}
+
+const LayerRenderData* TileRenderData::getLayerRenderData(const style::Layer::Impl&) const {
+    assert(false);
+    return nullptr;
+}
+
+Bucket* TileRenderData::getBucket(const style::Layer::Impl&) const {
+    assert(false);
+    return nullptr;
+}
+
+} // namespace mbgl
diff --git a/src/mbgl/renderer/tile_render_data.hpp b/src/mbgl/renderer/tile_render_data.hpp
new file mode 100644
index 0000000000..85bbc49565
--- /dev/null
+++ b/src/mbgl/renderer/tile_render_data.hpp
@@ -0,0 +1,61 @@
+#pragma once
+
+#include <mbgl/gfx/texture.hpp>
+#include <mbgl/renderer/image_atlas.hpp>
+#include <mbgl/style/layer_impl.hpp>
+
+#include <memory>
+
+namespace mbgl {
+
+namespace gfx {
+class UploadPass;
+} // namespace gfx
+
+class Bucket;
+class LayerRenderData;
+class SourcePrepareParameters;
+
+class TileAtlasTextures {
+public:    
+    optional<gfx::Texture> glyph;
+    optional<gfx::Texture> icon;
+};
+
+class TileRenderData {
+public:
+    virtual ~TileRenderData();
+    const gfx::Texture& getGlyphAtlasTexture() const;
+    const gfx::Texture& getIconAtlasTexture() const;
+    // To be implemented for concrete tile types.
+    virtual optional<ImagePosition> getPattern(const std::string&) const;
+    virtual const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const;
+    virtual Bucket* getBucket(const style::Layer::Impl&) const;
+    virtual void upload(gfx::UploadPass&) {}
+    virtual void prepare(const SourcePrepareParameters&) {}
+
+protected:
+    TileRenderData();
+    TileRenderData(std::shared_ptr<TileAtlasTextures>);
+    std::shared_ptr<TileAtlasTextures> atlasTextures;
+};
+
+template <typename BucketType>
+class SharedBucketTileRenderData final : public TileRenderData {
+public:
+    SharedBucketTileRenderData(std::shared_ptr<BucketType> bucket_)
+        : bucket(std::move(bucket_)) {}
+
+private:
+    // TileRenderData overrides.
+    Bucket* getBucket(const style::Layer::Impl&) const override {
+        return bucket ? bucket.get() : nullptr;
+    }
+    void upload(gfx::UploadPass& uploadPass) override {
+        if (bucket) bucket->upload(uploadPass);
+    }
+
+    std::shared_ptr<BucketType> bucket;
+};
+
+} // namespace mbgl