3 files changed, 201 insertions, 26 deletions
diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp
index 04126990b3..d23f0861f4 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.cpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.cpp
@@ -49,7 +49,7 @@ void CircleBucket::addFeature(const GeometryTileFeature& feature,
             // 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::Still) &&
+            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()) {
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.cpp b/src/mbgl/renderer/buckets/symbol_bucket.cpp
index a3f71f1f6e..60e8a0b504 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.cpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.cpp
@@ -16,10 +16,14 @@ SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layo
                            const style::DataDrivenPropertyValue<float>& iconSize,
                            float zoom,
                            bool sdfIcons_,
-                           bool iconsNeedLinear_)
+                           bool iconsNeedLinear_,
+                           bool sortFeaturesByY_,
+                           const std::vector<SymbolInstance>&& symbolInstances_)
     : layout(std::move(layout_)),
       sdfIcons(sdfIcons_),
       iconsNeedLinear(iconsNeedLinear_ || iconSize.isDataDriven() || !iconSize.isZoomConstant()),
+      sortFeaturesByY(sortFeaturesByY_),
+      symbolInstances(std::move(symbolInstances_)),
       textSizeBinder(SymbolSizeBinder::create(zoom, textSize, TextSize::defaultValue())),
       iconSizeBinder(SymbolSizeBinder::create(zoom, iconSize, IconSize::defaultValue())) {
     
@@ -36,28 +40,84 @@ SymbolBucket::SymbolBucket(style::SymbolLayoutProperties::PossiblyEvaluated layo
 
 void SymbolBucket::upload(gl::Context& context) {
     if (hasTextData()) {
-        text.vertexBuffer = context.createVertexBuffer(std::move(text.vertices));
-        text.dynamicVertexBuffer = context.createVertexBuffer(std::move(text.dynamicVertices), gl::BufferUsage::StreamDraw);
-        text.indexBuffer = context.createIndexBuffer(std::move(text.triangles));
+        if (!staticUploaded) {
+            text.indexBuffer = context.createIndexBuffer(std::move(text.triangles), sortFeaturesByY ? gl::BufferUsage::StreamDraw : gl::BufferUsage::StaticDraw);
+            text.vertexBuffer = context.createVertexBuffer(std::move(text.vertices));
+        } else if (!sortUploaded) {
+            context.updateIndexBuffer(*text.indexBuffer, std::move(text.triangles));
+        }
+        
+        if (!dynamicUploaded) {
+            text.dynamicVertexBuffer = context.createVertexBuffer(std::move(text.dynamicVertices), gl::BufferUsage::StreamDraw);
+        }
+        if (!placementChangesUploaded) {
+            if (!text.opacityVertexBuffer) {
+                text.opacityVertexBuffer = context.createVertexBuffer(std::move(text.opacityVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*text.opacityVertexBuffer, std::move(text.opacityVertices));
+            }
+        }
     }
 
     if (hasIconData()) {
-        icon.vertexBuffer = context.createVertexBuffer(std::move(icon.vertices));
-        icon.dynamicVertexBuffer = context.createVertexBuffer(std::move(icon.dynamicVertices), gl::BufferUsage::StreamDraw);
-        icon.indexBuffer = context.createIndexBuffer(std::move(icon.triangles));
+        if (!staticUploaded) {
+            icon.indexBuffer = context.createIndexBuffer(std::move(icon.triangles), sortFeaturesByY ? gl::BufferUsage::StreamDraw : gl::BufferUsage::StaticDraw);
+            icon.vertexBuffer = context.createVertexBuffer(std::move(icon.vertices));
+        } else if (!sortUploaded) {
+            context.updateIndexBuffer(*icon.indexBuffer, std::move(icon.triangles));
+        }
+        if (!dynamicUploaded) {
+            icon.dynamicVertexBuffer = context.createVertexBuffer(std::move(icon.dynamicVertices), gl::BufferUsage::StreamDraw);
+        }
+        if (!placementChangesUploaded) {
+            if (!icon.opacityVertexBuffer) {
+                icon.opacityVertexBuffer = context.createVertexBuffer(std::move(icon.opacityVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*icon.opacityVertexBuffer, std::move(icon.opacityVertices));
+            }
+        }
     }
 
-    if (!collisionBox.vertices.empty()) {
-        collisionBox.vertexBuffer = context.createVertexBuffer(std::move(collisionBox.vertices));
-        collisionBox.indexBuffer = context.createIndexBuffer(std::move(collisionBox.lines));
+    if (hasCollisionBoxData()) {
+        if (!staticUploaded) {
+            collisionBox.indexBuffer = context.createIndexBuffer(std::move(collisionBox.lines));
+            collisionBox.vertexBuffer = context.createVertexBuffer(std::move(collisionBox.vertices));
+        }
+        if (!placementChangesUploaded) {
+            if (!collisionBox.dynamicVertexBuffer) {
+                collisionBox.dynamicVertexBuffer = context.createVertexBuffer(std::move(collisionBox.dynamicVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*collisionBox.dynamicVertexBuffer, std::move(collisionBox.dynamicVertices));
+            }
+        }
     }
-
-    for (auto& pair : paintPropertyBinders) {
-        pair.second.first.upload(context);
-        pair.second.second.upload(context);
+    
+    if (hasCollisionCircleData()) {
+        if (!staticUploaded) {
+            collisionCircle.indexBuffer = context.createIndexBuffer(std::move(collisionCircle.triangles));
+            collisionCircle.vertexBuffer = context.createVertexBuffer(std::move(collisionCircle.vertices));
+        }
+        if (!placementChangesUploaded) {
+            if (!collisionCircle.dynamicVertexBuffer) {
+                collisionCircle.dynamicVertexBuffer = context.createVertexBuffer(std::move(collisionCircle.dynamicVertices), gl::BufferUsage::StreamDraw);
+            } else {
+                context.updateVertexBuffer(*collisionCircle.dynamicVertexBuffer, std::move(collisionCircle.dynamicVertices));
+            }
+        }
     }
 
+    if (!staticUploaded) {
+        for (auto& pair : paintPropertyBinders) {
+            pair.second.first.upload(context);
+            pair.second.second.upload(context);
+        }
+    }
+    
     uploaded = true;
+    staticUploaded = true;
+    placementChangesUploaded = true;
+    dynamicUploaded = true;
+    sortUploaded = true;
 }
 
 bool SymbolBucket::hasData() const {
@@ -76,4 +136,83 @@ bool SymbolBucket::hasCollisionBoxData() const {
     return !collisionBox.segments.empty();
 }
 
+bool SymbolBucket::hasCollisionCircleData() const {
+    return !collisionCircle.segments.empty();
+}
+
+void SymbolBucket::updateOpacity() {
+    placementChangesUploaded = false;
+    uploaded = false;
+}
+
+void addPlacedSymbol(gl::IndexVector<gl::Triangles>& triangles, const PlacedSymbol& placedSymbol) {
+    auto endIndex = placedSymbol.vertexStartIndex + placedSymbol.glyphOffsets.size() * 4;
+    for (auto vertexIndex = placedSymbol.vertexStartIndex; vertexIndex < endIndex; vertexIndex += 4) {
+        triangles.emplace_back(vertexIndex + 0, vertexIndex + 1, vertexIndex + 2);
+        triangles.emplace_back(vertexIndex + 1, vertexIndex + 2, vertexIndex + 3);
+    }
+}
+
+void SymbolBucket::sortFeatures(const float angle) {
+    if (!sortFeaturesByY) {
+        return;
+    }
+
+    if (sortedAngle && *sortedAngle == angle) {
+        return;
+    }
+    
+    sortedAngle = 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) {
+        return;
+    }
+    
+    sortUploaded = false;
+    uploaded = false;
+
+    // If the symbols are allowed to overlap sort them by their vertical screen position.
+    // The index array buffer is rewritten to reference the (unchanged) vertices in the
+    // sorted order.
+
+    // To avoid sorting the actual symbolInstance array we sort an array of indexes.
+    std::vector<size_t> symbolInstanceIndexes;
+    symbolInstanceIndexes.reserve(symbolInstances.size());
+    for (size_t i = 0; i < symbolInstances.size(); i++) {
+        symbolInstanceIndexes.push_back(i);
+    }
+    
+    const float sin = std::sin(angle);
+    const float cos = std::cos(angle);
+
+    std::sort(symbolInstanceIndexes.begin(), symbolInstanceIndexes.end(), [sin, cos, this](size_t &aIndex, size_t &bIndex) {
+        const SymbolInstance& a = symbolInstances[aIndex];
+        const SymbolInstance& b = symbolInstances[bIndex];
+        const int32_t aRotated = sin * a.anchor.point.x + cos * a.anchor.point.y;
+        const int32_t bRotated = sin * b.anchor.point.x + cos * b.anchor.point.y;
+        return aRotated != bRotated ?
+            aRotated < bRotated :
+            a.index > b.index;
+    });
+
+    text.triangles.clear();
+    icon.triangles.clear();
+
+    for (auto i : symbolInstanceIndexes) {
+        const SymbolInstance& symbolInstance = symbolInstances[i];
+
+        if (symbolInstance.placedTextIndex) {
+            addPlacedSymbol(text.triangles, text.placedSymbols[*symbolInstance.placedTextIndex]);
+        }
+        if (symbolInstance.placedVerticalTextIndex) {
+            addPlacedSymbol(text.triangles, text.placedSymbols[*symbolInstance.placedVerticalTextIndex]);
+        }
+        if (symbolInstance.placedIconIndex) {
+            addPlacedSymbol(icon.triangles, icon.placedSymbols[*symbolInstance.placedIconIndex]);
+        }
+    }
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/renderer/buckets/symbol_bucket.hpp b/src/mbgl/renderer/buckets/symbol_bucket.hpp
index 32f976bcb2..4abea90508 100644
--- a/src/mbgl/renderer/buckets/symbol_bucket.hpp
+++ b/src/mbgl/renderer/buckets/symbol_bucket.hpp
@@ -10,6 +10,7 @@
 #include <mbgl/text/glyph_range.hpp>
 #include <mbgl/style/layers/symbol_layer_properties.hpp>
 #include <mbgl/layout/symbol_feature.hpp>
+#include <mbgl/layout/symbol_instance.hpp>
 
 #include <vector>
 
@@ -18,18 +19,22 @@ namespace mbgl {
 class PlacedSymbol {
 public:
     PlacedSymbol(Point<float> anchorPoint_, uint16_t segment_, float lowerSize_, float upperSize_,
-            std::array<float, 2> lineOffset_, float placementZoom_, bool useVerticalMode_, GeometryCoordinates line_) :
+            std::array<float, 2> lineOffset_, WritingModeType writingModes_, GeometryCoordinates line_, std::vector<float> tileDistances_) :
         anchorPoint(anchorPoint_), segment(segment_), lowerSize(lowerSize_), upperSize(upperSize_),
-        lineOffset(lineOffset_), placementZoom(placementZoom_), useVerticalMode(useVerticalMode_), line(std::move(line_)) {}
+        lineOffset(lineOffset_), writingModes(writingModes_), line(std::move(line_)), tileDistances(std::move(tileDistances_)), hidden(false), vertexStartIndex(0)
+    {
+    }
     Point<float> anchorPoint;
     uint16_t segment;
     float lowerSize;
     float upperSize;
     std::array<float, 2> lineOffset;
-    float placementZoom;
-    bool useVerticalMode;
+    WritingModeType writingModes;
     GeometryCoordinates line;
+    std::vector<float> tileDistances;
     std::vector<float> glyphOffsets;
+    bool hidden;
+    size_t vertexStartIndex;
 };
 
 class SymbolBucket : public Bucket {
@@ -40,17 +45,33 @@ public:
                  const style::DataDrivenPropertyValue<float>& iconSize,
                  float zoom,
                  bool sdfIcons,
-                 bool iconsNeedLinear);
+                 bool iconsNeedLinear,
+                 bool sortFeaturesByY,
+                 const std::vector<SymbolInstance>&&);
 
     void upload(gl::Context&) override;
     bool hasData() const override;
     bool hasTextData() const;
     bool hasIconData() const;
     bool hasCollisionBoxData() const;
+    bool hasCollisionCircleData() const;
+    
+    void updateOpacity();
+    void sortFeatures(const float angle);
 
     const style::SymbolLayoutProperties::PossiblyEvaluated layout;
     const bool sdfIcons;
     const bool iconsNeedLinear;
+    const bool sortFeaturesByY;
+    
+    optional<float> sortedAngle;
+
+    bool staticUploaded = false;
+    bool placementChangesUploaded = false;
+    bool dynamicUploaded = false;
+    bool sortUploaded = false;
+
+    std::vector<SymbolInstance> symbolInstances;
 
     std::map<std::string, std::pair<
         SymbolIconProgram::PaintPropertyBinders,
@@ -61,12 +82,14 @@ public:
     struct TextBuffer {
         gl::VertexVector<SymbolLayoutVertex> vertices;
         gl::VertexVector<SymbolDynamicLayoutAttributes::Vertex> dynamicVertices;
+        gl::VertexVector<SymbolOpacityAttributes::Vertex> opacityVertices;
         gl::IndexVector<gl::Triangles> triangles;
         SegmentVector<SymbolTextAttributes> segments;
         std::vector<PlacedSymbol> placedSymbols;
 
         optional<gl::VertexBuffer<SymbolLayoutVertex>> vertexBuffer;
         optional<gl::VertexBuffer<SymbolDynamicLayoutAttributes::Vertex>> dynamicVertexBuffer;
+        optional<gl::VertexBuffer<SymbolOpacityAttributes::Vertex>> opacityVertexBuffer;
         optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
     } text;
     
@@ -75,6 +98,7 @@ public:
     struct IconBuffer {
         gl::VertexVector<SymbolLayoutVertex> vertices;
         gl::VertexVector<SymbolDynamicLayoutAttributes::Vertex> dynamicVertices;
+        gl::VertexVector<SymbolOpacityAttributes::Vertex> opacityVertices;
         gl::IndexVector<gl::Triangles> triangles;
         SegmentVector<SymbolIconAttributes> segments;
         std::vector<PlacedSymbol> placedSymbols;
@@ -82,18 +106,30 @@ public:
 
         optional<gl::VertexBuffer<SymbolLayoutVertex>> vertexBuffer;
         optional<gl::VertexBuffer<SymbolDynamicLayoutAttributes::Vertex>> dynamicVertexBuffer;
+        optional<gl::VertexBuffer<SymbolOpacityAttributes::Vertex>> opacityVertexBuffer;
         optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
     } icon;
 
-    struct CollisionBoxBuffer {
-        gl::VertexVector<CollisionBoxVertex> vertices;
-        gl::IndexVector<gl::Lines> lines;
-        SegmentVector<CollisionBoxAttributes> segments;
+    struct CollisionBuffer {
+        gl::VertexVector<CollisionBoxLayoutAttributes::Vertex> vertices;
+        gl::VertexVector<CollisionBoxDynamicAttributes::Vertex> dynamicVertices;
+        SegmentVector<CollisionBoxProgram::Attributes> segments;
 
-        optional<gl::VertexBuffer<CollisionBoxVertex>> vertexBuffer;
-        optional<gl::VertexBuffer<SymbolDynamicLayoutAttributes::Vertex>> dynamicVertexBuffer;
+        optional<gl::VertexBuffer<CollisionBoxLayoutAttributes::Vertex>> vertexBuffer;
+        optional<gl::VertexBuffer<CollisionBoxDynamicAttributes::Vertex>> dynamicVertexBuffer;
+    };
+
+    struct CollisionBoxBuffer : public CollisionBuffer {
+        gl::IndexVector<gl::Lines> lines;
         optional<gl::IndexBuffer<gl::Lines>> indexBuffer;
     } collisionBox;
+    
+    struct CollisionCircleBuffer : public CollisionBuffer {
+        gl::IndexVector<gl::Triangles> triangles;
+        optional<gl::IndexBuffer<gl::Triangles>> indexBuffer;
+    } collisionCircle;
+
+    uint32_t bucketInstanceId = 0;
 };
 
 } // namespace mbgl