[core] decouple crossfade zoom state and sprites, fix crossfading

31 files changed, 83 insertions, 57 deletions

diff --git a/src/mbgl/layout/pattern_layout.hpp b/src/mbgl/layout/pattern_layout.hpp
index ed89874fa0..9f4964ca6b 100644
--- a/src/mbgl/layout/pattern_layout.hpp
+++ b/src/mbgl/layout/pattern_layout.hpp
@@ -45,7 +45,7 @@ public:
             const typename B::PossiblyEvaluatedPaintProperties evaluatedProps = layer->as<PatternLayer>()->paintProperties();
             layerPaintProperties.emplace(layer->getID(), std::move(evaluatedProps));
             const auto patternProperty = evaluatedProps.template get<typename PatternLayer::PatternProperty>();
-            const auto constantPattern = patternProperty.constantOr(Faded<std::basic_string<char> >{ "", "", 0.0f, 0.0f, 0.0f});
+            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()) {
@@ -109,8 +109,9 @@ public:
     };
 
     std::map<std::string, typename B::PossiblyEvaluatedPaintProperties> layerPaintProperties;
-
     const std::string bucketLeaderID;
+
+
 private:
     const std::unique_ptr<GeometryTileLayer> sourceLayer;
     std::vector<PatternFeature> features;
diff --git a/src/mbgl/programs/background_program.cpp b/src/mbgl/programs/background_program.cpp
index ae9c923c73..94d7aab2c8 100644
--- a/src/mbgl/programs/background_program.cpp
+++ b/src/mbgl/programs/background_program.cpp
@@ -16,7 +16,7 @@ BackgroundPatternUniforms::values(mat4 matrix,
                                   Size atlasSize,
                                   const ImagePosition& a,
                                   const ImagePosition& b,
-                                  const Faded<std::string>& fading,
+                                  const CrossfadeParameters& fading,
                                   const UnwrappedTileID& tileID,
                                   const TransformState& state)
 {
diff --git a/src/mbgl/programs/background_program.hpp b/src/mbgl/programs/background_program.hpp
index b76318938c..667db7792b 100644
--- a/src/mbgl/programs/background_program.hpp
+++ b/src/mbgl/programs/background_program.hpp
@@ -50,7 +50,7 @@ struct BackgroundPatternUniforms : gl::Uniforms<
                          Size atlasSize,
                          const ImagePosition&,
                          const ImagePosition&,
-                         const Faded<std::string>&,
+                         const CrossfadeParameters&,
                          const UnwrappedTileID&,
                          const TransformState&);
 };
diff --git a/src/mbgl/programs/line_program.cpp b/src/mbgl/programs/line_program.cpp
index 3541a3bfae..55362ad6fe 100644
--- a/src/mbgl/programs/line_program.cpp
+++ b/src/mbgl/programs/line_program.cpp
@@ -52,9 +52,10 @@ LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated
                               const std::array<float, 2>& pixelsToGLUnits,
                               const LinePatternPos& posA,
                               const LinePatternPos& posB,
+                              const CrossfadeParameters& crossfade,
                               float atlasWidth) {
-    const float widthA = posA.width * properties.get<LineDasharray>().fromScale;
-    const float widthB = posB.width * properties.get<LineDasharray>().toScale;
+    const float widthA = posA.width * crossfade.fromScale;
+    const float widthB = posB.width * crossfade.toScale;
 
     std::array<float, 2> scaleA {{
         1.0f / tile.id.pixelsToTileUnits(widthA, state.getIntegerZoom()),
@@ -75,7 +76,7 @@ LineSDFProgram::uniformValues(const RenderLinePaintProperties::PossiblyEvaluated
         uniforms::u_patternscale_b::Value( scaleB ),
         uniforms::u_tex_y_a::Value( posA.y ),
         uniforms::u_tex_y_b::Value( posB.y ),
-        uniforms::u_mix::Value( properties.get<LineDasharray>().t ),
+        uniforms::u_mix::Value( crossfade.t ),
         uniforms::u_sdfgamma::Value( atlasWidth / (std::min(widthA, widthB) * 256.0f * pixelRatio) / 2.0f ),
         uniforms::u_image::Value( 0 )
     );
diff --git a/src/mbgl/programs/line_program.hpp b/src/mbgl/programs/line_program.hpp
index cc4ec8c764..9dde0939e7 100644
--- a/src/mbgl/programs/line_program.hpp
+++ b/src/mbgl/programs/line_program.hpp
@@ -151,6 +151,7 @@ public:
                                        const std::array<float, 2>& pixelsToGLUnits,
                                        const LinePatternPos& posA,
                                        const LinePatternPos& posB,
+                                       const CrossfadeParameters& crossfade,
                                        float atlasWidth);
 };
 
diff --git a/src/mbgl/renderer/cross_faded_property_evaluator.cpp b/src/mbgl/renderer/cross_faded_property_evaluator.cpp
index 9a7af8636c..7be9c2bcf5 100644
--- a/src/mbgl/renderer/cross_faded_property_evaluator.cpp
+++ b/src/mbgl/renderer/cross_faded_property_evaluator.cpp
@@ -25,16 +25,9 @@ Faded<T> CrossFadedPropertyEvaluator<T>::operator()(const style::PropertyExpress
 template <typename T>
 Faded<T> CrossFadedPropertyEvaluator<T>::calculate(const T& min, const T& mid, const T& max) const {
     const float z = parameters.z;
-    const float fraction = z - std::floor(z);
-    const std::chrono::duration<float> d = parameters.defaultFadeDuration;
-    const float t =
-        d != std::chrono::duration<float>::zero()
-            ? std::min((parameters.now - parameters.zoomHistory.lastIntegerZoomTime) / d, 1.0f)
-            : 1.0f;
-
     return z > parameters.zoomHistory.lastIntegerZoom
-        ? Faded<T> { min, mid, 2.0f, 1.0f, fraction + (1.0f - fraction) * t }
-        : Faded<T> { max, mid, 0.5f, 1.0f, 1 - (1 - t) * fraction };
+        ? Faded<T> { min, mid }
+        : Faded<T> { max, mid };
 }
 
 template class CrossFadedPropertyEvaluator<std::string>;
diff --git a/src/mbgl/renderer/cross_faded_property_evaluator.hpp b/src/mbgl/renderer/cross_faded_property_evaluator.hpp
index 1d17c5eb2f..e925b96fa3 100644
--- a/src/mbgl/renderer/cross_faded_property_evaluator.hpp
+++ b/src/mbgl/renderer/cross_faded_property_evaluator.hpp
@@ -11,9 +11,6 @@ class Faded {
 public:
     T from;
     T to;
-    float fromScale;
-    float toScale;
-    float t;
 };
 
 template <typename T>
diff --git a/src/mbgl/renderer/data_driven_property_evaluator.hpp b/src/mbgl/renderer/data_driven_property_evaluator.hpp
index f158dc2279..d65ac36713 100644
--- a/src/mbgl/renderer/data_driven_property_evaluator.hpp
+++ b/src/mbgl/renderer/data_driven_property_evaluator.hpp
@@ -71,16 +71,9 @@ public:
 private:
     Faded<T> calculate(const T& min, const T& mid, const T& max) const {
         const float z = parameters.z;
-        const float fraction = z - std::floor(z);
-        const std::chrono::duration<float> d = parameters.defaultFadeDuration;
-        const float t =
-            d != std::chrono::duration<float>::zero()
-                ? std::min((parameters.now - parameters.zoomHistory.lastIntegerZoomTime) / d, 1.0f)
-                : 1.0f;
-
         return z > parameters.zoomHistory.lastIntegerZoom
-            ? Faded<T> { min, mid, 2.0f, 1.0f, fraction + (1.0f - fraction) * t }
-            : Faded<T> { max, mid, 0.5f, 1.0f, 1 - (1 - t) * fraction };
+            ? Faded<T> { min, mid }
+            : Faded<T> { max, mid };
     };
 
     const PropertyEvaluationParameters& parameters;
diff --git a/src/mbgl/renderer/layers/render_background_layer.cpp b/src/mbgl/renderer/layers/render_background_layer.cpp
index 602c589b09..ad85fe0cce 100644
--- a/src/mbgl/renderer/layers/render_background_layer.cpp
+++ b/src/mbgl/renderer/layers/render_background_layer.cpp
@@ -34,6 +34,7 @@ void RenderBackgroundLayer::transition(const TransitionParameters &parameters) {
 
 void RenderBackgroundLayer::evaluate(const PropertyEvaluationParameters &parameters) {
     evaluated = unevaluated.evaluate(parameters);
+    crossfade = parameters.getCrossfadeParameters();
 
     passes = evaluated.get<style::BackgroundOpacity>() > 0 ? RenderPass::Translucent
                                                            : RenderPass::None;
@@ -43,6 +44,10 @@ bool RenderBackgroundLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderBackgroundLayer::hasCrossfade() const {
+    return crossfade.t != 1;
+}
+
 void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
     // Note that for bottommost layers without a pattern, the background color is drawn with
     // glClear rather than this method.
@@ -97,7 +102,7 @@ void RenderBackgroundLayer::render(PaintParameters& parameters, RenderSource*) {
                     parameters.imageManager.getPixelSize(),
                     *imagePosA,
                     *imagePosB,
-                    evaluated.get<BackgroundPattern>(),
+                    crossfade,
                     tileID,
                     parameters.state
                 )
diff --git a/src/mbgl/renderer/layers/render_background_layer.hpp b/src/mbgl/renderer/layers/render_background_layer.hpp
index a619670ee4..854c077a62 100644
--- a/src/mbgl/renderer/layers/render_background_layer.hpp
+++ b/src/mbgl/renderer/layers/render_background_layer.hpp
@@ -14,6 +14,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const override;
@@ -23,6 +24,8 @@ public:
     style::BackgroundPaintProperties::PossiblyEvaluated evaluated;
 
     const style::BackgroundLayer::Impl& impl() const;
+private:
+    CrossfadeParameters crossfade;
 };
 
 template <>
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index dacce35d75..af96e2e991 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -47,6 +47,10 @@ bool RenderCircleLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderCircleLayer::hasCrossfade() const {
+    return false;
+}
+
 void RenderCircleLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp
index c9eeae4652..53353fcdcb 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -14,6 +14,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
 
     bool queryIntersectsFeature(
diff --git a/src/mbgl/renderer/layers/render_custom_layer.cpp b/src/mbgl/renderer/layers/render_custom_layer.cpp
index be9f64d9eb..16c18447c5 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.cpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.cpp
@@ -38,6 +38,9 @@ void RenderCustomLayer::evaluate(const PropertyEvaluationParameters&) {
 bool RenderCustomLayer::hasTransition() const {
     return false;
 }
+bool RenderCustomLayer::hasCrossfade() const {
+    return false;
+}
 
 std::unique_ptr<Bucket> RenderCustomLayer::createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const {
     assert(false);
diff --git a/src/mbgl/renderer/layers/render_custom_layer.hpp b/src/mbgl/renderer/layers/render_custom_layer.hpp
index 971d8d8f42..47d5bb3f40 100644
--- a/src/mbgl/renderer/layers/render_custom_layer.hpp
+++ b/src/mbgl/renderer/layers/render_custom_layer.hpp
@@ -13,6 +13,7 @@ public:
     void transition(const TransitionParameters&) final {}
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
 
     std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<const RenderLayer*>&) const final;
     void render(PaintParameters&, RenderSource*) final;
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index 925a743d66..08e9d609cd 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -58,6 +58,10 @@ bool RenderFillExtrusionLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderFillExtrusionLayer::hasCrossfade() const {
+    return crossfade.t != 1;
+}
+
 void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
@@ -111,9 +115,8 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                 allAttributeBindings,
                 getID());
         };
-        const auto fillPattern = evaluated.get<FillExtrusionPattern>();
-        const auto fillPatternValue = fillPattern.constantOr(mbgl::Faded<std::basic_string<char> >{ "temp", "temp", 0.0f, 0.0f, 0.0f});
-        if (fillPatternValue.from.empty()) {
+
+        if (unevaluated.get<FillExtrusionPattern>().isUndefined()) {
             for (const RenderTile& tile : renderTiles) {
                 auto bucket_ = tile.tile.getBucket<FillExtrusionBucket>(*baseImpl);
                 if (!bucket_) {
@@ -140,7 +143,7 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters, RenderSource*
                 if (!bucket_) {
                     continue;
                 }
-
+                const auto fillPatternValue = evaluated.get<FillExtrusionPattern>().constantOr(mbgl::Faded<std::basic_string<char> >{"", ""});
                 assert(dynamic_cast<GeometryTile*>(&tile.tile));
                 GeometryTile& geometryTile = static_cast<GeometryTile&>(tile.tile);
                 optional<ImagePosition> patternPosA = geometryTile.getPattern(fillPatternValue.from);
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
index b5ba23649d..1a721d035b 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -24,6 +24,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
     style::FillExtrusionPaintProperties::PossiblyEvaluated paintProperties() const;
 
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 5819c90417..5d7ed02da8 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -69,10 +69,12 @@ bool RenderFillLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderFillLayer::hasCrossfade() const {
+    return crossfade.t != 1;
+}
+
 void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
-    const auto fillPattern = evaluated.get<FillPattern>();
-    const auto fillPatternValue = fillPattern.constantOr(mbgl::Faded<std::basic_string<char> >{ "temp", "temp", 0.0f, 0.0f, 0.0f});
-    if (fillPatternValue.from.empty()) {
+    if (unevaluated.get<FillPattern>().isUndefined()) {
         for (const RenderTile& tile : renderTiles) {
             auto bucket_ = tile.tile.getBucket<FillBucket>(*baseImpl);
             if (!bucket_) {
@@ -151,7 +153,7 @@ void RenderFillLayer::render(PaintParameters& parameters, RenderSource*) {
         if (parameters.pass != RenderPass::Translucent) {
             return;
         }
-
+        const auto fillPatternValue = evaluated.get<FillPattern>().constantOr(Faded<std::basic_string<char>>{"", ""});
         for (const RenderTile& tile : renderTiles) {
             assert(dynamic_cast<GeometryTile*>(&tile.tile));
             GeometryTile& geometryTile = static_cast<GeometryTile&>(tile.tile);
diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp
index 3403262121..5a3c05387d 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -20,6 +20,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
     style::FillPaintProperties::PossiblyEvaluated paintProperties() const;
 
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 9801ea5950..8e24cf8f32 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -45,6 +45,10 @@ bool RenderHeatmapLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderHeatmapLayer::hasCrossfade() const {
+    return false;
+}
+
 void RenderHeatmapLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
index 29fad7d8b8..6f8163ebf1 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -16,6 +16,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
 
     bool queryIntersectsFeature(
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.cpp b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
index 781f1af47c..b96030f44d 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.cpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.cpp
@@ -56,6 +56,10 @@ bool RenderHillshadeLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderHillshadeLayer::hasCrossfade() const {
+    return false;
+}
+
 void RenderHillshadeLayer::render(PaintParameters& parameters, RenderSource* src) {
     if (parameters.pass != RenderPass::Translucent && parameters.pass != RenderPass::Pass3D)
         return;
diff --git a/src/mbgl/renderer/layers/render_hillshade_layer.hpp b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
index 13093ee7ef..f88f1cd12f 100644
--- a/src/mbgl/renderer/layers/render_hillshade_layer.hpp
+++ b/src/mbgl/renderer/layers/render_hillshade_layer.hpp
@@ -15,6 +15,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
 
     void render(PaintParameters&, RenderSource* src) override;
 
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index cd134fb7da..ff8a98c950 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -51,7 +51,7 @@ 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();
 
@@ -65,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;
@@ -111,11 +115,7 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                 getID()
             );
         };
-        const auto linepattern = evaluated.get<LinePattern>();
 
-        // need a non-empty placeholder value that will result in the LinePattern program to be
-        // used if the line-pattern value is non-constant
-        const auto linePatternValue = linepattern.constantOr(mbgl::Faded<std::basic_string<char> >{ "temp", "temp", 0.0f, 0.0f, 0.0f});
         if (!evaluated.get<LineDasharray>().from.empty()) {
             const LinePatternCap cap = bucket.layout.get<LineCap>() == LineCapType::Round
                 ? LinePatternCap::Round : LinePatternCap::Square;
@@ -133,9 +133,11 @@ void RenderLineLayer::render(PaintParameters& parameters, RenderSource*) {
                      parameters.pixelsToGLUnits,
                      posA,
                      posB,
+                     crossfade,
                      parameters.lineAtlas.getSize().width), {}, {});
 
-        } else if (!linePatternValue.from.empty()) {
+        } 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);
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index 52d307e5a5..19ccccfb39 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -30,6 +30,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
 
     RenderLinePaintProperties::PossiblyEvaluated paintProperties() const;
@@ -53,7 +54,6 @@ public:
     style::LinePaintProperties::Unevaluated unevaluated;
     RenderLinePaintProperties::PossiblyEvaluated evaluated;
 
-
     const style::LineLayer::Impl& impl() const;
 
 private:
diff --git a/src/mbgl/renderer/layers/render_raster_layer.cpp b/src/mbgl/renderer/layers/render_raster_layer.cpp
index 3179a88207..b8df71b7c1 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.cpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.cpp
@@ -41,6 +41,10 @@ bool RenderRasterLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderRasterLayer::hasCrossfade() const {
+    return false;
+}
+
 static float saturationFactor(float saturation) {
     if (saturation > 0) {
         return 1 - 1 / (1.001 - saturation);
diff --git a/src/mbgl/renderer/layers/render_raster_layer.hpp b/src/mbgl/renderer/layers/render_raster_layer.hpp
index 87de316f7c..a8633c4d5e 100644
--- a/src/mbgl/renderer/layers/render_raster_layer.hpp
+++ b/src/mbgl/renderer/layers/render_raster_layer.hpp
@@ -14,6 +14,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
 
     void render(PaintParameters&, RenderSource*) override;
 
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 1eb8c83bf6..cf65e29048 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -69,6 +69,10 @@ bool RenderSymbolLayer::hasTransition() const {
     return unevaluated.hasTransition();
 }
 
+bool RenderSymbolLayer::hasCrossfade() const {
+    return false;
+}
+
 void RenderSymbolLayer::render(PaintParameters& parameters, RenderSource*) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.hpp b/src/mbgl/renderer/layers/render_symbol_layer.hpp
index 5b73b30294..efdcf0e932 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.hpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.hpp
@@ -64,6 +64,7 @@ public:
     void transition(const TransitionParameters&) override;
     void evaluate(const PropertyEvaluationParameters&) override;
     bool hasTransition() const override;
+    bool hasCrossfade() const override;
     void render(PaintParameters&, RenderSource*) override;
 
     style::IconPaintProperties::PossiblyEvaluated iconPaintProperties() const;
diff --git a/src/mbgl/renderer/possibly_evaluated_property_value.hpp b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
index b49299ac3a..353df2ab90 100644
--- a/src/mbgl/renderer/possibly_evaluated_property_value.hpp
+++ b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
@@ -87,16 +87,6 @@ public:
         return constant().value_or(t);
     }
 
-    std::vector<optional<T>> possibleOutputs() const {
-        return this->match(
-            [&] (const Faded<T>& constant_) {
-                return std::vector<optional<T>>{ optional<T>(constant_.to), optional<T>(constant_.from) }; },
-            [&] (const style::PropertyExpression<T>& expression) {
-                return expression.possibleOutputs();
-            }
-        );
-    }
-
     template <class... Ts>
     auto match(Ts&&... ts) const {
         return value.match(std::forward<Ts>(ts)...);
@@ -110,10 +100,10 @@ public:
                 if (!expression.isZoomConstant()) {
                     const T min = expression.evaluate(floor(zoom), feature, defaultValue);
                     const T max = expression.evaluate(floor(zoom) + 1, feature, defaultValue);
-                    return Faded<T> {min, max,  0.0f, 0.0f, 0.0f};
+                    return Faded<T> {min, max};
                 } else {
                     const T evaluated = expression.evaluate(feature, defaultValue);
-                    return Faded<T> {evaluated, evaluated, 0.0f, 0.0f, 0.0f};
+                    return Faded<T> {evaluated, evaluated};
                 }
             }
         );
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 3e2f1d7525..9f327c63e5 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -40,6 +40,9 @@ public:
     // Returns true if any paint properties have active transitions.
     virtual bool hasTransition() const = 0;
 
+    // Returns true if the layer has a pattern property and is actively crossfading.
+    virtual bool hasCrossfade() const = 0;
+
     // Check whether this layer is of the given subtype.
     template <class T>
     bool is() const;
diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 4e636b5c7e..92d04063ca 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -14,6 +14,7 @@
 #include <mbgl/renderer/layers/render_background_layer.hpp>
 #include <mbgl/renderer/layers/render_custom_layer.hpp>
 #include <mbgl/renderer/layers/render_fill_extrusion_layer.hpp>
+#include <mbgl/renderer/layers/render_fill_layer.hpp>
 #include <mbgl/renderer/layers/render_heatmap_layer.hpp>
 #include <mbgl/renderer/layers/render_hillshade_layer.hpp>
 #include <mbgl/renderer/style_diff.hpp>
@@ -195,7 +196,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
             }
         }
 
-        if (layerAdded || layerChanged || zoomChanged || layer.hasTransition()) {
+        if (layerAdded || layerChanged || zoomChanged || layer.hasTransition() || layer.hasCrossfade()) {
             layer.evaluate(evaluationParameters);
         }
     }