Split light.hpp into public and private implementation

12 files changed, 103 insertions, 121 deletions

diff --git a/cmake/core-files.cmake b/cmake/core-files.cmake
index f196a72d51..12c7f746d8 100644
--- a/cmake/core-files.cmake
+++ b/cmake/core-files.cmake
@@ -266,7 +266,6 @@ set(MBGL_CORE_FILES
     include/mbgl/style/query.hpp
     include/mbgl/style/source.hpp
     include/mbgl/style/transition_options.hpp
-    include/mbgl/style/transitioning_property.hpp
     include/mbgl/style/types.hpp
     include/mbgl/style/undefined.hpp
     src/mbgl/style/bucket_parameters.cpp
@@ -285,6 +284,7 @@ set(MBGL_CORE_FILES
     src/mbgl/style/layer_impl.hpp
     src/mbgl/style/layer_observer.hpp
     src/mbgl/style/layout_property.hpp
+    src/mbgl/style/light_impl.hpp
     src/mbgl/style/observer.hpp
     src/mbgl/style/paint_property.hpp
     src/mbgl/style/paint_property_binder.hpp
@@ -303,6 +303,7 @@ set(MBGL_CORE_FILES
     src/mbgl/style/style.hpp
     src/mbgl/style/tile_source_impl.cpp
     src/mbgl/style/tile_source_impl.hpp
+    src/mbgl/style/transitioning_property.hpp
     src/mbgl/style/types.cpp
     src/mbgl/style/update_batch.hpp
     src/mbgl/style/update_parameters.hpp
@@ -471,6 +472,7 @@ set(MBGL_CORE_FILES
     include/mbgl/util/geometry.hpp
     include/mbgl/util/ignore.hpp
     include/mbgl/util/image.hpp
+    include/mbgl/util/indexed_tuple.hpp
     include/mbgl/util/interpolate.hpp
     include/mbgl/util/logging.hpp
     include/mbgl/util/noncopyable.hpp
@@ -484,6 +486,7 @@ set(MBGL_CORE_FILES
     include/mbgl/util/tileset.hpp
     include/mbgl/util/timer.hpp
     include/mbgl/util/traits.hpp
+    include/mbgl/util/type_list.hpp
     include/mbgl/util/unitbezier.hpp
     include/mbgl/util/util.hpp
     include/mbgl/util/variant.hpp
@@ -511,7 +514,6 @@ set(MBGL_CORE_FILES
     src/mbgl/util/http_timeout.hpp
     src/mbgl/util/i18n.cpp
     src/mbgl/util/i18n.hpp
-    src/mbgl/util/indexed_tuple.hpp
     src/mbgl/util/interpolate.cpp
     src/mbgl/util/intersection_tests.cpp
     src/mbgl/util/intersection_tests.hpp
@@ -545,7 +547,6 @@ set(MBGL_CORE_FILES
     src/mbgl/util/tile_cover.cpp
     src/mbgl/util/tile_cover.hpp
     src/mbgl/util/token.hpp
-    src/mbgl/util/type_list.hpp
     src/mbgl/util/url.cpp
     src/mbgl/util/url.hpp
     src/mbgl/util/utf.hpp
diff --git a/include/mbgl/style/conversion/light.hpp b/include/mbgl/style/conversion/light.hpp
index f85c5b694e..631ed04ccb 100644
--- a/include/mbgl/style/conversion/light.hpp
+++ b/include/mbgl/style/conversion/light.hpp
@@ -28,7 +28,7 @@ public:
                 convert<PropertyValue<LightAnchorType>>(*anchor, error);
 
             if (convertedAnchor) {
-                light.set<LightAnchor>(*convertedAnchor);
+                light.get<LightAnchor>().value = *convertedAnchor;
             } else {
                 return {};
             }
@@ -39,7 +39,7 @@ public:
             optional<TransitionOptions> transition =
                 convert<TransitionOptions>(*anchorTransition, error);
             if (transition) {
-                light.setTransition<LightAnchor>(*transition);
+                light.get<LightAnchor>().transition = *transition;
             } else {
                 return {};
             }
@@ -51,7 +51,7 @@ public:
                 convert<PropertyValue<Color>>(*color, error);
 
             if (convertedColor) {
-                light.set<LightColor>(*convertedColor);
+                light.get<LightColor>().value = *convertedColor;
             } else {
                 return {};
             }
@@ -62,7 +62,7 @@ public:
             optional<TransitionOptions> transition =
                 convert<TransitionOptions>(*colorTransition, error);
             if (transition) {
-                light.setTransition<LightColor>(*transition);
+                light.get<LightColor>().transition = *transition;
             } else {
                 return {};
             }
@@ -74,7 +74,7 @@ public:
                 convert<PropertyValue<Position>>(*position, error);
 
             if (convertedPosition) {
-                light.set<LightPosition>(*convertedPosition);
+                light.get<LightPosition>().value = *convertedPosition;
             } else {
                 return {};
             }
@@ -85,7 +85,7 @@ public:
             optional<TransitionOptions> transition =
                 convert<TransitionOptions>(*positionTransition, error);
             if (transition) {
-                light.setTransition<LightPosition>(*transition);
+                light.get<LightPosition>().transition = *transition;
             } else {
                 return {};
             }
@@ -97,7 +97,7 @@ public:
                 convert<PropertyValue<float>>(*intensity, error);
 
             if (convertedIntensity) {
-                light.set<LightIntensity>(*convertedIntensity);
+                light.get<LightIntensity>().value = *convertedIntensity;
             } else {
                 return {};
             }
@@ -108,7 +108,7 @@ public:
             optional<TransitionOptions> transition =
                 convert<TransitionOptions>(*intensityTransition, error);
             if (transition) {
-                light.setTransition<LightIntensity>(*transition);
+                light.get<LightIntensity>().transition = *transition;
             } else {
                 return {};
             }
diff --git a/include/mbgl/style/light.hpp b/include/mbgl/style/light.hpp
index 3d28fec914..bec8e6ddeb 100644
--- a/include/mbgl/style/light.hpp
+++ b/include/mbgl/style/light.hpp
@@ -1,20 +1,11 @@
 #pragma once
 
-#include <mbgl/style/transitioning_property.hpp>
-#include <mbgl/style/types.hpp>
 #include <mbgl/style/property_value.hpp>
-#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/style/types.hpp>
+#include <mbgl/style/position.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 <memory>
 
 namespace mbgl {
 namespace style {
@@ -22,92 +13,11 @@ namespace style {
 template <class T>
 class LightProperty {
 public:
+    using Type = T;
     using ValueType = PropertyValue<T>;
-    using UnevaluatedType = TransitioningProperty<ValueType>;
-    using EvaluatorType = PropertyEvaluator<T>;
-    using EvaluatedType = T;
 
-    ValueType value;
+    PropertyValue<T> 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>
-class LightProperties {
-public:
-    using Properties = TypeList<Ps...>;
-
-    using EvaluatedTypes = TypeList<typename Ps::EvaluatedType...>;
-    using UnevaluatedTypes = TypeList<typename Ps::UnevaluatedType...>;
-
-    template <class TypeList>
-    using Tuple = IndexedTuple<Properties, TypeList>;
-
-    class Evaluated : public Tuple<EvaluatedTypes> {
-    public:
-        using Tuple<EvaluatedTypes>::Tuple;
-    };
-
-    class Unevaluated : public Tuple<UnevaluatedTypes> {
-    public:
-        using Tuple<UnevaluatedTypes>::Tuple;
-    };
-
-    class Cascading : public Tuple<Properties> {
-    public:
-        using Tuple<Properties>::Tuple;
-    };
-
-    template <class P>
-    auto get() const {
-        return cascading.template get<P>().value;
-    }
-
-    template <class P>
-    void set(const typename P::ValueType& value) {
-        cascading.template get<P>().value = value;
-    }
-
-    template <class P>
-    TransitionOptions getTransition() {
-        return cascading.template get<P>().transition();
-    }
-
-    template <class P>
-    void setTransition(const TransitionOptions& 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 unevaluated.template get<P>().evaluate(Evaluator(parameters, P::defaultValue()),
-                                                      parameters.now);
-    }
-
-    void evaluate(const PropertyEvaluationParameters& parameters) {
-        evaluated = Evaluated{ evaluate<Ps>(parameters)... };
-    }
-
-    bool hasTransition() const {
-        bool result = false;
-        util::ignore({ result |= unevaluated.template get<Ps>().hasTransition()... });
-        return result;
-    }
-
-    Cascading cascading;
-    Unevaluated unevaluated;
-    Evaluated evaluated;
 };
 
 struct LightAnchor : LightProperty<LightAnchorType> {
@@ -115,24 +25,28 @@ struct LightAnchor : LightProperty<LightAnchorType> {
         return LightAnchorType::Viewport;
     }
 };
+
 struct LightPosition : LightProperty<Position> {
     static Position defaultValue() {
         std::array<float, 3> default_ = { { 1.15, 210, 30 } };
         return Position{ { default_ } };
     }
 };
+
 struct LightColor : LightProperty<Color> {
     static Color defaultValue() {
         return Color::white();
     }
 };
+
 struct LightIntensity : LightProperty<float> {
     static float defaultValue() {
         return 0.5;
     }
 };
 
-class Light : public LightProperties<LightAnchor, LightPosition, LightColor, LightIntensity> {};
+using LightProperties = TypeList<LightAnchor, LightPosition, LightColor, LightIntensity>;
+class Light : public IndexedTuple<LightProperties, LightProperties> {};
 
 } // namespace style
 } // namespace mbgl
diff --git a/src/mbgl/util/indexed_tuple.hpp b/include/mbgl/util/indexed_tuple.hpp
index a414639530..a414639530 100644
--- a/src/mbgl/util/indexed_tuple.hpp
+++ b/include/mbgl/util/indexed_tuple.hpp
diff --git a/src/mbgl/util/type_list.hpp b/include/mbgl/util/type_list.hpp
index 4a5e95c8a4..4a5e95c8a4 100644
--- a/src/mbgl/util/type_list.hpp
+++ b/include/mbgl/util/type_list.hpp
diff --git a/src/mbgl/programs/fill_extrusion_program.cpp b/src/mbgl/programs/fill_extrusion_program.cpp
index 36d7818b2a..67426c8d9d 100644
--- a/src/mbgl/programs/fill_extrusion_program.cpp
+++ b/src/mbgl/programs/fill_extrusion_program.cpp
@@ -11,12 +11,12 @@ using namespace style;
 
 static_assert(sizeof(FillExtrusionLayoutVertex) == 12, "expected FillExtrusionLayoutVertex size");
 
-std::array<float, 3> lightColor(const style::Light::Evaluated& light) {
+std::array<float, 3> lightColor(const EvaluatedLight& light) {
     const auto color = light.get<LightColor>();
     return {{ color.r, color.g, color.b }};
 }
 
-std::array<float, 3> lightPosition(const style::Light::Evaluated& light, const TransformState& state) {
+std::array<float, 3> lightPosition(const EvaluatedLight& light, const TransformState& state) {
     auto lightPos = light.get<LightPosition>().getCartesian();
     mat3 lightMat;
     matrix::identity(lightMat);
@@ -27,14 +27,14 @@ std::array<float, 3> lightPosition(const style::Light::Evaluated& light, const T
     return lightPos;
 }
 
-float lightIntensity(const style::Light::Evaluated& light) {
+float lightIntensity(const EvaluatedLight& light) {
     return light.get<LightIntensity>();
 }
 
 FillExtrusionUniforms::Values
 FillExtrusionUniforms::values(mat4 matrix,
                               const TransformState& state,
-                              const style::Light::Evaluated& light) {
+                              const EvaluatedLight& light) {
     return FillExtrusionUniforms::Values{
         uniforms::u_matrix::Value{ matrix },
         uniforms::u_lightcolor::Value{ lightColor(light) },
@@ -51,7 +51,7 @@ FillExtrusionPatternUniforms::values(mat4 matrix,
                                      const UnwrappedTileID& tileID,
                                      const TransformState& state,
                                      const float heightFactor,
-                                     const style::Light::Evaluated& light) {
+                                     const EvaluatedLight& light) {
     int32_t tileSizeAtNearestZoom = util::tileSize * state.zoomScale(state.getIntegerZoom() - tileID.canonical.z);
     int32_t pixelX = tileSizeAtNearestZoom * (tileID.canonical.x + tileID.wrap * state.zoomScale(tileID.canonical.z));
     int32_t pixelY = tileSizeAtNearestZoom * tileID.canonical.y;
diff --git a/src/mbgl/programs/fill_extrusion_program.hpp b/src/mbgl/programs/fill_extrusion_program.hpp
index ed4ba6fe00..313304fc6e 100644
--- a/src/mbgl/programs/fill_extrusion_program.hpp
+++ b/src/mbgl/programs/fill_extrusion_program.hpp
@@ -10,7 +10,7 @@
 #include <mbgl/util/size.hpp>
 #include <mbgl/style/layers/fill_extrusion_layer_properties.hpp>
 #include <mbgl/style/style.hpp>
-#include <mbgl/style/light.hpp>
+#include <mbgl/style/light_impl.hpp>
 
 #include <string>
 
@@ -45,7 +45,7 @@ struct FillExtrusionUniforms : gl::Uniforms<
 {
     static Values values(mat4,
                          const TransformState&,
-                         const style::Light::Evaluated&);
+                         const style::EvaluatedLight&);
 };
 
 struct FillExtrusionPatternUniforms : gl::Uniforms<
@@ -75,7 +75,7 @@ struct FillExtrusionPatternUniforms : gl::Uniforms<
                          const UnwrappedTileID&,
                          const TransformState&,
                          const float,
-                         const style::Light::Evaluated&);
+                         const style::EvaluatedLight&);
 };
 
 class FillExtrusionProgram : public Program<
diff --git a/src/mbgl/renderer/painter_fill_extrusion.cpp b/src/mbgl/renderer/painter_fill_extrusion.cpp
index 71f5c24fe2..fbd817bc68 100644
--- a/src/mbgl/renderer/painter_fill_extrusion.cpp
+++ b/src/mbgl/renderer/painter_fill_extrusion.cpp
@@ -25,8 +25,6 @@ void Painter::renderFillExtrusion(PaintParameters& parameters,
         return;
     }
 
-    const auto light = style.light.evaluated;
-
     if (!properties.get<FillExtrusionPattern>().from.empty()) {
         optional<SpriteAtlasElement> imagePosA =
             spriteAtlas->getPattern(properties.get<FillExtrusionPattern>().from);
@@ -55,7 +53,7 @@ void Painter::renderFillExtrusion(PaintParameters& parameters,
                 tile.id,
                 state,
                 -std::pow(2, tile.id.canonical.z) / util::tileSize / 8.0f,
-                light
+                style.evaluatedLight
             ),
             *bucket.vertexBuffer,
             *bucket.indexBuffer,
@@ -76,7 +74,7 @@ void Painter::renderFillExtrusion(PaintParameters& parameters,
                                       properties.get<FillExtrusionTranslateAnchor>(),
                                       state),
                 state,
-                light
+                style.evaluatedLight
             ),
             *bucket.vertexBuffer,
             *bucket.indexBuffer,
diff --git a/src/mbgl/style/light_impl.hpp b/src/mbgl/style/light_impl.hpp
new file mode 100644
index 0000000000..e818747578
--- /dev/null
+++ b/src/mbgl/style/light_impl.hpp
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <mbgl/style/light.hpp>
+#include <mbgl/style/transitioning_property.hpp>
+#include <mbgl/style/cascade_parameters.hpp>
+#include <mbgl/style/property_evaluator.hpp>
+#include <mbgl/style/property_evaluation_parameters.hpp>
+
+namespace mbgl {
+namespace style {
+
+template <class TypeList>
+class Transitioning;
+
+template <class... Ps>
+class Transitioning<TypeList<Ps...>> : public IndexedTuple<
+    TypeList<Ps...>,
+    TypeList<TransitioningProperty<typename Ps::ValueType>...>>
+{
+private:
+    using Properties = TypeList<Ps...>;
+    using Raw = IndexedTuple<Properties, Properties>;
+    using Super = IndexedTuple<
+        TypeList<Ps...>,
+        TypeList<TransitioningProperty<typename Ps::ValueType>...>>;
+
+public:
+    Transitioning() = default;
+    Transitioning(const Raw& raw, Transitioning&& prior, const CascadeParameters& params)
+        : Super {
+            TransitioningProperty<typename Ps::ValueType>(
+                raw.template get<Ps>().value,
+                std::move(prior.template get<Ps>()),
+                raw.template get<Ps>().transition.reverseMerge(params.transition),
+                params.now)...
+        } {}
+};
+
+template <class TypeList>
+class Evaluated;
+
+template <class... Ps>
+class Evaluated<TypeList<Ps...>> : public IndexedTuple<
+    TypeList<Ps...>,
+    TypeList<typename Ps::Type...>>
+{
+private:
+    using Properties = TypeList<Ps...>;
+    using Transitioning = Transitioning<Properties>;
+    using Super = IndexedTuple<
+        TypeList<Ps...>,
+        TypeList<typename Ps::Type...>>;
+
+public:
+    Evaluated() = default;
+    Evaluated(Transitioning& transitioning, const PropertyEvaluationParameters& params)
+        : Super {
+            transitioning.template get<Ps>()
+                .evaluate(PropertyEvaluator<typename Ps::Type>(params, Ps::defaultValue()), params.now)...
+        } {}
+};
+
+using TransitioningLight = Transitioning<LightProperties>;
+using EvaluatedLight     = Evaluated<LightProperties>;
+
+} // namespace style
+} // namespace mbgl
diff --git a/src/mbgl/style/style.cpp b/src/mbgl/style/style.cpp
index aec9713c27..9286cc6885 100644
--- a/src/mbgl/style/style.cpp
+++ b/src/mbgl/style/style.cpp
@@ -309,7 +309,7 @@ void Style::cascade(const TimePoint& timePoint, MapMode mode) {
         layer->baseImpl->cascade(parameters);
     }
 
-    light.cascade(parameters);
+    transitioningLight = TransitioningLight(light, std::move(transitioningLight), parameters);
 }
 
 void Style::recalculate(float z, const TimePoint& timePoint, MapMode mode) {
@@ -347,7 +347,7 @@ void Style::recalculate(float z, const TimePoint& timePoint, MapMode mode) {
         }
     }
 
-    light.evaluate(parameters);
+    evaluatedLight = EvaluatedLight(transitioningLight, parameters);
 
     // Remove the existing tiles if we didn't end up re-enabling the source.
     for (const auto& source : sources) {
diff --git a/src/mbgl/style/style.hpp b/src/mbgl/style/style.hpp
index 8e784e15d2..5a9ce8dd9b 100644
--- a/src/mbgl/style/style.hpp
+++ b/src/mbgl/style/style.hpp
@@ -5,7 +5,7 @@
 #include <mbgl/style/source_observer.hpp>
 #include <mbgl/style/layer_observer.hpp>
 #include <mbgl/style/update_batch.hpp>
-#include <mbgl/style/light.hpp>
+#include <mbgl/style/light_impl.hpp>
 #include <mbgl/text/glyph_atlas_observer.hpp>
 #include <mbgl/sprite/sprite_atlas_observer.hpp>
 #include <mbgl/map/mode.hpp>
@@ -115,6 +115,8 @@ public:
     std::unique_ptr<LineAtlas> lineAtlas;
 
     Light light;
+    TransitioningLight transitioningLight;
+    EvaluatedLight evaluatedLight;
 
 private:
     std::vector<std::unique_ptr<Source>> sources;
diff --git a/include/mbgl/style/transitioning_property.hpp b/src/mbgl/style/transitioning_property.hpp
index 5456322b33..5456322b33 100644
--- a/include/mbgl/style/transitioning_property.hpp
+++ b/src/mbgl/style/transitioning_property.hpp