Per review:

* Reintroduce cascade params + rework light
* TODO: rename cascade->? (raw?); potentially add proper value/transition setters/getters

2 files changed, 35 insertions, 62 deletions

diff --git a/include/mbgl/style/light.hpp b/include/mbgl/style/light.hpp
index 3b8547c329..3d28fec914 100644
--- a/include/mbgl/style/light.hpp
+++ b/include/mbgl/style/light.hpp
@@ -6,75 +6,35 @@
 #include <mbgl/style/property_evaluator.hpp>
 #include <mbgl/style/property_evaluation_parameters.hpp>
 #include <mbgl/style/transition_options.hpp>
+#include <mbgl/style/cascade_parameters.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/interpolate.hpp>
 #include <mbgl/util/indexed_tuple.hpp>
 #include <mbgl/util/ignore.hpp>
-#include <mbgl/util/chrono.hpp>
 
 #include <memory>
 
 namespace mbgl {
 namespace style {
 
-template <class Value>
-class TransitioningLightProperty {
-public:
-    using UnevaluatedType = TransitioningProperty<Value>;
-
-    bool isUndefined() const {
-        return bool(value);
-    }
-
-    const Value& get() const {
-        return value;
-    }
-
-    template <class Evaluator>
-    auto evaluate(const Evaluator& evaluator, TimePoint now) {
-        return unevaluated.evaluate(evaluator, now);
-    }
-
-    void set(const Value& value_) {
-        value = value_;
-        unevaluated =
-            TransitioningProperty<Value>(std::move(value), unevaluated, transition, Clock::now());
-    }
-
-    const TransitionOptions& getTransition() const {
-        if (transition) {
-            return transition;
-        } else {
-            static const TransitionOptions staticValue{};
-            return staticValue;
-        }
-    }
-
-    void setTransition(const TransitionOptions& transition_) {
-        transition = transition_;
-        unevaluated = UnevaluatedType(value, std::move(unevaluated),
-                                      transition_.reverseMerge(transition), Clock::now());
-    }
-
-    bool hasTransition() const {
-        return unevaluated.hasTransition();
-    }
-
-private:
-    UnevaluatedType unevaluated;
-    Value value;
-    TransitionOptions transition;
-};
-
 template <class T>
 class LightProperty {
 public:
     using ValueType = PropertyValue<T>;
-    using TransitioningType = TransitioningLightProperty<ValueType>;
+    using UnevaluatedType = TransitioningProperty<ValueType>;
     using EvaluatorType = PropertyEvaluator<T>;
     using EvaluatedType = T;
+
+    ValueType value;
+    TransitionOptions transition;
+
+    TransitioningProperty<ValueType> cascade(const CascadeParameters& params,
+                                             TransitioningProperty<ValueType> prior) const {
+        return TransitioningProperty<ValueType>(
+            value, std::move(prior), transition.reverseMerge(params.transition), params.now);
+    }
 };
 
 template <class... Ps>
@@ -83,7 +43,7 @@ public:
     using Properties = TypeList<Ps...>;
 
     using EvaluatedTypes = TypeList<typename Ps::EvaluatedType...>;
-    using TransitioningTypes = TypeList<typename Ps::TransitioningType...>;
+    using UnevaluatedTypes = TypeList<typename Ps::UnevaluatedType...>;
 
     template <class TypeList>
     using Tuple = IndexedTuple<Properties, TypeList>;
@@ -93,36 +53,46 @@ public:
         using Tuple<EvaluatedTypes>::Tuple;
     };
 
-    class Transitioning : public Tuple<TransitioningTypes> {
+    class Unevaluated : public Tuple<UnevaluatedTypes> {
     public:
-        using Tuple<TransitioningTypes>::Tuple;
+        using Tuple<UnevaluatedTypes>::Tuple;
+    };
+
+    class Cascading : public Tuple<Properties> {
+    public:
+        using Tuple<Properties>::Tuple;
     };
 
     template <class P>
     auto get() const {
-        return transitioning.template get<P>().get();
+        return cascading.template get<P>().value;
     }
 
     template <class P>
     void set(const typename P::ValueType& value) {
-        transitioning.template get<P>().set(value);
+        cascading.template get<P>().value = value;
     }
 
     template <class P>
     TransitionOptions getTransition() {
-        return transitioning.template get<P>().getTransition();
+        return cascading.template get<P>().transition();
     }
 
     template <class P>
     void setTransition(const TransitionOptions& value) {
-        transitioning.template get<P>().setTransition(value);
+        cascading.template get<P>().transition = value;
+    }
+
+    void cascade(const CascadeParameters& parameters) {
+        unevaluated = Unevaluated{ cascading.template get<Ps>().cascade(
+            parameters, std::move(unevaluated.template get<Ps>()))... };
     }
 
     template <class P>
     auto evaluate(const PropertyEvaluationParameters& parameters) {
         using Evaluator = typename P::EvaluatorType;
-        return transitioning.template get<P>().evaluate(Evaluator(parameters, P::defaultValue()),
-                                                        parameters.now);
+        return unevaluated.template get<P>().evaluate(Evaluator(parameters, P::defaultValue()),
+                                                      parameters.now);
     }
 
     void evaluate(const PropertyEvaluationParameters& parameters) {
@@ -131,11 +101,12 @@ public:
 
     bool hasTransition() const {
         bool result = false;
-        util::ignore({ result |= transitioning.template get<Ps>().hasTransition()... });
+        util::ignore({ result |= unevaluated.template get<Ps>().hasTransition()... });
         return result;
     }
 
-    Transitioning transitioning;
+    Cascading cascading;
+    Unevaluated unevaluated;
     Evaluated evaluated;
 };
 
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index 640c1e9bdb..aec9713c27 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -308,6 +308,8 @@ void Style::cascade(const TimePoint& timePoint, MapMode mode) {
     for (const auto& layer : layers) {
         layer->baseImpl->cascade(parameters);
     }
+
+    light.cascade(parameters);
 }
 
 void Style::recalculate(float z, const TimePoint& timePoint, MapMode mode) {