[core] Let placement transitions use the transition duration, if set,…

… and allow disabling them entirely

include/mbgl/style/transition_options.hpp

@@ -10,16 +10,20 @@ class TransitionOptions {
 public:
     optional<Duration> duration;
     optional<Duration> delay;
+    bool enablePlacementTransitions;
 
     TransitionOptions(optional<Duration> duration_ = {},
-                      optional<Duration> delay_ = {})
+                      optional<Duration> delay_ = {},
+                      bool enablePlacementTransitions_ = true)
         : duration(std::move(duration_)),
-          delay(std::move(delay_)) {}
+          delay(std::move(delay_)),
+          enablePlacementTransitions(enablePlacementTransitions_) {}
 
     TransitionOptions reverseMerge(const TransitionOptions& defaults) const {
         return {
             duration ? duration : defaults.duration,
-            delay ? delay : defaults.delay
+            delay ? delay : defaults.delay,
+            enablePlacementTransitions
         };
     }
 

src/mbgl/renderer/renderer_impl.cpp

@@ -61,7 +61,7 @@ Renderer::Impl::Impl(RendererBackend& backend_,
     , sourceImpls(makeMutable<std::vector<Immutable<style::Source::Impl>>>())
     , layerImpls(makeMutable<std::vector<Immutable<style::Layer::Impl>>>())
     , renderLight(makeMutable<Light::Impl>())
-    , placement(std::make_unique<Placement>(TransformState{}, MapMode::Static, true)) {
+    , placement(std::make_unique<Placement>(TransformState{}, MapMode::Static, TransitionOptions{}, true)) {
     glyphManager->setObserver(this);
 }
 
@@ -405,7 +405,7 @@ void Renderer::Impl::render(const UpdateParameters& updateParameters) {
     if (!placement->stillRecent(parameters.timePoint)) {
         placementChanged = true;
 
-        auto newPlacement = std::make_unique<Placement>(parameters.state, parameters.mapMode, updateParameters.crossSourceCollisions);
+        auto newPlacement = std::make_unique<Placement>(parameters.state, parameters.mapMode, updateParameters.transitionOptions, updateParameters.crossSourceCollisions);
         std::set<std::string> usedSymbolLayers;
         for (auto it = order.rbegin(); it != order.rend(); ++it) {
             if (it->layer.is<RenderSymbolLayer>()) {

src/mbgl/text/placement.cpp

@@ -55,10 +55,11 @@ const CollisionGroups::CollisionGroup& CollisionGroups::get(const std::string& s
     }
 }
 
-Placement::Placement(const TransformState& state_, MapMode mapMode_, const bool crossSourceCollisions)
+Placement::Placement(const TransformState& state_, MapMode mapMode_, style::TransitionOptions transitionOptions_, const bool crossSourceCollisions)
     : collisionIndex(state_)
     , state(state_)
     , mapMode(mapMode_)
+    , transitionOptions(transitionOptions_)
     , collisionGroups(crossSourceCollisions)
 {}
 
@@ -244,8 +245,8 @@ void Placement::commit(const Placement& prevPlacement, TimePoint now) {
 
     bool placementChanged = false;
 
-    float increment = mapMode == MapMode::Continuous ?
-        std::chrono::duration<float>(commitTime - prevPlacement.commitTime) / Duration(std::chrono::milliseconds(300)) :
+    float increment = mapMode == MapMode::Continuous && transitionOptions.enablePlacementTransitions ?
+        std::chrono::duration<float>(commitTime - prevPlacement.commitTime) / transitionOptions.duration.value_or(util::DEFAULT_TRANSITION_DURATION) :
         1.0;
 
     // add the opacities from the current placement, and copy their current values from the previous placement
@@ -404,23 +405,25 @@ void Placement::updateBucketOpacities(SymbolBucket& bucket, std::set<uint32_t>&
 }
 
 float Placement::symbolFadeChange(TimePoint now) const {
-    if (mapMode == MapMode::Continuous) {
-        return std::chrono::duration<float>(now - commitTime) / Duration(std::chrono::milliseconds(300));
+    if (mapMode == MapMode::Continuous && transitionOptions.enablePlacementTransitions) {
+        return std::chrono::duration<float>(now - commitTime) / transitionOptions.duration.value_or(util::DEFAULT_TRANSITION_DURATION);
     } else {
         return 1.0;
     }
 }
 
 bool Placement::hasTransitions(TimePoint now) const {
-    if (mapMode == MapMode::Continuous) {
-        return stale || std::chrono::duration<float>(now - fadeStartTime) < Duration(std::chrono::milliseconds(300));
+    if (mapMode == MapMode::Continuous && transitionOptions.enablePlacementTransitions) {
+        return stale || std::chrono::duration<float>(now - fadeStartTime) < transitionOptions.duration.value_or(util::DEFAULT_TRANSITION_DURATION);
     } else {
         return false;
     }
 }
 
 bool Placement::stillRecent(TimePoint now) const {
-    return mapMode == MapMode::Continuous && commitTime + Duration(std::chrono::milliseconds(300)) > now;
+    return mapMode == MapMode::Continuous &&
+        transitionOptions.enablePlacementTransitions &&
+        commitTime + transitionOptions.duration.value_or(util::DEFAULT_TRANSITION_DURATION) > now;
 }
 
 void Placement::setStale() {

src/mbgl/text/placement.hpp

@@ -5,6 +5,7 @@
 #include <mbgl/util/chrono.hpp>
 #include <mbgl/text/collision_index.hpp>
 #include <mbgl/layout/symbol_projection.hpp>
+#include <mbgl/style/transition_options.hpp>
 #include <unordered_set>
 
 namespace mbgl {
@@ -79,7 +80,7 @@ class CollisionGroups {
 
 class Placement {
 public:
-    Placement(const TransformState&, MapMode mapMode, const bool crossSourceCollisions);
+    Placement(const TransformState&, MapMode, style::TransitionOptions, const bool crossSourceCollisions);
     void placeLayer(RenderSymbolLayer&, const mat4&, bool showCollisionBoxes);
     void commit(const Placement& prevPlacement, TimePoint);
     void updateLayerOpacities(RenderSymbolLayer&);
@@ -113,6 +114,8 @@ class Placement {
 
     TransformState state;
     MapMode mapMode;
+    style::TransitionOptions transitionOptions;
+
     TimePoint fadeStartTime;
     TimePoint commitTime;