From f6e79d70735361438655f279c8699a786d25458c Mon Sep 17 00:00:00 2001
From: Lauren Budorick <lauren@mapbox.com>
Date: Thu, 27 Apr 2017 15:56:55 -0700
Subject: [core] Render fill-extrusion layers (#8431)

---
 include/mbgl/style/conversion/constant.hpp |  49 ++++--------
 include/mbgl/style/conversion/layer.hpp    |   3 +
 include/mbgl/style/conversion/light.hpp    | 122 +++++++++++++++++++++++++++++
 include/mbgl/style/conversion/position.hpp |  29 +++++++
 4 files changed, 169 insertions(+), 34 deletions(-)
 create mode 100644 include/mbgl/style/conversion/light.hpp
 create mode 100644 include/mbgl/style/conversion/position.hpp

(limited to 'include/mbgl/style/conversion')

diff --git a/include/mbgl/style/conversion/constant.hpp b/include/mbgl/style/conversion/constant.hpp
index 1e1fdc2ee8..07c0a35fae 100644
--- a/include/mbgl/style/conversion/constant.hpp
+++ b/include/mbgl/style/conversion/constant.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/util/optional.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/util/enum.hpp>
+#include <mbgl/util/string.hpp>
 
 #include <array>
 #include <string>
@@ -92,45 +93,25 @@ struct Converter<Color> {
     }
 };
 
-template <>
-struct Converter<std::array<float, 2>> {
+template <size_t N>
+struct Converter<std::array<float, N>> {
     template <class V>
-    optional<std::array<float, 2>> operator()(const V& value, Error& error) const {
-        if (!isArray(value) || arrayLength(value) != 2) {
-            error = { "value must be an array of two numbers" };
+    optional<std::array<float, N>> operator()(const V& value, Error& error) const {
+        if (!isArray(value) || arrayLength(value) != N) {
+            error = { "value must be an array of " + util::toString(N) + " numbers" };
             return {};
         }
 
-        optional<float> first = toNumber(arrayMember(value, 0));
-        optional<float> second = toNumber(arrayMember(value, 1));
-        if (!first || !second) {
-            error = { "value must be an array of two numbers" };
-            return {};
-        }
-
-        return std::array<float, 2> {{ *first, *second }};
-    }
-};
-
-template <>
-struct Converter<std::array<float, 4>> {
-    template <class V>
-    optional<std::array<float, 4>> operator()(const V& value, Error& error) const {
-        if (!isArray(value) || arrayLength(value) != 4) {
-            error = { "value must be an array of four numbers" };
-            return {};
-        }
-
-        optional<float> first = toNumber(arrayMember(value, 0));
-        optional<float> second = toNumber(arrayMember(value, 1));
-        optional<float> third = toNumber(arrayMember(value, 2));
-        optional<float> fourth = toNumber(arrayMember(value, 3));
-        if (!first || !second) {
-            error = { "value must be an array of four numbers" };
-            return {};
+        std::array<float, N> result;
+        for (size_t i = 0; i < N; i++) {
+            optional<float> n = toNumber(arrayMember(value, i));
+            if (!n) {
+                error = { "value must be an array of " + util::toString(N) + " numbers" };
+                return {};
+            }
+            result[i] = *n;
         }
-
-        return std::array<float, 4> {{ *first, *second, *third, *fourth }};
+        return result;
     }
 };
 
diff --git a/include/mbgl/style/conversion/layer.hpp b/include/mbgl/style/conversion/layer.hpp
index efb1df8fef..3a64c36bf5 100644
--- a/include/mbgl/style/conversion/layer.hpp
+++ b/include/mbgl/style/conversion/layer.hpp
@@ -4,6 +4,7 @@
 #include <mbgl/style/layers/background_layer.hpp>
 #include <mbgl/style/layers/circle_layer.hpp>
 #include <mbgl/style/layers/fill_layer.hpp>
+#include <mbgl/style/layers/fill_extrusion_layer.hpp>
 #include <mbgl/style/layers/line_layer.hpp>
 #include <mbgl/style/layers/raster_layer.hpp>
 #include <mbgl/style/layers/symbol_layer.hpp>
@@ -92,6 +93,8 @@ public:
 
         if (*type == "fill") {
             converted = convertVectorLayer<FillLayer>(*id, value, error);
+        } else if (*type == "fill-extrusion") {
+            converted = convertVectorLayer<FillExtrusionLayer>(*id, value, error);
         } else if (*type == "line") {
             converted = convertVectorLayer<LineLayer>(*id, value, error);
         } else if (*type == "circle") {
diff --git a/include/mbgl/style/conversion/light.hpp b/include/mbgl/style/conversion/light.hpp
new file mode 100644
index 0000000000..631ed04ccb
--- /dev/null
+++ b/include/mbgl/style/conversion/light.hpp
@@ -0,0 +1,122 @@
+#pragma once
+
+#include <mbgl/style/light.hpp>
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/conversion/position.hpp>
+#include <mbgl/style/conversion/property_value.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <>
+struct Converter<Light> {
+public:
+    template <class V>
+    optional<Light> operator()(const V& value, Error& error) const {
+        if (!isObject(value)) {
+            error = { "light must be an object" };
+            return {};
+        }
+
+        Light light;
+
+        const auto anchor = objectMember(value, "anchor");
+        if (anchor) {
+            optional<PropertyValue<LightAnchorType>> convertedAnchor =
+                convert<PropertyValue<LightAnchorType>>(*anchor, error);
+
+            if (convertedAnchor) {
+                light.get<LightAnchor>().value = *convertedAnchor;
+            } else {
+                return {};
+            }
+        }
+
+        const auto anchorTransition = objectMember(value, "anchor-transition");
+        if (anchorTransition) {
+            optional<TransitionOptions> transition =
+                convert<TransitionOptions>(*anchorTransition, error);
+            if (transition) {
+                light.get<LightAnchor>().transition = *transition;
+            } else {
+                return {};
+            }
+        }
+
+        const auto color = objectMember(value, "color");
+        if (color) {
+            optional<PropertyValue<Color>> convertedColor =
+                convert<PropertyValue<Color>>(*color, error);
+
+            if (convertedColor) {
+                light.get<LightColor>().value = *convertedColor;
+            } else {
+                return {};
+            }
+        }
+
+        const auto colorTransition = objectMember(value, "color-transition");
+        if (colorTransition) {
+            optional<TransitionOptions> transition =
+                convert<TransitionOptions>(*colorTransition, error);
+            if (transition) {
+                light.get<LightColor>().transition = *transition;
+            } else {
+                return {};
+            }
+        }
+
+        const auto position = objectMember(value, "position");
+        if (position) {
+            optional<PropertyValue<Position>> convertedPosition =
+                convert<PropertyValue<Position>>(*position, error);
+
+            if (convertedPosition) {
+                light.get<LightPosition>().value = *convertedPosition;
+            } else {
+                return {};
+            }
+        }
+
+        const auto positionTransition = objectMember(value, "position-transition");
+        if (positionTransition) {
+            optional<TransitionOptions> transition =
+                convert<TransitionOptions>(*positionTransition, error);
+            if (transition) {
+                light.get<LightPosition>().transition = *transition;
+            } else {
+                return {};
+            }
+        }
+
+        const auto intensity = objectMember(value, "intensity");
+        if (intensity) {
+            optional<PropertyValue<float>> convertedIntensity =
+                convert<PropertyValue<float>>(*intensity, error);
+
+            if (convertedIntensity) {
+                light.get<LightIntensity>().value = *convertedIntensity;
+            } else {
+                return {};
+            }
+        }
+
+        const auto intensityTransition = objectMember(value, "intensity-transition");
+        if (intensityTransition) {
+            optional<TransitionOptions> transition =
+                convert<TransitionOptions>(*intensityTransition, error);
+            if (transition) {
+                light.get<LightIntensity>().transition = *transition;
+            } else {
+                return {};
+            }
+        }
+        return { light };
+    };
+};
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
diff --git a/include/mbgl/style/conversion/position.hpp b/include/mbgl/style/conversion/position.hpp
new file mode 100644
index 0000000000..7036b03822
--- /dev/null
+++ b/include/mbgl/style/conversion/position.hpp
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <mbgl/style/conversion.hpp>
+#include <mbgl/style/position.hpp>
+#include <mbgl/util/optional.hpp>
+
+#include <array>
+
+namespace mbgl {
+namespace style {
+namespace conversion {
+
+template <>
+struct Converter<Position> {
+    template <class V>
+    optional<Position> operator()(const V& value, Error& error) const {
+        optional<std::array<float, 3>> spherical = convert<std::array<float, 3>>(value, error);
+
+        if (!spherical) {
+            return {};
+        }
+
+        return Position(*spherical);
+    }
+};
+
+} // namespace conversion
+} // namespace style
+} // namespace mbgl
-- 
cgit v1.2.1