5 files changed, 53 insertions, 55 deletions

diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 3a50d957f6..109b6377e1 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -87,21 +87,22 @@ void GeometryTile::setData(std::unique_ptr<const GeometryTileData> data_) {
 }
 
 
-void GeometryTile::setLayers(const std::vector<Immutable<Layer::Impl>>& layers) {
+void GeometryTile::setLayers(const std::vector<Immutable<LayerProperties>>& layers) {
     // Mark the tile as pending again if it was complete before to prevent signaling a complete
     // state despite pending parse operations.
     pending = true;
 
-    std::vector<Immutable<Layer::Impl>> impls;
+    std::vector<Immutable<LayerProperties>> impls;
     impls.reserve(layers.size());
 
     for (const auto& layer : layers) {
         // Skip irrelevant layers.
-        assert(layer->getTypeInfo()->source != LayerTypeInfo::Source::NotRequired);
-        assert(layer->source == sourceID);
-        assert(layer->visibility != VisibilityType::None);
-        if (id.overscaledZ < std::floor(layer->minZoom) ||
-            id.overscaledZ >= std::ceil(layer->maxZoom)) {
+        const auto& layerImpl = *layer->baseImpl;
+        assert(layerImpl.getTypeInfo()->source != LayerTypeInfo::Source::NotRequired);
+        assert(layerImpl.source == sourceID);
+        assert(layerImpl.visibility != VisibilityType::None);
+        if (id.overscaledZ < std::floor(layerImpl.minZoom) ||
+            id.overscaledZ >= std::ceil(layerImpl.maxZoom)) {
             continue;
         }
 
@@ -127,7 +128,7 @@ void GeometryTile::onLayout(LayoutResult result, const uint64_t resultCorrelatio
         pending = false;
     }
     
-    buckets = std::move(result.buckets);
+    layerIdToLayerRenderData = std::move(result.renderData);
     
     latestFeatureIndex = std::move(result.featureIndex);
 
@@ -180,8 +181,8 @@ void GeometryTile::upload(gfx::Context& context) {
         }
     };
 
-    for (auto& entry : buckets) {
-        uploadFn(*entry.second);
+    for (auto& entry : layerIdToLayerRenderData) {
+        uploadFn(*entry.second.bucket);
     }
 
     if (glyphAtlasImage) {
@@ -200,14 +201,21 @@ void GeometryTile::upload(gfx::Context& context) {
 }
 
 Bucket* GeometryTile::getBucket(const Layer::Impl& layer) const {
-    const auto it = buckets.find(layer.id);
-    if (it == buckets.end()) {
+    const LayerRenderData* data = getLayerRenderData(layer);
+    return data ? data->bucket.get() : nullptr; 
+}
+
+const LayerRenderData* GeometryTile::getLayerRenderData(const style::Layer::Impl& layerImpl) const {
+    const auto it = layerIdToLayerRenderData.find(layerImpl.id);
+    if (it == layerIdToLayerRenderData.end()) {
+        return nullptr;
+    }
+    const LayerRenderData& result = it->second;
+    if (result.layerProperties->baseImpl->getTypeInfo() != layerImpl.getTypeInfo()) {
+        // Layer data might be outdated, see issue #12432.
         return nullptr;
     }
-    Bucket* result = it->second.get();
-    assert(result);
-    // Bucket might be outdated, see issue #12432.
-    return result->supportsLayer(layer) ? result : nullptr;
+    return &result;
 }
 
 float GeometryTile::getQueryPadding(const std::vector<const RenderLayer*>& layers) {
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index 53a8910c27..231e71190b 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -33,7 +33,7 @@ public:
     void setError(std::exception_ptr);
     void setData(std::unique_ptr<const GeometryTileData>);
 
-    void setLayers(const std::vector<Immutable<style::Layer::Impl>>&) override;
+    void setLayers(const std::vector<Immutable<style::LayerProperties>>&) override;
     void setShowCollisionBoxes(const bool showCollisionBoxes) override;
 
     void onGlyphsAvailable(GlyphMap) override;
@@ -44,6 +44,7 @@ public:
 
     void upload(gfx::Context&) override;
     Bucket* getBucket(const style::Layer::Impl&) const override;
+    const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const override;
 
     void queryRenderedFeatures(
             std::unordered_map<std::string, std::vector<Feature>>& result,
@@ -63,16 +64,16 @@ public:
 
     class LayoutResult {
     public:
-        std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
+        std::unordered_map<std::string, LayerRenderData> renderData;
         std::unique_ptr<FeatureIndex> featureIndex;
         optional<AlphaImage> glyphAtlasImage;
         ImageAtlas iconAtlas;
 
-        LayoutResult(std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets_,
+        LayoutResult(std::unordered_map<std::string, LayerRenderData> renderData_,
                      std::unique_ptr<FeatureIndex> featureIndex_,
                      optional<AlphaImage> glyphAtlasImage_,
                      ImageAtlas iconAtlas_)
-            : buckets(std::move(buckets_)),
+            : renderData(std::move(renderData_)),
               featureIndex(std::move(featureIndex_)),
               glyphAtlasImage(std::move(glyphAtlasImage_)),
               iconAtlas(std::move(iconAtlas_)) {}
@@ -109,7 +110,7 @@ private:
 
     uint64_t correlationID = 0;
 
-    std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
+    std::unordered_map<std::string, LayerRenderData> layerIdToLayerRenderData;
     
     std::shared_ptr<FeatureIndex> latestFeatureIndex;
 
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index 56f6401ce7..ad9de2c07b 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -139,7 +139,7 @@ void GeometryTileWorker::setData(std::unique_ptr<const GeometryTileData> data_,
     }
 }
 
-void GeometryTileWorker::setLayers(std::vector<Immutable<Layer::Impl>> layers_, uint64_t correlationID_) {
+void GeometryTileWorker::setLayers(std::vector<Immutable<LayerProperties>> layers_, uint64_t correlationID_) {
     try {
         layers = std::move(layers_);
         correlationID = correlationID_;
@@ -312,25 +312,6 @@ void GeometryTileWorker::requestNewImages(const ImageDependencies& imageDependen
     }
 }
 
-static std::vector<Immutable<style::LayerProperties>> toEvaluatedProperties(const std::vector<Immutable<style::Layer::Impl>>& layers, float zoom) {
-    std::vector<Immutable<style::LayerProperties>> result;
-    result.reserve(layers.size());
-    for (auto& layer : layers) {
-        auto renderLayer = LayerManager::get()->createRenderLayer(layer);
-
-        renderLayer->transition(TransitionParameters {
-            Clock::time_point::max(),
-            TransitionOptions()
-        });
-
-        renderLayer->evaluate(PropertyEvaluationParameters {
-            zoom
-        });
-        result.push_back(renderLayer->evaluatedProperties);
-    }
-    return result;
-}
-
 void GeometryTileWorker::parse() {
     if (!data || !layers) {
         return;
@@ -340,7 +321,7 @@ void GeometryTileWorker::parse() {
 
     std::unordered_map<std::string, std::unique_ptr<SymbolLayout>> symbolLayoutMap;
 
-    buckets.clear();
+    renderData.clear();
     layouts.clear();
 
     featureIndex = std::make_unique<FeatureIndex>(*data ? (*data)->clone() : nullptr);
@@ -349,9 +330,8 @@ void GeometryTileWorker::parse() {
     ImageDependencies imageDependencies;
 
     // Create render layers and group by layout
-    std::vector<Immutable<style::LayerProperties>> evaluatedProperties = toEvaluatedProperties(*layers, id.overscaledZ);
     std::unordered_map<std::string, std::vector<Immutable<style::LayerProperties>>> groupMap;
-    for (auto layer : evaluatedProperties) {
+    for (auto layer : *layers) {
         groupMap[layoutKey(*layer->baseImpl)].push_back(std::move(layer));
     }
 
@@ -389,7 +369,7 @@ void GeometryTileWorker::parse() {
             if (layout->hasDependencies()) {
                 layouts.push_back(std::move(layout));
             } else {
-                layout->createBucket({}, featureIndex, buckets, firstLoad, showCollisionBoxes);
+                layout->createBucket({}, featureIndex, renderData, firstLoad, showCollisionBoxes);
             }
         } else {
             const Filter& filter = leaderImpl.filter;
@@ -412,7 +392,7 @@ void GeometryTileWorker::parse() {
             }
 
             for (const auto& layer : group) {
-                buckets.emplace(layer->baseImpl->id, bucket);
+                renderData.emplace(layer->baseImpl->id, LayerRenderData{bucket, layer});
             }
         }
     }
@@ -466,7 +446,7 @@ void GeometryTileWorker::finalizeLayout() {
             }
 
             // layout adds the bucket to buckets
-            layout->createBucket(iconAtlas.patternPositions, featureIndex, buckets, firstLoad, showCollisionBoxes);
+            layout->createBucket(iconAtlas.patternPositions, featureIndex, renderData, firstLoad, showCollisionBoxes);
         }
     }
 
@@ -481,7 +461,7 @@ void GeometryTileWorker::finalizeLayout() {
                        " Time");
 
     parent.invoke(&GeometryTile::onLayout, GeometryTile::LayoutResult {
-        std::move(buckets),
+        std::move(renderData),
         std::move(featureIndex),
         std::move(glyphAtlasImage),
         std::move(iconAtlas)
diff --git a/src/mbgl/tile/geometry_tile_worker.hpp b/src/mbgl/tile/geometry_tile_worker.hpp
index fb841c63be..258f2cd186 100644
--- a/src/mbgl/tile/geometry_tile_worker.hpp
+++ b/src/mbgl/tile/geometry_tile_worker.hpp
@@ -7,9 +7,11 @@
 #include <mbgl/actor/actor_ref.hpp>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/immutable.hpp>
-#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layer_properties.hpp>
 #include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/renderer/bucket.hpp>
+#include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/tile/tile.hpp>
 
 #include <atomic>
 #include <memory>
@@ -36,7 +38,7 @@ public:
                        const bool showCollisionBoxes_);
     ~GeometryTileWorker();
 
-    void setLayers(std::vector<Immutable<style::Layer::Impl>>, uint64_t correlationID);
+    void setLayers(std::vector<Immutable<style::LayerProperties>>, uint64_t correlationID);
     void setData(std::unique_ptr<const GeometryTileData>, uint64_t correlationID);
     void setShowCollisionBoxes(bool showCollisionBoxes_, uint64_t correlationID_);
     
@@ -69,7 +71,7 @@ private:
     const float pixelRatio;
     
     std::unique_ptr<FeatureIndex> featureIndex;
-    std::unordered_map<std::string, std::shared_ptr<Bucket>> buckets;
+    std::unordered_map<std::string, LayerRenderData> renderData;
 
     enum State {
         Idle,
@@ -83,7 +85,7 @@ private:
     uint64_t imageCorrelationID = 0;
 
     // Outer optional indicates whether we've received it or not.
-    optional<std::vector<Immutable<style::Layer::Impl>>> layers;
+    optional<std::vector<Immutable<style::LayerProperties>>> layers;
     optional<std::unique_ptr<const GeometryTileData>> data;
 
     std::vector<std::unique_ptr<Layout>> layouts;
diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp
index 7708aecf17..50fd67bedd 100644
--- a/src/mbgl/tile/tile.hpp
+++ b/src/mbgl/tile/tile.hpp
@@ -11,7 +11,7 @@
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/storage/resource.hpp>
-#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layer_properties.hpp>
 
 #include <string>
 #include <memory>
@@ -21,6 +21,7 @@
 namespace mbgl {
 
 class DebugBucket;
+class LayerRenderData;
 class TransformState;
 class TileObserver;
 class RenderLayer;
@@ -33,13 +34,16 @@ namespace gl {
 class Context;
 } // namespace gl
 
-class Tile : private util::noncopyable {
+
+class Tile {
 public:
     enum class Kind : uint8_t {
         Geometry,
         Raster,
         RasterDEM
     };
+    Tile(const Tile&) = delete;
+    Tile& operator=(const Tile&) = delete;
 
     Tile(Kind, OverscaledTileID);
     virtual ~Tile();
@@ -53,6 +57,9 @@ public:
 
     virtual void upload(gfx::Context&) = 0;
     virtual Bucket* getBucket(const style::Layer::Impl&) const = 0;
+    virtual const LayerRenderData* getLayerRenderData(const style::Layer::Impl&) const {
+        return nullptr;
+    }
 
     template <class T>
     T* getBucket(const style::Layer::Impl& layer) const {
@@ -60,7 +67,7 @@ public:
     }
 
     virtual void setShowCollisionBoxes(const bool) {}
-    virtual void setLayers(const std::vector<Immutable<style::Layer::Impl>>&) {}
+    virtual void setLayers(const std::vector<Immutable<style::LayerProperties>>&) {}
     virtual void setMask(TileMask&&) {}
 
     virtual void queryRenderedFeatures(