Animation system sketch

drape_frontend/animation_system.cpp

@@ -0,0 +1,425 @@
+#include "animation_system.h"
+#include "animation/interpolations.hpp"
+
+namespace df
+{
+
+namespace
+{
+
+double CalcAnimSpeedDuration(double pxDiff, double pxSpeed)
+{
+  double const kEps = 1e-5;
+
+  if (my::AlmostEqualAbs(pxDiff, 0.0, kEps))
+    return 0.0;
+
+  return fabs(pxDiff) / pxSpeed;
+}
+
+}
+
+Interpolator::Interpolator(double duration, double delay)
+  : m_elapsedTime(0.0)
+  , m_duration(duration)
+  , m_delay(delay)
+{
+  ASSERT(m_duration >= 0.0, ());
+}
+
+Interpolator::~Interpolator()
+{
+}
+
+bool Interpolator::IsFinished() const
+{
+  return m_elapsedTime > (m_duration + m_delay);
+}
+
+void Interpolator::Advance(double elapsedSeconds)
+{
+  m_elapsedTime += elapsedSeconds;
+}
+
+void Interpolator::SetMaxDuration(double maxDuration)
+{
+  m_duration = min(m_duration, maxDuration);
+}
+
+double Interpolator::GetT() const
+{
+  if (IsFinished())
+    return 1.0;
+
+  return max(m_elapsedTime - m_delay, 0.0) / m_duration;
+}
+
+double Interpolator::GetElapsedTime() const
+{
+  return m_elapsedTime;
+}
+
+double Interpolator::GetDuration() const
+{
+  return m_duration;
+}
+
+//static
+double PositionInterpolator::GetMoveDuration(m2::PointD const & startPosition, m2::PointD const & endPosition, ScreenBase const & convertor)
+{
+  double const kMinMoveDuration = 0.2;
+  double const kMinSpeedScalar = 0.2;
+  double const kMaxSpeedScalar = 7.0;
+  double const kEps = 1e-5;
+
+  m2::RectD const & dispPxRect = convertor.PixelRect();
+  double const pixelLength = convertor.GtoP(endPosition).Length(convertor.GtoP(startPosition));
+  if (pixelLength < kEps)
+    return 0.0;
+
+  double const minSize = min(dispPxRect.SizeX(), dispPxRect.SizeY());
+  if (pixelLength < kMinSpeedScalar * minSize)
+    return kMinMoveDuration;
+
+  double const pixelSpeed = kMaxSpeedScalar * minSize;
+  return CalcAnimSpeedDuration(pixelLength, pixelSpeed);
+}
+
+PositionInterpolator::PositionInterpolator(m2::PointD const & startPosition, m2::PointD const & endPosition, ScreenBase const & convertor)
+  : PositionInterpolator(0.0 /* delay */, startPosition, endPosition, convertor)
+{
+}
+
+PositionInterpolator::PositionInterpolator(double delay, m2::PointD const & startPosition, m2::PointD const & endPosition, ScreenBase const & convertor)
+  : Interpolator(PositionInterpolator::GetMoveDuration(startPosition, endPosition, convertor), delay)
+  , m_startPosition(startPosition)
+  , m_endPosition(endPosition)
+  , m_position(startPosition)
+{
+
+}
+
+void PositionInterpolator::Advance(double elapsedSeconds)
+{
+  TBase::Advance(elapsedSeconds);
+  InterpolatePoint(m_startPosition, m_endPosition, GetT());
+}
+
+// static
+double AngleInterpolator::GetRotateDuration(double startAngle, double endAngle)
+{
+  return 0.5 * fabs(endAngle - startAngle) / math::pi4;
+}
+
+AngleInterpolator::AngleInterpolator(double startAngle, double endAngle)
+  : AngleInterpolator(0.0 /* delay */, startAngle, endAngle)
+{
+}
+
+AngleInterpolator::AngleInterpolator(double delay, double startAngle, double endAngle)
+  : Interpolator(AngleInterpolator::GetRotateDuration(startAngle, endAngle), delay)
+  , m_startAngle(startAngle)
+  , m_endAngle(endAngle)
+  , m_angle(startAngle)
+{
+}
+
+void AngleInterpolator::Advance(double elapsedSeconds)
+{
+  TBase::Advance(elapsedSeconds);
+  m_angle = InterpolateDouble(m_startAngle, m_endAngle, GetT());
+}
+
+// static
+double ScaleInterpolator::GetScaleDuration(double startScale, double endScale)
+{
+  // Resize 2.0 times should be done for 0.3 seconds.
+  double constexpr kPixelSpeed = 2.0 / 0.3;
+
+  if (startScale > endScale)
+    swap(startScale, endScale);
+
+  return CalcAnimSpeedDuration(endScale / startScale, kPixelSpeed);
+}
+
+ScaleInterpolator::ScaleInterpolator(double startScale, double endScale)
+  : ScaleInterpolator(0.0 /* delay */, startScale, endScale)
+{
+}
+
+ScaleInterpolator::ScaleInterpolator(double delay, double startScale, double endScale)
+  : Interpolator(ScaleInterpolator::GetScaleDuration(startScale, endScale), delay)
+  , m_startScale(startScale)
+  , m_endScale(endScale)
+  , m_scale(startScale)
+{
+}
+
+void ScaleInterpolator::Advance(double elapsedSeconds)
+{
+  TBase::Advance(elapsedSeconds);
+  m_scale = InterpolateDouble(m_startScale, m_endScale, GetT());
+}
+
+FollowAnimation::FollowAnimation(m2::PointD const & startPos, m2::PointD const & endPos,
+                                 double startAngle, double endAngle,
+                                 double startScale, double endScale, ScreenBase const & convertor)
+  : Animation(false, false)
+{
+  SetMove(startPos, endPos, convertor);
+  SetRotate(startAngle, endAngle);
+  SetScale(startScale, endScale);
+}
+
+FollowAnimation::FollowAnimation()
+  : Animation(false, false)
+{
+}
+
+void FollowAnimation::SetMove(m2::PointD const & startPos, m2::PointD const & endPos,
+                              ScreenBase const & convertor)
+{
+  if (startPos != endPos)
+    m_positionInterpolator = make_unique_dp<PositionInterpolator>(startPos, endPos, convertor);
+}
+
+void FollowAnimation::SetRotate(double startAngle, double endAngle)
+{
+  if (startAngle != endAngle)
+    m_angleInterpolator = make_unique_dp<AngleInterpolator>(startAngle, endAngle);
+}
+
+void FollowAnimation::SetScale(double startScale, double endScale)
+{
+  if (startScale != endScale)
+    m_scaleInterpolator = make_unique_dp<ScaleInterpolator>(startScale, endScale);
+}
+
+void FollowAnimation::Advance(double elapsedSeconds)
+{
+  if (m_angleInterpolator != nullptr)
+    m_angleInterpolator->Advance(elapsedSeconds);
+  if (m_scaleInterpolator != nullptr)
+    m_scaleInterpolator->Advance(elapsedSeconds);
+  if (m_positionInterpolator != nullptr)
+    m_positionInterpolator->Advance(elapsedSeconds);
+}
+
+void FollowAnimation::SetMaxDuration(double maxDuration)
+{
+  if (m_angleInterpolator != nullptr)
+    m_angleInterpolator->SetMaxDuration(maxDuration);
+  if (m_scaleInterpolator != nullptr)
+    m_scaleInterpolator->SetMaxDuration(maxDuration);
+  if (m_positionInterpolator != nullptr)
+    m_positionInterpolator->SetMaxDuration(maxDuration);
+}
+
+double FollowAnimation::GetDuration() const
+{
+  double duration = 0;
+  if (m_angleInterpolator != nullptr)
+    duration = m_angleInterpolator->GetDuration();
+  if (m_scaleInterpolator != nullptr)
+    duration = max(duration, m_scaleInterpolator->GetDuration());
+  if (m_positionInterpolator != nullptr)
+    duration = max(duration, m_positionInterpolator->GetDuration());
+  return duration;
+}
+
+bool FollowAnimation::IsFinished() const
+{
+  return ((m_angleInterpolator == nullptr || m_angleInterpolator->IsFinished())
+      && (m_scaleInterpolator == nullptr || m_scaleInterpolator->IsFinished())
+      && (m_positionInterpolator == nullptr || m_positionInterpolator->IsFinished()));
+}
+
+double FollowAnimation::GetScale(uint32_t object) const
+{
+  ASSERT(object & GetObjects(), ());
+  ASSERT(m_scaleInterpolator != nullptr, ());
+
+  if (m_scaleInterpolator != nullptr)
+    return m_scaleInterpolator->GetScale();
+
+  return 0.0;
+}
+
+double FollowAnimation::GetAngle(uint32_t object) const
+{
+  ASSERT(object & GetObjects(), ());
+  ASSERT(m_angleInterpolator != nullptr, ());
+
+  if (m_angleInterpolator != nullptr)
+    return m_angleInterpolator->GetAngle();
+
+  return 0.0;
+}
+
+m2::PointD FollowAnimation::GetPosition(uint32_t object) const
+{
+  ASSERT(object & GetObjects(), ());
+  ASSERT(m_positionInterpolator != nullptr, ());
+
+  if (m_positionInterpolator != nullptr)
+    return m_positionInterpolator->GetPosition();
+
+  return m2::PointD();
+}
+
+uint32_t ParallelAnimation::GetMask(uint32_t object) const
+{
+  int mask = 0;
+  for (auto const & anim : m_animations)
+    mask |= anim->GetMask(object);
+  return mask;
+}
+
+uint32_t ParallelAnimation::GetObjects() const
+{
+  int objects = 0;
+  for (auto const & anim : m_animations)
+    objects |= anim->GetObjects();
+  return objects;
+}
+
+void ParallelAnimation::AddAnimation(ref_ptr<Animation> animation)
+{
+  m_animations.push_back(animation);
+}
+
+void ParallelAnimation::OnStart()
+{
+  for (auto & anim : m_animations)
+    anim->OnStart();
+}
+
+void ParallelAnimation::OnFinish()
+{
+
+}
+
+void ParallelAnimation::Advance(double elapsedSeconds)
+{
+  auto iter = m_animations.begin();
+  while (iter != m_animations.end())
+  {
+    (*iter)->Advance(elapsedSeconds);
+    if ((*iter)->IsFinished())
+    {
+      (*iter)->OnFinish();
+      iter = m_animations.erase(iter);
+    }
+    else
+      ++iter;
+  }
+}
+
+uint32_t SequenceAnimation::GetMask(uint32_t object) const
+{
+  int mask = 0;
+  if (!m_animations.empty())
+    mask = m_animations.front()->GetMask(object);
+  return mask;
+}
+
+uint32_t SequenceAnimation::GetObjects() const
+{
+  int objects = 0;
+  if (!m_animations.empty())
+    objects = m_animations.front()->GetObjects();
+  return objects;
+}
+
+void SequenceAnimation::AddAnimation(ref_ptr<Animation> animation)
+{
+  m_animations.push_back(animation);
+}
+
+void SequenceAnimation::OnStart()
+{
+  if (m_animations.empty())
+    return;
+  m_animations.front()->OnStart();
+}
+
+void SequenceAnimation::OnFinish()
+{
+
+}
+
+void SequenceAnimation::Advance(double elapsedSeconds)
+{
+  if (m_animations.empty())
+    return;
+  m_animations.front()->Advance(elapsedSeconds);
+  if (m_animations.front()->IsFinished())
+  {
+    m_animations.front()->OnFinish();
+    m_animations.pop_front();
+  }
+}
+
+m2::AnyRectD AnimationSystem::GetRect(ScreenBase const & currentScreen)
+{
+  double scale = currentScreen.GetScale();
+  double angle = currentScreen.GetAngle();
+  m2::PointD pos = currentScreen.GlobalRect().GlobalZero();
+  for (auto const & anim : m_animations)
+  {
+    if (anim->GetObjects() & kPlaneAnimObjBit)
+    {
+      int mask = anim->GetMask(kPlaneAnimObjBit);
+      if (mask & kScaleAnimationBit)
+        scale = anim->GetScale(kPlaneAnimObjBit);
+      if (mask & kMoveAnimationBit)
+        pos = anim->GetPosition(kPlaneAnimObjBit);
+      if (mask & kRotateAnimationBit)
+        angle = anim->GetAngle(kPlaneAnimObjBit);
+    }
+  }
+  m2::RectD rect = currentScreen.PixelRect();
+  rect.Offset(-rect.Center());
+  rect.Scale(scale);
+  return m2::AnyRectD(pos, angle, rect);
+}
+
+bool AnimationSystem::AnimationExists(Animation::Object object)
+{
+  for (auto const & anim : m_animations)
+  {
+    if (anim->GetObjects() & (1 << object))
+      return true;
+  }
+  return false;
+}
+
+AnimationSystem & AnimationSystem::Instance()
+{
+  static AnimationSystem animSystem;
+  return animSystem;
+}
+
+void AnimationSystem::AddAnimation(drape_ptr<Animation> && animation)
+{
+  animation->OnStart();
+  m_animations.insert(move(animation));
+}
+
+void AnimationSystem::Advance(double elapsedSeconds)
+{
+  auto iter = m_animations.begin();
+  while (iter != m_animations.end())
+  {
+    (*iter)->Advance(elapsedSeconds);
+    if ((*iter)->IsFinished())
+    {
+      (*iter)->OnFinish();
+      iter = m_animations.erase(iter);
+    }
+    else
+      ++iter;
+  }
+}
+
+} // namespace df

drape_frontend/animation_system.h

@@ -0,0 +1,316 @@
+#pragma once
+
+#include "animation/base_interpolator.hpp"
+
+#include "drape/pointers.hpp"
+
+#include "geometry/screenbase.hpp"
+
+#include "std/deque.hpp"
+#include "std/noncopyable.hpp"
+
+namespace df
+{
+
+uint32_t constexpr kMoveAnimationBit = 1;
+uint32_t constexpr kScaleAnimationBit = 1 << 1;
+uint32_t constexpr kRotateAnimationBit = 1 << 2;
+uint32_t constexpr kPerspectiveAnimationBit = 1 << 3;
+
+uint32_t constexpr kArrowAnimObjBit = 1;
+uint32_t constexpr kPlaneAnimObjBit = 1 << 1;
+uint32_t constexpr kSelectionAnimBit = 1 << 2;
+
+class Animation
+{
+public:
+  enum Type
+  {
+    Sequence,
+    Parallel,
+    ModelView,
+    Perspective,
+    Arrow
+  };
+
+  enum Object
+  {
+    MyPositionArrow,
+    MapPlane,
+    Selection
+  };
+
+  Animation(bool couldBeInterrupted, bool couldBeMixed)
+    : m_couldBeInterrupted(couldBeInterrupted)
+    , m_couldBeMixed(couldBeMixed)
+  {}
+
+  virtual void OnStart() {}
+  virtual void OnFinish() {}
+
+  virtual Type GetType() const = 0;
+
+  virtual uint32_t GetMask(uint32_t object) const = 0;
+  virtual uint32_t GetObjects() const = 0;
+
+  virtual void SetMaxDuration(double maxDuration) = 0;
+  virtual double GetDuration() const = 0;
+  virtual bool IsFinished() const = 0;
+
+  virtual void Advance(double elapsedSeconds) = 0;
+
+  virtual double GetScale(uint32_t object) const = 0;
+  virtual double GetAngle(uint32_t object) const = 0;
+  virtual m2::PointD GetPosition(uint32_t object) const = 0;
+
+  bool CouldBeInterrupted() const { return m_couldBeInterrupted; }
+  bool CouldBeMixed() const { return m_couldBeMixed; }
+  bool CouldBeMixedWith(uint32_t object, int mask)
+  {
+    return m_couldBeMixed && !(mask & GetMask(object));
+  }
+
+protected:
+  bool m_couldBeInterrupted;
+  bool m_couldBeMixed;
+};
+
+class Interpolator
+{
+public:
+  Interpolator(double duration, double delay = 0);
+  virtual ~Interpolator();
+
+  bool IsFinished() const;
+  virtual void Advance(double elapsedSeconds);
+  void SetMaxDuration(double maxDuration);
+  double GetDuration() const;
+
+protected:
+  double GetT() const;
+  double GetElapsedTime() const;
+
+private:
+  double m_elapsedTime;
+  double m_duration;
+  double m_delay;
+};
+
+
+class PositionInterpolator: public Interpolator
+{
+  using TBase = Interpolator;
+
+public:
+  PositionInterpolator(m2::PointD const & startPosition, m2::PointD const & endPosition, ScreenBase const & convertor);
+  PositionInterpolator(double delay, m2::PointD const & startPosition, m2::PointD const & endPosition, ScreenBase const & convertor);
+
+  static double GetMoveDuration(m2::PointD const & startPosition, m2::PointD const & endPosition, ScreenBase const & convertor);
+
+  void Advance(double elapsedSeconds) override;
+  virtual m2::PointD GetPosition() const { return m_position; }
+
+private:
+  m2::PointD m_startPosition;
+  m2::PointD m_endPosition;
+  m2::PointD m_position;
+};
+
+class ScaleInterpolator: public Interpolator
+{
+  using TBase = Interpolator;
+
+public:
+  ScaleInterpolator(double startScale, double endScale);
+  ScaleInterpolator(double delay, double startScale, double endScale);
+
+  static double GetScaleDuration(double startScale, double endScale);
+
+  void Advance(double elapsedSeconds) override;
+  virtual double GetScale() const { return m_scale; }
+
+private:
+  double const m_startScale;
+  double const m_endScale;
+  double m_scale;
+};
+
+class AngleInterpolator: public Interpolator
+{
+  using TBase = Interpolator;
+
+public:
+  AngleInterpolator(double startAngle, double endAngle);
+  AngleInterpolator(double delay, double startAngle, double endAngle);
+
+  static double GetRotateDuration(double startAngle, double endAngle);
+
+  void Advance(double elapsedSeconds) override;
+  virtual double GetAngle() const { return m_angle; }
+
+private:
+  double const m_startAngle;
+  double const m_endAngle;
+  double m_angle;
+};
+
+class ArrowAnimation : public Animation
+{
+public:
+  ArrowAnimation(m2::PointD const & startPos, m2::PointD const & endPos,
+                 double startAngle, double endAngle, ScreenBase const & convertor)
+    : Animation(false, false)
+  {
+    m_positionInterpolator.reset(new PositionInterpolator(startPos, endPos, convertor));
+    m_angleInterpolator.reset(new AngleInterpolator(startAngle, endAngle));
+  }
+
+  Animation::Type GetType() const override { return Animation::Arrow; }
+
+  uint32_t GetMask(uint32_t object) const override
+  {
+    return (object & kArrowAnimObjBit) &&
+        ((m_angleInterpolator != nullptr ? kRotateAnimationBit : 0) |
+        (m_positionInterpolator != nullptr ? kMoveAnimationBit : 0));
+  }
+
+  uint32_t GetObjects() const override
+  {
+     return kArrowAnimObjBit;
+  }
+
+  void Advance(double elapsedSeconds) override;
+
+private:
+  drape_ptr<PositionInterpolator> m_positionInterpolator;
+  drape_ptr<AngleInterpolator> m_angleInterpolator;
+};
+
+class PerspectiveSwitchAnimation : public Animation
+{
+  PerspectiveSwitchAnimation()
+    : Animation(false, false)
+  {}
+
+  Animation::Type GetType() const override { return Animation::Perspective; }
+
+  uint32_t GetMask(uint32_t object) const override
+  {
+    return (object & kPlaneAnimObjBit) &&
+        (m_angleInterpolator != nullptr ? kPerspectiveAnimationBit : 0);
+  }
+
+  uint32_t GetObjects() const override
+  {
+     return kPlaneAnimObjBit;
+  }
+
+  void Advance(double elapsedSeconds) override;
+
+private:
+  drape_ptr<AngleInterpolator> m_angleInterpolator;
+};
+
+class FollowAnimation : public Animation
+{
+public:
+  FollowAnimation(m2::PointD const & startPos, m2::PointD const & endPos,
+                  double startAngle, double endAngle,
+                  double startScale, double endScale, ScreenBase const & convertor);
+  FollowAnimation();
+
+  void SetMove(m2::PointD const & startPos, m2::PointD const & endPos, ScreenBase const & convertor);
+  void SetRotate(double startAngle, double endAngle);
+  void SetScale(double startScale, double endScale);
+
+  Animation::Type GetType() const override { return Animation::ModelView; }
+
+  uint32_t GetMask(uint32_t object) const override
+  {
+    return (object & kPlaneAnimObjBit) ?
+        ((m_angleInterpolator != nullptr ? kPerspectiveAnimationBit : 0) |
+        (m_positionInterpolator != nullptr ? kMoveAnimationBit : 0) |
+        (m_scaleInterpolator != nullptr ? kScaleAnimationBit : 0)) : 0;
+  }
+
+  uint32_t GetObjects() const override
+  {
+     return kPlaneAnimObjBit;
+  }
+
+  void Advance(double elapsedSeconds) override;
+
+  void SetMaxDuration(double maxDuration) override;
+  double GetDuration() const override;
+  bool IsFinished() const override;
+
+  double GetScale(uint32_t object) const override;
+  double GetAngle(uint32_t object) const override;
+  m2::PointD GetPosition(uint32_t object) const override;
+
+private:
+  drape_ptr<AngleInterpolator> m_angleInterpolator;
+  drape_ptr<PositionInterpolator> m_positionInterpolator;
+  drape_ptr<ScaleInterpolator> m_scaleInterpolator;
+};
+
+using TAnimations = vector<ref_ptr<Animation>>;
+
+class SequenceAnimation : public Animation
+{
+public:
+  Animation::Type GetType() const override { return Animation::Sequence; }
+  uint32_t GetMask(uint32_t object) const override;
+  uint32_t GetObjects() const override;
+
+  void AddAnimation(ref_ptr<Animation> animation);
+
+  void OnStart() override;
+  void OnFinish() override;
+
+  void Advance(double elapsedSeconds) override;
+
+private:
+  deque<ref_ptr<Animation>> m_animations;
+};
+
+class ParallelAnimation : public Animation
+{
+public:
+  Animation::Type GetType() const override { return Animation::Parallel; }
+  uint32_t GetMask(uint32_t object) const override;
+  uint32_t GetObjects() const override;
+
+  void AddAnimation(ref_ptr<Animation> animation);
+
+  void OnStart() override;
+  void OnFinish() override;
+
+  void Advance(double elapsedSeconds) override;
+
+private:
+  TAnimations m_animations;
+};
+
+class AnimationSystem : private noncopyable
+{
+public:
+  static AnimationSystem & Instance();
+
+  m2::AnyRectD GetRect(ScreenBase const & currentScreen);
+
+  bool AnimationExists(Animation::Object object);
+
+  void AddAnimation(drape_ptr<Animation> && animation);
+
+  void Advance(double elapsedSeconds);
+
+private:
+  AnimationSystem() {}
+
+private:
+
+  set<drape_ptr<Animation>> m_animations;
+};
+
+}

drape_frontend/drape_frontend.pro

@@ -92,6 +92,7 @@ SOURCES += \
     watch/feature_processor.cpp \
     watch/default_font.cpp \
     batch_merge_helper.cpp \
+    animation_system.cpp
 
 HEADERS += \
     animation/base_interpolator.hpp \
@@ -191,3 +192,4 @@ HEADERS += \
     watch/geometry_processors.hpp \
     watch/feature_processor.hpp \
     batch_merge_helper.hpp \
+    animation_system.h

drape_frontend/frontend_renderer.cpp

@@ -1,5 +1,6 @@
 #include "drape_frontend/animation/interpolation_holder.hpp"
 #include "drape_frontend/gui/drape_gui.hpp"
+#include "drape_frontend/animation_system.h"
 #include "drape_frontend/framebuffer.hpp"
 #include "drape_frontend/frontend_renderer.hpp"
 #include "drape_frontend/message_subclasses.hpp"
@@ -1506,6 +1507,7 @@ void FrontendRenderer::Routine::Do()
     m_renderer.RenderScene(modelView);
 
     isActiveFrame |= InterpolationHolder::Instance().Advance(frameTime);
+    AnimationSystem::Instance().Advance(frameTime);
 
     if (modelViewChanged)
     {

drape_frontend/user_event_stream.cpp

@@ -1,5 +1,6 @@
 #include "drape_frontend/user_event_stream.hpp"
 #include "drape_frontend/animation_constants.hpp"
+#include "drape_frontend/animation_system.h"
 #include "drape_frontend/animation_utils.hpp"
 #include "drape_frontend/visual_params.hpp"
 
@@ -253,6 +254,12 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChange, bool &
     if (m_animation->IsFinished())
       m_animation.reset();
   }
+  if (AnimationSystem::Instance().AnimationExists(Animation::MapPlane))
+  {
+    m2::AnyRectD const rect = AnimationSystem::Instance().GetRect(GetCurrentScreen());
+    m_navigator.SetFromRect(rect);
+    modelViewChange = true;
+  }
 
   if (m_pendingEvent != nullptr &&
       m_pendingEvent->m_type == UserEvent::EVENT_ENABLE_PERSPECTIVE &&
@@ -322,7 +329,25 @@ bool UserEventStream::SetScale(m2::PointD const & pxScaleCenter, double factor,
 
     m2::PointD const offset = GetCurrentScreen().PixelRect().Center() - m_navigator.P3dtoP(scaleCenter);
 
-    auto const creator = [this, &glbScaleCenter, &offset](m2::AnyRectD const & startRect, m2::AnyRectD const & endRect,
+    ScreenBase const & startScreen = GetCurrentScreen();
+    ScreenBase endScreen = startScreen;
+    m_navigator.CalculateScale(scaleCenter, factor, endScreen);
+
+    drape_ptr<FollowAnimation> anim = make_unique_dp<FollowAnimation>();
+    anim->SetScale(startScreen.GetScale(), endScreen.GetScale());
+    anim->SetMove(startScreen.GlobalRect().GlobalZero(),
+                  endScreen.GlobalRect().GlobalZero(), startScreen);
+    anim->SetMaxDuration(kMaxAnimationTimeSec);
+    if (df::IsAnimationAllowed(anim->GetDuration(), startScreen))
+    {
+      AnimationSystem::Instance().AddAnimation(move(anim));
+      return false;
+    }
+
+    m_navigator.SetFromRect(endScreen.GlobalRect());
+    return true;
+
+    /*auto const creator = [this, &glbScaleCenter, &offset](m2::AnyRectD const & startRect, m2::AnyRectD const & endRect,
                                                           double aDuration, double mDuration, double sDuration)
     {
       m_animation.reset(new ScaleAnimation(startRect, endRect, aDuration, mDuration,
@@ -334,7 +359,7 @@ bool UserEventStream::SetScale(m2::PointD const & pxScaleCenter, double factor,
     ScreenBase screen = GetCurrentScreen();
     m_navigator.CalculateScale(scaleCenter, factor, screen);
 
-    return SetRect(screen.GlobalRect(), true, creator);
+    return SetRect(screen.GlobalRect(), true, creator);*/
   }
 
   m_navigator.Scale(scaleCenter, factor);