1 files changed, 56 insertions, 16 deletions

diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index f204c909e1..ff8a98c950 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -11,6 +11,7 @@
 #include <mbgl/geometry/feature_index.hpp>
 #include <mbgl/util/math.hpp>
 #include <mbgl/util/intersection_tests.hpp>
+#include <mbgl/tile/geometry_tile.hpp>
 
 namespace mbgl {
 
@@ -26,8 +27,17 @@ const style::LineLayer::Impl& RenderLineLayer::impl() const {
     return static_cast<const style::LineLayer::Impl&>(*baseImpl);
 }
 
-std::unique_ptr<Bucket> RenderLineLayer::createBucket(const BucketParameters& parameters, const std::vector<const RenderLayer*>& layers) const {
-    return std::make_unique<LineBucket>(parameters, layers, impl().layout);
+std::unique_ptr<Bucket> RenderLineLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
+    assert(false); // Should be calling createLayout() instead.
+    return nullptr;
+}
+
+std::unique_ptr<PatternLayout<LineBucket>>
+RenderLineLayer::createLayout(const BucketParameters& parameters,
+                              const std::vector<const RenderLayer*>& group,
+                              std::unique_ptr<GeometryTileLayer> layer,
+                              ImageDependencies& imageDependencies) const {
+    return std::make_unique<PatternLayout<LineBucket>>(parameters, group, std::move(layer), imageDependencies);
 }
 
 void RenderLineLayer::transition(const TransitionParameters& parameters) {
@@ -41,7 +51,9 @@ void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
     dashArrayParams.useIntegerZoom = true;
 
     evaluated = RenderLinePaintProperties::PossiblyEvaluated(
-        unevaluated.evaluate(parameters).concat(extra.evaluate(dashArrayParams)));
+    unevaluated.evaluate(parameters).concat(extra.evaluate(dashArrayParams)));
+
+    crossfade = parameters.getCrossfadeParameters();
 
     passes = (evaluated.get<style::LineOpacity>().constantOr(1.0) > 0
               && evaluated.get<style::LineColor>().constantOr(Color::black()).a > 0
@@ -53,6 +65,10 @@ bool RenderLineLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderLineLayer::hasCrossfade() const {
+    return crossfade.t != 1;
+}
+
 void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
@@ -65,11 +81,13 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
         }
         LineBucket& bucket = *bucket_;
 
-        auto draw = [&] (auto& program, auto&& uniformValues) {
+        auto draw = [&] (auto& program, auto&& uniformValues, const optional<ImagePosition>& patternPositionA, const optional<ImagePosition>& patternPositionB) {
             auto& programInstance = program.get(evaluated);
 
             const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
 
+            paintPropertyBinders.setPatternParameters(patternPositionA, patternPositionB, crossfade);
+
             const auto allUniformValues = programInstance.computeAllUniformValues(
                 std::move(uniformValues),
                 paintPropertyBinders,
@@ -115,16 +133,18 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                      parameters.pixelsToGLUnits,
                      posA,
                      posB,
-                     parameters.lineAtlas.getSize().width));
-
-        } else if (!evaluated.get<LinePattern>().from.empty()) {
-            optional<ImagePosition> posA = parameters.imageManager.getPattern(evaluated.get<LinePattern>().from);
-            optional<ImagePosition> posB = parameters.imageManager.getPattern(evaluated.get<LinePattern>().to);
+                     crossfade,
+                     parameters.lineAtlas.getSize().width), {}, {});
 
-            if (!posA || !posB)
-                return;
+        } else if (!unevaluated.get<LinePattern>().isUndefined()) {
+            const auto linePatternValue =  evaluated.get<LinePattern>().constantOr(Faded<std::basic_string<char>>{ "", ""});
+            assert(dynamic_cast<GeometryTile*>(&tile.tile));
+            GeometryTile& geometryTile = static_cast<GeometryTile&>(tile.tile);
+            parameters.context.bindTexture(*geometryTile.iconAtlasTexture, 0, gl::TextureFilter::Linear);
+            const Size texsize = geometryTile.iconAtlasTexture->size;
 
-            parameters.imageManager.bind(parameters.context, 0);
+            optional<ImagePosition> posA = geometryTile.getPattern(linePatternValue.from);
+            optional<ImagePosition> posB = geometryTile.getPattern(linePatternValue.to);
 
             draw(parameters.programs.linePattern,
                  LinePatternProgram::uniformValues(
@@ -132,9 +152,11 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                      tile,
                      parameters.state,
                      parameters.pixelsToGLUnits,
-                     parameters.imageManager.getPixelSize(),
+                     texsize,
+                     crossfade,
+                     parameters.pixelRatio),
                      *posA,
-                     *posB));
+                     *posB);
         } else if (!unevaluated.get<LineGradient>().getValue().isUndefined()) {
             if (!colorRampTexture) {
                 colorRampTexture = parameters.context.createTexture(colorRamp);
@@ -146,14 +168,14 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                     evaluated,
                     tile,
                     parameters.state,
-                    parameters.pixelsToGLUnits));
+                    parameters.pixelsToGLUnits), {}, {});
         } else {
             draw(parameters.programs.line,
                  LineProgram::uniformValues(
                      evaluated,
                      tile,
                      parameters.state,
-                     parameters.pixelsToGLUnits));
+                     parameters.pixelsToGLUnits), {}, {});
         }
     }
 }
@@ -240,6 +262,24 @@ void RenderLineLayer::updateColorRamp() {
     }
 }
 
+RenderLinePaintProperties::PossiblyEvaluated RenderLineLayer::paintProperties() const {
+    return RenderLinePaintProperties::PossiblyEvaluated {
+        evaluated.get<style::LineOpacity>(),
+        evaluated.get<style::LineColor>(),
+        evaluated.get<style::LineTranslate>(),
+        evaluated.get<style::LineTranslateAnchor>(),
+        evaluated.get<style::LineWidth>(),
+        evaluated.get<style::LineGapWidth>(),
+        evaluated.get<style::LineOffset>(),
+        evaluated.get<style::LineBlur>(),
+        evaluated.get<style::LineDasharray>(),
+        evaluated.get<style::LinePattern>(),
+        evaluated.get<style::LineGradient>(),
+        evaluated.get<LineFloorwidth>()
+
+    };
+}
+
 float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom) const {
     float lineWidth = evaluated.get<style::LineWidth>()
             .evaluate(feature, zoom, style::LineWidth::defaultValue());