[core] template PatternLayout on layer type

8 files changed, 71 insertions, 78 deletions

diff --git a/src/mbgl/layout/pattern_layout.cpp b/src/mbgl/layout/pattern_layout.cpp
deleted file mode 100644
index f2f236abf4..0000000000
--- a/src/mbgl/layout/pattern_layout.cpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#include <mbgl/layout/pattern_layout.hpp>
-
-
-namespace mbgl {
-
-using namespace style;
-
-PatternLayout::PatternLayout(const BucketParameters& parameters,
-                  const std::vector<const RenderLayer*>& layers,
-                  std::unique_ptr<GeometryTileLayer> sourceLayer_,
-                  ImageDependencies& patternDependencies)
-                  : bucketLeaderID(layers.at(0)->getID()),
-                    sourceLayer(std::move(sourceLayer_)),
-                    zoom(parameters.tileID.overscaledZ),
-                    overscaling(parameters.tileID.overscaleFactor()) {
-
-    const RenderLineLayer* renderLayer = layers.at(0)->as<RenderLineLayer>();
-    const LineLayer::Impl& leader = renderLayer->impl();
-    layout = leader.layout.evaluate(PropertyEvaluationParameters(zoom));
-    sourceLayerID = leader.sourceLayer;
-    groupID = renderLayer->getID();
-
-    for (const auto& layer : layers) {
-        const RenderLinePaintProperties::PossiblyEvaluated evaluatedProps = layer->as<RenderLineLayer>()->paintProperties();
-        layerPaintProperties.emplace(layer->getID(), std::move(evaluatedProps));
-        const auto patterns = evaluatedProps.get<LinePattern>().possibleOutputs();
-
-        for (auto& pattern : patterns) {
-            const auto patternString = pattern.value_or("");
-            if (!patternString.empty()) {
-                patternDependencies.emplace(patternString, ImageType::Pattern);
-            }
-        }
-    }
-    const size_t featureCount = sourceLayer->featureCount();
-    for (size_t i = 0; i < featureCount; ++i) {
-        auto feature = sourceLayer->getFeature(i);
-        if (!leader.filter(expression::EvaluationContext { this->zoom, feature.get() }))
-            continue;
-        features.push_back({i, std::move(feature)});
-    }
-}
-
-std::unique_ptr<LineBucket> PatternLayout::createBucket(const ImagePositions& patternPositions, std::unique_ptr<FeatureIndex>& featureIndex) {
-    auto bucket = std::make_unique<LineBucket>(layout, layerPaintProperties, zoom, overscaling);
-    for (auto & pair : features) {
-        std::unique_ptr<GeometryTileFeature> feature = std::move(pair.second);
-        const auto i = pair.first;
-        GeometryCollection geometries = feature->getGeometries();
-
-        bucket->addFeature(*feature, geometries, patternPositions);
-        featureIndex->insert(geometries, i, sourceLayerID, groupID);
-    }
-    return bucket;
-};
-
-} // namespace mbgl
diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp
index 78f17663fd..279c2b791c 100644
--- a/src/mbgl/layout/pattern_layout.hpp
+++ b/src/mbgl/layout/pattern_layout.hpp
@@ -1,32 +1,74 @@
 #pragma once
-#include <mbgl/renderer/buckets/line_bucket.hpp>
 #include <mbgl/renderer/bucket_parameters.hpp>
-#include <mbgl/style/layers/line_layer_impl.hpp>
 #include <mbgl/geometry/feature_index.hpp>
 
 namespace mbgl {
-  class LineBucket;
 
+template <class B, class L>
 class PatternLayout {
 public:
-    PatternLayout(const BucketParameters&,
-                  const std::vector<const RenderLayer*>&,
-                  std::unique_ptr<GeometryTileLayer>,
-                  ImageDependencies&);
+    PatternLayout(const BucketParameters& parameters,
+                  const std::vector<const RenderLayer*>& layers,
+                  std::unique_ptr<GeometryTileLayer> sourceLayer_,
+                  ImageDependencies& patternDependencies)
+                  : bucketLeaderID(layers.at(0)->getID()),
+                    sourceLayer(std::move(sourceLayer_)),
+                    zoom(parameters.tileID.overscaledZ),
+                    overscaling(parameters.tileID.overscaleFactor()) {
 
-    std::unique_ptr<LineBucket> createBucket(const ImagePositions&, std::unique_ptr<FeatureIndex>&);
-    std::map<std::string, RenderLinePaintProperties::PossiblyEvaluated> layerPaintProperties;
+        const L* renderLayer = layers.at(0)->as<L>();
+        const typename L::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 = layer->as<L>()->paintProperties();
+            layerPaintProperties.emplace(layer->getID(), std::move(evaluatedProps));
+            const auto patterns = evaluatedProps.template get<typename L::PatternProperty>().possibleOutputs();
+
+            for (auto& pattern : patterns) {
+                const auto patternString = pattern.value_or("");
+                if (!patternString.empty()) {
+                    patternDependencies.emplace(patternString, ImageType::Pattern);
+                }
+            }
+        }
+        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({i, std::move(feature)});
+        }
+    };
+
+    std::unique_ptr<B> createBucket(const ImagePositions& patternPositions, std::unique_ptr<FeatureIndex>& featureIndex) {
+        auto bucket = std::make_unique<B>(layout, layerPaintProperties, zoom, overscaling);
+        for (auto & pair : features) {
+            std::unique_ptr<GeometryTileFeature> feature = std::move(pair.second);
+            const auto i = pair.first;
+            GeometryCollection geometries = feature->getGeometries();
+
+            bucket->addFeature(*feature, geometries, patternPositions);
+            featureIndex->insert(geometries, i, sourceLayerID, groupID);
+        }
+        return bucket;
+    };
+
+    std::map<std::string, typename B::PossiblyEvaluatedPaintProperties> layerPaintProperties;
 
     const std::string bucketLeaderID;
 private:
     const std::unique_ptr<GeometryTileLayer> sourceLayer;
     std::vector<std::pair<uint32_t, std::unique_ptr<GeometryTileFeature>>> features;
-    style::LineLayoutProperties::PossiblyEvaluated layout;
+    typename B::PossiblyEvaluatedLayoutProperties layout;
 
     const float zoom;
     const uint32_t overscaling;
     std::string sourceLayerID;
     std::string groupID;
 };
+
 } // namespace mbgl
 
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index 5e6845cf37..69be21efd6 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -1,5 +1,4 @@
 #include <mbgl/renderer/buckets/line_bucket.hpp>
-#include <mbgl/renderer/layers/render_line_layer.hpp>
 #include <mbgl/renderer/bucket_parameters.hpp>
 #include <mbgl/style/layers/line_layer_impl.hpp>
 #include <mbgl/util/math.hpp>
diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp
index 4a0990a062..162d168a42 100644
--- a/src/mbgl/renderer/buckets/line_bucket.hpp
+++ b/src/mbgl/renderer/buckets/line_bucket.hpp
@@ -1,5 +1,4 @@
 #pragma once
-
 #include <mbgl/renderer/bucket.hpp>
 #include <mbgl/tile/geometry_tile_data.hpp>
 #include <mbgl/gl/vertex_buffer.hpp>
@@ -44,6 +43,10 @@ public:
 
     std::map<std::string, LineProgram::PaintPropertyBinders> paintPropertyBinders;
 
+    using RenderLayerType = RenderLineLayer;
+    using PossiblyEvaluatedPaintProperties = RenderLinePaintProperties::PossiblyEvaluated;
+    using PossiblyEvaluatedLayoutProperties = style::LineLayoutProperties::PossiblyEvaluated;
+
 private:
     void addGeometry(const GeometryCoordinates&, const GeometryTileFeature&);
 
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index aa84edfcb5..3fe38da8f1 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -12,7 +12,6 @@
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
 #include <mbgl/tile/geometry_tile.hpp>
-#include <mbgl/layout/pattern_layout.hpp>
 
 namespace mbgl {
 
@@ -33,11 +32,11 @@ std::unique_ptr<Bucket> RenderLineLayer::createBucket(const BucketParameters&, c
     return nullptr;
 }
 
-std::unique_ptr<PatternLayout> RenderLineLayer::createLayout(const BucketParameters& parameters,
+std::unique_ptr<PatternLayout<LineBucket, RenderLineLayer>> RenderLineLayer::createLayout(const BucketParameters& parameters,
                                                               const std::vector<const RenderLayer*>& group,
                                                               std::unique_ptr<GeometryTileLayer> layer,
                                                               ImageDependencies& imageDependencies) const {
-    return std::make_unique<PatternLayout>(parameters,
+    return std::make_unique<PatternLayout<LineBucket, RenderLineLayer>>(parameters,
                                           group,
                                           std::move(layer),
                                           imageDependencies);
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index e02e7e6b03..e2eb6ebed9 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -5,11 +5,10 @@
 #include <mbgl/style/layers/line_layer_properties.hpp>
 #include <mbgl/programs/uniforms.hpp>
 #include <mbgl/style/image_impl.hpp>
+#include <mbgl/layout/pattern_layout.hpp>
 
 namespace mbgl {
 
-class PatternLayout;
-
 struct LineFloorwidth : style::DataDrivenPaintProperty<float, attributes::a_floorwidth, uniforms::u_floorwidth> {
     static float defaultValue() { return 1; }
 };
@@ -18,6 +17,8 @@ class RenderLinePaintProperties : public style::ConcatenateProperties<
     style::LinePaintProperties,
     style::Properties<LineFloorwidth>> {};
 
+class LineBucket;
+
 class RenderLineLayer: public RenderLayer {
 public:
     RenderLineLayer(Immutable<style::LineLayer::Impl>);
@@ -41,7 +42,7 @@ public:
     void updateColorRamp();
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
-    std::unique_ptr<PatternLayout> createLayout(const BucketParameters&,
+    std::unique_ptr<PatternLayout<LineBucket, RenderLineLayer>> createLayout(const BucketParameters&,
                                                const std::vector<const RenderLayer*>&,
                                                std::unique_ptr<GeometryTileLayer>,
                                                ImageDependencies&) const;
@@ -49,6 +50,8 @@ public:
     style::LinePaintProperties::Unevaluated unevaluated;
     RenderLinePaintProperties::PossiblyEvaluated evaluated;
 
+    using StyleLayerImpl = style::LineLayer::Impl;
+    using PatternProperty = style::LinePattern;
     const style::LineLayer::Impl& impl() const;
 
 private:
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index c150e3aefe..f017f1f0ef 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -8,7 +8,6 @@
 #include <mbgl/style/filter.hpp>
 #include <mbgl/style/layers/symbol_layer_impl.hpp>
 #include <mbgl/renderer/layers/render_symbol_layer.hpp>
-#include <mbgl/renderer/layers/render_line_layer.hpp>
 #include <mbgl/renderer/buckets/symbol_bucket.hpp>
 #include <mbgl/renderer/buckets/line_bucket.hpp>
 #include <mbgl/util/logging.hpp>
@@ -341,7 +340,7 @@ void GeometryTileWorker::parse() {
     }
 
     std::unordered_map<std::string, std::unique_ptr<SymbolLayout>> symbolLayoutMap;
-    std::unordered_map<std::string, std::unique_ptr<PatternLayout>> patternLayoutMap;
+    std::unordered_map<std::string, std::unique_ptr<PatternLayout<LineBucket, RenderLineLayer>>> patternLayoutMap;
 
     buckets.clear();
     featureIndex = std::make_unique<FeatureIndex>(*data ? (*data)->clone() : nullptr);
diff --git a/src/mbgl/tile/geometry_tile_worker.hpp b/src/mbgl/tile/geometry_tile_worker.hpp
index 4585bdb8a0..440d4d7162 100644
--- a/src/mbgl/tile/geometry_tile_worker.hpp
+++ b/src/mbgl/tile/geometry_tile_worker.hpp
@@ -19,8 +19,13 @@ namespace mbgl {
 class GeometryTile;
 class GeometryTileData;
 class SymbolLayout;
+
+template <class B, class L>
 class PatternLayout;
 
+class RenderLineLayer;
+class LineBucket;
+
 namespace style {
 class Layer;
 } // namespace style
@@ -88,7 +93,7 @@ private:
     bool symbolLayoutsNeedPreparation = false;
 
     std::vector<std::unique_ptr<SymbolLayout>> symbolLayouts;
-    std::vector<std::unique_ptr<PatternLayout>> patternLayouts;
+    std::vector<std::unique_ptr<PatternLayout<LineBucket, RenderLineLayer>>> patternLayouts;
 
     GlyphDependencies pendingGlyphDependencies;
     ImageDependencies pendingImageDependencies;