[core] Use `style::LayerProperties` in render layers, buckets and layouts.

59 files changed, 383 insertions, 457 deletions

diff --git a/include/mbgl/layermanager/circle_layer_factory.hpp b/include/mbgl/layermanager/circle_layer_factory.hpp
index e9eb0f59cc..51135d3383 100644
--- a/include/mbgl/layermanager/circle_layer_factory.hpp
+++ b/include/mbgl/layermanager/circle_layer_factory.hpp
@@ -8,7 +8,7 @@ class CircleLayerFactory : public LayerFactory {
 protected:
     const style::LayerTypeInfo* getTypeInfo() const noexcept final;
     std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept final;
+    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
 };
 
diff --git a/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp b/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp
index 3430d3da1c..fbaa5c1254 100644
--- a/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp
+++ b/include/mbgl/layermanager/fill_extrusion_layer_factory.hpp
@@ -8,7 +8,7 @@ class FillExtrusionLayerFactory : public LayerFactory {
 protected:
     const style::LayerTypeInfo* getTypeInfo() const noexcept final;
     std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
-    std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept final;
+    std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
 };
 
diff --git a/include/mbgl/layermanager/fill_layer_factory.hpp b/include/mbgl/layermanager/fill_layer_factory.hpp
index 22762d1290..09afb0dc3a 100644
--- a/include/mbgl/layermanager/fill_layer_factory.hpp
+++ b/include/mbgl/layermanager/fill_layer_factory.hpp
@@ -8,7 +8,7 @@ class FillLayerFactory : public LayerFactory {
 protected:
     const style::LayerTypeInfo* getTypeInfo() const noexcept final;
     std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
-    std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept final;
+    std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
 };
 
diff --git a/include/mbgl/layermanager/heatmap_layer_factory.hpp b/include/mbgl/layermanager/heatmap_layer_factory.hpp
index 306af60938..2d0e1a5a02 100644
--- a/include/mbgl/layermanager/heatmap_layer_factory.hpp
+++ b/include/mbgl/layermanager/heatmap_layer_factory.hpp
@@ -8,7 +8,7 @@ class HeatmapLayerFactory : public LayerFactory {
 protected:
     const style::LayerTypeInfo* getTypeInfo() const noexcept final;
     std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept final;
+    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
 };
 
diff --git a/include/mbgl/layermanager/layer_factory.hpp b/include/mbgl/layermanager/layer_factory.hpp
index 037de1b647..f3cfef6bb6 100644
--- a/include/mbgl/layermanager/layer_factory.hpp
+++ b/include/mbgl/layermanager/layer_factory.hpp
@@ -6,6 +6,9 @@
 
 namespace mbgl {
 
+namespace style {
+class LayerProperties;
+}  // namespace style
 class Bucket;
 class BucketParameters;
 class GeometryTileLayer;
@@ -28,9 +31,9 @@ public:
     /// Returns a new RenderLayer instance.
     virtual std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept = 0;
     /// Returns a new Bucket instance on success call; returns `nullptr` otherwise. 
-    virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept;
+    virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept;
     /// Returns a new Layout instance on success call; returns `nullptr` otherwise. 
-    virtual std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept;
+    virtual std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<Immutable<style::LayerProperties>>&) noexcept;
 
 protected:
     optional<std::string> getSource(const style::conversion::Convertible& value) const noexcept;
diff --git a/include/mbgl/layermanager/layer_manager.hpp b/include/mbgl/layermanager/layer_manager.hpp
index de10b0207c..c6802dbb49 100644
--- a/include/mbgl/layermanager/layer_manager.hpp
+++ b/include/mbgl/layermanager/layer_manager.hpp
@@ -5,6 +5,9 @@
 #include <vector>
 
 namespace mbgl {
+namespace style {
+class LayerProperties;
+}  // namespace style
 class GeometryTileLayer;
 class LayerFactory;
 class RenderLayer;
@@ -37,9 +40,10 @@ public:
     /// Returns a new RenderLayer instance on success call; returns `nullptr` otherwise.
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept;
     /// Returns a new Bucket instance on success call; returns `nullptr` otherwise.
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept;
+    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept;
     /// Returns a new Layout instance on success call; returns `nullptr` otherwise. 
-    std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept;
+    std::unique_ptr<Layout> createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>,
+                                         const std::vector<Immutable<style::LayerProperties>>&) noexcept;
 
     /**
      * @brief a build-time flag to enable/disable annotations in mapbox-gl-native core.
diff --git a/include/mbgl/layermanager/line_layer_factory.hpp b/include/mbgl/layermanager/line_layer_factory.hpp
index a7081228ee..803f550e57 100644
--- a/include/mbgl/layermanager/line_layer_factory.hpp
+++ b/include/mbgl/layermanager/line_layer_factory.hpp
@@ -10,7 +10,7 @@ protected:
     std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
     std::unique_ptr<Layout> createLayout(const LayoutParameters& parameters,
                                          std::unique_ptr<GeometryTileLayer> tileLayer,
-                                         const std::vector<const RenderLayer*>& group) noexcept final;
+                                         const std::vector<Immutable<style::LayerProperties>>& group) noexcept final;
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
 };
 
diff --git a/include/mbgl/layermanager/symbol_layer_factory.hpp b/include/mbgl/layermanager/symbol_layer_factory.hpp
index dac515c9dc..38f382e96c 100644
--- a/include/mbgl/layermanager/symbol_layer_factory.hpp
+++ b/include/mbgl/layermanager/symbol_layer_factory.hpp
@@ -10,7 +10,7 @@ protected:
     std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
     std::unique_ptr<Layout> createLayout(const LayoutParameters& parameters,
                                          std::unique_ptr<GeometryTileLayer> tileLayer,
-                                         const std::vector<const RenderLayer*>& group) noexcept final;
+                                         const std::vector<Immutable<style::LayerProperties>>& group) noexcept final;
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
 };
 
diff --git a/src/mbgl/layermanager/circle_layer_factory.cpp b/src/mbgl/layermanager/circle_layer_factory.cpp
index 0ea56e5711..28c64fc400 100644
--- a/src/mbgl/layermanager/circle_layer_factory.cpp
+++ b/src/mbgl/layermanager/circle_layer_factory.cpp
@@ -24,7 +24,7 @@ std::unique_ptr<style::Layer> CircleLayerFactory::createLayer(const std::string&
     return layer;
 }
 
-std::unique_ptr<Bucket> CircleLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) noexcept {
+std::unique_ptr<Bucket> CircleLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
     return std::make_unique<CircleBucket>(parameters, layers);
 }
 
diff --git a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
index b2558825ef..bc1647afa4 100644
--- a/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_extrusion_layer_factory.cpp
@@ -26,8 +26,10 @@ std::unique_ptr<style::Layer> FillExtrusionLayerFactory::createLayer(const std::
 
 std::unique_ptr<Layout> FillExtrusionLayerFactory::createLayout(const LayoutParameters& parameters,
                                                                 std::unique_ptr<GeometryTileLayer> layer,
-                                                                const std::vector<const RenderLayer*>& group) noexcept {
-    return std::make_unique<PatternLayout<FillExtrusionBucket>>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
+                                                                const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
+    using namespace style;
+    using LayoutType = PatternLayout<FillExtrusionBucket, FillExtrusionLayerProperties, FillExtrusionPattern, FillExtrusionPaintProperties::PossiblyEvaluated>;
+    return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
 }
 
 std::unique_ptr<RenderLayer> FillExtrusionLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/fill_layer_factory.cpp b/src/mbgl/layermanager/fill_layer_factory.cpp
index 60a1818585..f9b59359c5 100644
--- a/src/mbgl/layermanager/fill_layer_factory.cpp
+++ b/src/mbgl/layermanager/fill_layer_factory.cpp
@@ -27,8 +27,10 @@ std::unique_ptr<style::Layer> FillLayerFactory::createLayer(const std::string& i
 std::unique_ptr<Layout>
 FillLayerFactory::createLayout(const LayoutParameters& parameters,
                                std::unique_ptr<GeometryTileLayer> layer,
-                               const std::vector<const RenderLayer*>& group) noexcept {
-    return std::make_unique<PatternLayout<FillBucket>>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
+                               const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
+    using namespace style;
+    using LayoutType = PatternLayout<FillBucket, FillLayerProperties, FillPattern, FillPaintProperties::PossiblyEvaluated>;
+    return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
 }
 
 std::unique_ptr<RenderLayer> FillLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/heatmap_layer_factory.cpp b/src/mbgl/layermanager/heatmap_layer_factory.cpp
index 5d6a595b46..1cd5d18f79 100644
--- a/src/mbgl/layermanager/heatmap_layer_factory.cpp
+++ b/src/mbgl/layermanager/heatmap_layer_factory.cpp
@@ -24,7 +24,7 @@ std::unique_ptr<style::Layer> HeatmapLayerFactory::createLayer(const std::string
     return layer;
 }
 
-std::unique_ptr<Bucket> HeatmapLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) noexcept {
+std::unique_ptr<Bucket> HeatmapLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
     return std::make_unique<HeatmapBucket>(parameters, layers);
 }
 
diff --git a/src/mbgl/layermanager/layer_factory.cpp b/src/mbgl/layermanager/layer_factory.cpp
index ceeb304f44..f4967b0e5d 100644
--- a/src/mbgl/layermanager/layer_factory.cpp
+++ b/src/mbgl/layermanager/layer_factory.cpp
@@ -25,12 +25,14 @@ optional<std::string> LayerFactory::getSource(const style::conversion::Convertib
     return source;
 }
 
-std::unique_ptr<Bucket> LayerFactory::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) noexcept {
+std::unique_ptr<Bucket> LayerFactory::createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept {
     assert(false);
     return nullptr;
 }
 
-std::unique_ptr<Layout> LayerFactory::createLayout(const LayoutParameters&, std::unique_ptr<GeometryTileLayer>, const std::vector<const RenderLayer*>&) noexcept {
+std::unique_ptr<Layout> LayerFactory::createLayout(const LayoutParameters&,
+                                                   std::unique_ptr<GeometryTileLayer>,
+                                                   const std::vector<Immutable<style::LayerProperties>>&) noexcept {
     assert(false);
     return nullptr;
 }
diff --git a/src/mbgl/layermanager/layer_manager.cpp b/src/mbgl/layermanager/layer_manager.cpp
index e6195caeba..1e2074cd70 100644
--- a/src/mbgl/layermanager/layer_manager.cpp
+++ b/src/mbgl/layermanager/layer_manager.cpp
@@ -25,7 +25,8 @@ std::unique_ptr<style::Layer> LayerManager::createLayer(
     return nullptr;
 }
 
-std::unique_ptr<Bucket> LayerManager::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) noexcept {
+std::unique_ptr<Bucket> LayerManager::createBucket(const BucketParameters& parameters,
+                                                   const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
     assert(!layers.empty());
     assert(parameters.layerType->layout == style::LayerTypeInfo::Layout::NotRequired);
     LayerFactory* factory = getFactory(parameters.layerType);
@@ -35,7 +36,7 @@ std::unique_ptr<Bucket> LayerManager::createBucket(const BucketParameters& param
 
 std::unique_ptr<Layout> LayerManager::createLayout(const LayoutParameters& parameters,
                                                    std::unique_ptr<GeometryTileLayer> tileLayer,
-                                                   const std::vector<const RenderLayer*>& layers) noexcept {
+                                                   const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
     assert(!layers.empty());
     assert(parameters.bucketParameters.layerType->layout == style::LayerTypeInfo::Layout::Required);
     LayerFactory* factory = getFactory(parameters.bucketParameters.layerType);
diff --git a/src/mbgl/layermanager/line_layer_factory.cpp b/src/mbgl/layermanager/line_layer_factory.cpp
index 8bf756e159..212fb45665 100644
--- a/src/mbgl/layermanager/line_layer_factory.cpp
+++ b/src/mbgl/layermanager/line_layer_factory.cpp
@@ -26,8 +26,10 @@ std::unique_ptr<style::Layer> LineLayerFactory::createLayer(const std::string& i
 
 std::unique_ptr<Layout> LineLayerFactory::createLayout(const LayoutParameters& parameters,
                                                        std::unique_ptr<GeometryTileLayer> layer,
-                                                       const std::vector<const RenderLayer*>& group) noexcept {
-    return std::make_unique<PatternLayout<LineBucket>>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
+                                                       const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
+    using namespace style;
+    using LayoutType = PatternLayout<LineBucket, LineLayerProperties, LinePattern, LinePaintProperties::PossiblyEvaluated, LineLayoutProperties::PossiblyEvaluated>;
+    return std::make_unique<LayoutType>(parameters.bucketParameters, group, std::move(layer), parameters.imageDependencies);
 }
 
 std::unique_ptr<RenderLayer> LineLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {
diff --git a/src/mbgl/layermanager/symbol_layer_factory.cpp b/src/mbgl/layermanager/symbol_layer_factory.cpp
index d992741551..f5a4640db7 100644
--- a/src/mbgl/layermanager/symbol_layer_factory.cpp
+++ b/src/mbgl/layermanager/symbol_layer_factory.cpp
@@ -26,7 +26,7 @@ std::unique_ptr<style::Layer> SymbolLayerFactory::createLayer(const std::string&
 
 std::unique_ptr<Layout> SymbolLayerFactory::createLayout(const LayoutParameters& parameters,
                                                          std::unique_ptr<GeometryTileLayer> tileLayer,
-                                                         const std::vector<const RenderLayer*>& group) noexcept {
+                                                         const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
     return std::make_unique<SymbolLayout>(parameters.bucketParameters,
                                           group,
                                           std::move(tileLayer),
diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp
index 8dabfab919..fe2e9c5950 100644
--- a/src/mbgl/layout/pattern_layout.hpp
+++ b/src/mbgl/layout/pattern_layout.hpp
@@ -3,6 +3,7 @@
 #include <mbgl/renderer/bucket_parameters.hpp>
 #include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/style/layer_properties.hpp>
 
 namespace mbgl {
 
@@ -22,31 +23,32 @@ public:
     PatternLayerMap patterns;
 };
 
-template <class B>
+template <class BucketType,
+          class LayerPropertiesType,
+          class PatternPropertyType,
+          class PossiblyEvaluatedPaintPropertiesType,
+          class PossiblyEvaluatedLayoutPropertiesType = typename style::Properties<>::PossiblyEvaluated>
 class PatternLayout : public Layout {
 public:
     PatternLayout(const BucketParameters& parameters,
-                  const std::vector<const RenderLayer*>& layers,
+                  const std::vector<Immutable<style::LayerProperties>>& group,
                   std::unique_ptr<GeometryTileLayer> sourceLayer_,
                   ImageDependencies& patternDependencies)
-                  : Layout(),
-                    bucketLeaderID(layers.at(0)->getID()),
-                    sourceLayer(std::move(sourceLayer_)),
+                  : sourceLayer(std::move(sourceLayer_)),
                     zoom(parameters.tileID.overscaledZ),
                     overscaling(parameters.tileID.overscaleFactor()),
                     hasPattern(false) {
-
-        using PatternLayer = typename B::RenderLayerType;
-        const auto renderLayer = static_cast<const PatternLayer*>(layers.at(0));
-        const typename PatternLayer::StyleLayerImpl& leader = renderLayer->impl();
-        layout = leader.layout.evaluate(PropertyEvaluationParameters(zoom));
-        sourceLayerID = leader.sourceLayer;
-        groupID = renderLayer->getID();
-
-        for (const auto& layer : layers) {
-            const typename B::PossiblyEvaluatedPaintProperties evaluatedProps = static_cast<const PatternLayer*>(layer)->evaluated;
-            const auto patternProperty = evaluatedProps.template get<typename PatternLayer::PatternProperty>();
-            const auto constantPattern = patternProperty.constantOr({ "", "" });
+        assert(!group.empty());
+        auto leaderLayerProperties = staticImmutableCast<LayerPropertiesType>(group.front());
+        layout = leaderLayerProperties->layerImpl().layout.evaluate(PropertyEvaluationParameters(zoom));
+        sourceLayerID = leaderLayerProperties->layerImpl().sourceLayer;
+        bucketLeaderID = leaderLayerProperties->layerImpl().id;
+
+        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 constantPattern = patternProperty.constantOr(Faded<std::basic_string<char> >{ "", ""});
             // determine if layer group has any layers that use *-pattern property and add
             // constant pattern dependencies.
             if (!patternProperty.isConstant()) {
@@ -56,33 +58,34 @@ public:
                 patternDependencies.emplace(constantPattern.to, ImageType::Pattern);
                 patternDependencies.emplace(constantPattern.from, ImageType::Pattern);
             }
-            layerPaintProperties.emplace(layer->getID(), std::move(evaluatedProps));
+            layerPaintProperties.emplace(layerId, std::move(evaluatedProps));
         }
 
         const size_t featureCount = sourceLayer->featureCount();
         for (size_t i = 0; i < featureCount; ++i) {
             auto feature = sourceLayer->getFeature(i);
-            if (!leader.filter(style::expression::EvaluationContext { this->zoom, feature.get() }))
+            if (!leaderLayerProperties->layerImpl().filter(style::expression::EvaluationContext { this->zoom, feature.get() }))
                 continue;
 
             PatternLayerMap patternDependencyMap;
             if (hasPattern) {
-                for (const auto& layer : layers) {
-                    const auto it = layerPaintProperties.find(layer->getID());
+                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 patternProperty = paint.template get<typename PatternLayer::PatternProperty>();
+                        const auto patternProperty = paint.template get<PatternPropertyType>();
                         if (!patternProperty.isConstant()) {
                             // For layers with non-data-constant pattern properties, evaluate their expression and add
                             // the patterns to the dependency vector
-                            const auto min = patternProperty.evaluate(*feature, zoom - 1, PatternLayer::PatternProperty::defaultValue());
-                            const auto mid = patternProperty.evaluate(*feature, zoom, PatternLayer::PatternProperty::defaultValue());
-                            const auto max = patternProperty.evaluate(*feature, zoom + 1, PatternLayer::PatternProperty::defaultValue());
+                            const auto min = patternProperty.evaluate(*feature, zoom - 1, PatternPropertyType::defaultValue());
+                            const auto mid = patternProperty.evaluate(*feature, zoom, PatternPropertyType::defaultValue());
+                            const auto max = patternProperty.evaluate(*feature, zoom + 1, PatternPropertyType::defaultValue());
 
                             patternDependencies.emplace(min.to, ImageType::Pattern);
                             patternDependencies.emplace(mid.to, ImageType::Pattern);
                             patternDependencies.emplace(max.to, ImageType::Pattern);
-                            patternDependencyMap.emplace(layer->getID(), PatternDependency {min.to, mid.to, max.to});
+                            patternDependencyMap.emplace(layerId, PatternDependency {min.to, mid.to, max.to});
 
                         }
                     }
@@ -99,15 +102,15 @@ public:
     }
 
     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<B>(layout, layerPaintProperties, zoom, overscaling);
+        auto bucket = std::make_shared<BucketType>(layout, layerPaintProperties, zoom, overscaling);
         for (auto & patternFeature : features) {
             const auto i = patternFeature.i;
             std::unique_ptr<GeometryTileFeature> feature = std::move(patternFeature.feature);
-            PatternLayerMap patterns = patternFeature.patterns;
+            const PatternLayerMap& patterns = patternFeature.patterns;
             GeometryCollection geometries = feature->getGeometries();
 
             bucket->addFeature(*feature, geometries, patternPositions, patterns);
-            featureIndex->insert(geometries, i, sourceLayerID, groupID);
+            featureIndex->insert(geometries, i, sourceLayerID, bucketLeaderID);
         }
         if (bucket->hasData()) {
             for (const auto& pair : layerPaintProperties) {
@@ -116,19 +119,18 @@ public:
         }
     };
 
-    std::map<std::string, typename B::PossiblyEvaluatedPaintProperties> layerPaintProperties;
-    const std::string bucketLeaderID;
+    std::map<std::string, PossiblyEvaluatedPaintPropertiesType> layerPaintProperties;
+    std::string bucketLeaderID;
 
 
 private:
     const std::unique_ptr<GeometryTileLayer> sourceLayer;
     std::vector<PatternFeature> features;
-    typename B::PossiblyEvaluatedLayoutProperties layout;
+    PossiblyEvaluatedLayoutPropertiesType layout;
 
     const float zoom;
     const uint32_t overscaling;
     std::string sourceLayerID;
-    std::string groupID;
     bool hasPattern;
 };
 
diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index 03cfe506ec..0eb98f7569 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -40,16 +40,18 @@ expression::Value sectionOptionsToValue(const SectionOptions& options) {
     }
     return result;
 }
-} // namespace
 
+inline const SymbolLayerProperties& toSymbolLayerProperties(const Immutable<LayerProperties>& layer) {
+    return static_cast<const SymbolLayerProperties&>(*layer);
+}
 
+} // namespace
 SymbolLayout::SymbolLayout(const BucketParameters& parameters,
-                           const std::vector<const RenderLayer*>& layers,
+                           const std::vector<Immutable<style::LayerProperties>>& layers,
                            std::unique_ptr<GeometryTileLayer> sourceLayer_,
                            ImageDependencies& imageDependencies,
                            GlyphDependencies& glyphDependencies)
-    : Layout(),
-      bucketLeaderID(layers.at(0)->getID()),
+    : bucketLeaderID(layers.front()->baseImpl->id),
       sourceLayer(std::move(sourceLayer_)),
       overscaling(parameters.tileID.overscaleFactor()),
       zoom(parameters.tileID.overscaledZ),
@@ -57,11 +59,11 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
       pixelRatio(parameters.pixelRatio),
       tileSize(util::tileSize * overscaling),
       tilePixelRatio(float(util::EXTENT) / tileSize),
-      textSize(toRenderSymbolLayer(layers.at(0))->impl().layout.get<TextSize>()),
-      iconSize(toRenderSymbolLayer(layers.at(0))->impl().layout.get<IconSize>())
+      textSize(toSymbolLayerProperties(layers.at(0)).layerImpl().layout.get<TextSize>()),
+      iconSize(toSymbolLayerProperties(layers.at(0)).layerImpl().layout.get<IconSize>())
     {
 
-    const SymbolLayer::Impl& leader = toRenderSymbolLayer(layers.at(0))->impl();
+    const SymbolLayer::Impl& leader = toSymbolLayerProperties(layers.at(0)).layerImpl();
 
     layout = leader.layout.evaluate(PropertyEvaluationParameters(zoom));
 
@@ -104,7 +106,7 @@ SymbolLayout::SymbolLayout(const BucketParameters& parameters,
         layout.get<TextIgnorePlacement>() || layout.get<IconIgnorePlacement>());
 
     for (const auto& layer : layers) {
-        layerPaintProperties.emplace(layer->getID(), toRenderSymbolLayer(layer)->evaluated);
+        layerPaintProperties.emplace(layer->baseImpl->id, toSymbolLayerProperties(layer).evaluated);
     }
 
     // Determine glyph dependencies
diff --git a/src/mbgl/layout/symbol_layout.hpp b/src/mbgl/layout/symbol_layout.hpp
index 9b8b0adfcc..9fc48d904c 100644
--- a/src/mbgl/layout/symbol_layout.hpp
+++ b/src/mbgl/layout/symbol_layout.hpp
@@ -16,7 +16,6 @@ namespace mbgl {
 
 class BucketParameters;
 class Anchor;
-class RenderLayer;
 class PlacedSymbol;
 
 namespace style {
@@ -26,7 +25,7 @@ class Filter;
 class SymbolLayout final : public Layout {
 public:
     SymbolLayout(const BucketParameters&,
-                 const std::vector<const RenderLayer*>&,
+                 const std::vector<Immutable<style::LayerProperties>>&,
                  std::unique_ptr<GeometryTileLayer>,
                  ImageDependencies&,
                  GlyphDependencies&);
diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index 1d775ede04..e345f0b5ec 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -31,9 +31,6 @@ public:
                             const ImagePositions&,
                             const PatternLayerMap&) {};
 
-    virtual void populateFeatureBuffers(const ImagePositions&) {};
-    virtual void addPatternDependencies(const std::vector<const RenderLayer*>&, ImageDependencies&) {};
-
     // As long as this bucket has a Prepare render pass, this function is getting called. Typically,
     // this only happens once when the bucket is being rendered for the first time.
     virtual void upload(gfx::Context&) = 0;
diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp
index 54ed374069..376f4e682f 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.cpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.cpp
@@ -10,14 +10,14 @@ namespace mbgl {
 
 using namespace style;
 
-CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers)
+CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& layers)
     : mode(parameters.mode) {
     for (const auto& layer : layers) {
         paintPropertyBinders.emplace(
             std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
+            std::forward_as_tuple(layer->baseImpl->id),
             std::forward_as_tuple(
-                toRenderCircleLayer(layer)->evaluated,
+                getEvaluated<CircleLayerProperties>(layer),
                 parameters.tileID.overscaledZ));
     }
 }
@@ -99,20 +99,20 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature,
 }
 
 template <class Property>
-static float get(const RenderCircleLayer& layer, const std::map<std::string, CircleProgram::Binders>& paintPropertyBinders) {
-    auto it = paintPropertyBinders.find(layer.getID());
+static float get(const CirclePaintProperties::PossiblyEvaluated& evaluated, const std::string& id, const std::map<std::string, CircleProgram::Binders>& paintPropertyBinders) {
+    auto it = paintPropertyBinders.find(id);
     if (it == paintPropertyBinders.end() || !it->second.statistics<Property>().max()) {
-        return layer.evaluated.get<Property>().constantOr(Property::defaultValue());
+        return evaluated.get<Property>().constantOr(Property::defaultValue());
     } else {
         return *it->second.statistics<Property>().max();
     }
 }
 
 float CircleBucket::getQueryRadius(const RenderLayer& layer) const {
-    const RenderCircleLayer* circleLayer = toRenderCircleLayer(&layer);
-    float radius = get<CircleRadius>(*circleLayer, paintPropertyBinders);
-    float stroke = get<CircleStrokeWidth>(*circleLayer, paintPropertyBinders);
-    auto translate = circleLayer->evaluated.get<CircleTranslate>();
+    const auto& evaluated = getEvaluated<CircleLayerProperties>(layer.evaluatedProperties);
+    float radius = get<CircleRadius>(evaluated, layer.getID(), paintPropertyBinders);
+    float stroke = get<CircleStrokeWidth>(evaluated, layer.getID(), paintPropertyBinders);
+    auto translate = evaluated.get<CircleTranslate>();
     return radius + stroke + util::length(translate[0], translate[1]);
 }
 
diff --git a/src/mbgl/renderer/buckets/circle_bucket.hpp b/src/mbgl/renderer/buckets/circle_bucket.hpp
index e9aceed2b1..58f76327ab 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.hpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.hpp
@@ -15,7 +15,7 @@ class BucketParameters;
 
 class CircleBucket final : public Bucket {
 public:
-    CircleBucket(const BucketParameters&, const std::vector<const RenderLayer*>&);
+    CircleBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&);
     ~CircleBucket() override;
 
     void addFeature(const GeometryTileFeature&,
diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp
index 927cb4a307..2dffc555e2 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.cpp
@@ -141,10 +141,9 @@ bool FillBucket::supportsLayer(const style::Layer::Impl& impl) const {
     return style::FillLayer::Impl::staticTypeInfo() == impl.getTypeInfo();
 }
 
-
 float FillBucket::getQueryRadius(const RenderLayer& layer) const {
-    const RenderFillLayer* fillLayer = toRenderFillLayer(&layer);
-    const std::array<float, 2>& translate = fillLayer->evaluated.get<FillTranslate>();
+    const auto& evaluated = getEvaluated<FillLayerProperties>(layer.evaluatedProperties);
+    const std::array<float, 2>& translate = evaluated.get<FillTranslate>();
     return util::length(translate[0], translate[1]);
 }
 
diff --git a/src/mbgl/renderer/buckets/fill_bucket.hpp b/src/mbgl/renderer/buckets/fill_bucket.hpp
index e1869e08d2..5844625d2a 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.hpp
@@ -18,8 +18,6 @@ class RenderFillLayer;
 class FillBucket final : public Bucket {
 public:
     ~FillBucket() override;
-    // These aliases are used by the PatternLayout template
-    using RenderLayerType = RenderFillLayer;
     using PossiblyEvaluatedPaintProperties = style::FillPaintProperties::PossiblyEvaluated;
     using PossiblyEvaluatedLayoutProperties = style::Properties<>::PossiblyEvaluated;
 
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
index e640cf504d..61fc6a1444 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
@@ -185,8 +185,8 @@ bool FillExtrusionBucket::supportsLayer(const style::Layer::Impl& impl) const {
 }
 
 float FillExtrusionBucket::getQueryRadius(const RenderLayer& layer) const {
-    const RenderFillExtrusionLayer* fillExtrusionLayer = toRenderFillExtrusionLayer(&layer);
-    const std::array<float, 2>& translate = fillExtrusionLayer->evaluated.get<FillExtrusionTranslate>();
+    const auto& evaluated = getEvaluated<FillExtrusionLayerProperties>(layer.evaluatedProperties);
+    const std::array<float, 2>& translate = evaluated.get<FillExtrusionTranslate>();
     return util::length(translate[0], translate[1]);
 }
 
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
index 81685e2c42..9dc2681bac 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
@@ -16,8 +16,6 @@ class RenderFillExtrusionLayer;
 class FillExtrusionBucket final : public Bucket {
 public:
     ~FillExtrusionBucket() override;
-    // These aliases are used by the PatternLayout template
-    using RenderLayerType = RenderFillExtrusionLayer;
     using PossiblyEvaluatedPaintProperties = style::FillExtrusionPaintProperties::PossiblyEvaluated;
     using PossiblyEvaluatedLayoutProperties = style::Properties<>::PossiblyEvaluated;
 
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
index 04fd58ec55..111911a88c 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
@@ -10,14 +10,14 @@ namespace mbgl {
 
 using namespace style;
 
-HeatmapBucket::HeatmapBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers)
+HeatmapBucket::HeatmapBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& layers)
     : mode(parameters.mode) {
     for (const auto& layer : layers) {
         paintPropertyBinders.emplace(
             std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
+            std::forward_as_tuple(layer->baseImpl->id),
             std::forward_as_tuple(
-                toRenderHeatmapLayer(layer)->evaluated,
+                getEvaluated<HeatmapLayerProperties>(layer),
                 parameters.tileID.overscaledZ));
     }
 }
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.hpp b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
index 62cb460e27..b11c1626cd 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.hpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
@@ -15,7 +15,7 @@ class BucketParameters;
 
 class HeatmapBucket final : public Bucket {
 public:
-    HeatmapBucket(const BucketParameters&, const std::vector<const RenderLayer*>&);
+    HeatmapBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&);
     ~HeatmapBucket() override;
 
     void addFeature(const GeometryTileFeature&,
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index 13f575ba38..9a5ed9e628 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -11,10 +11,10 @@ namespace mbgl {
 using namespace style;
 
 LineBucket::LineBucket(const style::LineLayoutProperties::PossiblyEvaluated layout_,
-                       std::map<std::string, style::LinePaintProperties::PossiblyEvaluated> layerPaintProperties,
+                       const std::map<std::string, style::LinePaintProperties::PossiblyEvaluated>& layerPaintProperties,
                        const float zoom_,
                        const uint32_t overscaling_)
-    : layout(layout_),
+    : layout(std::move(layout_)),
       zoom(zoom_),
       overscaling(overscaling_) {
 
@@ -528,31 +528,26 @@ bool LineBucket::supportsLayer(const style::Layer::Impl& impl) const {
 }
 
 template <class Property>
-static float get(const RenderLineLayer& layer, const std::map<std::string, LineProgram::Binders>& paintPropertyBinders) {
-    auto it = paintPropertyBinders.find(layer.getID());
+static float get(const LinePaintProperties::PossiblyEvaluated& evaluated, const std::string& id, const std::map<std::string, LineProgram::Binders>& paintPropertyBinders) {
+    auto it = paintPropertyBinders.find(id);
     if (it == paintPropertyBinders.end() || !it->second.statistics<Property>().max()) {
-        return layer.evaluated.get<Property>().constantOr(Property::defaultValue());
+        return evaluated.get<Property>().constantOr(Property::defaultValue());
     } else {
         return *it->second.statistics<Property>().max();
     }
 }
 
-float LineBucket::getLineWidth(const RenderLineLayer& layer) const {
-    float lineWidth = get<LineWidth>(layer, paintPropertyBinders);
-    float gapWidth = get<LineGapWidth>(layer, paintPropertyBinders);
-
+float LineBucket::getQueryRadius(const RenderLayer& layer) const {
+    const auto& evaluated = getEvaluated<LineLayerProperties>(layer.evaluatedProperties);
+    const std::array<float, 2>& translate = evaluated.get<LineTranslate>();
+    float offset = get<LineOffset>(evaluated, layer.getID(), paintPropertyBinders);
+    float lineWidth = get<LineWidth>(evaluated, layer.getID(), paintPropertyBinders);
+    float gapWidth = get<LineGapWidth>(evaluated, layer.getID(), paintPropertyBinders);
     if (gapWidth) {
-        return gapWidth + 2 * lineWidth;
-    } else {
-        return lineWidth;
+        lineWidth = gapWidth + 2 * lineWidth;
     }
-}
 
-float LineBucket::getQueryRadius(const RenderLayer& layer) const {
-    const RenderLineLayer* lineLayer = toRenderLineLayer(&layer);
-    const std::array<float, 2>& translate = lineLayer->evaluated.get<LineTranslate>();
-    float offset = get<LineOffset>(*lineLayer, paintPropertyBinders);
-    return getLineWidth(*lineLayer) / 2.0 + std::abs(offset) + util::length(translate[0], translate[1]);
+    return lineWidth / 2.0f + std::abs(offset) + util::length(translate[0], translate[1]);
 }
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp
index 7ee8677e50..6717ee7446 100644
--- a/src/mbgl/renderer/buckets/line_bucket.hpp
+++ b/src/mbgl/renderer/buckets/line_bucket.hpp
@@ -17,14 +17,11 @@ class RenderLineLayer;
 
 class LineBucket final : public Bucket {
 public:
-
-    // These aliases are used by the PatternLayout template
-    using RenderLayerType = RenderLineLayer;
     using PossiblyEvaluatedPaintProperties = style::LinePaintProperties::PossiblyEvaluated;
     using PossiblyEvaluatedLayoutProperties = style::LineLayoutProperties::PossiblyEvaluated;
 
     LineBucket(const PossiblyEvaluatedLayoutProperties layout,
-               std::map<std::string, PossiblyEvaluatedPaintProperties> layerPaintProperties,
+               const std::map<std::string, PossiblyEvaluatedPaintProperties>& layerPaintProperties,
                const float zoom,
                const uint32_t overscaling);
     ~LineBucket() override;
@@ -77,8 +74,6 @@ private:
 
     const float zoom;
     const uint32_t overscaling;
-
-    float getLineWidth(const RenderLineLayer& layer) const;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/group_by_layout.cpp b/src/mbgl/renderer/group_by_layout.cpp
index 41a895902c..5f78dd0d2b 100644
--- a/src/mbgl/renderer/group_by_layout.cpp
+++ b/src/mbgl/renderer/group_by_layout.cpp
@@ -1,6 +1,4 @@
 #include <mbgl/renderer/group_by_layout.hpp>
-#include <mbgl/renderer/render_layer.hpp>
-#include <mbgl/style/layer_impl.hpp>
 #include <mbgl/style/conversion/stringify.hpp>
 #include <mbgl/util/rapidjson.hpp>
 
@@ -11,38 +9,24 @@
 
 namespace mbgl {
 
-std::string layoutKey(const RenderLayer& layer) {
+std::string layoutKey(const style::Layer::Impl& impl) {
     using namespace style::conversion;
 
     rapidjson::StringBuffer s;
     rapidjson::Writer<rapidjson::StringBuffer> writer(s);
 
     writer.StartArray();
-    writer.Uint64(reinterpret_cast<uint64_t>(layer.baseImpl->getTypeInfo()));
-    writer.String(layer.baseImpl->source);
-    writer.String(layer.baseImpl->sourceLayer);
-    writer.Double(layer.baseImpl->minZoom);
-    writer.Double(layer.baseImpl->maxZoom);
-    writer.Uint(static_cast<uint32_t>(layer.baseImpl->visibility));
-    stringify(writer, layer.baseImpl->filter);
-    layer.baseImpl->stringifyLayout(writer);
+    writer.Uint64(reinterpret_cast<uint64_t>(impl.getTypeInfo()));
+    writer.String(impl.source);
+    writer.String(impl.sourceLayer);
+    writer.Double(impl.minZoom);
+    writer.Double(impl.maxZoom);
+    writer.Uint(static_cast<uint32_t>(impl.visibility));
+    stringify(writer, impl.filter);
+    impl.stringifyLayout(writer);
     writer.EndArray();
 
     return s.GetString();
 }
 
-std::vector<std::vector<const RenderLayer*>> groupByLayout(const std::vector<std::unique_ptr<RenderLayer>>& layers) {
-    std::unordered_map<std::string, std::vector<const RenderLayer*>> map;
-    for (auto& layer : layers) {
-        map[layoutKey(*layer)].push_back(layer.get());
-    }
-
-    std::vector<std::vector<const RenderLayer*>> result;
-    for (auto& pair : map) {
-        result.push_back(pair.second);
-    }
-
-    return result;
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/group_by_layout.hpp b/src/mbgl/renderer/group_by_layout.hpp
index bc3ecfae63..0a91465e92 100644
--- a/src/mbgl/renderer/group_by_layout.hpp
+++ b/src/mbgl/renderer/group_by_layout.hpp
@@ -1,12 +1,12 @@
 #pragma once
 
+#include <mbgl/style/layer_impl.hpp>
+
 #include <vector>
 #include <memory>
 
 namespace mbgl {
 
-class RenderLayer;
-
-std::vector<std::vector<const RenderLayer*>> groupByLayout(const std::vector<std::unique_ptr<RenderLayer>>&);
+std::string layoutKey(const style::Layer::Impl& impl);
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index b633ad0671..d5ba8c879f 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -14,25 +14,30 @@ namespace mbgl {
 
 using namespace style;
 
-RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()) {
+inline const BackgroundLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const style::BackgroundLayer::Impl&>(*impl);
 }
 
-const style::BackgroundLayer::Impl& RenderBackgroundLayer::impl() const {
-    return static_cast<const style::BackgroundLayer::Impl&>(*baseImpl);
+RenderBackgroundLayer::RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl> _impl)
+    : RenderLayer(makeMutable<BackgroundLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
+RenderBackgroundLayer::~RenderBackgroundLayer() = default;
+
 void RenderBackgroundLayer::transition(const TransitionParameters &parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
-    evaluated = unevaluated.evaluate(parameters);
-    crossfade = parameters.getCrossfadeParameters();
-
-    passes = evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent
-                                                           : RenderPass::None;
+    auto properties = makeMutable<BackgroundLayerProperties>(
+        staticImmutableCast<BackgroundLayer::Impl>(baseImpl),
+        parameters.getCrossfadeParameters(),
+        unevaluated.evaluate(parameters));
+
+    passes = properties->evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent
+                                                                       : RenderPass::None;
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderBackgroundLayer::hasTransition() const {
@@ -40,7 +45,7 @@ bool RenderBackgroundLayer::hasTransition() const {
 }
 
 bool RenderBackgroundLayer::hasCrossfade() const {
-    return crossfade.t != 1;
+    return static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
 }
 
 void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
@@ -81,7 +86,8 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
             getID()
         );
     };
-
+    const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
+    const auto& crossfade = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).crossfade;
     if (!evaluated.get<BackgroundPattern>().to.empty()) {
         optional<ImagePosition> imagePosA = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().from);
         optional<ImagePosition> imagePosB = parameters.imageManager.getPattern(evaluated.get<BackgroundPattern>().to);
@@ -123,6 +129,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
 }
 
 optional<Color> RenderBackgroundLayer::getSolidBackground() const {
+    const auto& evaluated = static_cast<const BackgroundLayerProperties&>(*evaluatedProperties).evaluated;
     if (!evaluated.get<BackgroundPattern>().from.empty()) {
         return nullopt;
     }
diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp
index 3cb30ac2a3..de553eef90 100644
--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -6,25 +6,21 @@
 
 namespace mbgl {
 
-class RenderBackgroundLayer: public RenderLayer {
+class RenderBackgroundLayer final : public RenderLayer {
 public:
-    RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl>);
-    ~RenderBackgroundLayer() final = default;
+    explicit RenderBackgroundLayer(Immutable<style::BackgroundLayer::Impl>);
+    ~RenderBackgroundLayer() override;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
-    optional<Color> getSolidBackground() const final;
+    optional<Color> getSolidBackground() const override;
     void render(PaintParameters&, RenderSource*) override;
 
     // Paint properties
     style::BackgroundPaintProperties::Unevaluated unevaluated;
-    style::BackgroundPaintProperties::PossiblyEvaluated evaluated;
-
-    const style::BackgroundLayer::Impl& impl() const;
-private:
-    CrossfadeParameters crossfade;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index ad4e6a020f..9df20cf874 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -15,21 +15,24 @@ namespace mbgl {
 
 using namespace style;
 
-RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()) {
+inline const style::CircleLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const style::CircleLayer::Impl&>(*impl);
 }
 
-const style::CircleLayer::Impl& RenderCircleLayer::impl() const {
-    return static_cast<const style::CircleLayer::Impl&>(*baseImpl);
+RenderCircleLayer::RenderCircleLayer(Immutable<style::CircleLayer::Impl> _impl)
+    : RenderLayer(makeMutable<CircleLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
 void RenderCircleLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
+    auto properties = makeMutable<CircleLayerProperties>(
+        staticImmutableCast<CircleLayer::Impl>(baseImpl),
+        unevaluated.evaluate(parameters));
+    const auto& evaluated = properties->evaluated;
 
     passes = ((evaluated.get<style::CircleRadius>().constantOr(1) > 0 ||
                evaluated.get<style::CircleStrokeWidth>().constantOr(1) > 0)
@@ -38,6 +41,7 @@ void RenderCircleLayer::evaluate(const PropertyEvaluationParameters& parameters)
               && (evaluated.get<style::CircleOpacity>().constantOr(1) > 0 ||
                   evaluated.get<style::CircleStrokeOpacity>().constantOr(1) > 0))
              ? RenderPass::Translucent : RenderPass::None;
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderCircleLayer::hasTransition() const {
@@ -52,7 +56,7 @@ void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
-
+    const auto& evaluated = static_cast<const CircleLayerProperties&>(*evaluatedProperties).evaluated;
     const bool scaleWithMap = evaluated.get<CirclePitchScale>() == CirclePitchScaleType::Map;
     const bool pitchWithMap = evaluated.get<CirclePitchAlignment>() == AlignmentType::Map;
 
@@ -139,7 +143,7 @@ bool RenderCircleLayer::queryIntersectsFeature(
         const TransformState& transformState,
         const float pixelsToTileUnits,
         const mat4& posMatrix) const {
-
+    const auto& evaluated = static_cast<const CircleLayerProperties&>(*evaluatedProperties).evaluated;
     // Translate query geometry
     const GeometryCoordinates& translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp
index 8b0678f6d8..fbe67c91ac 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -6,11 +6,12 @@
 
 namespace mbgl {
 
-class RenderCircleLayer: public RenderLayer {
+class RenderCircleLayer final : public RenderLayer {
 public:
-    RenderCircleLayer(Immutable<style::CircleLayer::Impl>);
+    explicit RenderCircleLayer(Immutable<style::CircleLayer::Impl>);
     ~RenderCircleLayer() final = default;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -27,13 +28,6 @@ public:
 
     // Paint properties
     style::CirclePaintProperties::Unevaluated unevaluated;
-    style::CirclePaintProperties::PossiblyEvaluated evaluated;
-
-    const style::CircleLayer::Impl& impl() const;
 };
 
-inline const RenderCircleLayer* toRenderCircleLayer(const RenderLayer* layer) {
-    return static_cast<const RenderCircleLayer*>(layer);
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index 9284ed8238..4148de1ddd 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -14,8 +14,13 @@ namespace mbgl {
 
 using namespace style;
 
+inline const CustomLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const CustomLayer::Impl&>(*impl);
+}
+
 RenderCustomLayer::RenderCustomLayer(Immutable<style::CustomLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)), host(impl().host) {
+    : RenderLayer(makeMutable<CustomLayerProperties>(std::move(_impl))),
+      host(impl(baseImpl).host) {
     assert(gfx::BackendScope::exists());
     MBGL_CHECK_ERROR(host->initialize());
 }
@@ -29,12 +34,9 @@ RenderCustomLayer::~RenderCustomLayer() {
     }
 }
 
-const CustomLayer::Impl& RenderCustomLayer::impl() const {
-    return static_cast<const CustomLayer::Impl&>(*baseImpl);
-}
-
 void RenderCustomLayer::evaluate(const PropertyEvaluationParameters&) {
     passes = RenderPass::Translucent;
+    // It is fine to not update `evaluatedProperties`, as `baseImpl` should never be updated for this layer.
 }
 
 bool RenderCustomLayer::hasTransition() const {
@@ -49,12 +51,12 @@ void RenderCustomLayer::markContextDestroyed() {
 }
 
 void RenderCustomLayer::render(PaintParameters& paintParameters, RenderSource*) {
-    if (host != impl().host) {
+    if (host != impl(baseImpl).host) {
         //If the context changed, deinitialize the previous one before initializing the new one.
         if (host && !contextDestroyed) {
             MBGL_CHECK_ERROR(host->deinitialize());
         }
-        host = impl().host;
+        host = impl(baseImpl).host;
         MBGL_CHECK_ERROR(host->initialize());
     }
 
diff --git a/src/mbgl/renderer/layers/render_custom_layer.hpp b/src/mbgl/renderer/layers/render_custom_layer.hpp
index 37b8592172..0c364cfc0c 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.hpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.hpp
@@ -5,22 +5,20 @@
 
 namespace mbgl {
 
-class RenderCustomLayer: public RenderLayer {
+class RenderCustomLayer final : public RenderLayer {
 public:
-    RenderCustomLayer(Immutable<style::CustomLayer::Impl>);
-    ~RenderCustomLayer() final;
+    explicit RenderCustomLayer(Immutable<style::CustomLayer::Impl>);
+    ~RenderCustomLayer() override;
 
-    void transition(const TransitionParameters&) final {}
+private:
+    void transition(const TransitionParameters&) override {}
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
-    void markContextDestroyed() final;
-
-    void render(PaintParameters&, RenderSource*) final;
+    void markContextDestroyed() override;
 
-    const style::CustomLayer::Impl& impl() const;
+    void render(PaintParameters&, RenderSource*) override;
 
-private:
     bool contextDestroyed = false;
     std::shared_ptr<style::CustomLayerHost> host;
 };
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 4041e420df..a313f53f1c 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -20,26 +20,31 @@ namespace mbgl {
 
 using namespace style;
 
-RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()) {
+inline const FillExtrusionLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const FillExtrusionLayer::Impl&>(*impl);
 }
 
-const style::FillExtrusionLayer::Impl& RenderFillExtrusionLayer::impl() const {
-    return static_cast<const style::FillExtrusionLayer::Impl&>(*baseImpl);
+RenderFillExtrusionLayer::RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl> _impl)
+    : RenderLayer(makeMutable<FillExtrusionLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
+RenderFillExtrusionLayer::~RenderFillExtrusionLayer() = default;
+
 void RenderFillExtrusionLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderFillExtrusionLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
-    crossfade = parameters.getCrossfadeParameters();
+    auto properties = makeMutable<FillExtrusionLayerProperties>(
+        staticImmutableCast<FillExtrusionLayer::Impl>(baseImpl),
+        parameters.getCrossfadeParameters(),
+        unevaluated.evaluate(parameters));
 
-    passes = (evaluated.get<style::FillExtrusionOpacity>() > 0)
+    passes = (properties->evaluated.get<style::FillExtrusionOpacity>() > 0)
                  ? (RenderPass::Translucent | RenderPass::Pass3D)
                  : RenderPass::None;
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderFillExtrusionLayer::hasTransition() const {
@@ -47,14 +52,15 @@ bool RenderFillExtrusionLayer::hasTransition() const {
 }
 
 bool RenderFillExtrusionLayer::hasCrossfade() const {
-    return crossfade.t != 1;
+    return static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
 }
 
 void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
-
+    const auto& evaluated = static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).evaluated;
+    const auto& crossfade = static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).crossfade;
     if (parameters.pass == RenderPass::Pass3D) {
         const auto& size = parameters.staticData.backendSize;
 
@@ -222,7 +228,7 @@ bool RenderFillExtrusionLayer::queryIntersectsFeature(
         const TransformState& transformState,
         const float pixelsToTileUnits,
         const mat4&) const {
-
+    const auto& evaluated = static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).evaluated;
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
             evaluated.get<style::FillExtrusionTranslate>(),
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
index 6f14fcd7a8..fa50ac6f2c 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -7,19 +7,12 @@
 
 namespace mbgl {
 
-template <class B>
-class PatternLayout;
-
-class FillExtrusionBucket;
-
-class RenderFillExtrusionLayer: public RenderLayer {
+class RenderFillExtrusionLayer final : public RenderLayer {
 public:
-    using StyleLayerImpl = style::FillExtrusionLayer::Impl;
-    using PatternProperty = style::FillExtrusionPattern;
-
-    RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl>);
-    ~RenderFillExtrusionLayer() final = default;
+    explicit RenderFillExtrusionLayer(Immutable<style::FillExtrusionLayer::Impl>);
+    ~RenderFillExtrusionLayer() override;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -36,17 +29,8 @@ public:
 
     // Paint properties
     style::FillExtrusionPaintProperties::Unevaluated unevaluated;
-    style::FillExtrusionPaintProperties::PossiblyEvaluated evaluated;
-
-    const style::FillExtrusionLayer::Impl& impl() const;
 
     std::unique_ptr<gfx::OffscreenTexture> renderTexture;
-private:
-    CrossfadeParameters crossfade;
 };
 
-inline const RenderFillExtrusionLayer* toRenderFillExtrusionLayer(const RenderLayer* layer) {
-    return static_cast<const RenderFillExtrusionLayer*>(layer);
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index e6447c83a4..5b0f020290 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -20,22 +20,27 @@ namespace mbgl {
 
 using namespace style;
 
-RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()) {
+inline const FillLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const FillLayer::Impl&>(*impl);
 }
 
-const style::FillLayer::Impl& RenderFillLayer::impl() const {
-    return static_cast<const style::FillLayer::Impl&>(*baseImpl);
+RenderFillLayer::RenderFillLayer(Immutable<style::FillLayer::Impl> _impl)
+    : RenderLayer(makeMutable<FillLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
+RenderFillLayer::~RenderFillLayer() = default;
+
 void RenderFillLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
-    crossfade = parameters.getCrossfadeParameters();
+    auto properties = makeMutable<FillLayerProperties>(
+        staticImmutableCast<FillLayer::Impl>(baseImpl),
+        parameters.getCrossfadeParameters(),
+        unevaluated.evaluate(parameters));
+    auto& evaluated = properties->evaluated;
 
     if (unevaluated.get<style::FillOutlineColor>().isUndefined()) {
         evaluated.get<style::FillOutlineColor>() = evaluated.get<style::FillColor>();
@@ -54,6 +59,8 @@ void RenderFillLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     } else {
         passes |= RenderPass::Opaque;
     }
+
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderFillLayer::hasTransition() const {
@@ -61,10 +68,12 @@ bool RenderFillLayer::hasTransition() const {
 }
 
 bool RenderFillLayer::hasCrossfade() const {
-    return crossfade.t != 1;
+    return static_cast<const FillLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
 }
 
 void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
+    const auto& evaluated = static_cast<const FillLayerProperties&>(*evaluatedProperties).evaluated;
+    const auto& crossfade = static_cast<const FillLayerProperties&>(*evaluatedProperties).crossfade;
     if (unevaluated.get<FillPattern>().isUndefined()) {
         for (const RenderTile& tile : renderTiles) {
             auto bucket_ = tile.tile.getBucket<FillBucket>(*baseImpl);
@@ -240,7 +249,7 @@ bool RenderFillLayer::queryIntersectsFeature(
         const TransformState& transformState,
         const float pixelsToTileUnits,
         const mat4&) const {
-
+    const auto& evaluated = static_cast<const FillLayerProperties&>(*evaluatedProperties).evaluated;
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
             evaluated.get<style::FillTranslate>(),
diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp
index 1c7ee6556e..5d5206efe2 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -9,14 +9,12 @@ namespace mbgl {
 
 class FillBucket;
 
-class RenderFillLayer: public RenderLayer {
+class RenderFillLayer final : public RenderLayer {
 public:
-    using StyleLayerImpl = style::FillLayer::Impl;
-    using PatternProperty = style::FillPattern;
-
-    RenderFillLayer(Immutable<style::FillLayer::Impl>);
-    ~RenderFillLayer() final = default;
+    explicit RenderFillLayer(Immutable<style::FillLayer::Impl>);
+    ~RenderFillLayer() override;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -33,16 +31,6 @@ public:
 
     // Paint properties
     style::FillPaintProperties::Unevaluated unevaluated;
-    style::FillPaintProperties::PossiblyEvaluated evaluated;
-
-    const style::FillLayer::Impl& impl() const;
-private:
-    CrossfadeParameters crossfade;
-
 };
 
-inline const RenderFillLayer* toRenderFillLayer(const RenderLayer* layer) {
-    return static_cast<const RenderFillLayer*>(layer);
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 333b8f9890..92b54c6cc8 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -19,25 +19,31 @@ namespace mbgl {
 
 using namespace style;
 
-RenderHeatmapLayer::RenderHeatmapLayer(Immutable<style::HeatmapLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-    unevaluated(impl().paint.untransitioned()), colorRamp({256, 1}) {
+inline const HeatmapLayer::Impl& impl(const Immutable<Layer::Impl>& impl) {
+    return static_cast<const HeatmapLayer::Impl&>(*impl);
 }
 
-const style::HeatmapLayer::Impl& RenderHeatmapLayer::impl() const {
-    return static_cast<const style::HeatmapLayer::Impl&>(*baseImpl);
+RenderHeatmapLayer::RenderHeatmapLayer(Immutable<HeatmapLayer::Impl> _impl)
+    : RenderLayer(makeMutable<HeatmapLayerProperties>(std::move(_impl))),
+    unevaluated(impl(baseImpl).paint.untransitioned()), colorRamp({256, 1}) {
 }
 
+RenderHeatmapLayer::~RenderHeatmapLayer() = default;
+
 void RenderHeatmapLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderHeatmapLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
+    auto properties = makeMutable<HeatmapLayerProperties>(
+        staticImmutableCast<HeatmapLayer::Impl>(baseImpl),
+        unevaluated.evaluate(parameters));
 
-    passes = (evaluated.get<style::HeatmapOpacity>() > 0)
+    passes = (properties->evaluated.get<style::HeatmapOpacity>() > 0)
             ? (RenderPass::Translucent | RenderPass::Pass3D)
             : RenderPass::None;
+
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderHeatmapLayer::hasTransition() const {
@@ -52,7 +58,7 @@ void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
-
+    const auto& evaluated = static_cast<const HeatmapLayerProperties&>(*evaluatedProperties).evaluated;
     if (parameters.pass == RenderPass::Pass3D) {
         const auto& viewportSize = parameters.staticData.backendSize;
         const auto size = Size{viewportSize.width / 4, viewportSize.height / 4};
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
index 22fe48f374..50a7d72e94 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -9,11 +9,12 @@
 
 namespace mbgl {
 
-class RenderHeatmapLayer: public RenderLayer {
+class RenderHeatmapLayer final : public RenderLayer {
 public:
-    RenderHeatmapLayer(Immutable<style::HeatmapLayer::Impl>);
-    ~RenderHeatmapLayer() final = default;
+    explicit RenderHeatmapLayer(Immutable<style::HeatmapLayer::Impl>);
+    ~RenderHeatmapLayer() override;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -31,20 +32,11 @@ public:
 
     // Paint properties
     style::HeatmapPaintProperties::Unevaluated unevaluated;
-    style::HeatmapPaintProperties::PossiblyEvaluated evaluated;
-
-    const style::HeatmapLayer::Impl& impl() const;
-
     PremultipliedImage colorRamp;
     std::unique_ptr<gfx::OffscreenTexture> renderTexture;
     optional<gfx::Texture> colorRampTexture;
 
-private:
     void updateColorRamp();
 };
 
-inline const RenderHeatmapLayer* toRenderHeatmapLayer(const RenderLayer* layer) {
-    return static_cast<const RenderHeatmapLayer*>(layer);
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 08efa898f6..19af5b6202 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -17,36 +17,44 @@
 namespace mbgl {
 
 using namespace style;
-RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()) {
+
+inline const HillshadeLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const HillshadeLayer::Impl&>(*impl);
 }
 
-const style::HillshadeLayer::Impl& RenderHillshadeLayer::impl() const {
-    return static_cast<const style::HillshadeLayer::Impl&>(*baseImpl);
+RenderHillshadeLayer::RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl> _impl)
+    : RenderLayer(makeMutable<HillshadeLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
+RenderHillshadeLayer::~RenderHillshadeLayer() = default;
+
 const std::array<float, 2> RenderHillshadeLayer::getLatRange(const UnwrappedTileID& id) {
    const LatLng latlng0 = LatLng(id);
    const LatLng latlng1 = LatLng(UnwrappedTileID(id.canonical.z, id.canonical.x, id.canonical.y + 1));
    return {{ (float)latlng0.latitude(), (float)latlng1.latitude() }};
 }
 
-const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters){
+const std::array<float, 2> RenderHillshadeLayer::getLight(const PaintParameters& parameters) {
+    const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;
     float azimuthal = evaluated.get<HillshadeIlluminationDirection>() * util::DEG2RAD;
     if (evaluated.get<HillshadeIlluminationAnchor>() == HillshadeIlluminationAnchorType::Viewport) azimuthal = azimuthal - parameters.state.getBearing();
     return {{evaluated.get<HillshadeExaggeration>(), azimuthal}};
 }
 
 void RenderHillshadeLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderHillshadeLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
-    passes = (evaluated.get<style::HillshadeExaggeration >() > 0)
+    auto properties = makeMutable<HillshadeLayerProperties>(
+        staticImmutableCast<HillshadeLayer::Impl>(baseImpl),
+        unevaluated.evaluate(parameters));
+    passes = (properties->evaluated.get<style::HillshadeExaggeration >() > 0)
                  ? (RenderPass::Translucent | RenderPass::Pass3D)
                  : RenderPass::None;
+
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderHillshadeLayer::hasTransition() const {
@@ -60,7 +68,7 @@ bool RenderHillshadeLayer::hasCrossfade() const {
 void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src) {
     if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D)
         return;
-
+    const auto& evaluated = static_cast<const HillshadeLayerProperties&>(*evaluatedProperties).evaluated;
     auto* demsrc = static_cast<RenderRasterDEMSource*>(src);
     const uint8_t TERRAIN_RGB_MAXZOOM = 15;
     const uint8_t maxzoom = demsrc != nullptr ? demsrc->getMaxZoom() : TERRAIN_RGB_MAXZOOM;
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.hpp b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
index 3985389763..7c7bc10835 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
@@ -9,9 +9,10 @@ namespace mbgl {
 
 class RenderHillshadeLayer: public RenderLayer {
 public:
-    RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl>);
-    ~RenderHillshadeLayer() final = default;
+    explicit RenderHillshadeLayer(Immutable<style::HillshadeLayer::Impl>);
+    ~RenderHillshadeLayer() override;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -21,10 +22,7 @@ public:
 
     // Paint properties
     style::HillshadePaintProperties::Unevaluated unevaluated;
-    style::HillshadePaintProperties::PossiblyEvaluated evaluated;
 
-    const style::HillshadeLayer::Impl& impl() const;
-private:
     const std::array<float, 2> getLatRange(const UnwrappedTileID& id);
     const std::array<float, 2> getLight(const PaintParameters& parameters);
 };
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 2ea910f911..cf4d3ed9b2 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -18,28 +18,34 @@ namespace mbgl {
 
 using namespace style;
 
+inline const LineLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const LineLayer::Impl&>(*impl);
+}
+
 RenderLineLayer::RenderLineLayer(Immutable<style::LineLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()),
+    : RenderLayer(makeMutable<LineLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()),
       colorRamp({256, 1}) {
 }
 
-const style::LineLayer::Impl& RenderLineLayer::impl() const {
-    return static_cast<const style::LineLayer::Impl&>(*baseImpl);
-}
+RenderLineLayer::~RenderLineLayer() = default;
 
 void RenderLineLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
-    crossfade = parameters.getCrossfadeParameters();
+    auto properties = makeMutable<LineLayerProperties>(
+        staticImmutableCast<LineLayer::Impl>(baseImpl),
+        parameters.getCrossfadeParameters(),
+        unevaluated.evaluate(parameters));
+    auto& evaluated = properties->evaluated;
 
     passes = (evaluated.get<style::LineOpacity>().constantOr(1.0) > 0
               && evaluated.get<style::LineColor>().constantOr(Color::black()).a > 0
               && evaluated.get<style::LineWidth>().constantOr(1.0) > 0)
              ? RenderPass::Translucent : RenderPass::None;
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderLineLayer::hasTransition() const {
@@ -47,13 +53,15 @@ bool RenderLineLayer::hasTransition() const {
 }
 
 bool RenderLineLayer::hasCrossfade() const {
-    return crossfade.t != 1;
+    return static_cast<const LineLayerProperties&>(*evaluatedProperties).crossfade.t != 1;
 }
 
 void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
+    const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
+    const auto& crossfade = static_cast<const LineLayerProperties&>(*evaluatedProperties).crossfade;
 
     for (const RenderTile& tile : renderTiles) {
         auto bucket_ = tile.tile.getBucket<LineBucket>(*baseImpl);
@@ -213,7 +221,7 @@ bool RenderLineLayer::queryIntersectsFeature(
         const TransformState& transformState,
         const float pixelsToTileUnits,
         const mat4&) const {
-
+    const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
     // Translate query geometry
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
@@ -259,6 +267,7 @@ void RenderLineLayer::updateColorRamp() {
 }
 
 float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom) const {
+    const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
     float lineWidth = evaluated.get<style::LineWidth>()
             .evaluate(feature, zoom, style::LineWidth::defaultValue());
     float gapWidth = evaluated.get<style::LineGapWidth>()
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index cb4492ebc3..da64f58455 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -10,20 +10,18 @@
 
 namespace mbgl {
 
-class RenderLineLayer: public RenderLayer {
+class RenderLineLayer final : public RenderLayer {
 public:
-    using StyleLayerImpl = style::LineLayer::Impl;
-    using PatternProperty = style::LinePattern;
-
-    RenderLineLayer(Immutable<style::LineLayer::Impl>);
-    ~RenderLineLayer() final = default;
+    explicit RenderLineLayer(Immutable<style::LineLayer::Impl>);
+    ~RenderLineLayer() override;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
-    void update() final;
+    void update() override;
 
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
@@ -35,20 +33,12 @@ public:
 
     // Paint properties
     style::LinePaintProperties::Unevaluated unevaluated;
-    style::LinePaintProperties::PossiblyEvaluated evaluated;
-
-    const style::LineLayer::Impl& impl() const;
 
-private:
     float getLineWidth(const GeometryTileFeature&, const float) const;
     void updateColorRamp();
-    CrossfadeParameters crossfade;
+
     PremultipliedImage colorRamp;
     optional<gfx::Texture> colorRampTexture;
 };
 
-inline const RenderLineLayer* toRenderLineLayer(const RenderLayer* layer) {
-    return static_cast<const RenderLineLayer*>(layer);
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index 55caeaf5b0..48ca0584fc 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -14,23 +14,27 @@ namespace mbgl {
 
 using namespace style;
 
-RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()) {
+inline const RasterLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const RasterLayer::Impl&>(*impl);
 }
 
-const style::RasterLayer::Impl& RenderRasterLayer::impl() const {
-    return static_cast<const style::RasterLayer::Impl&>(*baseImpl);
+RenderRasterLayer::RenderRasterLayer(Immutable<style::RasterLayer::Impl> _impl)
+    : RenderLayer(makeMutable<RasterLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
+RenderRasterLayer::~RenderRasterLayer() = default;
+
 void RenderRasterLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderRasterLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
-
-    passes = evaluated.get<style::RasterOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None;
+    auto properties = makeMutable<RasterLayerProperties>(
+        staticImmutableCast<RasterLayer::Impl>(baseImpl),
+        unevaluated.evaluate(parameters));
+    passes = properties->evaluated.get<style::RasterOpacity>() > 0 ? RenderPass::Translucent : RenderPass::None;
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderRasterLayer::hasTransition() const {
@@ -72,7 +76,7 @@ static std::array<float, 3> spinWeights(float spin) {
 void RenderRasterLayer::render(PaintParameters& parameters, RenderSource* source) {
     if (parameters.pass != RenderPass::Translucent)
         return;
-
+    const auto& evaluated = static_cast<const RasterLayerProperties&>(*evaluatedProperties).evaluated;
     RasterProgram::Binders paintAttributeData{ evaluated, 0 };
 
     auto draw = [&] (const mat4& matrix,
diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp
index 516c163c27..9d70e9fb4d 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -6,11 +6,12 @@
 
 namespace mbgl {
 
-class RenderRasterLayer: public RenderLayer {
+class RenderRasterLayer final : public RenderLayer {
 public:
-    RenderRasterLayer(Immutable<style::RasterLayer::Impl>);
-    ~RenderRasterLayer() final = default;
+    explicit RenderRasterLayer(Immutable<style::RasterLayer::Impl>);
+    ~RenderRasterLayer() override;
 
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -20,9 +21,6 @@ public:
 
     // Paint properties
     style::RasterPaintProperties::Unevaluated unevaluated;
-    style::RasterPaintProperties::PossiblyEvaluated evaluated;
-
-    const style::RasterLayer::Impl& impl() const;
 };
 
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 634e0cf01b..95df9435f9 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -306,24 +306,29 @@ void drawText(const DrawFn& draw,
             });
     }
 }
+
+inline const SymbolLayer::Impl& impl(const Immutable<style::Layer::Impl>& impl) {
+    return static_cast<const SymbolLayer::Impl&>(*impl);
+}
+
 } // namespace
 
 RenderSymbolLayer::RenderSymbolLayer(Immutable<style::SymbolLayer::Impl> _impl)
-    : RenderLayer(std::move(_impl)),
-      unevaluated(impl().paint.untransitioned()) {
+    : RenderLayer(makeMutable<SymbolLayerProperties>(std::move(_impl))),
+      unevaluated(impl(baseImpl).paint.untransitioned()) {
 }
 
-const style::SymbolLayer::Impl& RenderSymbolLayer::impl() const {
-    return static_cast<const style::SymbolLayer::Impl&>(*baseImpl);
-}
+RenderSymbolLayer::~RenderSymbolLayer() = default;
 
 void RenderSymbolLayer::transition(const TransitionParameters& parameters) {
-    unevaluated = impl().paint.transitioned(parameters, std::move(unevaluated));
+    unevaluated = impl(baseImpl).paint.transitioned(parameters, std::move(unevaluated));
 }
 
 void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    evaluated = unevaluated.evaluate(parameters);
-
+    auto properties = makeMutable<SymbolLayerProperties>(
+        staticImmutableCast<SymbolLayer::Impl>(baseImpl),
+        unevaluated.evaluate(parameters));
+    const auto& evaluated = properties->evaluated;
     auto hasIconOpacity = evaluated.get<style::IconColor>().constantOr(Color::black()).a > 0 ||
                           evaluated.get<style::IconHaloColor>().constantOr(Color::black()).a > 0;
     auto hasTextOpacity = evaluated.get<style::TextColor>().constantOr(Color::black()).a > 0 ||
@@ -332,6 +337,7 @@ void RenderSymbolLayer::evaluate(const PropertyEvaluationParameters& parameters)
     passes = ((evaluated.get<style::IconOpacity>().constantOr(1) > 0 && hasIconOpacity && iconSize > 0)
               || (evaluated.get<style::TextOpacity>().constantOr(1) > 0 && hasTextOpacity && textSize > 0))
              ? RenderPass::Translucent : RenderPass::None;
+    evaluatedProperties = std::move(properties);
 }
 
 bool RenderSymbolLayer::hasTransition() const {
@@ -363,7 +369,7 @@ void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
         return;
     }
 
-    const bool sortFeaturesByKey = !impl().layout.get<SymbolSortKey>().isUndefined();
+    const bool sortFeaturesByKey = !impl(baseImpl).layout.get<SymbolSortKey>().isUndefined();
     std::set<RenderableSegment> renderableSegments;
 
     const auto draw = [&parameters, this] (auto& programInstance,
@@ -598,6 +604,7 @@ void RenderSymbolLayer::setRenderTiles(RenderTiles tiles, const TransformState&
 
 void RenderSymbolLayer::updateBucketPaintProperties(Bucket* bucket) const {
     assert(bucket->supportsLayer(*baseImpl));
+    const auto& evaluated = static_cast<const SymbolLayerProperties&>(*evaluatedProperties).evaluated;
     static_cast<SymbolBucket*>(bucket)->updatePaintProperties(getID(), evaluated);
 }
 
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index 7b6d249b2e..552dd30ca2 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -53,15 +53,15 @@ public:
 
 } // namespace style
 
-class BucketParameters;
-class SymbolLayout;
-class GeometryTileLayer;
-
 class RenderSymbolLayer final: public RenderLayer, public RenderLayerSymbolInterface {
 public:
-    RenderSymbolLayer(Immutable<style::SymbolLayer::Impl>);
-    ~RenderSymbolLayer() final = default;
+    explicit RenderSymbolLayer(Immutable<style::SymbolLayer::Impl>);
+    ~RenderSymbolLayer() override;
 
+    static style::IconPaintProperties::PossiblyEvaluated iconPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
+    static style::TextPaintProperties::PossiblyEvaluated textPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
+
+private:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -69,30 +69,20 @@ public:
     void render(PaintParameters&, RenderSource*) override;
     void setRenderTiles(RenderTiles, const TransformState&) override;
 
-    static style::IconPaintProperties::PossiblyEvaluated iconPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
-    static style::TextPaintProperties::PossiblyEvaluated textPaintProperties(const style::SymbolPaintProperties::PossiblyEvaluated&);
-
     // RenderLayerSymbolInterface overrides
-    const RenderLayerSymbolInterface* getSymbolInterface() const final;
-    const std::string& layerID() const final;
-    const std::vector<std::reference_wrapper<RenderTile>>& getRenderTiles() const final;
-    SymbolBucket* getSymbolBucket(const RenderTile&) const final;
+    const RenderLayerSymbolInterface* getSymbolInterface() const override;
+    const std::string& layerID() const override;
+    const std::vector<std::reference_wrapper<RenderTile>>& getRenderTiles() const override;
+    SymbolBucket* getSymbolBucket(const RenderTile&) const override;
 
     // Paint properties
     style::SymbolPaintProperties::Unevaluated unevaluated;
-    style::SymbolPaintProperties::PossiblyEvaluated evaluated;
 
     float iconSize = 1.0f;
     float textSize = 16.0f;
 
-    const style::SymbolLayer::Impl& impl() const;
-
 protected:
     void updateBucketPaintProperties(Bucket*) const final;
 };
 
-inline const RenderSymbolLayer* toRenderSymbolLayer(const RenderLayer* layer) {
-    return static_cast<const RenderSymbolLayer*>(layer);
-}
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/render_layer.cpp b/src/mbgl/renderer/render_layer.cpp
index 24a45b9146..c2719fef91 100644
--- a/src/mbgl/renderer/render_layer.cpp
+++ b/src/mbgl/renderer/render_layer.cpp
@@ -10,8 +10,9 @@ namespace mbgl {
 
 using namespace style;
 
-RenderLayer::RenderLayer(Immutable<style::Layer::Impl> baseImpl_)
-    : baseImpl(std::move(baseImpl_)) {
+RenderLayer::RenderLayer(Immutable<style::LayerProperties> properties)
+    : evaluatedProperties(std::move(properties)),
+      baseImpl(evaluatedProperties->baseImpl) {
 }
 
 void RenderLayer::setImpl(Immutable<style::Layer::Impl> impl) {
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 98e151435a..9654b9213f 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include <mbgl/layout/layout.hpp>
 #include <mbgl/renderer/render_pass.hpp>
-#include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layer_properties.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/util/mat4.hpp>
 
@@ -11,7 +11,6 @@
 namespace mbgl {
 
 class Bucket;
-class BucketParameters;
 class TransitionParameters;
 class PropertyEvaluationParameters;
 class PaintParameters;
@@ -22,7 +21,7 @@ class TransformState;
 
 class RenderLayer {
 protected:
-    RenderLayer(Immutable<style::Layer::Impl>);
+    RenderLayer(Immutable<style::LayerProperties>);
 
 public:
     virtual ~RenderLayer() = default;
@@ -31,6 +30,7 @@ public:
     virtual void transition(const TransitionParameters&) = 0;
 
     // Fully evaluate possibly-transitioning paint properties based on a zoom level.
+    // Updates the contained `evaluatedProperties` member.
     virtual void evaluate(const PropertyEvaluationParameters&) = 0;
 
     // Returns true if any paint properties have active transitions.
@@ -65,6 +65,8 @@ public:
     using RenderTiles = std::vector<std::reference_wrapper<RenderTile>>;
     virtual void setRenderTiles(RenderTiles, const TransformState&);
 
+    // Latest evaluated properties.
+    Immutable<style::LayerProperties> evaluatedProperties;
     // Private implementation
     Immutable<style::Layer::Impl> baseImpl;
     void setImpl(Immutable<style::Layer::Impl>);
diff --git a/src/mbgl/style/layers/custom_layer_impl.hpp b/src/mbgl/style/layers/custom_layer_impl.hpp
index 1ebf1b53f1..d8b8a7f286 100644
--- a/src/mbgl/style/layers/custom_layer_impl.hpp
+++ b/src/mbgl/style/layers/custom_layer_impl.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layer_properties.hpp>
 #include <mbgl/style/layers/custom_layer.hpp>
 
 #include <memory>
@@ -24,5 +25,11 @@ public:
     DECLARE_LAYER_TYPE_INFO;
 };
 
+class CustomLayerProperties final : public LayerProperties {
+public:
+    explicit CustomLayerProperties(Immutable<CustomLayer::Impl> impl)
+        : LayerProperties(std::move(impl)) {}
+};
+
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index 0c8b7a4ca1..56f6401ce7 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -312,22 +312,23 @@ void GeometryTileWorker::requestNewImages(const ImageDependencies& imageDependen
     }
 }
 
-static std::vector<std::unique_ptr<RenderLayer>> toRenderLayers(const std::vector<Immutable<style::Layer::Impl>>& layers, float zoom) {
-    std::vector<std::unique_ptr<RenderLayer>> renderLayers;
-    renderLayers.reserve(layers.size());
+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) {
-        renderLayers.push_back(LayerManager::get()->createRenderLayer(layer));
+        auto renderLayer = LayerManager::get()->createRenderLayer(layer);
 
-        renderLayers.back()->transition(TransitionParameters {
+        renderLayer->transition(TransitionParameters {
             Clock::time_point::max(),
             TransitionOptions()
         });
 
-        renderLayers.back()->evaluate(PropertyEvaluationParameters {
+        renderLayer->evaluate(PropertyEvaluationParameters {
             zoom
         });
+        result.push_back(renderLayer->evaluatedProperties);
     }
-    return renderLayers;
+    return result;
 }
 
 void GeometryTileWorker::parse() {
@@ -348,10 +349,14 @@ void GeometryTileWorker::parse() {
     ImageDependencies imageDependencies;
 
     // Create render layers and group by layout
-    std::vector<std::unique_ptr<RenderLayer>> renderLayers = toRenderLayers(*layers, id.overscaledZ);
-    std::vector<std::vector<const RenderLayer*>> groups = groupByLayout(renderLayers);
+    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) {
+        groupMap[layoutKey(*layer->baseImpl)].push_back(std::move(layer));
+    }
 
-    for (auto& group : groups) {
+    for (auto& pair : groupMap) {
+        const auto& group = pair.second;
         if (obsolete) {
             return;
         }
@@ -360,35 +365,35 @@ void GeometryTileWorker::parse() {
             continue; // Tile has no data.
         }
 
-        const RenderLayer& leader = *group.at(0);
-        BucketParameters parameters { id, mode, pixelRatio, leader.baseImpl->getTypeInfo() };
+        const style::Layer::Impl& leaderImpl = *(group.at(0)->baseImpl);
+        BucketParameters parameters { id, mode, pixelRatio, leaderImpl.getTypeInfo() };
 
-        auto geometryLayer = (*data)->getLayer(leader.baseImpl->sourceLayer);
+        auto geometryLayer = (*data)->getLayer(leaderImpl.sourceLayer);
         if (!geometryLayer) {
             continue;
         }
 
-        std::vector<std::string> layerIDs;
+        std::vector<std::string> layerIDs(group.size());
         for (const auto& layer : group) {
-            layerIDs.push_back(layer->getID());
+            layerIDs.push_back(layer->baseImpl->id);
         }
 
-        featureIndex->setBucketLayerIDs(leader.getID(), layerIDs);
+        featureIndex->setBucketLayerIDs(leaderImpl.id, layerIDs);
 
         // Symbol layers and layers that support pattern properties have an extra step at layout time to figure out what images/glyphs
         // are needed to render the layer. They use the intermediate Layout data structure to accomplish this,
         // and either immediately create a bucket if no images/glyphs are used, or the Layout is stored until
         // the images/glyphs are available to add the features to the buckets.
-        if (leader.baseImpl->getTypeInfo()->layout == LayerTypeInfo::Layout::Required) {
-            auto layout = LayerManager::get()->createLayout({parameters, glyphDependencies, imageDependencies}, std::move(geometryLayer), group);
+        if (leaderImpl.getTypeInfo()->layout == LayerTypeInfo::Layout::Required) {
+            std::unique_ptr<Layout> layout = LayerManager::get()->createLayout({parameters, glyphDependencies, imageDependencies}, std::move(geometryLayer), group);
             if (layout->hasDependencies()) {
                 layouts.push_back(std::move(layout));
             } else {
                 layout->createBucket({}, featureIndex, buckets, firstLoad, showCollisionBoxes);
             }
         } else {
-            const Filter& filter = leader.baseImpl->filter;
-            const std::string& sourceLayerID = leader.baseImpl->sourceLayer;
+            const Filter& filter = leaderImpl.filter;
+            const std::string& sourceLayerID = leaderImpl.sourceLayer;
             std::shared_ptr<Bucket> bucket = LayerManager::get()->createBucket(parameters, group);
 
             for (std::size_t i = 0; !obsolete && i < geometryLayer->featureCount(); i++) {
@@ -399,7 +404,7 @@ void GeometryTileWorker::parse() {
 
                 GeometryCollection geometries = feature->getGeometries();
                 bucket->addFeature(*feature, geometries, {}, PatternLayerMap ());
-                featureIndex->insert(geometries, i, sourceLayerID, leader.getID());
+                featureIndex->insert(geometries, i, sourceLayerID, leaderImpl.id);
             }
 
             if (!bucket->hasData()) {
@@ -407,7 +412,7 @@ void GeometryTileWorker::parse() {
             }
 
             for (const auto& layer : group) {
-                buckets.emplace(layer->getID(), bucket);
+                buckets.emplace(layer->baseImpl->id, bucket);
             }
         }
     }
diff --git a/src/mbgl/tile/geometry_tile_worker.hpp b/src/mbgl/tile/geometry_tile_worker.hpp
index 4402875603..fb841c63be 100644
--- a/src/mbgl/tile/geometry_tile_worker.hpp
+++ b/src/mbgl/tile/geometry_tile_worker.hpp
@@ -20,9 +20,6 @@ class GeometryTile;
 class GeometryTileData;
 class Layout;
 
-template <class B>
-class PatternLayout;
-
 namespace style {
 class Layer;
 } // namespace style
diff --git a/test/renderer/group_by_layout.test.cpp b/test/renderer/group_by_layout.test.cpp
deleted file mode 100644
index d1a7a0bf5f..0000000000
--- a/test/renderer/group_by_layout.test.cpp
+++ /dev/null
@@ -1,60 +0,0 @@
-#include <mbgl/test/util.hpp>
-
-#include <mbgl/layermanager/layer_manager.hpp>
-#include <mbgl/renderer/group_by_layout.hpp>
-#include <mbgl/renderer/render_layer.hpp>
-#include <mbgl/style/layers/background_layer.hpp>
-#include <mbgl/style/layers/circle_layer.hpp>
-#include <mbgl/style/layers/line_layer.hpp>
-#include <mbgl/style/expression/dsl.hpp>
-
-using namespace mbgl;
-using namespace mbgl::style;
-using namespace mbgl::style::expression;
-
-static std::vector<std::unique_ptr<RenderLayer>> toRenderLayers(const std::vector<std::unique_ptr<Layer>>& layers) {
-    std::vector<std::unique_ptr<RenderLayer>> result;
-    result.reserve(layers.size());
-    for (auto& layer : layers) {
-        result.push_back(LayerManager::get()->createRenderLayer(layer->baseImpl));
-    }
-    return result;
-}
-
-TEST(GroupByLayout, Related) {
-    std::vector<std::unique_ptr<Layer>> layers;
-    layers.push_back(std::make_unique<LineLayer>("a", "source"));
-    layers.push_back(std::make_unique<LineLayer>("b", "source"));
-    auto result = groupByLayout(toRenderLayers(layers));
-    ASSERT_EQ(1u, result.size());
-    ASSERT_EQ(2u, result[0].size());
-}
-
-TEST(GroupByLayout, UnrelatedType) {
-    std::vector<std::unique_ptr<Layer>> layers;
-    layers.push_back(std::make_unique<BackgroundLayer>("background"));
-    layers.push_back(std::make_unique<CircleLayer>("circle", "source"));
-    auto result = groupByLayout(toRenderLayers(layers));
-    ASSERT_EQ(2u, result.size());
-}
-
-TEST(GroupByLayout, UnrelatedFilter) {
-    using namespace mbgl::style::expression::dsl;
-    std::vector<std::unique_ptr<Layer>> layers;
-    auto lineLayer = std::make_unique<LineLayer>("a", "source");
-    lineLayer->setFilter(Filter(get("property")));
-    layers.push_back(std::move(lineLayer));
-    layers.push_back(std::make_unique<LineLayer>("b", "source"));
-    auto result = groupByLayout(toRenderLayers(layers));
-    ASSERT_EQ(2u, result.size());
-}
-
-TEST(GroupByLayout, UnrelatedLayout) {
-    std::vector<std::unique_ptr<Layer>> layers;
-    auto lineLayer = std::make_unique<LineLayer>("a", "source");
-    lineLayer->setLineCap(LineCapType::Square);
-    layers.push_back(std::move(lineLayer));
-    layers.push_back(std::make_unique<LineLayer>("b", "source"));
-    auto result = groupByLayout(toRenderLayers(layers));
-    ASSERT_EQ(2u, result.size());
-}
diff --git a/test/test-files.json b/test/test-files.json
index 0ba0a07577..df46689d50 100644
--- a/test/test-files.json
+++ b/test/test-files.json
@@ -28,7 +28,6 @@
         "test/programs/binary_program.test.cpp",
         "test/programs/symbol_program.test.cpp",
         "test/renderer/backend_scope.test.cpp",
-        "test/renderer/group_by_layout.test.cpp",
         "test/renderer/image_manager.test.cpp",
         "test/sprite/sprite_loader.test.cpp",
         "test/sprite/sprite_parser.test.cpp",