Merge branch 'main' into opaque-cutoff-compared-to-right-layer-index

Author: alexcristici

.clang-tidy

@@ -109,7 +109,11 @@ Checks: [
     -readability-suspicious-call-argument,
     -readability-uppercase-literal-suffix,
     -readability-use-anyofallof,
-    -modernize-loop-convert # since C++20 this complains about reverse loops with iterators, but good ranges support only landed in clang 15
+    -modernize-loop-convert, # since C++20 this complains about reverse loops with iterators, but good ranges support only landed in clang 15
+    -performance-enum-size,
+    -misc-include-cleaner,
+    -readability-redundant-inline-specifier,
+    -readability-avoid-nested-conditional-operator
 ]
 WarningsAsErrors: '*'
 HeaderFilterRegex: '.*'

.github/workflows/android-ci.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Get all Android files that have changed
         if: github.event_name != 'workflow_dispatch'
         id: changed-files
-        uses: tj-actions/changed-files@v44
+        uses: tj-actions/changed-files@v45
         with:
           files_yaml_from_source_file: .github/changed-files.yml
 

.github/workflows/gh-pages-android-api.yml

@@ -26,7 +26,7 @@ jobs:
         run: ./gradlew dokkaHtml
 
       - name: Deploy 🚀
-        uses: JamesIves/[email protected].3
+        uses: JamesIves/[email protected].8
         with:
           branch: gh-pages
           folder: platform/android/MapLibreAndroid/build/dokka/html

.github/workflows/gh-pages-cpp-api.yml

@@ -20,7 +20,7 @@ jobs:
         run: doxygen
 
       - name: Deploy 🚀
-        uses: JamesIves/[email protected].3
+        uses: JamesIves/[email protected].8
         with:
           branch: gh-pages
           folder: docs/doxygen/html

.github/workflows/gh-pages-mdbook.yml

@@ -39,7 +39,7 @@ jobs:
           name: book
           path: artifacts/book
       - name: Deploy
-        uses: JamesIves/[email protected].3
+        uses: JamesIves/[email protected].8
         with:
           branch: gh-pages
           folder: artifacts/book

.github/workflows/ios-ci.yml

@@ -43,7 +43,7 @@ jobs:
       - name: Get all iOS files that have changed
         if: github.event_name != 'workflow_dispatch'
         id: changed-files-yaml
-        uses: tj-actions/changed-files@v44
+        uses: tj-actions/changed-files@v45
         with:
           files_yaml_from_source_file: .github/changed-files.yml
 
@@ -201,7 +201,7 @@ jobs:
 
       - name: Deploy DocC documentation (main) 🚀
         if: github.ref == 'refs/heads/main'
-        uses: JamesIves/[email protected].4
+        uses: JamesIves/[email protected].8
         continue-on-error: true
         with:
           branch: gh-pages
@@ -224,7 +224,7 @@ jobs:
 
       - name: VERSION file changed
         id: version-file-ios-changed
-        uses: tj-actions/changed-files@v44
+        uses: tj-actions/changed-files@v45
         with:
           files: platform/ios/VERSION
 

.github/workflows/linux-ci.yml

@@ -37,7 +37,7 @@ jobs:
       - name: Get all Linux files that have changed
         if: github.event_name != 'workflow_dispatch'
         id: changed-files
-        uses: tj-actions/changed-files@v44
+        uses: tj-actions/changed-files@v45
         with:
           files_yaml_from_source_file: .github/changed-files.yml
 

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/gfx/shader_group.hpp

@@ -130,8 +130,10 @@ class ShaderGroup {
     /// @tparam T Derived type, inheriting `gfx::Shader`
     /// @param to Location to store the shader
     /// @return True if 'to' has a valid program object, false otherwise.
-    template <typename T, typename std::enable_if_t<is_shader_v<T>, bool>* = nullptr>
-    bool populate(std::shared_ptr<T>& to) noexcept {
+    template <typename T>
+    bool populate(std::shared_ptr<T>& to) noexcept
+        requires(is_shader_v<T>)
+    {
         if (to) {
             return true;
         }

include/mbgl/gfx/vertex_attribute.hpp

@@ -191,12 +191,15 @@ class VertexAttribute {
     }
 
     template <std::size_t I = 0, typename... Tp>
-    inline typename std::enable_if_t<I == sizeof...(Tp), void> set(std::size_t, std::tuple<Tp...>, std::size_t) {}
+    inline void set(std::size_t, std::tuple<Tp...>, std::size_t)
+        requires(I == sizeof...(Tp))
+    {}
 
     /// Set item value
     template <std::size_t I = 0, typename... Tp>
-        inline typename std::enable_if_t <
-        I<sizeof...(Tp), void> set(std::size_t i, std::tuple<Tp...> tuple, std::size_t tupleIndex) {
+    inline void set(std::size_t i, std::tuple<Tp...> tuple, std::size_t tupleIndex)
+        requires(I < sizeof...(Tp))
+    {
         if (tupleIndex == 0) {
             set(i, std::get<I>(tuple).a1);
         } else {

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: