refind code structure

3 files changed, 79 insertions, 155 deletions

diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index 8dcc92cd60..df917cbea3 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -811,18 +811,14 @@ void SymbolLayout::addToDebugBuffers(SymbolBucket& bucket) {
     if (!hasSymbolInstances()) {
         return;
     }
-
+    
     for (const SymbolInstance& symbolInstance : symbolInstances) {
         auto populateCollisionBox = [&](const auto& feature, bool isText) {
             SymbolBucket::CollisionBuffer& collisionBuffer =
-                feature.alongLine ? (isText ? static_cast<SymbolBucket::CollisionBuffer&>(
-                                                  bucket.getOrCreateTextCollisionCircleBuffer())
-                                            : static_cast<SymbolBucket::CollisionBuffer&>(
-                                                  bucket.getOrCreateIconCollisionCircleBuffer()))
-                                  : (isText ? static_cast<SymbolBucket::CollisionBuffer&>(
-                                                  bucket.getOrCreateTextCollisionBox())
-                                            : static_cast<SymbolBucket::CollisionBuffer&>(
-                                                  bucket.getOrCreateIconCollisionBox()));
+                feature.alongLine ? (isText ? static_cast<SymbolBucket::CollisionBuffer&>(bucket.getOrCreateTextCollisionCircleBuffer())
+                                            : static_cast<SymbolBucket::CollisionBuffer&>(bucket.getOrCreateIconCollisionCircleBuffer()))
+                                  : (isText ? static_cast<SymbolBucket::CollisionBuffer&>(bucket.getOrCreateTextCollisionBox())
+                                            : static_cast<SymbolBucket::CollisionBuffer&>(bucket.getOrCreateIconCollisionBox()));
 
             for (const CollisionBox& box : feature.boxes) {
                 auto& anchor = box.anchor;
@@ -835,16 +831,12 @@ void SymbolLayout::addToDebugBuffers(SymbolBucket& bucket) {
                 static constexpr std::size_t vertexLength = 4;
                 const std::size_t indexLength = feature.alongLine ? 6 : 8;
 
-                if (collisionBuffer.segments.empty() ||
-                    collisionBuffer.segments.back().vertexLength + vertexLength >
-                        std::numeric_limits<uint16_t>::max()) {
+                if (collisionBuffer.segments.empty() || collisionBuffer.segments.back().vertexLength + vertexLength > std::numeric_limits<uint16_t>::max()) {
                     collisionBuffer.segments.emplace_back(
                         collisionBuffer.vertices.elements(),
                         feature.alongLine
-                            ? (isText ? bucket.textCollisionCircle->triangles.elements()
-                                      : bucket.iconCollisionCircle->triangles.elements())
-                            : (isText ? bucket.textCollisionBox->lines.elements()
-                                      : bucket.iconCollisionBox->lines.elements()));
+                            ? (isText ? bucket.textCollisionCircle->triangles.elements() : bucket.iconCollisionCircle->triangles.elements())
+                            : (isText ? bucket.textCollisionBox->lines.elements() : bucket.iconCollisionBox->lines.elements()));
                 }
 
                 auto& segment = collisionBuffer.segments.back();
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp
index 90006f67f8..b12f257ce1 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.cpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp
@@ -118,78 +118,46 @@ void SymbolBucket::upload(gfx::UploadPass& uploadPass) {
         updateIconBuffer(sdfIcon);
     }
 
-    if (hasIconCollisionBoxData()) {
+    const auto updateCollisionBox = [&](CollisionBoxBuffer& collisionBox) {
         if (!staticUploaded) {
-            iconCollisionBox->indexBuffer =
-                uploadPass.createIndexBuffer(std::move(iconCollisionBox->lines));
-            iconCollisionBox->vertexBuffer =
-                uploadPass.createVertexBuffer(std::move(iconCollisionBox->vertices));
+            collisionBox.indexBuffer = uploadPass.createIndexBuffer(std::move(collisionBox.lines));
+            collisionBox.vertexBuffer = uploadPass.createVertexBuffer(std::move(collisionBox.vertices));
         }
         if (!placementChangesUploaded) {
-            if (!iconCollisionBox->dynamicVertexBuffer) {
-                iconCollisionBox->dynamicVertexBuffer = uploadPass.createVertexBuffer(
-                    std::move(iconCollisionBox->dynamicVertices), gfx::BufferUsageType::StreamDraw);
+            if (!collisionBox.dynamicVertexBuffer) {
+                collisionBox.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(collisionBox.dynamicVertices), gfx::BufferUsageType::StreamDraw);
             } else {
-                uploadPass.updateVertexBuffer(*iconCollisionBox->dynamicVertexBuffer,
-                                              std::move(iconCollisionBox->dynamicVertices));
+                uploadPass.updateVertexBuffer(*collisionBox.dynamicVertexBuffer, std::move(collisionBox.dynamicVertices));
             }
         }
+    };
+    if (hasIconCollisionBoxData()) {
+        updateCollisionBox(*iconCollisionBox);
     }
 
     if (hasTextCollisionBoxData()) {
-        if (!staticUploaded) {
-            textCollisionBox->indexBuffer =
-                uploadPass.createIndexBuffer(std::move(textCollisionBox->lines));
-            textCollisionBox->vertexBuffer =
-                uploadPass.createVertexBuffer(std::move(textCollisionBox->vertices));
-        }
-        if (!placementChangesUploaded) {
-            if (!textCollisionBox->dynamicVertexBuffer) {
-                textCollisionBox->dynamicVertexBuffer = uploadPass.createVertexBuffer(
-                    std::move(textCollisionBox->dynamicVertices), gfx::BufferUsageType::StreamDraw);
-            } else {
-                uploadPass.updateVertexBuffer(*textCollisionBox->dynamicVertexBuffer,
-                                              std::move(textCollisionBox->dynamicVertices));
-            }
-        }
+        updateCollisionBox(*textCollisionBox);
     }
 
-    if (hasIconCollisionCircleData()) {
+    const auto updateCollisionCircle = [&](CollisionCircleBuffer& collisionCircle) {
         if (!staticUploaded) {
-            iconCollisionCircle->indexBuffer =
-                uploadPass.createIndexBuffer(std::move(iconCollisionCircle->triangles));
-            iconCollisionCircle->vertexBuffer =
-                uploadPass.createVertexBuffer(std::move(iconCollisionCircle->vertices));
+            collisionCircle.indexBuffer = uploadPass.createIndexBuffer(std::move(collisionCircle.triangles));
+            collisionCircle.vertexBuffer = uploadPass.createVertexBuffer(std::move(collisionCircle.vertices));
         }
         if (!placementChangesUploaded) {
-            if (!iconCollisionCircle->dynamicVertexBuffer) {
-                iconCollisionCircle->dynamicVertexBuffer =
-                    uploadPass.createVertexBuffer(std::move(iconCollisionCircle->dynamicVertices),
-                                                  gfx::BufferUsageType::StreamDraw);
+            if (!collisionCircle.dynamicVertexBuffer) {
+                collisionCircle.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(collisionCircle.dynamicVertices), gfx::BufferUsageType::StreamDraw);
             } else {
-                uploadPass.updateVertexBuffer(*iconCollisionCircle->dynamicVertexBuffer,
-                                              std::move(iconCollisionCircle->dynamicVertices));
+                uploadPass.updateVertexBuffer(*collisionCircle.dynamicVertexBuffer, std::move(collisionCircle.dynamicVertices));
             }
         }
+    };
+    if (hasIconCollisionCircleData()) {
+        updateCollisionCircle(*iconCollisionCircle);
     }
 
     if (hasTextCollisionCircleData()) {
-        if (!staticUploaded) {
-            textCollisionCircle->indexBuffer =
-                uploadPass.createIndexBuffer(std::move(textCollisionCircle->triangles));
-            textCollisionCircle->vertexBuffer =
-                uploadPass.createVertexBuffer(std::move(textCollisionCircle->vertices));
-        }
-        if (!placementChangesUploaded) {
-            if (!textCollisionCircle->dynamicVertexBuffer) {
-                textCollisionCircle->dynamicVertexBuffer =
-                    uploadPass.createVertexBuffer(std::move(textCollisionCircle->dynamicVertices),
-                                                  gfx::BufferUsageType::StreamDraw);
-            } else {
-                uploadPass.updateVertexBuffer(*textCollisionCircle->dynamicVertexBuffer,
-                                              std::move(textCollisionCircle->dynamicVertices));
-            }
-        }
+        updateCollisionCircle(*textCollisionCircle);
     }
 
     uploaded = true;
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index 47dd484cf3..16283565d9 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -392,98 +392,62 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
             }
         }
 
-        static const style::Properties<>::PossiblyEvaluated properties {};
-        static const CollisionBoxProgram::Binders paintAttributeData(properties, 0);
-
-        auto pixelRatio = tile.id.pixelsToTileUnits(1, parameters.state.getZoom());
-        const float scale = std::pow(2, parameters.state.getZoom() - tile.getOverscaledTileID().overscaledZ);
-        std::array<float,2> extrudeScale =
+        const auto drawCollisonData = [&](const bool isText, const bool hasCollisionBox, const bool hasCollisionCircle) {
+            if (!hasCollisionBox && !hasCollisionCircle) return;
+            
+            static const style::Properties<>::PossiblyEvaluated properties {};
+            static const CollisionBoxProgram::Binders paintAttributeData(properties, 0);
+            auto pixelRatio = tile.id.pixelsToTileUnits(1, parameters.state.getZoom());
+            const float scale = std::pow(2, parameters.state.getZoom() - tile.getOverscaledTileID().overscaledZ);
+            std::array<float,2> extrudeScale =
             {{
                 parameters.pixelsToGLUnits[0] / (pixelRatio * scale),
                 parameters.pixelsToGLUnits[1] / (pixelRatio * scale)
             }};
-        const auto& evaluated = getEvaluated<SymbolLayerProperties>(renderData->layerProperties);
-        const auto& layout = *bucket.layout;
-
-        if (bucket.hasIconCollisionBoxData()) {
-            const auto values = iconPropertyValues(evaluated, layout);
-            parameters.programs.getSymbolLayerPrograms().collisionBox.draw(
-                parameters.context, *parameters.renderPass, gfx::Lines{ 1.0f },
-                gfx::DepthMode::disabled(), gfx::StencilMode::disabled(),
-                parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(),
-                CollisionBoxProgram::LayoutUniformValues{
-                    uniforms::matrix::Value(tile.translatedMatrix(
-                        values.translate, values.translateAnchor, parameters.state)),
-                    uniforms::extrude_scale::Value(extrudeScale),
-                    uniforms::camera_to_center_distance::Value(
-                        parameters.state.getCameraToCenterDistance()) },
-                *bucket.iconCollisionBox->vertexBuffer,
-                *bucket.iconCollisionBox->dynamicVertexBuffer,
-                *bucket.iconCollisionBox->indexBuffer, bucket.iconCollisionBox->segments,
-                paintAttributeData, properties, CollisionBoxProgram::TextureBindings{},
-                parameters.state.getZoom(), getID());
-        }
-
-        if (bucket.hasTextCollisionBoxData()) {
-            auto values = textPropertyValues(evaluated, layout);
-            parameters.programs.getSymbolLayerPrograms().collisionBox.draw(
-                parameters.context, *parameters.renderPass, gfx::Lines{ 1.0f },
-                gfx::DepthMode::disabled(), gfx::StencilMode::disabled(),
-                parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(),
-                CollisionBoxProgram::LayoutUniformValues{
-                    uniforms::matrix::Value(tile.translatedMatrix(
-                        values.translate, values.translateAnchor, parameters.state)),
-                    uniforms::extrude_scale::Value(extrudeScale),
-                    uniforms::camera_to_center_distance::Value(
-                        parameters.state.getCameraToCenterDistance()) },
-                *bucket.textCollisionBox->vertexBuffer,
-                *bucket.textCollisionBox->dynamicVertexBuffer,
-                *bucket.textCollisionBox->indexBuffer, bucket.textCollisionBox->segments,
-                paintAttributeData, properties, CollisionBoxProgram::TextureBindings{},
-                parameters.state.getZoom(), getID());
-        }
-
-        if (bucket.hasIconCollisionCircleData()) {
-            auto values = iconPropertyValues(evaluated, layout);
-            parameters.programs.getSymbolLayerPrograms().collisionCircle.draw(
-                parameters.context, *parameters.renderPass, gfx::Triangles(),
-                gfx::DepthMode::disabled(), gfx::StencilMode::disabled(),
-                parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(),
-                CollisionCircleProgram::LayoutUniformValues{
-                    uniforms::matrix::Value(tile.translatedMatrix(
-                        values.translate, values.translateAnchor, parameters.state)),
-                    uniforms::extrude_scale::Value(extrudeScale),
-                    uniforms::overscale_factor::Value(
-                        float(tile.getOverscaledTileID().overscaleFactor())),
-                    uniforms::camera_to_center_distance::Value(
-                        parameters.state.getCameraToCenterDistance()) },
-                *bucket.iconCollisionCircle->vertexBuffer,
-                *bucket.iconCollisionCircle->dynamicVertexBuffer,
-                *bucket.iconCollisionCircle->indexBuffer, bucket.iconCollisionCircle->segments,
-                paintAttributeData, properties, CollisionCircleProgram::TextureBindings{},
-                parameters.state.getZoom(), getID());
-        }
+            const auto& evaluated = getEvaluated<SymbolLayerProperties>(renderData->layerProperties);
+            const auto& layout = *bucket.layout;
+            const auto values = isText ? textPropertyValues(evaluated, layout) : iconPropertyValues(evaluated, layout);
+            const bool needTranslate = values.translate[0] != 0 || values.translate[1] != 0;
+            
+            if (hasCollisionBox) {
+                const auto& collisionBox = isText ? bucket.textCollisionBox : bucket.iconCollisionBox;
+                parameters.programs.getSymbolLayerPrograms().collisionBox.draw(
+                   parameters.context, *parameters.renderPass, gfx::Lines{ 1.0f },
+                   gfx::DepthMode::disabled(), gfx::StencilMode::disabled(),
+                   parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(),
+                   CollisionBoxProgram::LayoutUniformValues{
+                       uniforms::matrix::Value((needTranslate
+                                                ? tile.translatedMatrix(values.translate, values.translateAnchor, parameters.state)
+                                                : tile.matrix)),
+                       uniforms::extrude_scale::Value(extrudeScale),
+                       uniforms::camera_to_center_distance::Value(parameters.state.getCameraToCenterDistance()) },
+                   *collisionBox->vertexBuffer, *collisionBox->dynamicVertexBuffer,
+                   *collisionBox->indexBuffer, collisionBox->segments, paintAttributeData, properties,
+                   CollisionBoxProgram::TextureBindings{}, parameters.state.getZoom(), getID());
+            }
+            if (hasCollisionCircle) {
+                const auto& collisionCircle = isText ? bucket.textCollisionCircle : bucket.iconCollisionCircle;
+                parameters.programs.getSymbolLayerPrograms().collisionCircle.draw(
+                    parameters.context, *parameters.renderPass, gfx::Triangles(),
+                    gfx::DepthMode::disabled(), gfx::StencilMode::disabled(),
+                    parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(),
+                    CollisionCircleProgram::LayoutUniformValues{
+                      uniforms::matrix::Value((needTranslate
+                                               ? tile.translatedMatrix(values.translate, values.translateAnchor, parameters.state)
+                                               : tile.matrix)),
+                      uniforms::extrude_scale::Value(extrudeScale),
+                      uniforms::overscale_factor::Value(float(tile.getOverscaledTileID().overscaleFactor())),
+                      uniforms::camera_to_center_distance::Value(parameters.state.getCameraToCenterDistance()) },
+                    *collisionCircle->vertexBuffer, *collisionCircle->dynamicVertexBuffer,
+                    *collisionCircle->indexBuffer, collisionCircle->segments, paintAttributeData,
+                    properties, CollisionCircleProgram::TextureBindings{}, parameters.state.getZoom(),
+                    getID());
+            }
+        };
+        drawCollisonData( false /*isText*/, bucket.hasIconCollisionBoxData(), bucket.hasIconCollisionCircleData());
+   
+        drawCollisonData( true /*isText*/, bucket.hasTextCollisionBoxData(), bucket.hasTextCollisionCircleData());
 
-        if (bucket.hasTextCollisionCircleData()) {
-            auto values = textPropertyValues(evaluated, layout);
-            parameters.programs.getSymbolLayerPrograms().collisionCircle.draw(
-                parameters.context, *parameters.renderPass, gfx::Triangles(),
-                gfx::DepthMode::disabled(), gfx::StencilMode::disabled(),
-                parameters.colorModeForRenderPass(), gfx::CullFaceMode::disabled(),
-                CollisionCircleProgram::LayoutUniformValues{
-                    uniforms::matrix::Value(tile.translatedMatrix(
-                        values.translate, values.translateAnchor, parameters.state)),
-                    uniforms::extrude_scale::Value(extrudeScale),
-                    uniforms::overscale_factor::Value(
-                        float(tile.getOverscaledTileID().overscaleFactor())),
-                    uniforms::camera_to_center_distance::Value(
-                        parameters.state.getCameraToCenterDistance()) },
-                *bucket.textCollisionCircle->vertexBuffer,
-                *bucket.textCollisionCircle->dynamicVertexBuffer,
-                *bucket.textCollisionCircle->indexBuffer, bucket.textCollisionCircle->segments,
-                paintAttributeData, properties, CollisionCircleProgram::TextureBindings{},
-                parameters.state.getZoom(), getID());
-        }
     }
 
     if (sortFeaturesByKey) {