AndrewShkrob/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Perspective animation refactoring.

Browse source
This commit is contained in:
Daria Volvenkova 2016-04-21 23:08:52 +03:00 • committed by r.kuznetsov
parent 621f187fe6
commit c239c29805
5 changed files with 235 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

158
drape_frontend/animation_system.cpp
View file

@ -364,7 +364,7 @@ bool MapLinearAnimation::IsFinished() const
&& (m_positionInterpolator == nullptr || m_positionInterpolator->IsFinished()));
}
Animation::PropertyValue MapLinearAnimation::GetProperty(TObject object, TProperty property) const
bool MapLinearAnimation::GetProperty(TObject object, TProperty property, PropertyValue & value) const
{
ASSERT(object == Animation::MapPlane, ());
@ -373,23 +373,32 @@ Animation::PropertyValue MapLinearAnimation::GetProperty(TObject object, TProper
case Animation::Position:
ASSERT(m_positionInterpolator != nullptr, ());
if (m_positionInterpolator != nullptr)
return m_positionInterpolator->GetPosition();
break;
{
value = m_positionInterpolator->GetPosition();
return true;
}
return false;
case Animation::Scale:
ASSERT(m_scaleInterpolator != nullptr, ());
if (m_scaleInterpolator != nullptr)
return m_scaleInterpolator->GetScale();
break;
{
value = m_scaleInterpolator->GetScale();
return true;
}
return false;
case Animation::Angle:
ASSERT(m_angleInterpolator != nullptr, ());
if (m_angleInterpolator != nullptr)
return m_angleInterpolator->GetAngle();
break;
{
value = m_angleInterpolator->GetAngle();
return true;
}
return false;
default:
ASSERT(!"Wrong property", ());
}
return 0.0;
return false;
}
MapScaleAnimation::MapScaleAnimation(double startScale, double endScale,
@ -441,21 +450,22 @@ bool MapScaleAnimation::IsFinished() const
return m_scaleInterpolator->IsFinished();
}
Animation::PropertyValue MapScaleAnimation::GetProperty(TObject object, TProperty property) const
bool MapScaleAnimation::GetProperty(TObject object, TProperty property, PropertyValue & value) const
{
if (property == Animation::Position)
{
ScreenBase screen = AnimationSystem::Instance().GetLastScreen();
screen.SetScale(m_scaleInterpolator->GetScale());
return screen.PtoG(screen.GtoP(m_globalPosition) + m_pixelOffset);
value = screen.PtoG(screen.GtoP(m_globalPosition) + m_pixelOffset);
return true;
}
if (property == Animation::Scale)
{
return m_scaleInterpolator->GetScale();
value = m_scaleInterpolator->GetScale();
return true;
}
ASSERT(!"Wrong property", ());
return 0.0;
return false;
}
MapFollowAnimation::MapFollowAnimation(m2::PointD const & globalPosition,
@ -532,9 +542,8 @@ bool MapFollowAnimation::IsFinished() const
&& (m_scaleInterpolator == nullptr || m_scaleInterpolator->IsFinished()));
}
Animation::PropertyValue MapFollowAnimation::GetProperty(TObject object, TProperty property) const
bool MapFollowAnimation::GetProperty(TObject object, TProperty property, PropertyValue & value) const
{
if (property == Animation::Position)
{
m2::RectD const pixelRect = AnimationSystem::Instance().GetLastScreen().PixelRect();
@ -542,26 +551,35 @@ Animation::PropertyValue MapFollowAnimation::GetProperty(TObject object, TProper
m2::PointD formingVector = (pixelRect.Center() - pixelPos) * m_scaleInterpolator->GetScale();
formingVector.y = -formingVector.y;
formingVector.Rotate(m_angleInterpolator->GetAngle());
return m_globalPosition + formingVector;
value = m_globalPosition + formingVector;
return true;
}
if (property == Animation::Angle)
{
return m_angleInterpolator->GetAngle();
value = m_angleInterpolator->GetAngle();
return true;
}
if (property == Animation::Scale)
{
return m_scaleInterpolator->GetScale();
value = m_scaleInterpolator->GetScale();
return true;
}
ASSERT(!"Wrong property", ());
return 0.0;
return false;
}
PerspectiveSwitchAnimation::PerspectiveSwitchAnimation(double startAngle, double endAngle)
PerspectiveSwitchAnimation::PerspectiveSwitchAnimation(double startAngle, double endAngle, double angleFOV)
: Animation(false, false)
, m_startAngle(startAngle)
, m_endAngle(endAngle)
, m_angleFOV(angleFOV)
, m_needPerspectiveSwitch(false)
{
m_isEnablePerspectiveAnim = m_endAngle > 0.0;
m_angleInterpolator = make_unique_dp<AngleInterpolator>(GetRotateDuration(startAngle, endAngle), startAngle, endAngle);
m_objects.insert(Animation::MapPlane);
m_properties.insert(Animation::AnglePerspective);
m_properties.insert(Animation::SwitchPerspective);
}
// static
@ -592,6 +610,20 @@ void PerspectiveSwitchAnimation::Finish()
Animation::Finish();
}
void PerspectiveSwitchAnimation::OnStart()
{
if (m_isEnablePerspectiveAnim)
m_needPerspectiveSwitch = true;
Animation::OnStart();
}
void PerspectiveSwitchAnimation::OnFinish()
{
if (!m_isEnablePerspectiveAnim)
m_needPerspectiveSwitch = true;
Animation::OnFinish();
}
void PerspectiveSwitchAnimation::SetMaxDuration(double maxDuration)
{
m_angleInterpolator->SetMaxDuration(maxDuration);
@ -607,20 +639,29 @@ bool PerspectiveSwitchAnimation::IsFinished() const
return m_angleInterpolator->IsFinished();
}
Animation::PropertyValue PerspectiveSwitchAnimation::GetProperty(TObject object, TProperty property) const
bool PerspectiveSwitchAnimation::GetProperty(TObject object, TProperty property, PropertyValue & value) const
{
ASSERT(object == Animation::MapPlane, ());
switch (property)
{
case Animation::AnglePerspective:
return m_angleInterpolator->GetAngle();
break;
value = m_angleInterpolator->GetAngle();
return true;
case Animation::SwitchPerspective:
if (m_needPerspectiveSwitch)
{
m_needPerspectiveSwitch = false;
value = SwitchPerspectiveParams(m_isEnablePerspectiveAnim,
m_startAngle, m_endAngle, m_angleFOV);
return true;
}
return false;
default:
ASSERT(!"Wrong property", ());
}
return 0.0;
return false;
}
Animation::TObjectProperties const & ParallelAnimation::GetProperties(TObject object) const
@ -741,23 +782,52 @@ AnimationSystem::AnimationSystem()
}
double AnimationSystem::GetPerspectiveAngle(double currentAngle)
bool AnimationSystem::GetRect(ScreenBase const & currentScreen, m2::AnyRectD & rect)
{
return GetProperty(Animation::MapPlane, Animation::AnglePerspective, currentAngle).m_valueD;
m_lastScreen = currentScreen;
double scale = currentScreen.GetScale();
double angle = currentScreen.GetAngle();
m2::PointD pos = currentScreen.GlobalRect().GlobalZero();
Animation::PropertyValue value;
if (GetProperty(Animation::MapPlane, Animation::Scale, value))
scale = value.m_valueD;
if (GetProperty(Animation::MapPlane, Animation::Angle, value))
angle = value.m_valueD;
if (GetProperty(Animation::MapPlane, Animation::Position, value))
pos = value.m_valuePointD;
m2::RectD localRect = currentScreen.PixelRect();
localRect.Offset(-localRect.Center());
localRect.Scale(scale);
rect = m2::AnyRectD(pos, angle, localRect);
return true;
}
m2::AnyRectD AnimationSystem::GetRect(ScreenBase const & currentScreen, bool & viewportChanged)
bool AnimationSystem::GetPerspectiveAngle(double & angle)
{
const Animation::TObject obj = Animation::MapPlane;
viewportChanged |= m_lastScreen != nullptr && (m_lastScreen->isPerspective() != currentScreen.isPerspective());
m_lastScreen = make_unique_dp<ScreenBase>(currentScreen);
double scale = GetProperty(obj, Animation::Scale, currentScreen.GetScale()).m_valueD;
double angle = GetProperty(obj, Animation::Angle, currentScreen.GetAngle()).m_valueD;
m2::PointD pos = GetProperty(obj, Animation::Position, currentScreen.GlobalRect().GlobalZero()).m_valuePointD;
m2::RectD rect = currentScreen.PixelRect();
rect.Offset(-rect.Center());
rect.Scale(scale);
return m2::AnyRectD(pos, angle, rect);
Animation::PropertyValue value;
if (GetProperty(Animation::MapPlane, Animation::AnglePerspective, value))
{
angle = value.m_valueD;
return true;
}
return false;
}
bool AnimationSystem::SwitchPerspective(Animation::SwitchPerspectiveParams & params)
{
Animation::PropertyValue value;
if (GetProperty(Animation::MapPlane, Animation::SwitchPerspective, value))
{
params = value.m_valuePerspectiveParams;
return true;
}
return false;
}
bool AnimationSystem::AnimationExists(Animation::TObject object) const
@ -906,24 +976,24 @@ void AnimationSystem::Advance(double elapsedSeconds)
StartNextAnimations();
}
Animation::PropertyValue AnimationSystem::GetProperty(Animation::TObject object, Animation::TProperty property, Animation::PropertyValue current) const
bool AnimationSystem::GetProperty(Animation::TObject object, Animation::TProperty property, Animation::PropertyValue & value) const
{
if (!m_animationChain.empty())
{
for (auto const & anim : m_animationChain.front())
{
if (anim->HasProperty(object, property))
return anim->GetProperty(object, property);
return anim->GetProperty(object, property, value);
}
}
auto it = m_propertyCache.find(make_pair(object, property));
if (it != m_propertyCache.end())
{
Animation::PropertyValue value(it->second);
value = it->second;
m_propertyCache.erase(it);
return value;
return true;
}
return current;
return false;
}
void AnimationSystem::SaveAnimationResult(Animation const & animation)
@ -932,7 +1002,9 @@ void AnimationSystem::SaveAnimationResult(Animation const & animation)
{
for (auto const & property : animation.GetProperties(object))
{
m_propertyCache[make_pair(object, property)] = animation.GetProperty(object, property);
Animation::PropertyValue value;
if (animation.GetProperty(object, property, value))
m_propertyCache[make_pair(object, property)] = value;
}
}
}

73
drape_frontend/animation_system.h
View file

@ -39,13 +39,34 @@ public:
Position,
Scale,
Angle,
AnglePerspective
AnglePerspective,
SwitchPerspective
};
enum PropertyValueType
{
ValueD,
ValuePointD
ValuePointD,
ValuePerspectiveParams
};
struct SwitchPerspectiveParams
{
SwitchPerspectiveParams()
: m_enable(false)
{}
SwitchPerspectiveParams(bool enable, double startAngle, double endAngle, double angleFOV)
: m_enable(enable)
, m_startAngle(startAngle)
, m_endAngle(endAngle)
, m_angleFOV(angleFOV)
{}
bool m_enable;
double m_startAngle;
double m_endAngle;
double m_angleFOV;
};
struct PropertyValue
@ -55,20 +76,27 @@ public:
}
PropertyValue(double value)
: m_type(ValueD),
m_valueD(value)
: m_type(ValueD)
, m_valueD(value)
{}
PropertyValue(m2::PointD value)
: m_type(ValuePointD),
m_valuePointD(value)
: m_type(ValuePointD)
, m_valuePointD(value)
{}
PropertyValue(SwitchPerspectiveParams const & params)
: m_type(ValuePerspectiveParams)
{
m_valuePerspectiveParams = params;
}
PropertyValueType m_type;
union
{
m2::PointD m_valuePointD;
double m_valueD;
SwitchPerspectiveParams m_valuePerspectiveParams;
};
};
@ -101,7 +129,7 @@ public:
virtual void Advance(double elapsedSeconds) = 0;
virtual void Finish() { OnFinish(); }
virtual PropertyValue GetProperty(TObject object, TProperty property) const = 0;
virtual bool GetProperty(TObject object, TProperty property, PropertyValue & value) const = 0;
void SetOnStartAction(TAction const & action) { m_onStartAction = action; }
void SetOnFinishAction(TAction const & action) { m_onFinishAction = action; }
@ -249,7 +277,7 @@ private:
class PerspectiveSwitchAnimation : public Animation
{
public:
PerspectiveSwitchAnimation(double startAngle, double endAngle);
PerspectiveSwitchAnimation(double startAngle, double endAngle, double angleFOV);
static double GetRotateDuration(double startAngle, double endAngle);
@ -269,14 +297,23 @@ public:
void Advance(double elapsedSeconds) override;
void Finish() override;
void OnStart() override;
void OnFinish() override;
void SetMaxDuration(double maxDuration) override;
double GetDuration() const override;
bool IsFinished() const override;
PropertyValue GetProperty(TObject object, TProperty property) const override;
bool GetProperty(TObject object, TProperty property, PropertyValue & value) const override;
private:
drape_ptr<AngleInterpolator> m_angleInterpolator;
double m_startAngle;
double m_endAngle;
double m_angleFOV;
bool m_isEnablePerspectiveAnim;
mutable bool m_needPerspectiveSwitch;
TAnimObjects m_objects;
TObjectProperties m_properties;
};
@ -313,7 +350,7 @@ public:
double GetDuration() const override;
bool IsFinished() const override;
PropertyValue GetProperty(TObject object, TProperty property) const override;
bool GetProperty(TObject object, TProperty property, PropertyValue & value) const override;
private:
drape_ptr<AngleInterpolator> m_angleInterpolator;
@ -349,7 +386,7 @@ public:
double GetDuration() const override;
bool IsFinished() const override;
PropertyValue GetProperty(TObject object, TProperty property) const override;
bool GetProperty(TObject object, TProperty property, PropertyValue & value) const override;
private:
drape_ptr<ScaleInterpolator> m_scaleInterpolator;
@ -388,7 +425,7 @@ public:
double GetDuration() const override;
bool IsFinished() const override;
PropertyValue GetProperty(TObject object, TProperty property) const override;
bool GetProperty(TObject object, TProperty property, PropertyValue & value) const override;
private:
drape_ptr<ScaleInterpolator> m_scaleInterpolator;
@ -455,8 +492,10 @@ class AnimationSystem : private noncopyable
public:
static AnimationSystem & Instance();
m2::AnyRectD GetRect(ScreenBase const & currentScreen, bool & viewportChanged);
double GetPerspectiveAngle(double currentAngle);
bool GetRect(ScreenBase const & currentScreen, m2::AnyRectD & rect);
bool SwitchPerspective(Animation::SwitchPerspectiveParams & params);
bool GetPerspectiveAngle(double & angle);
bool AnimationExists(Animation::TObject object) const;
@ -468,10 +507,10 @@ public:
void Advance(double elapsedSeconds);
ScreenBase const & GetLastScreen() { return *m_lastScreen.get(); }
ScreenBase const & GetLastScreen() { return m_lastScreen; }
private:
Animation::PropertyValue GetProperty(Animation::TObject object, Animation::TProperty property, Animation::PropertyValue current) const;
bool GetProperty(Animation::TObject object, Animation::TProperty property, Animation::PropertyValue & value) const;
void SaveAnimationResult(Animation const & animation);
void StartNextAnimations();
@ -484,7 +523,7 @@ private:
TAnimationChain m_animationChain;
mutable TPropertyCache m_propertyCache;
drape_ptr<ScreenBase> m_lastScreen;
ScreenBase m_lastScreen;
};
}

6
drape_frontend/frontend_renderer.cpp
View file

@ -1507,15 +1507,15 @@ void FrontendRenderer::Routine::Do()
isActiveFrame |= m_renderer.m_texMng->UpdateDynamicTextures();
m_renderer.RenderScene(modelView);
isActiveFrame |= InterpolationHolder::Instance().Advance(frameTime);
AnimationSystem::Instance().Advance(frameTime);
if (modelViewChanged)
{
m_renderer.UpdateScene(modelView);
m_renderer.EmitModelViewChanged(modelView);
}
isActiveFrame |= InterpolationHolder::Instance().Advance(frameTime);
AnimationSystem::Instance().Advance(frameTime);
isActiveFrame |= m_renderer.m_userEventStream.IsWaitingForActionCompletion();
if (isActiveFrame)

97
drape_frontend/user_event_stream.cpp
View file

@ -206,13 +206,12 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChange, bool &
break;
case UserEvent::EVENT_ENABLE_PERSPECTIVE:
SetEnable3dMode(e.m_enable3dMode.m_rotationAngle, e.m_enable3dMode.m_angleFOV,
e.m_enable3dMode.m_isAnim, e.m_enable3dMode.m_immediatelyStart,
viewportChanged);
e.m_enable3dMode.m_isAnim, e.m_enable3dMode.m_immediatelyStart);
m_discardedFOV = m_discardedAngle = 0.0;
break;
case UserEvent::EVENT_DISABLE_PERSPECTIVE:
if (m_navigator.Screen().isPerspective())
SetDisable3dModeAnimation(viewportChanged);
SetDisable3dModeAnimation();
m_discardedFOV = m_discardedAngle = 0.0;
break;
case UserEvent::EVENT_SWITCH_VIEW_MODE:
@ -220,12 +219,11 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChange, bool &
{
m_discardedFOV = m_navigator.Screen().GetAngleFOV();
m_discardedAngle = m_navigator.Screen().GetRotationAngle();
SetDisable3dModeAnimation(viewportChanged);
SetDisable3dModeAnimation();
}
else if (m_discardedFOV > 0.0)
{
SetEnable3dMode(m_discardedAngle, m_discardedFOV, true /* isAnim */, true /* immediatelyStart */,
viewportChanged);
SetEnable3dMode(m_discardedAngle, m_discardedFOV, true /* isAnim */, true /* immediatelyStart */);
m_discardedFOV = m_discardedAngle = 0.0;
}
break;
@ -249,22 +247,23 @@ 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(), viewportChanged);
m_navigator.SetFromRect(rect);
ScreenBase const & screen = GetCurrentScreen();
if (screen.isPerspective())
{
double const angle = AnimationSystem::Instance().GetPerspectiveAngle(screen.GetRotationAngle());
m_navigator.SetRotationIn3dMode(angle);
}
modelViewChange = true;
}
ApplyAnimations(modelViewChange, viewportChanged);
if (m_perspectiveAnimation)
{
TouchCancel(m_touches);
}
else
{
if (m_pendingEvent != nullptr && m_pendingEvent->m_type == UserEvent::EVENT_SET_RECT)
{
SetRect(m_pendingEvent->m_rectEvent.m_rect, m_pendingEvent->m_rectEvent.m_zoom,
m_pendingEvent->m_rectEvent.m_applyRotation, m_pendingEvent->m_rectEvent.m_isAnim);
m_pendingEvent.reset();
modelViewChange = true;
}
}
if (GetValidTouchesCount(m_touches) == 1)
{
@ -277,6 +276,35 @@ ScreenBase const & UserEventStream::ProcessEvents(bool & modelViewChange, bool &
return m_navigator.Screen();
}
void UserEventStream::ApplyAnimations(bool & modelViewChanged, bool & viewportChanged)
{
if (AnimationSystem::Instance().AnimationExists(Animation::MapPlane))
{
m2::AnyRectD rect;
if (AnimationSystem::Instance().GetRect(GetCurrentScreen(), rect))
m_navigator.SetFromRect(rect);
Animation::SwitchPerspectiveParams switchPerspective;
if (AnimationSystem::Instance().SwitchPerspective(switchPerspective))
{
if (switchPerspective.m_enable)
m_navigator.Enable3dMode(switchPerspective.m_startAngle, switchPerspective.m_endAngle, switchPerspective.m_angleFOV);
else
m_navigator.Disable3dMode();
viewportChanged = true;
}
double perspectiveAngle;
if (AnimationSystem::Instance().GetPerspectiveAngle(perspectiveAngle) &&
GetCurrentScreen().isPerspective())
{
m_navigator.SetRotationIn3dMode(perspectiveAngle);
}
modelViewChanged = true;
}
}
ScreenBase const & UserEventStream::GetCurrentScreen() const
{
return m_navigator.Screen();
@ -526,22 +554,20 @@ bool UserEventStream::FilterEventWhile3dAnimation(UserEvent::EEventType type) co
}
void UserEventStream::SetEnable3dMode(double maxRotationAngle, double angleFOV,
bool isAnim, bool immediatelyStart,
bool & viewportChanged)
bool isAnim, bool immediatelyStart)
{
AnimationSystem::Instance().FinishAnimations(Animation::MapLinear, true /* rewind */);
m_navigator.SetFromRect(AnimationSystem::Instance().GetRect(GetCurrentScreen(), viewportChanged));
m2::AnyRectD rect;
if (AnimationSystem::Instance().GetRect(GetCurrentScreen(), rect))
m_navigator.SetFromRect(rect);
double const startAngle = isAnim ? 0.0 : maxRotationAngle;
double const endAngle = maxRotationAngle;
drape_ptr<PerspectiveSwitchAnimation> anim = make_unique_dp<PerspectiveSwitchAnimation>(startAngle, endAngle);
anim->SetOnStartAction([this, startAngle, endAngle, angleFOV, &viewportChanged](Animation const &)
drape_ptr<PerspectiveSwitchAnimation> anim = make_unique_dp<PerspectiveSwitchAnimation>(startAngle, endAngle, angleFOV);
anim->SetOnStartAction([this, startAngle, endAngle, angleFOV](Animation const &)
{
m_perspectiveAnimation = true;
m_navigator.SetFromRect(AnimationSystem::Instance().GetRect(GetCurrentScreen(), viewportChanged));
m_navigator.Enable3dMode(startAngle, endAngle, angleFOV);
});
anim->SetOnFinishAction([this](Animation const &)
{
@ -553,31 +579,24 @@ void UserEventStream::SetEnable3dMode(double maxRotationAngle, double angleFOV,
AnimationSystem::Instance().PushAnimation(move(anim));
}
void UserEventStream::SetDisable3dModeAnimation(bool & viewportChanged)
void UserEventStream::SetDisable3dModeAnimation()
{
AnimationSystem::Instance().FinishAnimations(Animation::MapLinear, true /* rewind */);
m_navigator.SetFromRect(AnimationSystem::Instance().GetRect(GetCurrentScreen(), viewportChanged));
m2::AnyRectD rect;
if (AnimationSystem::Instance().GetRect(GetCurrentScreen(), rect))
m_navigator.SetFromRect(rect);
double const startAngle = m_navigator.Screen().GetRotationAngle();
double const endAngle = 0.0;
drape_ptr<PerspectiveSwitchAnimation> anim = make_unique_dp<PerspectiveSwitchAnimation>(startAngle, endAngle);
drape_ptr<PerspectiveSwitchAnimation> anim = make_unique_dp<PerspectiveSwitchAnimation>(startAngle, endAngle, m_navigator.Screen().GetAngleFOV());
anim->SetOnStartAction([this](Animation const &)
{
m_perspectiveAnimation = true;
});
anim->SetOnFinishAction([this, &viewportChanged](Animation const &)
anim->SetOnFinishAction([this](Animation const &)
{
m_perspectiveAnimation = false;
m_navigator.SetFromRect(AnimationSystem::Instance().GetRect(GetCurrentScreen(), viewportChanged));
m_navigator.Disable3dMode();
if (m_pendingEvent != nullptr && m_pendingEvent->m_type == UserEvent::EVENT_SET_RECT)
{
SetRect(m_pendingEvent->m_rectEvent.m_rect, m_pendingEvent->m_rectEvent.m_zoom,
m_pendingEvent->m_rectEvent.m_applyRotation, m_pendingEvent->m_rectEvent.m_isAnim);
m_pendingEvent.reset();
}
});
AnimationSystem::Instance().AddAnimation(move(anim), true /* force */);
}

5
drape_frontend/user_event_stream.hpp
View file

@ -311,8 +311,8 @@ private:
bool FilterEventWhile3dAnimation(UserEvent::EEventType type) const;
void SetEnable3dMode(double maxRotationAngle, double angleFOV,
bool isAnim, bool immediatelyStart, bool & viewportChanged);
void SetDisable3dModeAnimation(bool & viewportChanged);
bool isAnim, bool immediatelyStart);
void SetDisable3dModeAnimation();
m2::AnyRectD GetCurrentRect() const;
@ -353,6 +353,7 @@ private:
void EndFilter(Touch const & t);
void CancelFilter(Touch const & t);
void ApplyAnimations(bool & modelViewChanged, bool & viewportChanged);
void ResetCurrentAnimation(bool finishAnimation = false);
list<UserEvent> m_events;