1 files changed, 77 insertions, 37 deletions

diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 5987e69374..aa138df662 100644
--- a/src/mbgl/renderer/renderer_impl.cpp
+++ b/src/mbgl/renderer/renderer_impl.cpp
@@ -56,7 +56,8 @@ Renderer::Impl::Impl(RendererBackend& backend_,
     , imageImpls(makeMutable<std::vector<Immutable<style::Image::Impl>>>())
     , sourceImpls(makeMutable<std::vector<Immutable<style::Source::Impl>>>())
     , layerImpls(makeMutable<std::vector<Immutable<style::Layer::Impl>>>())
-    , renderLight(makeMutable<Light::Impl>()) {
+    , renderLight(makeMutable<Light::Impl>())
+    , placement(std::make_unique<Placement>(TransformState{}, MapMode::Static)) {
     glyphManager->setObserver(this);
 }
 
@@ -80,7 +81,7 @@ void Renderer::Impl::setObserver(RendererObserver* observer_) {
 }
 
 void Renderer::Impl::render(const UpdateParameters& updateParameters) {
-    if (updateParameters.mode == MapMode::Still) {
+    if (updateParameters.mode != MapMode::Continuous) {
         // Don't load/render anyting in still mode until explicitly requested.
         if (!updateParameters.stillImageRequest) {
             return;
@@ -252,13 +253,12 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         updateParameters,
         renderLight.getEvaluated(),
         *staticData,
-        frameHistory,
         *imageManager,
         *lineAtlas
     };
 
     bool loaded = updateParameters.styleLoaded && isLoaded();
-    if (updateParameters.mode == MapMode::Still && !loaded) {
+    if (updateParameters.mode != MapMode::Continuous && !loaded) {
         return;
     }
 
@@ -334,11 +334,15 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
                 auto par = util::rotate(pa, parameters.state.getAngle());
                 auto pbr = util::rotate(pb, parameters.state.getAngle());
 
-                return std::tie(par.y, par.x) < std::tie(pbr.y, pbr.x);
+                return std::tie(b.id.canonical.z, par.y, par.x) < std::tie(a.id.canonical.z, pbr.y, pbr.x);
             });
         } else {
             std::sort(sortedTiles.begin(), sortedTiles.end(),
                       [](const auto& a, const auto& b) { return a.get().id < b.get().id; });
+            // Don't render non-symbol layers for tiles that we're only holding on to for symbol fading
+            sortedTiles.erase(std::remove_if(sortedTiles.begin(), sortedTiles.end(),
+                                             [](const auto& tile) { return tile.get().tile.holdForFade(); }),
+                              sortedTiles.end());
         }
 
         std::vector<std::reference_wrapper<RenderTile>> sortedTilesForInsertion;
@@ -348,35 +352,13 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
                 continue;
             }
 
-            // We're not clipping symbol layers, so when we have both parents and children of symbol
-            // layers, we drop all children in favor of their parent to avoid duplicate labels.
-            // See https://github.com/mapbox/mapbox-gl-native/issues/2482
-            if (symbolLayer) {
-                bool skip = false;
-                // Look back through the buckets we decided to render to find out whether there is
-                // already a bucket from this layer that is a parent of this tile. Tiles are ordered
-                // by zoom level when we obtain them from getTiles().
-                for (auto it = sortedTilesForInsertion.rbegin();
-                     it != sortedTilesForInsertion.rend(); ++it) {
-                    if (tile.tile.id.isChildOf(it->get().tile.id)) {
-                        skip = true;
-                        break;
-                    }
-                }
-                if (skip) {
-                    continue;
-                }
-            }
-
             auto bucket = tile.tile.getBucket(*layer->baseImpl);
             if (bucket) {
                 sortedTilesForInsertion.emplace_back(tile);
                 tile.used = true;
 
-                // We only need clipping when we're _not_ drawing a symbol layer. The only exception
-                // for symbol layers is when we're rendering still images. See render_symbol_layer.cpp
-                // for the exception we make there.
-                if (!symbolLayer || parameters.mapMode == MapMode::Still) {
+                // We only need clipping when we're _not_ drawing a symbol layer.
+                if (!symbolLayer) {
                     tile.needsClipping = true;
                 }
             }
@@ -385,9 +367,47 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         order.emplace_back(RenderItem { *layer, source });
     }
 
-    frameHistory.record(parameters.timePoint,
-                        parameters.state.getZoom(),
-                        parameters.mapMode == MapMode::Continuous ? util::DEFAULT_TRANSITION_DURATION : Milliseconds(0));
+    bool symbolBucketsChanged = false;
+    if (parameters.mapMode != MapMode::Continuous) {
+        // TODO: Think about right way for symbol index to handle still rendering
+        crossTileSymbolIndex.reset();
+    }
+    for (auto it = order.rbegin(); it != order.rend(); ++it) {
+        if (it->layer.is<RenderSymbolLayer>()) {
+            if (crossTileSymbolIndex.addLayer(*it->layer.as<RenderSymbolLayer>())) symbolBucketsChanged = true;
+        }
+    }
+
+    bool placementChanged = false;
+    if (!placement->stillRecent(parameters.timePoint)) {
+        auto newPlacement = std::make_unique<Placement>(parameters.state, parameters.mapMode);
+        for (auto it = order.rbegin(); it != order.rend(); ++it) {
+            if (it->layer.is<RenderSymbolLayer>()) {
+                newPlacement->placeLayer(*it->layer.as<RenderSymbolLayer>(), parameters.projMatrix, parameters.debugOptions & MapDebugOptions::Collision);
+            }
+        }
+
+        placementChanged = newPlacement->commit(*placement, parameters.timePoint);
+        if (placementChanged || symbolBucketsChanged) {
+            placement = std::move(newPlacement);
+        }
+
+        placement->setRecent(parameters.timePoint);
+        
+        updateFadingTiles();
+    } else {
+        placement->setStale();
+    }
+
+    parameters.symbolFadeChange = placement->symbolFadeChange(parameters.timePoint);
+
+    if (placementChanged || symbolBucketsChanged) {
+        for (auto it = order.rbegin(); it != order.rend(); ++it) {
+            if (it->layer.is<RenderSymbolLayer>()) {
+                placement->updateLayerOpacities(*it->layer.as<RenderSymbolLayer>());
+            }
+        }
+    }
 
     // - UPLOAD PASS -------------------------------------------------------------------------------
     // Uploads all required buffers and images before we do any actual rendering.
@@ -396,8 +416,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
         parameters.imageManager.upload(parameters.context, 0);
         parameters.lineAtlas.upload(parameters.context, 0);
-        parameters.frameHistory.upload(parameters.context, 0);
-
+        
         // Update all clipping IDs + upload buckets.
         for (const auto& entry : renderSources) {
             if (entry.second->isEnabled()) {
@@ -607,7 +626,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
     observer->onDidFinishRenderingFrame(
         loaded ? RendererObserver::RenderMode::Full : RendererObserver::RenderMode::Partial,
-        updateParameters.mode == MapMode::Continuous && (hasTransitions() || frameHistory.needsAnimation(util::DEFAULT_TRANSITION_DURATION))
+        updateParameters.mode == MapMode::Continuous && hasTransitions(parameters.timePoint)
     );
 
     if (!loaded) {
@@ -647,7 +666,7 @@ std::vector<Feature> Renderer::Impl::queryRenderedFeatures(const ScreenLineStrin
     std::unordered_map<std::string, std::vector<Feature>> resultsByLayer;
     for (const auto& sourceID : sourceIDs) {
         if (RenderSource* renderSource = getRenderSource(sourceID)) {
-            auto sourceResults = renderSource->queryRenderedFeatures(geometry, transformState, layers, options);
+            auto sourceResults = renderSource->queryRenderedFeatures(geometry, transformState, layers, options, placement->getCollisionIndex());
             std::move(sourceResults.begin(), sourceResults.end(), std::inserter(resultsByLayer, resultsByLayer.begin()));
         }
     }
@@ -727,7 +746,7 @@ RenderSource* Renderer::Impl::getRenderSource(const std::string& id) const {
     return it != renderSources.end() ? it->second.get() : nullptr;
 }
 
-bool Renderer::Impl::hasTransitions() const {
+bool Renderer::Impl::hasTransitions(TimePoint timePoint) const {
     if (renderLight.hasTransition()) {
         return true;
     }
@@ -738,9 +757,30 @@ bool Renderer::Impl::hasTransitions() const {
         }
     }
 
+    if (placement->hasTransitions(timePoint)) {
+        return true;
+    }
+    
+    if (fadingTiles) {
+        return true;
+    }
+
     return false;
 }
 
+void Renderer::Impl::updateFadingTiles() {
+    fadingTiles = false;
+    for (auto& source : renderSources) {
+        for (auto& renderTile : source.second->getRenderTiles()) {
+            Tile& tile = renderTile.get().tile;
+            if (tile.holdForFade()) {
+                fadingTiles = true;
+                tile.performedFadePlacement();
+            }
+        }
+    }
+}
+
 bool Renderer::Impl::isLoaded() const {
     for (const auto& entry: renderSources) {
         if (!entry.second->isLoaded()) {