fix build error

4 files changed, 44 insertions, 57 deletions

diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index 8a1ea7fa14..69ef4b1cf0 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -409,7 +409,7 @@ void SymbolLayout::prepareSymbols(const GlyphMap& glyphMap, const GlyphPositions
                     layout->evaluate<IconAnchor>(zoom, feature),
                     layout->evaluate<IconRotate>(zoom, feature) * util::DEG2RAD);
                 if (image->second->sdf) {
-                   iconFlag |= 0x02;
+                    iconFlag |= 0x02;
                 }
                 if (image->second->pixelRatio != pixelRatio) {
                     iconsNeedLinear = true;
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp
index 6c503d9487..1061934b47 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.cpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp
@@ -85,62 +85,37 @@ void SymbolBucket::upload(gfx::UploadPass& uploadPass) {
         }
     }
 
-    if (hasIconData()) {
+    auto updateIconBuffer = [&](Buffer& iconBuffer) {
         if (!staticUploaded) {
-            icon.indexBuffer = uploadPass.createIndexBuffer(std::move(icon.triangles), sortFeaturesByY ? gfx::BufferUsageType::StreamDraw : gfx::BufferUsageType::StaticDraw);
-            icon.vertexBuffer = uploadPass.createVertexBuffer(std::move(icon.vertices));
+            iconBuffer.indexBuffer = uploadPass.createIndexBuffer(std::move(iconBuffer.triangles), sortFeaturesByY ? gfx::BufferUsageType::StreamDraw : gfx::BufferUsageType::StaticDraw);
+            iconBuffer.vertexBuffer = uploadPass.createVertexBuffer(std::move(iconBuffer.vertices));
             for (auto& pair : paintProperties) {
                 pair.second.iconBinders.upload(uploadPass);
             }
         } else if (!sortUploaded) {
-            uploadPass.updateIndexBuffer(*icon.indexBuffer, std::move(icon.triangles));
+            uploadPass.updateIndexBuffer(*iconBuffer.indexBuffer, std::move(iconBuffer.triangles));
         }
         if (!dynamicUploaded) {
-            if (!icon.dynamicVertexBuffer) {
-                icon.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(icon.dynamicVertices), gfx::BufferUsageType::StreamDraw);
+            if (!iconBuffer.dynamicVertexBuffer) {
+                iconBuffer.dynamicVertexBuffer = uploadPass.createVertexBuffer(std::move(iconBuffer.dynamicVertices), gfx::BufferUsageType::StreamDraw);
             } else {
-                uploadPass.updateVertexBuffer(*icon.dynamicVertexBuffer, std::move(icon.dynamicVertices));
+                uploadPass.updateVertexBuffer(*iconBuffer.dynamicVertexBuffer, std::move(iconBuffer.dynamicVertices));
             }
         }
         if (!placementChangesUploaded) {
-            if (!icon.opacityVertexBuffer) {
-                icon.opacityVertexBuffer = uploadPass.createVertexBuffer(std::move(icon.opacityVertices), gfx::BufferUsageType::StreamDraw);
+            if (!iconBuffer.opacityVertexBuffer) {
+                iconBuffer.opacityVertexBuffer = uploadPass.createVertexBuffer(std::move(iconBuffer.opacityVertices), gfx::BufferUsageType::StreamDraw);
             } else {
-                uploadPass.updateVertexBuffer(*icon.opacityVertexBuffer, std::move(icon.opacityVertices));
+                uploadPass.updateVertexBuffer(*iconBuffer.opacityVertexBuffer, std::move(iconBuffer.opacityVertices));
             }
         }
+    };
+    if (hasIconData()) {
+        updateIconBuffer(icon);
     }
 
     if (hasSdfIconData()) {
-        if (!staticUploaded) {
-            sdfIcon.indexBuffer = uploadPass.createIndexBuffer(
-                std::move(sdfIcon.triangles), sortFeaturesByY ? gfx::BufferUsageType::StreamDraw
-                                                              : gfx::BufferUsageType::StaticDraw);
-            sdfIcon.vertexBuffer = uploadPass.createVertexBuffer(std::move(sdfIcon.vertices));
-            for (auto& pair : paintProperties) {
-                pair.second.iconBinders.upload(uploadPass);
-            }
-        } else if (!sortUploaded) {
-            uploadPass.updateIndexBuffer(*icon.indexBuffer, std::move(sdfIcon.triangles));
-        }
-        if (!dynamicUploaded) {
-            if (!sdfIcon.dynamicVertexBuffer) {
-                sdfIcon.dynamicVertexBuffer = uploadPass.createVertexBuffer(
-                    std::move(sdfIcon.dynamicVertices), gfx::BufferUsageType::StreamDraw);
-            } else {
-                uploadPass.updateVertexBuffer(*sdfIcon.dynamicVertexBuffer,
-                                              std::move(sdfIcon.dynamicVertices));
-            }
-        }
-        if (!placementChangesUploaded) {
-            if (!sdfIcon.opacityVertexBuffer) {
-                sdfIcon.opacityVertexBuffer = uploadPass.createVertexBuffer(
-                    std::move(sdfIcon.opacityVertices), gfx::BufferUsageType::StreamDraw);
-            } else {
-                uploadPass.updateVertexBuffer(*sdfIcon.opacityVertexBuffer,
-                                              std::move(sdfIcon.opacityVertices));
-            }
-        }
+        updateIconBuffer(sdfIcon);
     }
 
     if (hasCollisionBoxData()) {
@@ -224,7 +199,7 @@ void SymbolBucket::sortFeatures(const float angle) {
 
     // The current approach to sorting doesn't sort across segments so don't try.
     // Sorting within segments separately seemed not to be worth the complexity.
-    if (text.segments.size() > 1 || icon.segments.size() > 1) {
+    if (text.segments.size() > 1 || (icon.segments.size() > 1 || sdfIcon.segments.size() > 1)) {
         return;
     }
 
@@ -271,7 +246,11 @@ void SymbolBucket::sortFeatures(const float angle) {
         }
 
         if (symbolInstance.placedVerticalIconIndex) {
-            addPlacedSymbol(icon.triangles, icon.placedSymbols[*symbolInstance.placedVerticalIconIndex]);
+            if (symbolInstance.hasSdfIcon()) {
+                addPlacedSymbol(sdfIcon.triangles,               sdfIcon.placedSymbols[*symbolInstance.placedVerticalIconIndex]);
+            } else {
+                addPlacedSymbol(icon.triangles, icon.placedSymbols[*symbolInstance.placedVerticalIconIndex]);
+            }
         }
     }
 }
diff --git a/src/mbgl/renderer/layers/render_symbol_layer.cpp b/src/mbgl/renderer/layers/render_symbol_layer.cpp
index a3ec83e29c..54d982127d 100644
--- a/src/mbgl/renderer/layers/render_symbol_layer.cpp
+++ b/src/mbgl/renderer/layers/render_symbol_layer.cpp
@@ -364,13 +364,13 @@ void RenderSymbolLayer::render(PaintParameters& parameters) {
         const auto& bucketPaintProperties = bucket.paintProperties.at(getID());
 
         auto addRenderables =
-            [&tile, renderData, &bucketPaintProperties,
-             it = renderableSegments.begin()](std::multiset<RenderableSegment>& renderableSegments,
+            [&tile, renderData, &bucketPaintProperties](std::multiset<RenderableSegment>& renderableSegs,
                                               auto& segments, bool isText) mutable {
+                auto it = renderableSegs.begin();
                 for (auto& segment : segments) {
-                    it = renderableSegments.emplace_hint(it, SegmentWrapper{ std::ref(segment) },
-                                                         tile, *renderData, bucketPaintProperties,
-                                                         segment.sortKey, isText);
+                    it = renderableSegs.emplace_hint(it, SegmentWrapper{ std::ref(segment) },
+                                                     tile, *renderData, bucketPaintProperties,
+                                                     segment.sortKey, isText);
                 }
             };
 
diff --git a/src/mbgl/text/placement.cpp b/src/mbgl/text/placement.cpp
index 928ed06c17..06a8628b6d 100644
--- a/src/mbgl/text/placement.cpp
+++ b/src/mbgl/text/placement.cpp
@@ -367,8 +367,8 @@ void Placement::placeBucket(
                 shift = {0.0f, 0.0f};
             }
 
-            const auto& icon = symbolInstance.hasSdfIcon() ? bucket.sdfIcon : bucket.icon;
-            const PlacedSymbol& placedSymbol = icon.placedSymbols.at(*symbolInstance.placedIconIndex);
+            const auto& iconBuffer = symbolInstance.hasSdfIcon() ? bucket.sdfIcon : bucket.icon;
+            const PlacedSymbol& placedSymbol = iconBuffer.placedSymbols.at(*symbolInstance.placedIconIndex);
             const float fontSize = evaluateSizeForFeature(partiallyEvaluatedIconSize, placedSymbol);
             const auto& placeIconFeature = [&] (const CollisionFeature& collisionFeature) {
                 return collisionIndex.placeFeature(collisionFeature, shift,
@@ -546,18 +546,18 @@ bool Placement::updateBucketDynamicVertices(SymbolBucket& bucket, const Transfor
         if (layout.get<IconRotationAlignment>() == AlignmentType::Map) {
             const bool pitchWithMap = layout.get<style::IconPitchAlignment>() == style::AlignmentType::Map;
             const bool keepUpright = layout.get<style::IconKeepUpright>();
-            if (bucket.hasIconData()) {
-                reprojectLineLabels(bucket.icon.dynamicVertices, bucket.icon.placedSymbols,
-                    tile.matrix, pitchWithMap, true /*rotateWithMap*/, keepUpright,
-                    tile, *bucket.iconSizeBinder, state);
-                result = true;
-            }
             if(bucket.hasSdfIconData()) {
                 reprojectLineLabels(bucket.sdfIcon.dynamicVertices, bucket.sdfIcon.placedSymbols,
                                     tile.matrix, pitchWithMap, true /*rotateWithMap*/, keepUpright,
                                     tile, *bucket.iconSizeBinder, state);
                 result = true;
             }
+            if (bucket.hasIconData()) {
+                reprojectLineLabels(bucket.icon.dynamicVertices, bucket.icon.placedSymbols,
+                    tile.matrix, pitchWithMap, true /*rotateWithMap*/, keepUpright,
+                    tile, *bucket.iconSizeBinder, state);
+                result = true;
+            }
         }
 
         if (bucket.hasTextData() && layout.get<TextRotationAlignment>() == AlignmentType::Map) {
@@ -932,11 +932,19 @@ void Placement::markUsedOrientation(SymbolBucket& bucket, style::TextWritingMode
     }
 
     if (symbolInstance.placedIconIndex) {
-        bucket.icon.placedSymbols.at(*symbolInstance.placedIconIndex).placedOrientation = horizontal;
+        if (symbolInstance.hasSdfIcon()) {
+            bucket.sdfIcon.placedSymbols.at(*symbolInstance.placedIconIndex).placedOrientation = horizontal;
+        } else {
+            bucket.icon.placedSymbols.at(*symbolInstance.placedIconIndex).placedOrientation = horizontal;
+        }
     }
 
     if (symbolInstance.placedVerticalIconIndex) {
-        bucket.icon.placedSymbols.at(*symbolInstance.placedVerticalIconIndex).placedOrientation = vertical;
+        if (symbolInstance.hasSdfIcon()) {
+            bucket.sdfIcon.placedSymbols.at(*symbolInstance.placedVerticalIconIndex).placedOrientation = vertical;
+        } else {
+            bucket.icon.placedSymbols.at(*symbolInstance.placedVerticalIconIndex).placedOrientation = vertical;
+        }
     }
 }