[core] Enable circle-sort-key property

CHANGELOG.md

@@ -19,6 +19,12 @@
   - `getPlacedSymbolsData()`
     if collecting of the placed symbols data is enabled, returns the reference to the `PlacedSymbolData` vector holding the collected data.
 
+- [core] Enable circle-sort-key property [#15875](https://github.com/mapbox/mapbox-gl-native/pull/15875/)
+
+  Adds support for `circle-sort-key` property, consistent with `symbol-sort-key`.
+
+  Sorts drawing order by sort key both within-tile and cross-tile.
+
 ### 🐞 Bug fixes
 
 - [core][tile mode] Reduce cut-off labels (part 2) ([#16369](https://github.com/mapbox/mapbox-gl-native/pull/16369))

CMakeLists.txt

@@ -341,6 +341,7 @@ add_library(
     ${PROJECT_SOURCE_DIR}/src/mbgl/layermanager/line_layer_factory.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/layermanager/raster_layer_factory.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/layermanager/symbol_layer_factory.cpp
+    ${PROJECT_SOURCE_DIR}/src/mbgl/layout/circle_layout.hpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/layout/clip_lines.cpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/layout/clip_lines.hpp
     ${PROJECT_SOURCE_DIR}/src/mbgl/layout/layout.hpp

include/mbgl/layermanager/circle_layer_factory.hpp

@@ -8,7 +8,9 @@ class CircleLayerFactory : public LayerFactory {
 protected:
     const style::LayerTypeInfo* getTypeInfo() const noexcept final;
     std::unique_ptr<style::Layer> createLayer(const std::string& id, const style::conversion::Convertible& value) noexcept final;
-    std::unique_ptr<Bucket> createBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&) noexcept final;
+    std::unique_ptr<Layout> createLayout(const LayoutParameters& parameters,
+                                         std::unique_ptr<GeometryTileLayer> tileLayer,
+                                         const std::vector<Immutable<style::LayerProperties>>& group) noexcept final;
     std::unique_ptr<RenderLayer> createRenderLayer(Immutable<style::Layer::Impl>) noexcept final;
 };
 

include/mbgl/style/layers/circle_layer.hpp

@@ -19,6 +19,12 @@ class CircleLayer : public Layer {
     CircleLayer(const std::string& layerID, const std::string& sourceID);
     ~CircleLayer() final;
 
+    // Layout properties
+
+    static PropertyValue<float> getDefaultCircleSortKey();
+    const PropertyValue<float>& getCircleSortKey() const;
+    void setCircleSortKey(const PropertyValue<float>&);
+
     // Paint properties
 
     static PropertyValue<float> getDefaultCircleBlur();

metrics/android-render-test-runner/render-tests/circle-sort-key/literal/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            0,
+            0
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            4,
+            9,
+            13,
+            1,
+            [
+                65552,
+                65552
+            ],
+            [
+                94,
+                94
+            ],
+            [
+                448,
+                448
+            ]
+        ]
+    ]
+}

metrics/ignores/platform-all.json

@@ -55,7 +55,6 @@
     "render-tests/background-color/transition": "https://github.com/mapbox/mapbox-gl-native/issues/10619",
     "render-tests/canvas/default": "skip - js specific",
     "render-tests/canvas/update": "skip - js specific",
-    "render-tests/circle-sort-key/literal": "https://github.com/mapbox/mapbox-gl-native/issues/15008",
     "render-tests/collator/default": "Some test platforms don't resolve 'en' locale",
     "render-tests/collator/resolved-locale": "Some test platforms don't resolve 'en' locale",
     "render-tests/custom-layer-js/depth": "skip - js specific",

metrics/ios-render-test-runner/render-tests/circle-sort-key/literal/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            0,
+            0
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            4,
+            9,
+            13,
+            1,
+            [
+                65552,
+                65552
+            ],
+            [
+                94,
+                94
+            ],
+            [
+                448,
+                448
+            ]
+        ]
+    ]
+}

metrics/linux-clang8-release/render-tests/circle-sort-key/literal/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            0,
+            0
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            4,
+            9,
+            13,
+            1,
+            [
+                65552,
+                65552
+            ],
+            [
+                94,
+                94
+            ],
+            [
+                448,
+                448
+            ]
+        ]
+    ]
+}

metrics/linux-gcc8-release/render-tests/circle-sort-key/literal/metrics.json

@@ -0,0 +1,35 @@
+{
+    "network": [
+        [
+            "probeNetwork - default - end",
+            0,
+            0
+        ],
+        [
+            "probeNetwork - default - start",
+            0,
+            0
+        ]
+    ],
+    "gfx": [
+        [
+            "probeGFX - default - end",
+            4,
+            9,
+            13,
+            1,
+            [
+                65552,
+                65552
+            ],
+            [
+                94,
+                94
+            ],
+            [
+                448,
+                448
+            ]
+        ]
+    ]
+}

scripts/generate-style-code.js

@@ -6,9 +6,6 @@ const ejs = require('ejs');
 const spec = require('./style-spec');
 const colorParser = require('csscolorparser');
 
-// FIXME: https://github.com/mapbox/mapbox-gl-native/issues/15008
-delete spec.layout_circle["circle-sort-key"]
-
 require('./style-code');
 
 function parseCSSColor(str) {

src/mbgl/layermanager/circle_layer_factory.cpp

@@ -1,5 +1,6 @@
 #include <mbgl/layermanager/circle_layer_factory.hpp>
 
+#include <mbgl/layout/circle_layout.hpp>
 #include <mbgl/renderer/buckets/circle_bucket.hpp>
 #include <mbgl/renderer/layers/render_circle_layer.hpp>
 #include <mbgl/style/layers/circle_layer.hpp>
@@ -20,8 +21,11 @@ std::unique_ptr<style::Layer> CircleLayerFactory::createLayer(const std::string&
     return std::unique_ptr<style::Layer>(new style::CircleLayer(id, *source));
 }
 
-std::unique_ptr<Bucket> CircleLayerFactory::createBucket(const BucketParameters& parameters, const std::vector<Immutable<style::LayerProperties>>& layers) noexcept {
-    return std::make_unique<CircleBucket>(parameters, layers);
+std::unique_ptr<Layout> CircleLayerFactory::createLayout(
+    const LayoutParameters& parameters,
+    std::unique_ptr<GeometryTileLayer> layer,
+    const std::vector<Immutable<style::LayerProperties>>& group) noexcept {
+    return std::make_unique<CircleLayout>(parameters.bucketParameters, group, std::move(layer));
 }
 
 std::unique_ptr<RenderLayer> CircleLayerFactory::createRenderLayer(Immutable<style::Layer::Impl> impl) noexcept {

src/mbgl/layout/circle_layout.hpp

@@ -0,0 +1,161 @@
+#pragma once
+#include <mbgl/geometry/feature_index.hpp>
+#include <mbgl/layout/layout.hpp>
+#include <mbgl/renderer/bucket_parameters.hpp>
+#include <mbgl/renderer/buckets/circle_bucket.hpp>
+#include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/style/layers/circle_layer_impl.hpp>
+
+namespace mbgl {
+
+class CircleLayout final : public Layout {
+public:
+    CircleLayout(const BucketParameters& parameters,
+                 const std::vector<Immutable<style::LayerProperties>>& group,
+                 std::unique_ptr<GeometryTileLayer> sourceLayer_)
+        : sourceLayer(std::move(sourceLayer_)), zoom(parameters.tileID.overscaledZ), mode(parameters.mode) {
+        assert(!group.empty());
+        auto leaderLayerProperties = staticImmutableCast<style::CircleLayerProperties>(group.front());
+        const auto& unevaluatedLayout = leaderLayerProperties->layerImpl().layout;
+        const bool sortFeaturesByKey = !unevaluatedLayout.get<style::CircleSortKey>().isUndefined();
+        const auto& layout = unevaluatedLayout.evaluate(PropertyEvaluationParameters(zoom));
+        sourceLayerID = leaderLayerProperties->layerImpl().sourceLayer;
+        bucketLeaderID = leaderLayerProperties->layerImpl().id;
+
+        for (const auto& layerProperties : group) {
+            const std::string& layerId = layerProperties->baseImpl->id;
+            layerPropertiesMap.emplace(layerId, layerProperties);
+        }
+
+        const size_t featureCount = sourceLayer->featureCount();
+        for (size_t i = 0; i < featureCount; ++i) {
+            auto feature = sourceLayer->getFeature(i);
+            if (!leaderLayerProperties->layerImpl().filter(style::expression::EvaluationContext(zoom, feature.get())
+                                                               .withCanonicalTileID(&parameters.tileID.canonical))) {
+                continue;
+            }
+
+            if (!sortFeaturesByKey) {
+                features.push_back({i, std::move(feature), style::CircleSortKey::defaultValue()});
+                continue;
+            }
+
+            const auto& sortKeyProperty = layout.template get<style::CircleSortKey>();
+            float sortKey = sortKeyProperty.evaluate(*feature, zoom, style::CircleSortKey::defaultValue());
+            CircleFeature circleFeature{i, std::move(feature), sortKey};
+            const auto sortPosition = std::lower_bound(features.cbegin(), features.cend(), circleFeature);
+            features.insert(sortPosition, std::move(circleFeature));
+        }
+    }
+
+    bool hasDependencies() const override { return false; }
+
+    void createBucket(const ImagePositions&,
+                      std::unique_ptr<FeatureIndex>& featureIndex,
+                      std::unordered_map<std::string, LayerRenderData>& renderData,
+                      const bool,
+                      const bool,
+                      const CanonicalTileID& canonical) override {
+        auto bucket = std::make_shared<CircleBucket>(layerPropertiesMap, mode, zoom);
+
+        for (auto& circleFeature : features) {
+            const auto i = circleFeature.i;
+            const std::unique_ptr<GeometryTileFeature>& feature = circleFeature.feature;
+            const GeometryCollection& geometries = feature->getGeometries();
+
+            addCircle(*bucket, *feature, geometries, i, circleFeature.sortKey, canonical);
+
+            bucket->addFeature(*feature, geometries, {}, PatternLayerMap(), i, canonical);
+            featureIndex->insert(geometries, i, sourceLayerID, bucketLeaderID);
+        }
+
+        if (!bucket->hasData()) return;
+
+        for (const auto& pair : layerPropertiesMap) {
+            renderData.emplace(pair.first, LayerRenderData{bucket, pair.second});
+        }
+    }
+
+private:
+    struct CircleFeature {
+        friend bool operator<(const CircleFeature& lhs, const CircleFeature& rhs) { return lhs.sortKey < rhs.sortKey; }
+
+        size_t i;
+        std::unique_ptr<GeometryTileFeature> feature;
+        float sortKey;
+    };
+
+    void addCircle(CircleBucket& bucket,
+                   const GeometryTileFeature& feature,
+                   const GeometryCollection& geometry,
+                   std::size_t featureIndex,
+                   float sortKey,
+                   const CanonicalTileID& canonical) {
+        constexpr const uint16_t vertexLength = 4;
+
+        auto& segments = bucket.segments;
+        auto& vertices = bucket.vertices;
+        auto& triangles = bucket.triangles;
+
+        for (auto& circle : geometry) {
+            for (auto& point : circle) {
+                auto x = point.x;
+                auto y = point.y;
+
+                // Do not include points that are outside the tile boundaries.
+                // Include all points in Still mode. You need to include points from
+                // neighbouring tiles so that they are not clipped at tile boundaries.
+                if ((mode == MapMode::Continuous) && (x < 0 || x >= util::EXTENT || y < 0 || y >= util::EXTENT))
+                    continue;
+
+                if (segments.empty() ||
+                    segments.back().vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
+                    // Move to a new segments because the old one can't hold the geometry.
+                    segments.emplace_back(vertices.elements(), triangles.elements(), 0ul, 0ul, sortKey);
+                }
+
+                // this geometry will be of the Point type, and we'll derive
+                // two triangles from it.
+                //
+                // ┌─────────┐
+                // │ 4     3 │
+                // │         │
+                // │ 1     2 │
+                // └─────────┘
+                //
+                vertices.emplace_back(CircleProgram::vertex(point, -1, -1)); // 1
+                vertices.emplace_back(CircleProgram::vertex(point, 1, -1));  // 2
+                vertices.emplace_back(CircleProgram::vertex(point, 1, 1));   // 3
+                vertices.emplace_back(CircleProgram::vertex(point, -1, 1));  // 4
+
+                auto& segment = segments.back();
+                assert(segment.vertexLength <= std::numeric_limits<uint16_t>::max());
+                uint16_t index = segment.vertexLength;
+
+                // 1, 2, 3
+                // 1, 4, 3
+                triangles.emplace_back(index, index + 1, index + 2);
+                triangles.emplace_back(index, index + 3, index + 2);
+
+                segment.vertexLength += vertexLength;
+                segment.indexLength += 6;
+            }
+        }
+
+        for (auto& pair : bucket.paintPropertyBinders) {
+            pair.second.populateVertexVectors(feature, vertices.elements(), featureIndex, {}, {}, canonical);
+        }
+    }
+
+    std::map<std::string, Immutable<style::LayerProperties>> layerPropertiesMap;
+    std::string bucketLeaderID;
+
+    const std::unique_ptr<GeometryTileLayer> sourceLayer;
+    std::list<CircleFeature> features;
+
+    const float zoom;
+    const MapMode mode;
+    std::string sourceLayerID;
+};
+
+} // namespace mbgl