add (disabled) ability to remove old buckets from crosstilesymbolindex

3 files changed, 41 insertions, 62 deletions

diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 2801fb5d90..d96215a550 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -366,9 +366,10 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         order.emplace_back(RenderItem { *layer, source });
     }
 
+    bool symbolBucketsChanged = false;
     for (auto it = order.rbegin(); it != order.rend(); ++it) {
         if (it->layer.is<RenderSymbolLayer>()) {
-            crossTileSymbolIndex->addLayer(*it->layer.as<RenderSymbolLayer>());
+            if (crossTileSymbolIndex->addLayer(*it->layer.as<RenderSymbolLayer>())) symbolBucketsChanged = true;
         }
     }
 
@@ -383,10 +384,11 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     if (placementChanged) placement = std::move(newPlacement);
     parameters.symbolFadeChange = placement->symbolFadeChange(parameters.timePoint);
 
-    // TODO only update when necessary
-    for (auto it = order.rbegin(); it != order.rend(); ++it) {
-        if (it->layer.is<RenderSymbolLayer>()) {
-            placement->updateLayerOpacities(*it->layer.as<RenderSymbolLayer>());
+    if (placementChanged || symbolBucketsChanged) {
+        for (auto it = order.rbegin(); it != order.rend(); ++it) {
+            if (it->layer.is<RenderSymbolLayer>()) {
+                placement->updateLayerOpacities(*it->layer.as<RenderSymbolLayer>());
+            }
         }
     }
 
diff --git a/src/mbgl/text/cross_tile_symbol_index.cpp b/src/mbgl/text/cross_tile_symbol_index.cpp
index 316c3505dc..fc94ed3501 100644
--- a/src/mbgl/text/cross_tile_symbol_index.cpp
+++ b/src/mbgl/text/cross_tile_symbol_index.cpp
@@ -7,8 +7,8 @@
 namespace mbgl {
 
 
-TileLayerIndex::TileLayerIndex(OverscaledTileID coord_, std::vector<SymbolInstance>& symbolInstances) 
-    : coord(coord_) {
+TileLayerIndex::TileLayerIndex(OverscaledTileID coord_, std::vector<SymbolInstance>& symbolInstances, uint32_t bucketInstanceId_) 
+    : coord(coord_), bucketInstanceId(bucketInstanceId_) {
         for (SymbolInstance& symbolInstance : symbolInstances) {
             if (symbolInstance.insideTileBoundaries) {
                 indexedSymbolInstances[symbolInstance.key].emplace_back(symbolInstance.crossTileID, getScaledCoordinates(symbolInstance, coord));
@@ -100,75 +100,49 @@ void CrossTileSymbolLayerIndex::addBucket(const OverscaledTileID& coord, SymbolB
         }
     }
 
-    TileLayerIndex tileIndex(coord, bucket.symbolInstances);
-    indexes[coord.overscaledZ].emplace(coord, std::move(tileIndex));
+    indexes[coord.overscaledZ].emplace(coord, TileLayerIndex(coord, bucket.symbolInstances, bucket.bucketInstanceId));
 }
 
-/*
-void CrossTileSymbolLayerIndex::removeTile(const OverscaledTileID& coord) {
-	
-	auto removedIndex = indexes.at(coord.overscaledZ).at(coord);
-
-    uint8_t minZoom = 25;
-    for (auto& it : indexes) {
-        auto z = it.first;
-        minZoom = std::min(minZoom, z);
-    }
-
-    for (auto z = coord.overscaledZ - 1; z >= minZoom; z--) {
-        auto parentCoord = coord.scaledTo(z);
-        auto zoomIndexes = indexes.find(z);
-        if (zoomIndexes != indexes.end()) {
-            auto parentIndex = zoomIndexes->second.find(parentCoord);
-            if (parentIndex != zoomIndexes->second.end()) {
-                unblockLabels(removedIndex, parentIndex->second);
+bool CrossTileSymbolLayerIndex::removeStaleBuckets(const std::unordered_set<uint32_t>& currentIDs) {
+    bool tilesChanged = false;
+    for (auto& zoomIndexes : indexes) {
+        for (auto it = zoomIndexes.second.begin(); it != zoomIndexes.second.end();) {
+            // TODO remove false condition when pyramid flickering is fixed
+            if (false && !currentIDs.count(it->second.bucketInstanceId)) {
+                it = zoomIndexes.second.erase(it);
+                tilesChanged = true;
+            } else {
+                ++it;
             }
         }
     }
-
-    indexes.at(coord.overscaledZ).erase(coord);
-    if (indexes.at(coord.overscaledZ).size() == 0) {
-        indexes.erase(coord.overscaledZ);
-    }
+    return tilesChanged;
 }
-*/
 
 CrossTileSymbolIndex::CrossTileSymbolIndex() {}
 
-void CrossTileSymbolIndex::addLayer(RenderSymbolLayer& symbolLayer) {
+bool CrossTileSymbolIndex::addLayer(RenderSymbolLayer& symbolLayer) {
 
     auto& layerIndex = layerIndexes[symbolLayer.getID()];
 
-     for (RenderTile& renderTile : symbolLayer.renderTiles) {
-         if (!renderTile.tile.isRenderable()) {
-             continue;
-         }
-
-
+    bool symbolBucketsChanged = false;
+    std::unordered_set<uint32_t> currentBucketIDs;
 
-         auto bucket = renderTile.tile.getBucket(*symbolLayer.baseImpl);
-         assert(dynamic_cast<SymbolBucket*>(bucket));
-         SymbolBucket& symbolBucket = *reinterpret_cast<SymbolBucket*>(bucket);
+    for (RenderTile& renderTile : symbolLayer.renderTiles) {
+        if (!renderTile.tile.isRenderable()) {
+            continue;
+        }
 
-         layerIndex.addBucket(renderTile.tile.id, symbolBucket);
-     }
-}
+        auto bucket = renderTile.tile.getBucket(*symbolLayer.baseImpl);
+        assert(dynamic_cast<SymbolBucket*>(bucket));
+        SymbolBucket& symbolBucket = *reinterpret_cast<SymbolBucket*>(bucket);
 
-/*
-void CrossTileSymbolIndex::addTileLayer(std::string& layerId, const OverscaledTileID& coord, std::shared_ptr<std::vector<SymbolInstance>> symbolInstances) {
-    if (layerIndexes.find(layerId) == layerIndexes.end()) {
-        layerIndexes.emplace(layerId, CrossTileSymbolLayerIndex());
+        if (!symbolBucket.bucketInstanceId) symbolBucketsChanged = true;
+        layerIndex.addBucket(renderTile.tile.id, symbolBucket);
+        currentBucketIDs.insert(symbolBucket.bucketInstanceId);
     }
 
-    CrossTileSymbolLayerIndex& layerIndex = layerIndexes.at(layerId);
-    layerIndex.addTile(coord, symbolInstances);
-}
-
-void CrossTileSymbolIndex::removeTileLayer(std::string& layerId, const OverscaledTileID& coord) {
-    auto it = layerIndexes.find(layerId);
-    if (it != layerIndexes.end()) {
-        it->second.removeTile(coord);
-    }
+    if (layerIndex.removeStaleBuckets(currentBucketIDs)) symbolBucketsChanged = true;
+    return symbolBucketsChanged;
 }
-*/
 } // namespace mbgl
diff --git a/src/mbgl/text/cross_tile_symbol_index.hpp b/src/mbgl/text/cross_tile_symbol_index.hpp
index 187149429b..e2bb5c66a8 100644
--- a/src/mbgl/text/cross_tile_symbol_index.hpp
+++ b/src/mbgl/text/cross_tile_symbol_index.hpp
@@ -9,6 +9,7 @@
 #include <vector>
 #include <string>
 #include <memory>
+#include <unordered_set>
 
 namespace mbgl {
 
@@ -31,12 +32,13 @@ class IndexedSymbolInstance {
 
 class TileLayerIndex {
     public:
-        TileLayerIndex(OverscaledTileID coord, std::vector<SymbolInstance>&);
+        TileLayerIndex(OverscaledTileID coord, std::vector<SymbolInstance>&, uint32_t bucketInstanceId);
 
         Point<double> getScaledCoordinates(SymbolInstance&, const OverscaledTileID&);
         void findMatches(std::vector<SymbolInstance>&, const OverscaledTileID&);
         
         OverscaledTileID coord;
+        uint32_t bucketInstanceId;
         std::map<std::u16string,std::vector<IndexedSymbolInstance>> indexedSymbolInstances;
 };
 
@@ -44,6 +46,7 @@ class CrossTileSymbolLayerIndex {
     public:
         CrossTileSymbolLayerIndex();
         void addBucket(const OverscaledTileID&, SymbolBucket&);
+        bool removeStaleBuckets(const std::unordered_set<uint32_t>& currentIDs);
     private:
         std::map<uint8_t,std::map<OverscaledTileID,TileLayerIndex>> indexes;
         uint32_t maxBucketInstanceId = 0;
@@ -54,7 +57,7 @@ class CrossTileSymbolIndex {
     public:
         CrossTileSymbolIndex();
 
-        void addLayer(RenderSymbolLayer&);
+        bool addLayer(RenderSymbolLayer&);
     private:
         std::map<std::string,CrossTileSymbolLayerIndex> layerIndexes;
 };