[core] Introduce `LayerRenderData`. Source::update() accepts layer properties.

39 files changed, 122 insertions, 113 deletions

diff --git a/src/mbgl/annotation/render_annotation_source.cpp b/src/mbgl/annotation/render_annotation_source.cpp
index d83f4d0fa4..ff6e6e34b7 100644
--- a/src/mbgl/annotation/render_annotation_source.cpp
+++ b/src/mbgl/annotation/render_annotation_source.cpp
@@ -27,7 +27,7 @@ bool RenderAnnotationSource::isLoaded() const {
 }
 
 void RenderAnnotationSource::update(Immutable<style::Source::Impl> baseImpl_,
-                                    const std::vector<Immutable<Layer::Impl>>& layers,
+                                    const std::vector<Immutable<style::LayerProperties>>& layers,
                                     const bool needsRendering,
                                     const bool needsRelayout,
                                     const TileParameters& parameters) {
diff --git a/src/mbgl/annotation/render_annotation_source.hpp b/src/mbgl/annotation/render_annotation_source.hpp
index da87d13814..0d08d0af99 100644
--- a/src/mbgl/annotation/render_annotation_source.hpp
+++ b/src/mbgl/annotation/render_annotation_source.hpp
@@ -13,7 +13,7 @@ public:
     bool isLoaded() const final;
 
     void update(Immutable<style::Source::Impl>,
-                const std::vector<Immutable<style::Layer::Impl>>&,
+                const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&) final;
diff --git a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
index bc1647afa4..6ffbcaadae 100644
--- a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
@@ -28,7 +28,7 @@ std::unique_ptr<Layout> FillExtrusionLayerFactory::createLayout(const LayoutPara
                                                                 std::unique_ptr<GeometryTileLayer> layer,
                                                                 const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
     using namespace style;
-    using LayoutType = PatternLayout<FillExtrusionBucket, FillExtrusionLayerProperties, FillExtrusionPattern, FillExtrusionPaintProperties::PossiblyEvaluated>;
+    using LayoutType = PatternLayout<FillExtrusionBucket, FillExtrusionLayerProperties, FillExtrusionPattern>;
     return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
 }
 
diff --git a/src/mbgl/layermanager/fill_layer_factory.cpp b/src/mbgl/layermanager/fill_layer_factory.cpp
index f9b59359c5..32779f2deb 100644
--- a/src/mbgl/layermanager/fill_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_layer_factory.cpp
@@ -29,7 +29,7 @@ FillLayerFactory::createLayout(const LayoutParameters& parameters,
                                std::unique_ptr<GeometryTileLayer> layer,
                                const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
     using namespace style;
-    using LayoutType = PatternLayout<FillBucket, FillLayerProperties, FillPattern, FillPaintProperties::PossiblyEvaluated>;
+    using LayoutType = PatternLayout<FillBucket, FillLayerProperties, FillPattern>;
     return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
 }
 
diff --git a/src/mbgl/layermanager/line_layer_factory.cpp b/src/mbgl/layermanager/line_layer_factory.cpp
index 212fb45665..e819656ad0 100644
--- a/src/mbgl/layermanager/line_layer_factory.cpp
+++ b/src/mbgl/layermanager/line_layer_factory.cpp
@@ -28,7 +28,7 @@ std::unique_ptr<Layout> LineLayerFactory::createLayout(const LayoutParameters& p
                                                        std::unique_ptr<GeometryTileLayer> layer,
                                                        const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
     using namespace style;
-    using LayoutType = PatternLayout<LineBucket, LineLayerProperties, LinePattern, LinePaintProperties::PossiblyEvaluated, LineLayoutProperties::PossiblyEvaluated>;
+    using LayoutType = PatternLayout<LineBucket, LineLayerProperties, LinePattern, LineLayoutProperties::PossiblyEvaluated>;
     return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
 }
 
diff --git a/src/mbgl/layout/layout.hpp b/src/mbgl/layout/layout.hpp
index 1deaf13193..d1f03792c1 100644
--- a/src/mbgl/layout/layout.hpp
+++ b/src/mbgl/layout/layout.hpp
@@ -11,6 +11,7 @@ class Bucket;
 class BucketParameters;
 class RenderLayer;
 class FeatureIndex;
+class LayerRenderData;
 
 class Layout {
 public:
@@ -18,7 +19,7 @@ public:
 
     virtual void createBucket(const ImagePositions&,
                               std::unique_ptr<FeatureIndex>&,
-                              std::unordered_map<std::string, std::shared_ptr<Bucket>>&,
+                              std::unordered_map<std::string, LayerRenderData>&,
                               const bool,
                               const bool) = 0;
 
diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp
index fe2e9c5950..95f8b181fc 100644
--- a/src/mbgl/layout/pattern_layout.hpp
+++ b/src/mbgl/layout/pattern_layout.hpp
@@ -26,7 +26,6 @@ public:
 template <class BucketType,
           class LayerPropertiesType,
           class PatternPropertyType,
-          class PossiblyEvaluatedPaintPropertiesType,
           class PossiblyEvaluatedLayoutPropertiesType = typename style::Properties<>::PossiblyEvaluated>
 class PatternLayout : public Layout {
 public:
@@ -46,8 +45,8 @@ public:
 
         for (const auto& layerProperties : group) {
             const std::string& layerId = layerProperties->baseImpl->id;
-            const auto evaluatedProps = static_cast<const LayerPropertiesType&>(*layerProperties).evaluated;
-            const auto patternProperty = evaluatedProps.template get<PatternPropertyType>();
+            const auto& evaluated = style::getEvaluated<LayerPropertiesType>(layerProperties);
+            const auto patternProperty = evaluated.template get<PatternPropertyType>();
             const auto constantPattern = patternProperty.constantOr(Faded<std::basic_string<char> >{ "", ""});
             // determine if layer group has any layers that use *-pattern property and add
             // constant pattern dependencies.
@@ -58,7 +57,7 @@ public:
                 patternDependencies.emplace(constantPattern.to, ImageType::Pattern);
                 patternDependencies.emplace(constantPattern.from, ImageType::Pattern);
             }
-            layerPaintProperties.emplace(layerId, std::move(evaluatedProps));
+            layerPropertiesMap.emplace(layerId, layerProperties);
         }
 
         const size_t featureCount = sourceLayer->featureCount();
@@ -71,9 +70,9 @@ public:
             if (hasPattern) {
                 for (const auto& layerProperties : group) {
                     const std::string& layerId = layerProperties->baseImpl->id;
-                    const auto it = layerPaintProperties.find(layerId);
-                    if (it != layerPaintProperties.end()) {
-                        const auto paint = it->second;
+                    const auto it = layerPropertiesMap.find(layerId);
+                    if (it != layerPropertiesMap.end()) {
+                        const auto paint = static_cast<const LayerPropertiesType&>(*it->second).evaluated;
                         const auto patternProperty = paint.template get<PatternPropertyType>();
                         if (!patternProperty.isConstant()) {
                             // For layers with non-data-constant pattern properties, evaluate their expression and add
@@ -101,8 +100,8 @@ public:
         return hasPattern;
     }
 
-    void createBucket(const ImagePositions& patternPositions, std::unique_ptr<FeatureIndex>& featureIndex, std::unordered_map<std::string, std::shared_ptr<Bucket>>& buckets, const bool, const bool) override {
-        auto bucket = std::make_shared<BucketType>(layout, layerPaintProperties, zoom, overscaling);
+    void createBucket(const ImagePositions& patternPositions, std::unique_ptr<FeatureIndex>& featureIndex, std::unordered_map<std::string, LayerRenderData>& renderData, const bool, const bool) override {
+        auto bucket = std::make_shared<BucketType>(layout, layerPropertiesMap, zoom, overscaling);
         for (auto & patternFeature : features) {
             const auto i = patternFeature.i;
             std::unique_ptr<GeometryTileFeature> feature = std::move(patternFeature.feature);
@@ -113,17 +112,16 @@ public:
             featureIndex->insert(geometries, i, sourceLayerID, bucketLeaderID);
         }
         if (bucket->hasData()) {
-            for (const auto& pair : layerPaintProperties) {
-                buckets.emplace(pair.first, bucket);
+            for (const auto& pair : layerPropertiesMap) {
+                renderData.emplace(pair.first, LayerRenderData {bucket, pair.second});
             }
         }
     };
 
-    std::map<std::string, PossiblyEvaluatedPaintPropertiesType> layerPaintProperties;
+private:
+    std::map<std::string, Immutable<style::LayerProperties>> layerPropertiesMap;
     std::string bucketLeaderID;
 
-
-private:
     const std::unique_ptr<GeometryTileLayer> sourceLayer;
     std::vector<PatternFeature> features;
     PossiblyEvaluatedLayoutPropertiesType layout;
diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index 0eb98f7569..d8d143632c 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -12,6 +12,7 @@
 #include <mbgl/util/i18n.hpp>
 #include <mbgl/util/platform.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
+#include <mbgl/tile/tile.hpp>
 
 #include <mapbox/polylabel.hpp>
 
@@ -106,7 +107,7 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
         layout.get<TextIgnorePlacement>() || layout.get<IconIgnorePlacement>());
 
     for (const auto& layer : layers) {
-        layerPaintProperties.emplace(layer->baseImpl->id, toSymbolLayerProperties(layer).evaluated);
+        layerPaintProperties.emplace(layer->baseImpl->id, layer);
     }
 
     // Determine glyph dependencies
@@ -555,7 +556,7 @@ std::vector<float> CalculateTileDistances(const GeometryCoordinates& line, const
     return tileDistances;
 }
 
-void SymbolLayout::createBucket(const ImagePositions&, std::unique_ptr<FeatureIndex>&, std::unordered_map<std::string, std::shared_ptr<Bucket>>& buckets, const bool firstLoad, const bool showCollisionBoxes) {
+void SymbolLayout::createBucket(const ImagePositions&, std::unique_ptr<FeatureIndex>&, std::unordered_map<std::string, LayerRenderData>& renderData, const bool firstLoad, const bool showCollisionBoxes) {
     auto bucket = std::make_shared<SymbolBucket>(layout, layerPaintProperties, textSize, iconSize, zoom, sdfIcons, iconsNeedLinear, sortFeaturesByY, bucketLeaderID, std::move(symbolInstances), tilePixelRatio);
 
     for (SymbolInstance &symbolInstance : bucket->symbolInstances) {
@@ -618,7 +619,7 @@ void SymbolLayout::createBucket(const ImagePositions&, std::unique_ptr<FeatureIn
             if (!firstLoad) {
                 bucket->justReloaded = true;
             }
-            buckets.emplace(pair.first, bucket);
+            renderData.emplace(pair.first, LayerRenderData{bucket, pair.second});
         }
     }
 
diff --git a/src/mbgl/layout/symbol_layout.hpp b/src/mbgl/layout/symbol_layout.hpp
index 9fc48d904c..4397c5543e 100644
--- a/src/mbgl/layout/symbol_layout.hpp
+++ b/src/mbgl/layout/symbol_layout.hpp
@@ -35,12 +35,12 @@ public:
     void prepareSymbols(const GlyphMap&, const GlyphPositions&,
                  const ImageMap&, const ImagePositions&) override;
 
-    void createBucket(const ImagePositions&, std::unique_ptr<FeatureIndex>&, std::unordered_map<std::string, std::shared_ptr<Bucket>>&, const bool firstLoad, const bool showCollisionBoxes) override;
+    void createBucket(const ImagePositions&, std::unique_ptr<FeatureIndex>&, std::unordered_map<std::string, LayerRenderData>&, const bool firstLoad, const bool showCollisionBoxes) override;
 
     bool hasSymbolInstances() const override;
     bool hasDependencies() const override;
 
-    std::map<std::string, style::SymbolPaintProperties::PossiblyEvaluated> layerPaintProperties;
+    std::map<std::string, Immutable<style::LayerProperties>> layerPaintProperties;
 
     const std::string bucketLeaderID;
     std::vector<SymbolInstance> symbolInstances;
diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp
index 2dffc555e2..c69b60327d 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.cpp
@@ -28,7 +28,7 @@ using namespace style;
 struct GeometryTooLongException : std::exception {};
 
 FillBucket::FillBucket(const FillBucket::PossiblyEvaluatedLayoutProperties,
-                       std::map<std::string, FillBucket::PossiblyEvaluatedPaintProperties> layerPaintProperties,
+                       const std::map<std::string, Immutable<style::LayerProperties>>& layerPaintProperties,
                        const float zoom,
                        const uint32_t) {
 
@@ -37,7 +37,7 @@ FillBucket::FillBucket(const FillBucket::PossiblyEvaluatedLayoutProperties,
             std::piecewise_construct,
             std::forward_as_tuple(pair.first),
             std::forward_as_tuple(
-                pair.second,
+                getEvaluated<FillLayerProperties>(pair.second),
                 zoom));
     }
 }
diff --git a/src/mbgl/renderer/buckets/fill_bucket.hpp b/src/mbgl/renderer/buckets/fill_bucket.hpp
index 5844625d2a..217524c945 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.hpp
@@ -22,7 +22,7 @@ public:
     using PossiblyEvaluatedLayoutProperties = style::Properties<>::PossiblyEvaluated;
 
     FillBucket(const PossiblyEvaluatedLayoutProperties layout,
-               std::map<std::string, PossiblyEvaluatedPaintProperties> layerPaintProperties,
+               const std::map<std::string, Immutable<style::LayerProperties>>& layerPaintProperties,
                const float zoom,
                const uint32_t overscaling);
 
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
index 61fc6a1444..7fa7293f33 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
@@ -34,8 +34,8 @@ using namespace style;
 
 struct GeometryTooLongException : std::exception {};
 
-FillExtrusionBucket::FillExtrusionBucket(const FillExtrusionBucket::PossiblyEvaluatedLayoutProperties,
-                       std::map<std::string, FillExtrusionBucket::PossiblyEvaluatedPaintProperties> layerPaintProperties,
+FillExtrusionBucket::FillExtrusionBucket(const FillExtrusionBucket::PossiblyEvaluatedLayoutProperties&,
+                       const std::map<std::string, Immutable<style::LayerProperties>>& layerPaintProperties,
                        const float zoom,
                        const uint32_t) {
     for (const auto& pair : layerPaintProperties) {
@@ -43,7 +43,7 @@ FillExtrusionBucket::FillExtrusionBucket(const FillExtrusionBucket::PossiblyEval
             std::piecewise_construct,
             std::forward_as_tuple(pair.first),
             std::forward_as_tuple(
-                pair.second,
+                getEvaluated<FillExtrusionLayerProperties>(pair.second),
                 zoom));
     }
 }
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
index 9dc2681bac..85867031a7 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
@@ -19,8 +19,8 @@ public:
     using PossiblyEvaluatedPaintProperties = style::FillExtrusionPaintProperties::PossiblyEvaluated;
     using PossiblyEvaluatedLayoutProperties = style::Properties<>::PossiblyEvaluated;
 
-    FillExtrusionBucket(const PossiblyEvaluatedLayoutProperties,
-                        std::map<std::string, PossiblyEvaluatedPaintProperties>,
+    FillExtrusionBucket(const PossiblyEvaluatedLayoutProperties&,
+                        const std::map<std::string, Immutable<style::LayerProperties>>&,
                         const float,
                         const uint32_t);
 
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index 9a5ed9e628..c2cce632b3 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -11,7 +11,7 @@ namespace mbgl {
 using namespace style;
 
 LineBucket::LineBucket(const style::LineLayoutProperties::PossiblyEvaluated layout_,
-                       const std::map<std::string, style::LinePaintProperties::PossiblyEvaluated>& layerPaintProperties,
+                       const std::map<std::string, Immutable<style::LayerProperties>>& layerPaintProperties,
                        const float zoom_,
                        const uint32_t overscaling_)
     : layout(std::move(layout_)),
@@ -23,7 +23,7 @@ LineBucket::LineBucket(const style::LineLayoutProperties::PossiblyEvaluated layo
             std::piecewise_construct,
             std::forward_as_tuple(pair.first),
             std::forward_as_tuple(
-                pair.second,
+                getEvaluated<LineLayerProperties>(pair.second),
                 zoom));
     }
 }
diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp
index 6717ee7446..9afe7fecee 100644
--- a/src/mbgl/renderer/buckets/line_bucket.hpp
+++ b/src/mbgl/renderer/buckets/line_bucket.hpp
@@ -21,7 +21,7 @@ public:
     using PossiblyEvaluatedLayoutProperties = style::LineLayoutProperties::PossiblyEvaluated;
 
     LineBucket(const PossiblyEvaluatedLayoutProperties layout,
-               const std::map<std::string, PossiblyEvaluatedPaintProperties>& layerPaintProperties,
+               const std::map<std::string, Immutable<style::LayerProperties>>& layerPaintProperties,
                const float zoom,
                const uint32_t overscaling);
     ~LineBucket() override;
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp
index a0ebab20be..4b5207da39 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.cpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp
@@ -8,8 +8,12 @@ namespace mbgl {
 
 using namespace style;
 
+const SymbolLayerProperties& toSymbolLayerProperties(const Immutable<LayerProperties>& layer) {
+    return static_cast<const SymbolLayerProperties&>(*layer);
+}
+
 SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layout_,
-                           const std::map<std::string, style::SymbolPaintProperties::PossiblyEvaluated>& paintProperties_,
+                           const std::map<std::string, Immutable<style::LayerProperties>>& paintProperties_,
                            const style::PropertyValue<float>& textSize,
                            const style::PropertyValue<float>& iconSize,
                            float zoom,
@@ -30,7 +34,7 @@ SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layo
       tilePixelRatio(tilePixelRatio_) {
 
     for (const auto& pair : paintProperties_) {
-        auto layerPaintProperties = pair.second;
+        auto layerPaintProperties = toSymbolLayerProperties(pair.second).evaluated;
         if (hasFormatSectionOverrides()) {
             setPaintPropertyOverrides(layerPaintProperties);
         }
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp
index f8ffc1a8eb..ca740c5488 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.hpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp
@@ -42,7 +42,7 @@ public:
 class SymbolBucket final : public Bucket {
 public:
     SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated,
-                 const std::map<std::string, style::SymbolPaintProperties::PossiblyEvaluated>&,
+                 const std::map<std::string, Immutable<style::LayerProperties>>&,
                  const style::PropertyValue<float>& textSize,
                  const style::PropertyValue<float>& iconSize,
                  float zoom,
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 9654b9213f..3a762947db 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -19,6 +19,12 @@ class RenderLayerSymbolInterface;
 class RenderTile;
 class TransformState;
 
+class LayerRenderData {
+public:
+    std::shared_ptr<Bucket> bucket;
+    Immutable<style::LayerProperties> layerProperties;
+};
+
 class RenderLayer {
 protected:
     RenderLayer(Immutable<style::LayerProperties>);
@@ -90,6 +96,7 @@ protected:
     // the cached paint properties) can be still in use while the tile is loading new buckets (which will
     // correpond to the current paint properties of the layer).
     virtual void updateBucketPaintProperties(Bucket*) const;
+
     using FilterFunctionPtr = bool (*)(RenderTile&);
     RenderTiles filterRenderTiles(RenderTiles, FilterFunctionPtr) const;
 
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index fe8ac364bc..89e7f095fa 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -7,7 +7,7 @@
 #include <mbgl/util/geojson.hpp>
 #include <mbgl/util/feature.hpp>
 #include <mbgl/style/source_impl.hpp>
-#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layer_properties.hpp>
 
 #include <unordered_map>
 #include <vector>
@@ -50,7 +50,7 @@ public:
     virtual bool isLoaded() const = 0;
 
     virtual void update(Immutable<style::Source::Impl>,
-                        const std::vector<Immutable<style::Layer::Impl>>&,
+                        const std::vector<Immutable<style::LayerProperties>>&,
                         bool needsRendering,
                         bool needsRelayout,
                         const TileParameters&) = 0;
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 5078e01edb..4a618919d4 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -242,7 +242,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     staticData->has3D = false;
     for (const auto& sourceImpl : *sourceImpls) {
         RenderSource* source = renderSources.at(sourceImpl->id).get();
-        std::vector<Immutable<Layer::Impl>> filteredLayersForSource;
+        std::vector<Immutable<LayerProperties>> filteredLayersForSource;
         filteredLayersForSource.reserve(layerImpls->size());
         bool sourceNeedsRendering = false;
         bool sourceNeedsRelayout = false;       
@@ -262,7 +262,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
                     sourceNeedsRelayout = (sourceNeedsRelayout || hasImageDiff || hasLayoutDifference(layerDiff, layerImpl->id));
                     if (layerNeedsRendering) {
                         sourceNeedsRendering = true;
-                        filteredLayersForSource.push_back(layerImpl);
+                        filteredLayersForSource.push_back(layer->evaluatedProperties);
                         renderItemsEmplaceHint = renderItems.emplace_hint(renderItemsEmplaceHint, *layer, source, index);
                     }
                 }
diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
index 2d28b8dd84..30b6e65f24 100644
--- a/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.cpp
@@ -24,7 +24,7 @@ bool RenderCustomGeometrySource::isLoaded() const {
 }
 
 void RenderCustomGeometrySource::update(Immutable<style::Source::Impl> baseImpl_,
-                                 const std::vector<Immutable<Layer::Impl>>& layers,
+                                 const std::vector<Immutable<style::LayerProperties>>& layers,
                                  const bool needsRendering,
                                  const bool needsRelayout,
                                  const TileParameters& parameters) {
diff --git a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
index 5533fe2b83..be9e022eb9 100644
--- a/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
+++ b/src/mbgl/renderer/sources/render_custom_geometry_source.hpp
@@ -13,7 +13,7 @@ public:
     bool isLoaded() const final;
 
     void update(Immutable<style::Source::Impl>,
-                const std::vector<Immutable<style::Layer::Impl>>&,
+                const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&) final;
diff --git a/src/mbgl/renderer/sources/render_geojson_source.cpp b/src/mbgl/renderer/sources/render_geojson_source.cpp
index 3cfcfc7392..332ea4d170 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.cpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.cpp
@@ -84,7 +84,7 @@ bool RenderGeoJSONSource::isLoaded() const {
 }
 
 void RenderGeoJSONSource::update(Immutable<style::Source::Impl> baseImpl_,
-                                 const std::vector<Immutable<Layer::Impl>>& layers,
+                                 const std::vector<Immutable<LayerProperties>>& layers,
                                  const bool needsRendering,
                                  const bool needsRelayout,
                                  const TileParameters& parameters) {
diff --git a/src/mbgl/renderer/sources/render_geojson_source.hpp b/src/mbgl/renderer/sources/render_geojson_source.hpp
index c23559c09a..c8e98f96ee 100644
--- a/src/mbgl/renderer/sources/render_geojson_source.hpp
+++ b/src/mbgl/renderer/sources/render_geojson_source.hpp
@@ -18,7 +18,7 @@ public:
     bool isLoaded() const final;
 
     void update(Immutable<style::Source::Impl>,
-                const std::vector<Immutable<style::Layer::Impl>>&,
+                const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&) final;
diff --git a/src/mbgl/renderer/sources/render_image_source.cpp b/src/mbgl/renderer/sources/render_image_source.cpp
index 7190f25bc7..b6a75acacc 100644
--- a/src/mbgl/renderer/sources/render_image_source.cpp
+++ b/src/mbgl/renderer/sources/render_image_source.cpp
@@ -106,7 +106,7 @@ std::vector<Feature> RenderImageSource::querySourceFeatures(const SourceQueryOpt
 }
 
 void RenderImageSource::update(Immutable<style::Source::Impl> baseImpl_,
-                               const std::vector<Immutable<Layer::Impl>>&,
+                               const std::vector<Immutable<LayerProperties>>&,
                                const bool needsRendering,
                                const bool,
                                const TileParameters& parameters) {
diff --git a/src/mbgl/renderer/sources/render_image_source.hpp b/src/mbgl/renderer/sources/render_image_source.hpp
index cf14e180fd..e5cdcd4d81 100644
--- a/src/mbgl/renderer/sources/render_image_source.hpp
+++ b/src/mbgl/renderer/sources/render_image_source.hpp
@@ -19,7 +19,7 @@ public:
     void finishRender(PaintParameters&) final;
 
     void update(Immutable<style::Source::Impl>,
-                const std::vector<Immutable<style::Layer::Impl>>&,
+                const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&) final;
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.cpp b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
index 63ab3ca370..c942432e64 100644
--- a/src/mbgl/renderer/sources/render_raster_dem_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.cpp
@@ -23,7 +23,7 @@ bool RenderRasterDEMSource::isLoaded() const {
 }
 
 void RenderRasterDEMSource::update(Immutable<style::Source::Impl> baseImpl_,
-                                const std::vector<Immutable<Layer::Impl>>& layers,
+                                const std::vector<Immutable<LayerProperties>>& layers,
                                 const bool needsRendering,
                                 const bool needsRelayout,
                                 const TileParameters& parameters) {
diff --git a/src/mbgl/renderer/sources/render_raster_dem_source.hpp b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
index 48c7803e92..af76e22da7 100644
--- a/src/mbgl/renderer/sources/render_raster_dem_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_dem_source.hpp
@@ -13,7 +13,7 @@ public:
     bool isLoaded() const final;
 
     void update(Immutable<style::Source::Impl>,
-                const std::vector<Immutable<style::Layer::Impl>>&,
+                const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&) final;
diff --git a/src/mbgl/renderer/sources/render_raster_source.cpp b/src/mbgl/renderer/sources/render_raster_source.cpp
index 017763b96a..96e793f9b2 100644
--- a/src/mbgl/renderer/sources/render_raster_source.cpp
+++ b/src/mbgl/renderer/sources/render_raster_source.cpp
@@ -21,7 +21,7 @@ bool RenderRasterSource::isLoaded() const {
 }
 
 void RenderRasterSource::update(Immutable<style::Source::Impl> baseImpl_,
-                                const std::vector<Immutable<Layer::Impl>>& layers,
+                                const std::vector<Immutable<LayerProperties>>& layers,
                                 const bool needsRendering,
                                 const bool needsRelayout,
                                 const TileParameters& parameters) {
diff --git a/src/mbgl/renderer/sources/render_raster_source.hpp b/src/mbgl/renderer/sources/render_raster_source.hpp
index 32539a046d..24242949bb 100644
--- a/src/mbgl/renderer/sources/render_raster_source.hpp
+++ b/src/mbgl/renderer/sources/render_raster_source.hpp
@@ -13,7 +13,7 @@ public:
     bool isLoaded() const final;
 
     void update(Immutable<style::Source::Impl>,
-                const std::vector<Immutable<style::Layer::Impl>>&,
+                const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&) final;
diff --git a/src/mbgl/renderer/sources/render_vector_source.cpp b/src/mbgl/renderer/sources/render_vector_source.cpp
index 61954a68e6..efcd11094c 100644
--- a/src/mbgl/renderer/sources/render_vector_source.cpp
+++ b/src/mbgl/renderer/sources/render_vector_source.cpp
@@ -24,7 +24,7 @@ bool RenderVectorSource::isLoaded() const {
 }
 
 void RenderVectorSource::update(Immutable<style::Source::Impl> baseImpl_,
-                                const std::vector<Immutable<Layer::Impl>>& layers,
+                                const std::vector<Immutable<style::LayerProperties>>& layers,
                                 const bool needsRendering,
                                 const bool needsRelayout,
                                 const TileParameters& parameters) {
diff --git a/src/mbgl/renderer/sources/render_vector_source.hpp b/src/mbgl/renderer/sources/render_vector_source.hpp
index 6fd2425aa3..fe7147fc25 100644
--- a/src/mbgl/renderer/sources/render_vector_source.hpp
+++ b/src/mbgl/renderer/sources/render_vector_source.hpp
@@ -13,7 +13,7 @@ public:
     bool isLoaded() const final;
 
     void update(Immutable<style::Source::Impl>,
-                const std::vector<Immutable<style::Layer::Impl>>&,
+                const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&) final;
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index b169fddf9c..6e1bddec0a 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -61,7 +61,7 @@ Tile* TilePyramid::getTile(const OverscaledTileID& tileID){
         return it == tiles.end() ? cache.get(tileID) : it->second.get();
 }
 
-void TilePyramid::update(const std::vector<Immutable<style::Layer::Impl>>& layers,
+void TilePyramid::update(const std::vector<Immutable<style::LayerProperties>>& layers,
                          const bool needsRendering,
                          const bool needsRelayout,
                          const TileParameters& parameters,
diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp
index bc2c370780..594330e0c9 100644
--- a/src/mbgl/renderer/tile_pyramid.hpp
+++ b/src/mbgl/renderer/tile_pyramid.hpp
@@ -5,7 +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/style/layer_properties.hpp>
 
 #include <mbgl/util/mat4.hpp>
 #include <mbgl/util/feature.hpp>
@@ -33,7 +33,7 @@ public:
 
     bool isLoaded() const;
 
-    void update(const std::vector<Immutable<style::Layer::Impl>>&,
+    void update(const std::vector<Immutable<style::LayerProperties>>&,
                 bool needsRendering,
                 bool needsRelayout,
                 const TileParameters&,
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(