[core] Enable property functions for line-width (#9250)

9 files changed, 52 insertions, 22 deletions

diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index ab9cfe9376..3af3cd63d3 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -480,7 +480,7 @@ static float get(const RenderLineLayer& layer, const std::map<std::string, LineP
 }
 
 float LineBucket::getLineWidth(const RenderLineLayer& layer) const {
-    float lineWidth = layer.evaluated.get<LineWidth>();
+    float lineWidth = get<LineWidth>(layer, paintPropertyBinders);
     float gapWidth = get<LineGapWidth>(layer, paintPropertyBinders);
 
     if (gapWidth) {
diff --git a/src/mbgl/renderer/data_driven_property_evaluator.hpp b/src/mbgl/renderer/data_driven_property_evaluator.hpp
index 6406b3478b..79ecd0d495 100644
--- a/src/mbgl/renderer/data_driven_property_evaluator.hpp
+++ b/src/mbgl/renderer/data_driven_property_evaluator.hpp
@@ -24,12 +24,18 @@ public:
     }
 
     ResultType operator()(const style::CameraFunction<T>& function) const {
-        return ResultType(function.evaluate(parameters.z));
+        if (!parameters.useIntegerZoom) {
+            return ResultType(function.evaluate(parameters.z));
+        } else {
+            return ResultType(function.evaluate(floor(parameters.z)));
+        }
     }
 
     template <class Function>
     ResultType operator()(const Function& function) const {
-        return ResultType(function);
+        auto returnFunction = function;
+        returnFunction.useIntegerZoom = parameters.useIntegerZoom;
+        return ResultType(returnFunction);
     }
 
 private:
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index 076ee77aff..5998c1f2fb 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -24,16 +24,18 @@ void RenderLineLayer::transition(const TransitionParameters& parameters) {
 }
 
 void RenderLineLayer::evaluate(const PropertyEvaluationParameters& parameters) {
-    // for scaling dasharrays
+    style::Properties<LineFloorwidth>::Unevaluated extra;
+    extra.get<LineFloorwidth>() = unevaluated.get<style::LineWidth>();
+
     auto dashArrayParams = parameters;
-    dashArrayParams.z = std::floor(dashArrayParams.z);
-    dashLineWidth = unevaluated.evaluate<style::LineWidth>(dashArrayParams);
+    dashArrayParams.useIntegerZoom = true;
 
-    evaluated = unevaluated.evaluate(parameters);
+    evaluated = RenderLinePaintProperties::PossiblyEvaluated(
+        unevaluated.evaluate(parameters).concat(extra.evaluate(dashArrayParams)));
 
     passes = (evaluated.get<style::LineOpacity>().constantOr(1.0) > 0
               && evaluated.get<style::LineColor>().constantOr(Color::black()).a > 0
-              && evaluated.get<style::LineWidth>() > 0)
+              && evaluated.get<style::LineWidth>().constantOr(1.0) > 0)
              ? RenderPass::Translucent : RenderPass::None;
 }
 
@@ -102,7 +104,8 @@ bool RenderLineLayer::queryIntersectsFeature(
 }
 
 float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom) const {
-    float lineWidth = evaluated.get<style::LineWidth>();
+    float lineWidth = evaluated.get<style::LineWidth>()
+            .evaluate(feature, zoom, style::LineWidth::defaultValue());
     float gapWidth = evaluated.get<style::LineGapWidth>()
             .evaluate(feature, zoom, style::LineGapWidth::defaultValue());
     if (gapWidth) {
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index 04ba745533..77551b6b7c 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -3,9 +3,18 @@
 #include <mbgl/renderer/render_layer.hpp>
 #include <mbgl/style/layers/line_layer_impl.hpp>
 #include <mbgl/style/layers/line_layer_properties.hpp>
+#include <mbgl/programs/uniforms.hpp>
 
 namespace mbgl {
 
+struct LineFloorwidth : style::DataDrivenPaintProperty<float, attributes::a_floorwidth, uniforms::u_floorwidth> {
+    static float defaultValue() { return 1; }
+};
+
+class RenderLinePaintProperties : public style::ConcatenateProperties<
+    style::LinePaintProperties::PropertyTypes,
+    TypeList<LineFloorwidth>>::Type {};
+
 class RenderLineLayer: public RenderLayer {
 public:
     RenderLineLayer(Immutable<style::LineLayer::Impl>);
@@ -26,13 +35,10 @@ public:
 
     // Paint properties
     style::LinePaintProperties::Unevaluated unevaluated;
-    style::LinePaintProperties::PossiblyEvaluated evaluated;
+    RenderLinePaintProperties::PossiblyEvaluated evaluated;
 
     const style::LineLayer::Impl& impl() const;
 
-    // Special case
-    float dashLineWidth = 1;
-
 private:
     float getLineWidth(const GeometryTileFeature&, const float) const;
 };
diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp
index 8ac6ce8cf1..f78147fc87 100644
--- a/src/mbgl/renderer/paint_property_binder.hpp
+++ b/src/mbgl/renderer/paint_property_binder.hpp
@@ -217,7 +217,11 @@ public:
     }
 
     float interpolationFactor(float currentZoom) const override {
-        return util::interpolationFactor(1.0f, { rangeOfCoveringRanges.min.zoom, rangeOfCoveringRanges.max.zoom }, currentZoom);
+        if (function.useIntegerZoom) {
+            return util::interpolationFactor(1.0f, { rangeOfCoveringRanges.min.zoom, rangeOfCoveringRanges.max.zoom }, std::floor(currentZoom));
+        } else {
+            return util::interpolationFactor(1.0f, { rangeOfCoveringRanges.min.zoom, rangeOfCoveringRanges.max.zoom }, currentZoom);
+        }
     }
 
     T uniformValue(const PossiblyEvaluatedPropertyValue<T>& currentValue) const override {
diff --git a/src/mbgl/renderer/painter.cpp b/src/mbgl/renderer/painter.cpp
index edec98047d..5a70243a54 100644
--- a/src/mbgl/renderer/painter.cpp
+++ b/src/mbgl/renderer/painter.cpp
@@ -328,7 +328,7 @@ void Painter::renderPass(PaintParameters& parameters,
             mat4 viewportMat;
             matrix::ortho(viewportMat, 0, size.width, size.height, 0, 0, 1);
 
-            const Properties<>::PossiblyEvaluated properties{};
+            const Properties<>::PossiblyEvaluated properties;
 
             parameters.programs.extrusionTexture.draw(
                 context, gl::Triangles(), gl::DepthMode::disabled(), gl::StencilMode::disabled(),
diff --git a/src/mbgl/renderer/painters/painter_line.cpp b/src/mbgl/renderer/painters/painter_line.cpp
index 49fee36925..58f4131d96 100644
--- a/src/mbgl/renderer/painters/painter_line.cpp
+++ b/src/mbgl/renderer/painters/painter_line.cpp
@@ -21,7 +21,7 @@ void Painter::renderLine(PaintParameters& parameters,
         return;
     }
 
-    const LinePaintProperties::PossiblyEvaluated& properties = layer.evaluated;
+    const RenderLinePaintProperties::PossiblyEvaluated& properties = layer.evaluated;
 
     auto draw = [&] (auto& program, auto&& uniformValues) {
         program.get(properties).draw(
@@ -57,7 +57,6 @@ void Painter::renderLine(PaintParameters& parameters,
                  pixelsToGLUnits,
                  posA,
                  posB,
-                 layer.dashLineWidth,
                  lineAtlas->getSize().width));
 
     } else if (!properties.get<LinePattern>().from.empty()) {
diff --git a/src/mbgl/renderer/possibly_evaluated_property_value.hpp b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
index a0bcec2bf1..8a5dfbe4ea 100644
--- a/src/mbgl/renderer/possibly_evaluated_property_value.hpp
+++ b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
@@ -19,7 +19,9 @@ private:
 
 public:
     PossiblyEvaluatedPropertyValue() = default;
-    PossiblyEvaluatedPropertyValue(Value v) : value(std::move(v)) {}
+    PossiblyEvaluatedPropertyValue(Value v, bool useIntegerZoom_ = false)
+        : value(std::move(v)),
+          useIntegerZoom(useIntegerZoom_) {}
 
     bool isConstant() const {
         return value.template is<T>();
@@ -48,10 +50,16 @@ public:
                     return function.evaluate(feature, defaultValue);
                 },
                 [&] (const style::CompositeFunction<T>& function) {
-                    return function.evaluate(zoom, feature, defaultValue);
+                    if (useIntegerZoom) {
+                        return function.evaluate(floor(zoom), feature, defaultValue);
+                    } else {
+                        return function.evaluate(zoom, feature, defaultValue);
+                    }
                 }
         );
     }
+
+    bool useIntegerZoom;
 };
 
 namespace util {
diff --git a/src/mbgl/renderer/property_evaluation_parameters.hpp b/src/mbgl/renderer/property_evaluation_parameters.hpp
index 39b663bdb9..da6a4a0892 100644
--- a/src/mbgl/renderer/property_evaluation_parameters.hpp
+++ b/src/mbgl/renderer/property_evaluation_parameters.hpp
@@ -11,20 +11,24 @@ public:
         : z(z_),
           now(Clock::time_point::max()),
           zoomHistory(),
-          defaultFadeDuration(0) {}
+          defaultFadeDuration(0),
+          useIntegerZoom(false) {}
 
     PropertyEvaluationParameters(ZoomHistory zoomHistory_,
                           TimePoint now_,
-                          Duration defaultFadeDuration_)
+                          Duration defaultFadeDuration_,
+                          bool useIntegerZoom_ = false)
         : z(zoomHistory_.lastZoom),
           now(std::move(now_)),
           zoomHistory(std::move(zoomHistory_)),
-          defaultFadeDuration(std::move(defaultFadeDuration_)) {}
+          defaultFadeDuration(std::move(defaultFadeDuration_)),
+          useIntegerZoom(useIntegerZoom_) {}
 
     float z;
     TimePoint now;
     ZoomHistory zoomHistory;
     Duration defaultFadeDuration;
+    bool useIntegerZoom;
 };
 
 } // namespace mbgl