keep rendering until labels fade in [skip ci]

4 files changed, 52 insertions, 43 deletions

diff --git a/src/mbgl/renderer/renderer_impl.cpp b/src/mbgl/renderer/renderer_impl.cpp
index 7fcb3c6a3b..ca4bda721f 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{})) {
     glyphManager->setObserver(this);
 }
 
@@ -371,8 +372,9 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         }
     }
 
-    newPlacement->commit(std::move(placement), parameters.timePoint);
-    placement = std::move(newPlacement);
+    const bool placementChanged = newPlacement->commit(*placement, parameters.timePoint);
+    if (placementChanged) placement = std::move(newPlacement);
+    parameters.symbolFadeChange = placement->symbolFadeChange(parameters.timePoint);
 
     // - UPLOAD PASS -------------------------------------------------------------------------------
     // Uploads all required buffers and images before we do any actual rendering.
@@ -390,12 +392,14 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
         }
     }
 
+    // TODO only update when necessary
+    // TODO move this before the upload pass and use upload pass to update buffers
     for (auto it = order.rbegin(); it != order.rend(); ++it) {
         if (it->layer.is<RenderSymbolLayer>()) {
             placement->updateLayerOpacities(*it->layer.as<RenderSymbolLayer>(), parameters.context);
         }
     }
-   
+
     // - 3D PASS -------------------------------------------------------------------------------------
     // Renders any 3D layers bottom-to-top to unique FBOs with texture attachments, but share the same
     // depth rbo between them.
@@ -593,7 +597,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
 
     observer->onDidFinishRenderingFrame(
         loaded ? RendererObserver::RenderMode::Full : RendererObserver::RenderMode::Partial,
-        updateParameters.mode == MapMode::Continuous && (hasTransitions())
+        updateParameters.mode == MapMode::Continuous && (hasTransitions(parameters.timePoint))
     );
 
     if (!loaded) {
@@ -694,7 +698,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;
     }
@@ -705,6 +709,10 @@ bool Renderer::Impl::hasTransitions() const {
         }
     }
 
+    if (placement->hasTransitions(timePoint)) {
+        return true;
+    }
+
     return false;
 }
 
diff --git a/src/mbgl/renderer/renderer_impl.hpp b/src/mbgl/renderer/renderer_impl.hpp
index 836f573abe..e0252e748d 100644
--- a/src/mbgl/renderer/renderer_impl.hpp
+++ b/src/mbgl/renderer/renderer_impl.hpp
@@ -55,7 +55,7 @@ public:
 
 private:
     bool isLoaded() const;
-    bool hasTransitions() const;
+    bool hasTransitions(TimePoint) const;
 
     RenderSource* getRenderSource(const std::string& id) const;
 
diff --git a/src/mbgl/text/placement.cpp b/src/mbgl/text/placement.cpp
index a80966a9c2..0d428513c0 100644
--- a/src/mbgl/text/placement.cpp
+++ b/src/mbgl/text/placement.cpp
@@ -10,7 +10,7 @@ namespace mbgl {
 
 OpacityState::OpacityState(bool placed_) : opacity(0), placed(placed_) {}
 
-OpacityState::OpacityState(OpacityState& prevState, float increment, bool placed_) :
+OpacityState::OpacityState(const OpacityState& prevState, float increment, bool placed_) :
     opacity(std::fmax(0, std::fmin(1, prevState.opacity + (prevState.placed ? increment : -increment)))),
     placed(placed_) {}
 
@@ -22,7 +22,7 @@ JointOpacityState::JointOpacityState(bool placedIcon, bool placedText) :
     icon(OpacityState(placedIcon)),
     text(OpacityState(placedText)) {}
 
-JointOpacityState::JointOpacityState(JointOpacityState& prevOpacityState, float increment, bool placedIcon, bool placedText) :
+JointOpacityState::JointOpacityState(const JointOpacityState& prevOpacityState, float increment, bool placedIcon, bool placedText) :
     icon(OpacityState(prevOpacityState.icon, increment, placedIcon)),
     text(OpacityState(prevOpacityState.text, increment, placedText)) {}
 
@@ -152,44 +152,35 @@ void Placement::placeLayerBucket(
     } 
 }
 
-bool Placement::commit(std::unique_ptr<Placement> prevPlacement, TimePoint now) {
+bool Placement::commit(const Placement& prevPlacement, TimePoint now) {
     commitTime = now;
 
     bool placementChanged = false;
 
-    if (!prevPlacement) {
-        // First time doing placement. Fade in all labels from 0.
-        for (auto& placementPair : placements) {
+    float increment = std::chrono::duration<float>(commitTime - prevPlacement.commitTime) / Duration(std::chrono::milliseconds(300));
+
+    if (increment) {}
+    // add the opacities from the current placement, and copy their current values from the previous placement
+    for (auto& placementPair : placements) {
+        auto prevOpacity = prevPlacement.opacities.find(placementPair.first);
+        if (prevOpacity != prevPlacement.opacities.end()) {
+            opacities.emplace(placementPair.first, JointOpacityState(prevOpacity->second, increment, placementPair.second.icon, placementPair.second.text));
+            placementChanged = placementChanged ||
+                placementPair.second.icon != prevOpacity->second.icon.placed ||
+                placementPair.second.text != prevOpacity->second.text.placed;
+        } else {
             opacities.emplace(placementPair.first, JointOpacityState(placementPair.second.icon, placementPair.second.text));
+            placementChanged = placementChanged || placementPair.second.icon || placementPair.second.text;
         }
-        placementChanged = true;
-
-    } else {
-        float increment = std::chrono::duration<float>(commitTime - prevPlacement->commitTime) / Duration(std::chrono::milliseconds(300));
-
-        if (increment) {}
-        // add the opacities from the current placement, and copy their current values from the previous placement
-        for (auto& placementPair : placements) {
-            auto prevOpacity = prevPlacement->opacities.find(placementPair.first);
-            if (prevOpacity != prevPlacement->opacities.end()) {
-                opacities.emplace(placementPair.first, JointOpacityState(prevOpacity->second, increment, placementPair.second.icon, placementPair.second.text));
-                placementChanged = placementChanged ||
-                    placementPair.second.icon != prevOpacity->second.icon.placed ||
-                    placementPair.second.text != prevOpacity->second.text.placed;
-            } else {
-                opacities.emplace(placementPair.first, JointOpacityState(placementPair.second.icon, placementPair.second.text));
-                placementChanged = true;
-            }
-        }
+    }
 
-        // copy and update values from the previous placement that aren't in the current placement but haven't finished fading
-        for (auto& prevOpacity : prevPlacement->opacities) {
-            if (opacities.find(prevOpacity.first) != opacities.end()) {
-                JointOpacityState jointOpacity(prevOpacity.second, increment, false, false);
-                if (!jointOpacity.isHidden()) {
-                    opacities.emplace(prevOpacity.first, jointOpacity);
-                    placementChanged = placementChanged || prevOpacity.second.icon.placed || prevOpacity.second.text.placed;
-                }
+    // copy and update values from the previous placement that aren't in the current placement but haven't finished fading
+    for (auto& prevOpacity : prevPlacement.opacities) {
+        if (opacities.find(prevOpacity.first) == opacities.end()) {
+            JointOpacityState jointOpacity(prevOpacity.second, increment, false, false);
+            if (!jointOpacity.isHidden()) {
+                opacities.emplace(prevOpacity.first, jointOpacity);
+                placementChanged = placementChanged || prevOpacity.second.icon.placed || prevOpacity.second.text.placed;
             }
         }
     }
@@ -276,4 +267,12 @@ JointOpacityState Placement::getOpacity(uint32_t crossTileSymbolID) const {
 
 }
 
+float Placement::symbolFadeChange(TimePoint now) const {
+    return std::chrono::duration<float>(now - commitTime) / Duration(std::chrono::milliseconds(300));
+}
+
+bool Placement::hasTransitions(TimePoint now) const {
+    return symbolFadeChange(now) < 1.0;
+}
+
 } // namespace mbgl
diff --git a/src/mbgl/text/placement.hpp b/src/mbgl/text/placement.hpp
index 42bab912b3..1fbd71caf5 100644
--- a/src/mbgl/text/placement.hpp
+++ b/src/mbgl/text/placement.hpp
@@ -14,7 +14,7 @@ namespace mbgl {
     class OpacityState {
         public:
             OpacityState(bool placed);
-            OpacityState(OpacityState& prevOpacityState, float increment, bool placed);
+            OpacityState(const OpacityState& prevOpacityState, float increment, bool placed);
             bool isHidden() const;
             float opacity;
             bool placed;
@@ -23,7 +23,7 @@ namespace mbgl {
     class JointOpacityState {
         public:
             JointOpacityState(bool placedIcon, bool placedText);
-            JointOpacityState(JointOpacityState& prevOpacityState, float increment, bool placedIcon, bool placedText);
+            JointOpacityState(const JointOpacityState& prevOpacityState, float increment, bool placedIcon, bool placedText);
             bool isHidden() const;
             OpacityState icon;
             OpacityState text;
@@ -40,9 +40,11 @@ namespace mbgl {
         public:
             Placement(const TransformState&);
             void placeLayer(RenderSymbolLayer&, bool showCollisionBoxes);
-            bool commit(std::unique_ptr<Placement> prevPlacement, TimePoint);
+            bool commit(const Placement& prevPlacement, TimePoint);
             void updateLayerOpacities(RenderSymbolLayer&, gl::Context&);
             JointOpacityState getOpacity(uint32_t crossTileSymbolID) const;
+            float symbolFadeChange(TimePoint now) const;
+            bool hasTransitions(TimePoint now) const;
 
         private: