[core] replace createBucket with createLayout for all layersupstream/circle-layout

30 files changed, 208 insertions, 111 deletions

diff --git a/cmake/core-files.txt b/cmake/core-files.txt
index bccdc27066..2d2802c6bc 100644
--- a/cmake/core-files.txt
+++ b/cmake/core-files.txt
@@ -101,6 +101,7 @@ src/mbgl/layermanager/layer_factory.cpp
 src/mbgl/layermanager/layer_manager.cpp
 
 # layout
+src/mbgl/layout/circle_layout.hpp
 src/mbgl/layout/clip_lines.cpp
 src/mbgl/layout/clip_lines.hpp
 src/mbgl/layout/layout.hpp
diff --git a/src/mbgl/layout/circle_layout.hpp b/src/mbgl/layout/circle_layout.hpp
new file mode 100644
index 0000000000..9aa91ec21b
--- /dev/null
+++ b/src/mbgl/layout/circle_layout.hpp
@@ -0,0 +1,85 @@
+#pragma once
+#include <mbgl/layout/layout.hpp>
+#include <mbgl/renderer/bucket_parameters.hpp>
+#include <mbgl/geometry/feature_index.hpp>
+#include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/renderer/layers/render_circle_layer.hpp>
+
+namespace mbgl {
+
+class CircleFeature  {
+public:
+    const uint32_t i;
+    std::unique_ptr<GeometryTileFeature> feature;
+};
+
+template <class B>
+class CircleLayout : public Layout {
+public:
+
+    CircleLayout(const BucketParameters& parameters,
+                 const std::vector<const RenderLayer*>& layers,
+                 std::unique_ptr<GeometryTileLayer> sourceLayer_,
+                 ImageDependencies&)
+                : Layout(),
+                bucketLeaderID(layers.at(0)->getID()),
+                mode(parameters.mode),
+                sourceLayer(std::move(sourceLayer_)),
+                zoom(parameters.tileID.overscaledZ),
+                overscaling(parameters.tileID.overscaleFactor()) {
+
+        using Layer = typename B::RenderLayerType;
+        const auto renderLayer = static_cast<const Layer*>(layers.at(0));
+        const typename Layer::StyleLayerImpl& leader = renderLayer->impl();
+        sourceLayerID = leader.sourceLayer;
+
+        for (const auto& layer : layers) {
+            const typename B::PossiblyEvaluatedPaintProperties evaluatedProps = static_cast<const Layer*>(layer)->paintProperties();
+            layerPaintProperties.emplace(layer->getID(), 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() })) continue;
+            features.push_back({static_cast<uint32_t>(i), std::move(feature)});
+        }
+    }
+
+    ~CircleLayout() final = default;
+
+    bool hasDependencies() const override {
+        return false;
+    }
+
+    void createBucket(const ImagePositions&, 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>(layerPaintProperties, zoom, mode);
+        for (auto & f : features) {
+            const auto i = f.i;
+            std::unique_ptr<GeometryTileFeature> feature = std::move(f.feature);
+            GeometryCollection geometries = feature->getGeometries();
+
+            bucket->addFeature(*feature, geometries, {}, {});
+            featureIndex->insert(geometries, i, sourceLayerID, bucketLeaderID);
+        }
+
+        if (bucket->hasData()) {
+            for (const auto& pair : layerPaintProperties) {
+                buckets.emplace(pair.first, bucket);
+            }
+        }
+    };
+
+    std::map<std::string, typename B::PossiblyEvaluatedPaintProperties> layerPaintProperties;
+    std::string bucketLeaderID;
+    const MapMode mode;
+private:
+    const std::unique_ptr<GeometryTileLayer> sourceLayer;
+    std::vector<CircleFeature> features;
+
+    std::string sourceLayerID;
+    const float zoom;
+    const uint32_t overscaling;
+};
+
+} // namespace mbgl
diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp
index a29221c547..16f20d6899 100644
--- a/src/mbgl/layout/pattern_layout.hpp
+++ b/src/mbgl/layout/pattern_layout.hpp
@@ -41,7 +41,6 @@ public:
         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)->paintProperties();
@@ -107,7 +106,7 @@ public:
             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) {
@@ -118,8 +117,6 @@ public:
 
     std::map<std::string, typename B::PossiblyEvaluatedPaintProperties> layerPaintProperties;
     const std::string bucketLeaderID;
-
-
 private:
     const std::unique_ptr<GeometryTileLayer> sourceLayer;
     std::vector<PatternFeature> features;
@@ -128,7 +125,6 @@ private:
     const float zoom;
     const uint32_t overscaling;
     std::string sourceLayerID;
-    std::string groupID;
     bool hasPattern;
 };
 
diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp
index 51da3eb892..c0d7b8c836 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.cpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.cpp
@@ -10,16 +10,18 @@ namespace mbgl {
 
 using namespace style;
 
-CircleBucket::CircleBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers)
+CircleBucket::CircleBucket(std::map<std::string, CircleBucket::PossiblyEvaluatedPaintProperties> layerPaintProperties,
+                           const float zoom,
+                           MapMode mode_)
     : Bucket(LayerType::Circle),
-      mode(parameters.mode) {
-    for (const auto& layer : layers) {
+      mode(mode_) {
+    for (const auto& pair : layerPaintProperties) {
         paintPropertyBinders.emplace(
             std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
+            std::forward_as_tuple(pair.first),
             std::forward_as_tuple(
-                toRenderCircleLayer(layer)->evaluated,
-                parameters.tileID.overscaledZ));
+                pair.second,
+                zoom));
     }
 }
 
diff --git a/src/mbgl/renderer/buckets/circle_bucket.hpp b/src/mbgl/renderer/buckets/circle_bucket.hpp
index db61a0c112..e6ad4ed5e8 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.hpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.hpp
@@ -12,10 +12,17 @@
 namespace mbgl {
 
 class BucketParameters;
+class RenderCircleLayer;
 
 class CircleBucket : public Bucket {
 public:
-    CircleBucket(const BucketParameters&, const std::vector<const RenderLayer*>&);
+
+    using RenderLayerType = RenderCircleLayer;
+    using PossiblyEvaluatedPaintProperties = style::CirclePaintProperties::PossiblyEvaluated;
+
+    CircleBucket(std::map<std::string, PossiblyEvaluatedPaintProperties>,
+                const float,
+                MapMode);
 
     void addFeature(const GeometryTileFeature&,
                     const GeometryCollection&,
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
index ee7db9a1df..beda347842 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
@@ -10,16 +10,18 @@ namespace mbgl {
 
 using namespace style;
 
-HeatmapBucket::HeatmapBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers)
+HeatmapBucket::HeatmapBucket(std::map<std::string, HeatmapBucket::PossiblyEvaluatedPaintProperties> layerPaintProperties,
+                             const float zoom,
+                             MapMode mode_)
     : Bucket(LayerType::Heatmap),
-      mode(parameters.mode) {
-    for (const auto& layer : layers) {
+      mode(mode_) {
+    for (const auto& pair : layerPaintProperties) {
         paintPropertyBinders.emplace(
             std::piecewise_construct,
-            std::forward_as_tuple(layer->getID()),
+            std::forward_as_tuple(pair.first),
             std::forward_as_tuple(
-                toRenderHeatmapLayer(layer)->evaluated,
-                parameters.tileID.overscaledZ));
+                pair.second,
+                zoom));
     }
 }
 
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.hpp b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
index b2d866d2a2..d0b3931b48 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.hpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
@@ -12,10 +12,16 @@
 namespace mbgl {
 
 class BucketParameters;
+class RenderHeatmapLayer;
 
 class HeatmapBucket : public Bucket {
 public:
-    HeatmapBucket(const BucketParameters&, const std::vector<const RenderLayer*>&);
+    using RenderLayerType = RenderHeatmapLayer;
+    using PossiblyEvaluatedPaintProperties = style::HeatmapPaintProperties::PossiblyEvaluated;
+
+    HeatmapBucket(std::map<std::string, PossiblyEvaluatedPaintProperties> layerPaintProperties,
+                  const float zoom,
+                  MapMode mode_);
 
     void addFeature(const GeometryTileFeature&,
                             const GeometryCollection&,
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index d7bf0dc6bd..77c62b6b7e 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -22,8 +22,10 @@ const style::BackgroundLayer::Impl& RenderBackgroundLayer::impl() const {
     return static_cast<const style::BackgroundLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderBackgroundLayer::createBucket(const BucketParameters &,
-                                                            const std::vector<const RenderLayer *> &) const {
+std::unique_ptr<Layout>
+RenderBackgroundLayer::createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                    std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                    ImageDependencies&) const {
     assert(false);
     return nullptr;
 }
diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp
index fea3890484..085e017f50 100644
--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -18,8 +18,9 @@ public:
     optional<Color> getSolidBackground() const final;
     void render(PaintParameters&, RenderSource*) override;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
-
+    std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const override;
     // Paint properties
     style::BackgroundPaintProperties::Unevaluated unevaluated;
     style::BackgroundPaintProperties::PossiblyEvaluated evaluated;
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index b984c596d3..c607b23c47 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -23,8 +23,11 @@ const style::CircleLayer::Impl& RenderCircleLayer::impl() const {
     return static_cast<const style::CircleLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderCircleLayer::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) const {
-    return std::make_unique<CircleBucket>(parameters, layers);
+std::unique_ptr<Layout>
+RenderCircleLayer::createLayout(const BucketParameters& parameters, const std::vector<const RenderLayer*>& group,
+                                std::unique_ptr<GeometryTileLayer> layer, GlyphDependencies&,
+                                ImageDependencies& imageDependencies) const {
+    return std::make_unique<CircleLayout<CircleBucket>>(parameters, group, std::move(layer), imageDependencies);
 }
 
 void RenderCircleLayer::transition(const TransitionParameters& parameters) {
@@ -133,6 +136,22 @@ GeometryCoordinates projectQueryGeometry(const GeometryCoordinates& queryGeometr
     return projectedGeometry;
 }
 
+style::CirclePaintProperties::PossiblyEvaluated RenderCircleLayer::paintProperties() const {
+    return CirclePaintProperties::PossiblyEvaluated {
+        evaluated.get<style::CircleRadius>(),
+        evaluated.get<style::CircleColor>(),
+        evaluated.get<style::CircleBlur>(),
+        evaluated.get<style::CircleOpacity>(),
+        evaluated.get<style::CircleTranslate>(),
+        evaluated.get<style::CircleTranslateAnchor>(),
+        evaluated.get<style::CirclePitchScale>(),
+        evaluated.get<style::CirclePitchAlignment>(),
+        evaluated.get<style::CircleStrokeWidth>(),
+        evaluated.get<style::CircleStrokeColor>(),
+        evaluated.get<style::CircleStrokeOpacity>()
+    };
+}
+
 bool RenderCircleLayer::queryIntersectsFeature(
         const GeometryCoordinates& queryGeometry,
         const GeometryTileFeature& feature,
diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp
index 5515aa0452..ec57f61ba0 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -3,6 +3,7 @@
 #include <mbgl/renderer/render_layer.hpp>
 #include <mbgl/style/layers/circle_layer_impl.hpp>
 #include <mbgl/style/layers/circle_layer_properties.hpp>
+#include <mbgl/layout/circle_layout.hpp>
 
 namespace mbgl {
 
@@ -11,12 +12,16 @@ public:
     RenderCircleLayer(Immutable<style::CircleLayer::Impl>);
     ~RenderCircleLayer() final = default;
 
+    using StyleLayerImpl = style::CircleLayer::Impl;
+
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
     bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
 
+    style::CirclePaintProperties::PossiblyEvaluated paintProperties() const;
+
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
             const GeometryTileFeature&,
@@ -25,8 +30,9 @@ public:
             const float,
             const mat4&) const override;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
-
+    std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const override;
     // Paint properties
     style::CirclePaintProperties::Unevaluated unevaluated;
     style::CirclePaintProperties::PossiblyEvaluated evaluated;
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index 9e65830faf..89f0fc436b 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -41,12 +41,14 @@ bool RenderCustomLayer::hasTransition() const {
 bool RenderCustomLayer::hasCrossfade() const {
     return false;
 }
-
 void RenderCustomLayer::markContextDestroyed() {
     contextDestroyed = true;
 }
 
-std::unique_ptr<Bucket> RenderCustomLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
+std::unique_ptr<Layout>
+RenderCustomLayer::createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                ImageDependencies&) const {
     assert(false);
     return nullptr;
 }
diff --git a/src/mbgl/renderer/layers/render_custom_layer.hpp b/src/mbgl/renderer/layers/render_custom_layer.hpp
index a6c1696493..f0105ba033 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.hpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.hpp
@@ -16,7 +16,10 @@ public:
     bool hasCrossfade() const override;
     void markContextDestroyed() final;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const final;
+    std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const final;
+
     void render(PaintParameters&, RenderSource*) final;
 
     const style::CustomLayer::Impl& impl() const;
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index aaf3756cfb..129d42c5a7 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -27,12 +27,6 @@ const style::FillExtrusionLayer::Impl& RenderFillExtrusionLayer::impl() const {
     return static_cast<const style::FillExtrusionLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderFillExtrusionLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
-    // Should be calling createLayout() instead.
-    assert(baseImpl->getTypeInfo()->layout == LayerTypeInfo::Layout::NotRequired);
-    return nullptr;
-}
-
 std::unique_ptr<Layout> RenderFillExtrusionLayer::createLayout(const BucketParameters& parameters,
                         const std::vector<const RenderLayer*>& group,
                         std::unique_ptr<GeometryTileLayer> layer,
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
index 481c394fbd..b83ea807a6 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -36,9 +36,9 @@ public:
         const float,
         const mat4&) const override;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
     std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
-                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&, ImageDependencies&) const override;
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const override;
 
     // Paint properties
     style::FillExtrusionPaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 391c2d5b0f..86db2fdebe 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -25,12 +25,6 @@ const style::FillLayer::Impl& RenderFillLayer::impl() const {
     return static_cast<const style::FillLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderFillLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
-    // Should be calling createLayout() instead.
-    assert(baseImpl->getTypeInfo()->layout == LayerTypeInfo::Layout::NotRequired);
-    return nullptr;
-}
-
 std::unique_ptr<Layout>
 RenderFillLayer::createLayout(const BucketParameters& parameters,
                               const std::vector<const RenderLayer*>& group,
diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp
index 6ce90be4a3..87303f85ed 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -32,9 +32,9 @@ public:
             const float,
             const mat4&) const override;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
     std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
-                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&, ImageDependencies&) const override;
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const override;
 
     // Paint properties
     style::FillPaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 1842cdac93..51bfb12057 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -25,8 +25,12 @@ const style::HeatmapLayer::Impl& RenderHeatmapLayer::impl() const {
     return static_cast<const style::HeatmapLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderHeatmapLayer::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) const {
-    return std::make_unique<HeatmapBucket>(parameters, layers);
+std::unique_ptr<Layout> RenderHeatmapLayer::createLayout(const BucketParameters& parameters,
+                                                      const std::vector<const RenderLayer*>& group,
+                                                      std::unique_ptr<GeometryTileLayer> layer,
+                                                      GlyphDependencies&,
+                                                      ImageDependencies& imageDependencies) const {
+    return std::make_unique<CircleLayout<HeatmapBucket>>(parameters, group, std::move(layer), imageDependencies);
 }
 
 void RenderHeatmapLayer::transition(const TransitionParameters& parameters) {
@@ -209,6 +213,15 @@ void RenderHeatmapLayer::updateColorRamp() {
         colorRampTexture = nullopt;
     }
 }
+style::HeatmapPaintProperties::PossiblyEvaluated RenderHeatmapLayer::paintProperties() const {
+    return HeatmapPaintProperties::PossiblyEvaluated {
+        evaluated.get<style::HeatmapRadius>(),
+        evaluated.get<style::HeatmapWeight>(),
+        evaluated.get<style::HeatmapIntensity>(),
+        evaluated.get<style::HeatmapColor>(),
+        evaluated.get<style::HeatmapOpacity>()
+    };
+}
 
 bool RenderHeatmapLayer::queryIntersectsFeature(
         const GeometryCoordinates& queryGeometry,
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
index a0148fb4a3..d18d03f5de 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -5,6 +5,7 @@
 #include <mbgl/style/layers/heatmap_layer_properties.hpp>
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/offscreen_texture.hpp>
+#include <mbgl/layout/circle_layout.hpp>
 
 namespace mbgl {
 
@@ -13,6 +14,8 @@ public:
     RenderHeatmapLayer(Immutable<style::HeatmapLayer::Impl>);
     ~RenderHeatmapLayer() final = default;
 
+    using StyleLayerImpl = style::HeatmapLayer::Impl;
+
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
@@ -20,6 +23,8 @@ public:
     void render(PaintParameters&, RenderSource*) override;
     void update() final;
 
+    style::HeatmapPaintProperties::PossiblyEvaluated paintProperties() const;
+
     bool queryIntersectsFeature(
             const GeometryCoordinates&,
             const GeometryTileFeature&,
@@ -28,8 +33,10 @@ public:
             const float,
             const mat4&) const override;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
 
+    std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const override;
     // Paint properties
     style::HeatmapPaintProperties::Unevaluated unevaluated;
     style::HeatmapPaintProperties::PossiblyEvaluated evaluated;
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index ba7e782f16..22c842eadb 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -24,7 +24,7 @@ const style::HillshadeLayer::Impl& RenderHillshadeLayer::impl() const {
     return static_cast<const style::HillshadeLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderHillshadeLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
+std::unique_ptr<Layout> RenderHillshadeLayer::createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&, std::unique_ptr<GeometryTileLayer>, GlyphDependencies&, ImageDependencies&) const {
     assert(false);
     return nullptr;
 }
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.hpp b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
index 3f3ddaccf0..b20b00c36a 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
@@ -19,7 +19,9 @@ public:
 
     void render(PaintParameters&, RenderSource* src) override;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
+    std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&, 
+                                         ImageDependencies&) const override;
 
     // Paint properties
     style::HillshadePaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index fcdbc0b47a..679e3e3007 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -27,12 +27,6 @@ const style::LineLayer::Impl& RenderLineLayer::impl() const {
     return static_cast<const style::LineLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderLineLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
-    // Should be calling createLayout() instead.
-    assert(baseImpl->getTypeInfo()->layout == LayerTypeInfo::Layout::NotRequired);
-    return nullptr;
-}
-
 std::unique_ptr<Layout> RenderLineLayer::createLayout(const BucketParameters& parameters,
                                                       const std::vector<const RenderLayer*>& group,
                                                       std::unique_ptr<GeometryTileLayer> layer,
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index 5819484a2c..15a27ce537 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -45,13 +45,9 @@ public:
             const mat4&) const override;
 
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
-    std::unique_ptr<Layout> createLayout(const BucketParameters&,
-                                               const std::vector<const RenderLayer*>&,
-                                               std::unique_ptr<GeometryTileLayer>,
-                                               GlyphDependencies&,
-                                               ImageDependencies&) const override;
-
+    std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const override;
     // Paint properties
     style::LinePaintProperties::Unevaluated unevaluated;
     RenderLinePaintProperties::PossiblyEvaluated evaluated;
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index e0a7e427ad..6dacf65208 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -22,7 +22,7 @@ const style::RasterLayer::Impl& RenderRasterLayer::impl() const {
     return static_cast<const style::RasterLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderRasterLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
+std::unique_ptr<Layout> RenderRasterLayer::createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&, std::unique_ptr<GeometryTileLayer>, GlyphDependencies&, ImageDependencies&) const {
     assert(false);
     return nullptr;
 }
diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp
index 7783d924b7..7fadf7ab3b 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -18,7 +18,9 @@ public:
 
     void render(PaintParameters&, RenderSource*) override;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
+    std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                         std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                         ImageDependencies&) const override;
 
     // Paint properties
     style::RasterPaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 11ffd74b10..ca6ae08a7e 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -31,12 +31,6 @@ const style::SymbolLayer::Impl& RenderSymbolLayer::impl() const {
     return static_cast<const style::SymbolLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderSymbolLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
-    // Should be calling createLayout() instead.
-    assert(baseImpl->getTypeInfo()->layout == LayerTypeInfo::Layout::NotRequired);
-    return nullptr;
-}
-
 std::unique_ptr<Layout> RenderSymbolLayer::createLayout(const BucketParameters& parameters,
                                                               const std::vector<const RenderLayer*>& group,
                                                               std::unique_ptr<GeometryTileLayer> layer,
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index 832fb94001..570fc39929 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -74,7 +74,6 @@ public:
     style::SymbolPropertyValues iconPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated&) const;
     style::SymbolPropertyValues textPropertyValues(const style::SymbolLayoutProperties::PossiblyEvaluated&) const;
 
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
     std::unique_ptr<Layout> createLayout(const BucketParameters&,
                                                const std::vector<const RenderLayer*>&,
                                                std::unique_ptr<GeometryTileLayer>,
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 4e0e1913b6..4ba8e0c2d2 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -63,14 +63,9 @@ public:
             const float,
             const mat4&) const { return false; };
 
-    virtual std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const = 0;
-    virtual std::unique_ptr<Layout> createLayout(const BucketParameters&,
-                                               const std::vector<const RenderLayer*>&,
-                                               std::unique_ptr<GeometryTileLayer>,
-                                               GlyphDependencies&,
-                                               ImageDependencies&) const {
-        return nullptr;
-    }
+    virtual std::unique_ptr<Layout> createLayout(const BucketParameters&, const std::vector<const RenderLayer*>&,
+                                                 std::unique_ptr<GeometryTileLayer>, GlyphDependencies&,
+                                                 ImageDependencies&) const = 0;
 
     using RenderTiles = std::vector<std::reference_wrapper<RenderTile>>;
     void setRenderTiles(RenderTiles, const TransformState&);
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index 854bfcf1a4..fd33b030ab 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -376,36 +376,11 @@ void GeometryTileWorker::parse() {
         // 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 = leader.createLayout(parameters, group, std::move(geometryLayer), glyphDependencies, imageDependencies);
-            if (layout->hasDependencies()) {
-                layouts.push_back(std::move(layout));
-            } else {
-                layout->createBucket({}, featureIndex, buckets, firstLoad, showCollisionBoxes);
-            }
+        auto layout = leader.createLayout(parameters, group, std::move(geometryLayer), glyphDependencies, imageDependencies);
+        if (layout->hasDependencies()) {
+            layouts.push_back(std::move(layout));
         } else {
-            const Filter& filter = leader.baseImpl->filter;
-            const std::string& sourceLayerID = leader.baseImpl->sourceLayer;
-            std::shared_ptr<Bucket> bucket = leader.createBucket(parameters, group);
-
-            for (std::size_t i = 0; !obsolete && i < geometryLayer->featureCount(); i++) {
-                std::unique_ptr<GeometryTileFeature> feature = geometryLayer->getFeature(i);
-
-                if (!filter(expression::EvaluationContext { static_cast<float>(this->id.overscaledZ), feature.get() }))
-                    continue;
-
-                GeometryCollection geometries = feature->getGeometries();
-                bucket->addFeature(*feature, geometries, {}, PatternLayerMap ());
-                featureIndex->insert(geometries, i, sourceLayerID, leader.getID());
-            }
-
-            if (!bucket->hasData()) {
-                continue;
-            }
-
-            for (const auto& layer : group) {
-                buckets.emplace(layer->getID(), bucket);
-            }
+            layout->createBucket({}, featureIndex, buckets, firstLoad, showCollisionBoxes);
         }
     }
 
diff --git a/test/gl/bucket.test.cpp b/test/gl/bucket.test.cpp
index 04e6447ad8..752ee5abc7 100644
--- a/test/gl/bucket.test.cpp
+++ b/test/gl/bucket.test.cpp
@@ -47,7 +47,7 @@ TEST(Buckets, CircleBucket) {
     BackendScope scope { backend };
 
     gl::Context context;
-    CircleBucket bucket { { {0, 0, 0}, MapMode::Static, 1.0 }, {} };
+    CircleBucket bucket { {}, 10.0f, MapMode::Continuous };
     ASSERT_FALSE(bucket.hasData());
     ASSERT_FALSE(bucket.needsUpload());