Add support for text-variable-anchor-offset property

CMakeLists.txt

@@ -379,6 +379,7 @@ list(APPEND INCLUDE_FILES
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/transition_options.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/types.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/style/undefined.hpp
+    ${PROJECT_SOURCE_DIR}/include/mbgl/style/variable_anchor_offset_collection.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/text/glyph.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/text/glyph_range.hpp
     ${PROJECT_SOURCE_DIR}/include/mbgl/tile/tile_id.hpp
@@ -864,6 +865,7 @@ list(APPEND SRC_FILES
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/style_impl.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/style_impl.hpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/types.cpp
+    ${PROJECT_SOURCE_DIR}/src/mbgl/style/variable_anchor_offset_collection.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/layers/custom_layer.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/style/layers/custom_layer_render_parameters.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/layermanager/custom_layer_factory.cpp

bazel/core.bzl

@@ -511,6 +511,7 @@ MLN_CORE_SOURCE = [
     "src/mbgl/style/style_impl.cpp",
     "src/mbgl/style/style_impl.hpp",
     "src/mbgl/style/types.cpp",
+    "src/mbgl/style/variable_anchor_offset_collection.cpp",
     "src/mbgl/text/bidi.hpp",
     "src/mbgl/text/check_max_angle.cpp",
     "src/mbgl/text/check_max_angle.hpp",
@@ -802,6 +803,7 @@ MLN_CORE_HEADERS = [
     "include/mbgl/style/transition_options.hpp",
     "include/mbgl/style/types.hpp",
     "include/mbgl/style/undefined.hpp",
+    "include/mbgl/style/variable_anchor_offset_collection.hpp",
     "include/mbgl/text/glyph.hpp",
     "include/mbgl/text/glyph_range.hpp",
     "include/mbgl/tile/tile_id.hpp",

include/mbgl/style/conversion/constant.hpp

@@ -2,6 +2,7 @@
 
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/types.hpp>
+#include <mbgl/style/variable_anchor_offset_collection.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/util/enum.hpp>
 #include <mbgl/util/padding.hpp>
@@ -50,6 +51,11 @@ struct Converter<Padding> {
     std::optional<Padding> operator()(const Convertible& value, Error& error) const;
 };
 
+template <>
+struct Converter<VariableAnchorOffsetCollection> {
+    std::optional<VariableAnchorOffsetCollection> operator()(const Convertible& value, Error& error) const;
+};
+
 template <size_t N>
 struct Converter<std::array<float, N>> {
     std::optional<std::array<float, N>> operator()(const Convertible& value, Error& error) const;

include/mbgl/style/conversion_impl.hpp

@@ -320,6 +320,13 @@ struct ValueFactory<Padding> {
     static Value make(const Padding& padding) { return padding.serialize(); }
 };
 
+template <>
+struct ValueFactory<VariableAnchorOffsetCollection> {
+    static Value make(const VariableAnchorOffsetCollection& variableAnchorOffset) {
+        return variableAnchorOffset.serialize();
+    }
+};
+
 template <typename T>
 struct ValueFactory<T, typename std::enable_if_t<(!std::is_enum_v<T> && !is_linear_container<T>::value)>> {
     static Value make(const T& arg) { return {arg}; }
@@ -370,6 +377,9 @@ StyleProperty makeStyleProperty(const PropertyValue<T>& value) {
         [](const Undefined&) -> StyleProperty { return {}; },
         [](const Color& c) -> StyleProperty { return {makeValue(c), StyleProperty::Kind::Expression}; },
         [](const Padding& p) -> StyleProperty { return {makeValue(p), StyleProperty::Kind::Expression}; },
+        [](const VariableAnchorOffsetCollection& v) -> StyleProperty {
+            return {makeValue(v), StyleProperty::Kind::Expression};
+        },
         [](const PropertyExpression<T>& fn) -> StyleProperty {
             return {fn.getExpression().serialize(), StyleProperty::Kind::Expression};
         },

include/mbgl/style/expression/dsl.hpp

@@ -43,6 +43,8 @@ std::unique_ptr<Expression> boolean(std::unique_ptr<Expression>, std::unique_ptr
 
 std::unique_ptr<Expression> toColor(std::unique_ptr<Expression>, std::unique_ptr<Expression> def = nullptr);
 std::unique_ptr<Expression> toPadding(std::unique_ptr<Expression> value, std::unique_ptr<Expression> def = nullptr);
+std::unique_ptr<Expression> toVariableAnchorOffset(std::unique_ptr<Expression>,
+                                                   std::unique_ptr<Expression> def = nullptr);
 std::unique_ptr<Expression> toString(std::unique_ptr<Expression>, std::unique_ptr<Expression> def = nullptr);
 std::unique_ptr<Expression> toFormatted(std::unique_ptr<Expression>, std::unique_ptr<Expression> def = nullptr);
 std::unique_ptr<Expression> toImage(std::unique_ptr<Expression>, std::unique_ptr<Expression> def = nullptr);

include/mbgl/style/expression/type.hpp

@@ -50,6 +50,12 @@ struct PaddingType {
     bool operator==(const PaddingType&) const { return true; }
 };
 
+struct VariableAnchorOffsetCollectionType {
+    constexpr VariableAnchorOffsetCollectionType() = default;
+    std::string getName() const { return "variableAnchorOffsetCollection"; }
+    bool operator==(const VariableAnchorOffsetCollectionType&) const { return true; }
+};
+
 struct ObjectType {
     constexpr ObjectType() = default;
     std::string getName() const { return "object"; }
@@ -92,6 +98,7 @@ constexpr StringType String;
 constexpr BooleanType Boolean;
 constexpr ColorType Color;
 constexpr PaddingType Padding;
+constexpr VariableAnchorOffsetCollectionType VariableAnchorOffsetCollection;
 constexpr ValueType Value;
 constexpr ObjectType Object;
 constexpr CollatorType Collator;
@@ -107,6 +114,7 @@ using Type = variant<NullType,
                      StringType,
                      ColorType,
                      PaddingType,
+                     VariableAnchorOffsetCollectionType,
                      ObjectType,
                      ValueType,
                      mapbox::util::recursive_wrapper<Array>,

include/mbgl/style/expression/value.hpp

@@ -7,6 +7,7 @@
 #include <mbgl/style/position.hpp>
 #include <mbgl/style/rotation.hpp>
 #include <mbgl/style/types.hpp>
+#include <mbgl/style/variable_anchor_offset_collection.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/util/enum.hpp>
 #include <mbgl/util/feature.hpp>
@@ -28,6 +29,7 @@ using ValueBase = variant<NullValue,
                           double,
                           std::string,
                           Color,
+                          VariableAnchorOffsetCollection,
                           Collator,
                           Formatted,
                           Image,

include/mbgl/style/layers/layer.hpp.ejs

@@ -20,6 +20,7 @@
 <% } -%>
 <% if (type === 'symbol') { -%>
 #include <mbgl/style/expression/formatted.hpp>
+#include <mbgl/style/variable_anchor_offset_collection.hpp>
 <% } -%>
 #include <mbgl/util/color.hpp>
 

include/mbgl/style/layers/symbol_layer.hpp

@@ -8,6 +8,7 @@
 #include <mbgl/style/filter.hpp>
 #include <mbgl/style/property_value.hpp>
 #include <mbgl/style/expression/formatted.hpp>
+#include <mbgl/style/variable_anchor_offset_collection.hpp>
 #include <mbgl/util/color.hpp>
 
 #include <vector>
@@ -184,6 +185,10 @@ class SymbolLayer final : public Layer {
     const PropertyValue<std::vector<TextVariableAnchorType>>& getTextVariableAnchor() const;
     void setTextVariableAnchor(const PropertyValue<std::vector<TextVariableAnchorType>>&);
 
+    static PropertyValue<VariableAnchorOffsetCollection> getDefaultTextVariableAnchorOffset();
+    const PropertyValue<VariableAnchorOffsetCollection>& getTextVariableAnchorOffset() const;
+    void setTextVariableAnchorOffset(const PropertyValue<VariableAnchorOffsetCollection>&);
+
     static PropertyValue<std::vector<TextWritingModeType>> getDefaultTextWritingMode();
     const PropertyValue<std::vector<TextWritingModeType>>& getTextWritingMode() const;
     void setTextWritingMode(const PropertyValue<std::vector<TextWritingModeType>>&);

include/mbgl/style/variable_anchor_offset_collection.hpp

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <mbgl/style/types.hpp>
+#include <mbgl/util/feature.hpp>
+#include <mbgl/util/geometry.hpp>
+
+#include <array>
+#include <string>
+#include <vector>
+
+namespace mbgl {
+
+struct AnchorOffsetPair {
+    style::SymbolAnchorType anchorType;
+    std::array<float, 2> offset;
+
+    AnchorOffsetPair(style::SymbolAnchorType anchorType_, std::array<float, 2> offset_)
+        : anchorType(anchorType_),
+          offset(offset_) {}
+
+    bool operator==(const AnchorOffsetPair& other) const = default;
+};
+
+class VariableAnchorOffsetCollection {
+private:
+    using CollectionType = std::vector<AnchorOffsetPair>;
+    CollectionType anchorOffsets;
+
+public:
+    VariableAnchorOffsetCollection() = default;
+
+    VariableAnchorOffsetCollection(const VariableAnchorOffsetCollection& other) = default;
+
+    VariableAnchorOffsetCollection(VariableAnchorOffsetCollection&& other) noexcept = default;
+
+    VariableAnchorOffsetCollection(std::vector<AnchorOffsetPair>&& values) { anchorOffsets = std::move(values); }
+
+    std::array<float, 2> getOffsetByAnchor(const style::SymbolAnchorType& anchorType) const;
+
+    std::string toString() const;
+
+    mbgl::Value serialize() const;
+
+    bool empty() const { return anchorOffsets.size() == 0; }
+
+    CollectionType::size_type size() const { return anchorOffsets.size(); }
+
+    CollectionType::const_iterator begin() const { return anchorOffsets.begin(); }
+
+    CollectionType::const_iterator end() const { return anchorOffsets.end(); }
+
+    const AnchorOffsetPair& operator[](size_t index) const { return anchorOffsets[index]; }
+
+    VariableAnchorOffsetCollection& operator=(const VariableAnchorOffsetCollection& other) = default;
+
+    VariableAnchorOffsetCollection& operator=(VariableAnchorOffsetCollection&& other) noexcept = default;
+
+    bool operator==(const VariableAnchorOffsetCollection& other) const = default;
+};
+
+} // namespace mbgl

include/mbgl/util/interpolate.hpp

@@ -3,8 +3,12 @@
 #include <mbgl/style/expression/value.hpp>
 #include <mbgl/style/position.hpp>
 #include <mbgl/style/rotation.hpp>
+#include <mbgl/style/types.hpp>
+#include <mbgl/style/variable_anchor_offset_collection.hpp>
+#include <mbgl/util/enum.hpp>
 #include <mbgl/util/color.hpp>
 #include <mbgl/util/range.hpp>
+#include <mbgl/util/string.hpp>
 
 #include <array>
 #include <vector>
@@ -143,6 +147,36 @@ struct Interpolator<Padding> {
     }
 };
 
+template <>
+struct Interpolator<VariableAnchorOffsetCollection> {
+public:
+    VariableAnchorOffsetCollection operator()(const VariableAnchorOffsetCollection& a,
+                                              const VariableAnchorOffsetCollection& b,
+                                              const float t) const {
+        if (a.size() != b.size()) {
+            throw std::runtime_error("Cannot interpolate values of different length. from: " + a.toString() +
+                                     ", to: " + b.toString());
+        }
+        std::vector<AnchorOffsetPair> offsetMap;
+        offsetMap.reserve(a.size());
+        for (size_t index = 0; index < a.size(); index++) {
+            const auto& aPair = a[index];
+            const auto& bPair = b[index];
+            if (aPair.anchorType != bPair.anchorType) {
+                throw std::runtime_error(
+                    "Cannot interpolate values containing mismatched anchors. index: " + util::toString(index) +
+                    "from: " + Enum<style::SymbolAnchorType>::toString(aPair.anchorType) +
+                    ", to: " + Enum<style::SymbolAnchorType>::toString(bPair.anchorType));
+            }
+            auto offset = std::array<float, 2>{interpolate(aPair.offset[0], bPair.offset[0], t),
+                                               interpolate(aPair.offset[1], bPair.offset[1], t)};
+            offsetMap.emplace_back(aPair.anchorType, offset);
+        }
+
+        return VariableAnchorOffsetCollection(std::move(offsetMap));
+    }
+};
+
 template <>
 struct Interpolator<style::Rotation> {
 public:

metrics/android-render-test-runner/render-tests/text-variable-anchor-offset/all-anchors-icon-text-fit/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            7,
+            1778473
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            8,
+            13,
+            37,
+            1,
+            [
+                90448,
+                90448
+            ],
+            [
+                100366,
+                100366
+            ],
+            [
+                1337984,
+                1337984
+            ]
+        ]
+    ]
+}

metrics/android-render-test-runner/render-tests/text-variable-anchor-offset/all-anchors-text-allow-overlap/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            4,
+            686859
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            1,
+            5,
+            9,
+            1,
+            [
+                52212,
+                52212
+            ],
+            [
+                5494,
+                5494
+            ],
+            [
+                73024,
+                73024
+            ]
+        ]
+    ]
+}

metrics/android-render-test-runner/render-tests/text-variable-anchor-offset/all-anchors/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            7,
+            1778473
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            4,
+            13,
+            21,
+            1,
+            [
+                143312,
+                143312
+            ],
+            [
+                97654,
+                97654
+            ],
+            [
+                1301824,
+                1301824
+            ]
+        ]
+    ]
+}