[core] Move render-related sources out of style directory/namespace

Moves the following to the renderer directory and out of the style namespace:

* CascadeParameters
* PropertyEvaluationParameters
* UpdateParameters
* PropertyEvaluator
* DataDrivenPropertyEvaluator
* CrossFadedPropertyEvaluator
* PaintPropertyBinder
* PaintProperyStatistics
* PossiblyEvaluatedPropertyValue
* TransitioningLight
* EvaluatedLight

1 files changed, 74 insertions, 0 deletions

diff --git a/src/mbgl/renderer/possibly_evaluated_property_value.hpp b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
new file mode 100644
index 0000000000..a0bcec2bf1
--- /dev/null
+++ b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include <mbgl/style/function/source_function.hpp>
+#include <mbgl/style/function/composite_function.hpp>
+#include <mbgl/util/interpolate.hpp>
+#include <mbgl/util/variant.hpp>
+
+namespace mbgl {
+
+template <class T>
+class PossiblyEvaluatedPropertyValue {
+private:
+    using Value = variant<
+        T,
+        style::SourceFunction<T>,
+        style::CompositeFunction<T>>;
+
+    Value value;
+
+public:
+    PossiblyEvaluatedPropertyValue() = default;
+    PossiblyEvaluatedPropertyValue(Value v) : value(std::move(v)) {}
+
+    bool isConstant() const {
+        return value.template is<T>();
+    }
+
+    optional<T> constant() const {
+        return value.match(
+            [&] (const T& t) { return optional<T>(t); },
+            [&] (const auto&) { return optional<T>(); });
+    }
+
+    T constantOr(const T& t) const {
+        return constant().value_or(t);
+    }
+
+    template <class... Ts>
+    auto match(Ts&&... ts) const {
+        return value.match(std::forward<Ts>(ts)...);
+    }
+
+    template <class Feature>
+    T evaluate(const Feature& feature, float zoom, T defaultValue) const {
+        return this->match(
+                [&] (const T& constant) { return constant; },
+                [&] (const style::SourceFunction<T>& function) {
+                    return function.evaluate(feature, defaultValue);
+                },
+                [&] (const style::CompositeFunction<T>& function) {
+                    return function.evaluate(zoom, feature, defaultValue);
+                }
+        );
+    }
+};
+
+namespace util {
+
+template <typename T>
+struct Interpolator<PossiblyEvaluatedPropertyValue<T>> {
+    PossiblyEvaluatedPropertyValue<T> operator()(const PossiblyEvaluatedPropertyValue<T>& a,
+                                                 const PossiblyEvaluatedPropertyValue<T>& b,
+                                                 const double t) const {
+        if (a.isConstant() && b.isConstant()) {
+            return { interpolate(*a.constant(), *b.constant(), t) };
+        } else {
+            return { a };
+        }
+    }
+};
+
+} // namespace util
+
+} // namespace mbgl