[core] RenderCircleLayer fixes

1 files changed, 45 insertions, 61 deletions

diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index a85b82b2d2..6be623d41c 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -19,26 +19,18 @@ namespace {
 
 struct RenderableSegment {
     RenderableSegment(const Segment<CircleAttributes>& segment_,
-                      CircleProgram& programInstance_,
-                      const CircleBucket& bucket_,
-                      const CircleProgram::UniformValues& allUniformValues_,
-                      const CircleProgram::AttributeBindings& allAttributeBindings_,
+                      const RenderTile& tile_,
+                      const LayerRenderData* renderData_,
                       float sortKey_)
-        : segment(segment_),
-          programInstance(programInstance_),
-          bucket(bucket_),
-          allUniformValues(allUniformValues_),
-          allAttributeBindings(allAttributeBindings_),
-          sortKey(sortKey_) {}
+        : segment(segment_), tile(tile_), renderData(renderData_), sortKey(sortKey_) {}
 
     const Segment<CircleAttributes>& segment;
-    CircleProgram& programInstance;
-    const CircleBucket& bucket;
-    const CircleProgram::UniformValues& allUniformValues;
-    const CircleProgram::AttributeBindings& allAttributeBindings;
+    const RenderTile& tile;
+    const LayerRenderData* renderData;
     const float sortKey;
 
     friend bool operator<(const RenderableSegment& lhs, const RenderableSegment& rhs) {
+        if (lhs.sortKey == rhs.sortKey) return lhs.tile.id < rhs.tile.id;
         return lhs.sortKey < rhs.sortKey;
     }
 };
@@ -88,24 +80,17 @@ void RenderCircleLayer::render(PaintParameters& parameters) {
     if (parameters.pass == RenderPass::Opaque) {
         return;
     }
-
-    const bool sortFeaturesByKey = !impl_cast(baseImpl).layout.get<CircleSortKey>().isUndefined();
-    std::multiset<RenderableSegment> renderableSegments{};
-
-    for (const RenderTile& tile : *renderTiles) {
-        const LayerRenderData* renderData = getRenderDataForPass(tile, parameters.pass);
-        if (!renderData) {
-            continue;
-        }
-        auto& bucket = static_cast<CircleBucket&>(*renderData->bucket);
-        const auto& evaluated = getEvaluated<CircleLayerProperties>(renderData->layerProperties);
+    const auto drawTile = [this, &parameters](
+                              const RenderTile& tile, const LayerRenderData* data, const auto& segments) {
+        auto& circleBucket = static_cast<CircleBucket&>(*data->bucket);
+        const auto& evaluated = getEvaluated<CircleLayerProperties>(data->layerProperties);
         const bool scaleWithMap = evaluated.get<CirclePitchScale>() == CirclePitchScaleType::Map;
         const bool pitchWithMap = evaluated.get<CirclePitchAlignment>() == AlignmentType::Map;
-        const auto& paintPropertyBinders = bucket.paintPropertyBinders.at(getID());
+        const auto& paintPropertyBinders = circleBucket.paintPropertyBinders.at(getID());
 
         auto& programInstance = parameters.programs.getCircleLayerPrograms().circle;
 
-        const auto allUniformValues = CircleProgram::computeAllUniformValues(
+        const auto& allUniformValues = CircleProgram::computeAllUniformValues(
             CircleProgram::LayoutUniformValues{
                 uniforms::matrix::Value(tile.translatedMatrix(
                     evaluated.get<CircleTranslate>(), evaluated.get<CircleTranslateAnchor>(), parameters.state)),
@@ -120,48 +105,47 @@ void RenderCircleLayer::render(PaintParameters& parameters) {
             paintPropertyBinders,
             evaluated,
             parameters.state.getZoom());
-        const auto allAttributeBindings =
-            CircleProgram::computeAllAttributeBindings(*bucket.vertexBuffer, paintPropertyBinders, evaluated);
+        const auto& allAttributeBindings =
+            CircleProgram::computeAllAttributeBindings(*circleBucket.vertexBuffer, paintPropertyBinders, evaluated);
 
         checkRenderability(parameters, CircleProgram::activeBindingCount(allAttributeBindings));
 
-        if (sortFeaturesByKey) {
-            for (auto& segment : bucket.segments) {
-                renderableSegments.emplace(
-                    segment, programInstance, bucket, allUniformValues, allAttributeBindings, segment.sortKey);
-            }
-        } else {
-            programInstance.draw(parameters.context,
-                                 *parameters.renderPass,
-                                 gfx::Triangles(),
-                                 parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
-                                 gfx::StencilMode::disabled(),
-                                 parameters.colorModeForRenderPass(),
-                                 gfx::CullFaceMode::disabled(),
-                                 *bucket.indexBuffer,
-                                 bucket.segments,
-                                 allUniformValues,
-                                 allAttributeBindings,
-                                 CircleProgram::TextureBindings{},
-                                 getID());
+        programInstance.draw(parameters.context,
+                             *parameters.renderPass,
+                             gfx::Triangles(),
+                             parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
+                             gfx::StencilMode::disabled(),
+                             parameters.colorModeForRenderPass(),
+                             gfx::CullFaceMode::disabled(),
+                             *circleBucket.indexBuffer,
+                             segments,
+                             allUniformValues,
+                             allAttributeBindings,
+                             CircleProgram::TextureBindings{},
+                             getID());
+    };
+
+    const bool sortFeaturesByKey = !impl_cast(baseImpl).layout.get<CircleSortKey>().isUndefined();
+    std::multiset<RenderableSegment> renderableSegments;
+
+    for (const RenderTile& renderTile : *renderTiles) {
+        const LayerRenderData* renderData = getRenderDataForPass(renderTile, parameters.pass);
+        if (!renderData) {
+            continue;
+        }
+        auto& bucket = static_cast<CircleBucket&>(*renderData->bucket);
+        if (!sortFeaturesByKey) {
+            drawTile(renderTile, renderData, bucket.segments);
+            continue;
+        }
+        for (auto& segment : bucket.segments) {
+            renderableSegments.emplace(segment, renderTile, renderData, segment.sortKey);
         }
     }
 
     if (sortFeaturesByKey) {
         for (const auto& renderable : renderableSegments) {
-            renderable.programInstance.draw(parameters.context,
-                                            *parameters.renderPass,
-                                            gfx::Triangles(),
-                                            parameters.depthModeForSublayer(0, gfx::DepthMaskType::ReadOnly),
-                                            gfx::StencilMode::disabled(),
-                                            parameters.colorModeForRenderPass(),
-                                            gfx::CullFaceMode::disabled(),
-                                            *renderable.bucket.indexBuffer,
-                                            renderable.segment,
-                                            renderable.allUniformValues,
-                                            renderable.allAttributeBindings,
-                                            CircleProgram::TextureBindings{},
-                                            getID());
+            drawTile(renderable.tile, renderable.renderData, renderable.segment);
         }
     }
 }