Triangulated fill outlines

platform/ios/src/MLNMapView+Metal.mm

@@ -82,7 +82,7 @@ void swap() override {
 
         // Un-comment for synchronous, which can help troubleshoot rendering problems,
         // particularly those related to resource tracking and multiple queued buffers.
-        //[commandBuffer waitUntilCompleted];
+        [commandBuffer waitUntilCompleted];
 
         commandBuffer = nil;
         commandBufferPtr.reset();

src/mbgl/renderer/buckets/fill_bucket.cpp

@@ -5,6 +5,10 @@
 #include <mbgl/renderer/layers/render_fill_layer.hpp>
 #include <mbgl/util/math.hpp>
 
+#if MLN_DRAWABLE_RENDERER
+#include <mbgl/gfx/polyline_generator.hpp>
+#endif
+
 #ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable : 4244)
@@ -53,6 +57,7 @@ FillBucket::~FillBucket() {
     sharedVertices->release();
 }
 
+#if MLN_LEGACY_RENDERER
 void FillBucket::addFeature(const GeometryTileFeature& feature,
                             const GeometryCollection& geometry,
                             const ImagePositions& patternPositions,
@@ -132,6 +137,84 @@ void FillBucket::addFeature(const GeometryTileFeature& feature,
         }
     }
 }
+#endif
+
+#if MLN_DRAWABLE_RENDERER
+void FillBucket::addFeature(const GeometryTileFeature& feature,
+                            const GeometryCollection& geometry,
+                            const ImagePositions& patternPositions,
+                            const PatternLayerMap& patternDependencies,
+                            std::size_t index,
+                            const CanonicalTileID& canonical) {
+    gfx::PolylineGenerator<LineLayoutVertex, Segment<LineAttributes>> generator(
+        lineVertices,
+        LineProgram::layoutVertex,
+        lineSegments,
+        [](std::size_t vertexOffset, std::size_t indexOffset) -> Segment<LineAttributes> {
+            return Segment<LineAttributes>(vertexOffset, indexOffset);
+        },
+        [](auto& seg) -> Segment<LineAttributes>& { return seg; },
+        lineIndexes);
+
+    gfx::PolylineGeneratorOptions options;
+    options.type = FeatureType::Polygon;
+
+    for (auto& polygon : classifyRings(geometry)) {
+        // Optimize polygons with many interior rings for earcut tesselation.
+        limitHoles(polygon, 500);
+
+        std::size_t totalVertices = 0;
+
+        for (const auto& ring : polygon) {
+            totalVertices += ring.size();
+            if (totalVertices > std::numeric_limits<uint16_t>::max()) throw GeometryTooLongException();
+        }
+
+        // generate outline
+        for (const auto& ring : polygon) {
+            generator.generate(ring, options);
+        }
+
+        // generate fill
+        std::size_t startVertices = vertices.elements();
+        for (const auto& ring : polygon) {
+            for (auto& p : ring) {
+                vertices.emplace_back(FillProgram::layoutVertex(p));
+            }
+        }
+        std::vector<uint32_t> indices = mapbox::earcut(polygon);
+        std::size_t nIndices = indices.size();
+        assert(nIndices % 3 == 0);
+
+        if (triangleSegments.empty() ||
+            triangleSegments.back().vertexLength + totalVertices > std::numeric_limits<uint16_t>::max()) {
+            triangleSegments.emplace_back(startVertices, triangles.elements());
+        }
+
+        auto& triangleSegment = triangleSegments.back();
+        assert(triangleSegment.vertexLength <= std::numeric_limits<uint16_t>::max());
+        const auto triangleIndex = static_cast<uint16_t>(triangleSegment.vertexLength);
+
+        for (std::size_t i = 0; i < nIndices; i += 3) {
+            triangles.emplace_back(
+                triangleIndex + indices[i], triangleIndex + indices[i + 1], triangleIndex + indices[i + 2]);
+        }
+
+        triangleSegment.vertexLength += totalVertices;
+        triangleSegment.indexLength += nIndices;
+    }
+
+    for (auto& pair : paintPropertyBinders) {
+        const auto it = patternDependencies.find(pair.first);
+        if (it != patternDependencies.end()) {
+            pair.second.populateVertexVectors(
+                feature, vertices.elements(), index, patternPositions, it->second, canonical);
+        } else {
+            pair.second.populateVertexVectors(feature, vertices.elements(), index, patternPositions, {}, canonical);
+        }
+    }
+}
+#endif
 
 void FillBucket::upload([[maybe_unused]] gfx::UploadPass& uploadPass) {
 #if MLN_LEGACY_RENDERER

src/mbgl/renderer/buckets/fill_bucket.hpp

@@ -8,6 +8,10 @@
 #include <mbgl/programs/fill_program.hpp>
 #include <mbgl/style/layers/fill_layer_properties.hpp>
 
+#if MLN_DRAWABLE_RENDERER
+#include <mbgl/programs/line_program.hpp>
+#endif
+
 #include <vector>
 
 namespace mbgl {
@@ -40,22 +44,35 @@ class FillBucket final : public Bucket {
 
     void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) override;
 
+#if MLN_DRAWABLE_RENDERER
+    using LineVertexVector = gfx::VertexVector<LineLayoutVertex>;
+    const std::shared_ptr<LineVertexVector> sharedLineVertices = std::make_shared<LineVertexVector>();
+    LineVertexVector& lineVertices = *sharedLineVertices;
+
+    using LineIndexVector = gfx::IndexVector<gfx::Triangles>;
+    const std::shared_ptr<LineIndexVector> sharedLineIndexes = std::make_shared<LineIndexVector>();
+    LineIndexVector& lineIndexes = *sharedLineIndexes;
+
+    SegmentVector<LineAttributes> lineSegments;
+#endif
+
     using VertexVector = gfx::VertexVector<FillLayoutVertex>;
     const std::shared_ptr<VertexVector> sharedVertices = std::make_shared<VertexVector>();
     VertexVector& vertices = *sharedVertices;
 
-    using LineIndexVector = gfx::IndexVector<gfx::Lines>;
-    const std::shared_ptr<LineIndexVector> sharedLines = std::make_shared<LineIndexVector>();
-    LineIndexVector& lines = *sharedLines;
-
     using TriangleIndexVector = gfx::IndexVector<gfx::Triangles>;
     const std::shared_ptr<TriangleIndexVector> sharedTriangles = std::make_shared<TriangleIndexVector>();
     TriangleIndexVector& triangles = *sharedTriangles;
 
-    SegmentVector<FillAttributes> lineSegments;
     SegmentVector<FillAttributes> triangleSegments;
 
 #if MLN_LEGACY_RENDERER
+    using LineIndexVector = gfx::IndexVector<gfx::Lines>;
+    const std::shared_ptr<LineIndexVector> sharedLines = std::make_shared<LineIndexVector>();
+    LineIndexVector& lines = *sharedLines;
+
+    SegmentVector<FillAttributes> lineSegments;
+
     std::optional<gfx::VertexBuffer<FillLayoutVertex>> vertexBuffer;
     std::optional<gfx::IndexBuffer> lineIndexBuffer;
     std::optional<gfx::IndexBuffer> triangleIndexBuffer;