added base animation classes for single values and AnyRect's interpolations.

anim/angle_interpolation.cpp

@@ -27,7 +27,7 @@ namespace anim
 
   void AngleInterpolation::OnStep(double ts)
   {
-    if (ts - m_startTime > m_interval)
+    if (ts - m_startTime >= m_interval)
     {
       End();
       return;

anim/anim.pro

@@ -14,9 +14,13 @@ HEADERS += \
     task.hpp \
     angle_interpolation.hpp \
     segment_interpolation.hpp \
+    anyrect_interpolation.hpp \
+    value_interpolation.hpp \
 
 SOURCES += \
     controller.cpp \
     task.cpp \
     angle_interpolation.cpp \
     segment_interpolation.cpp \
+    value_interpolation.cpp \
+    anyrect_interpolation.cpp \

anim/anyrect_interpolation.cpp

@@ -0,0 +1,79 @@
+#include "anyrect_interpolation.hpp"
+
+namespace anim
+{
+  AnyRectInterpolation::AnyRectInterpolation(m2::AnyRectD const & startRect,
+                                             m2::AnyRectD const & endRect,
+                                             double rotationSpeed,
+                                             m2::AnyRectD & outRect)
+    : m_interval(rotationSpeed * fabs(ang::GetShortestDistance(startRect.Angle().val(),
+                                                               endRect.Angle().val())) / (2 * math::pi)),
+      m_angleInt(startRect.Angle().val(),
+                 endRect.Angle().val(),
+                 rotationSpeed,
+                 m_curAngle),
+      m_segmentInt(startRect.GlobalCenter(),
+                   endRect.GlobalCenter(),
+                   m_interval,
+                   m_curCenter),
+      m_sizeXInt(startRect.GetLocalRect().SizeX(),
+                 endRect.GetLocalRect().SizeX(),
+                 m_interval,
+                 m_curSizeX),
+      m_sizeYInt(startRect.GetLocalRect().SizeY(),
+                 endRect.GetLocalRect().SizeY(),
+                 m_interval,
+                 m_curSizeY),
+      m_startRect(startRect),
+      m_endRect(endRect),
+      m_outRect(outRect)
+  {
+  }
+
+  void AnyRectInterpolation::OnStart(double ts)
+  {
+    m_startTime = ts;
+
+    m_angleInt.OnStart(ts);
+    m_segmentInt.OnStart(ts);
+    m_sizeXInt.OnStart(ts);
+    m_sizeYInt.OnStart(ts);
+
+    m_outRect = m_startRect;
+
+    anim::Task::OnStart(ts);
+  }
+
+  void AnyRectInterpolation::OnStep(double ts)
+  {
+    if (ts - m_startTime >= m_interval)
+    {
+      End();
+      return;
+    }
+
+    if (!IsRunning())
+      return;
+
+    m_angleInt.OnStep(ts);
+    m_segmentInt.OnStep(ts);
+    m_sizeXInt.OnStep(ts);
+    m_sizeYInt.OnStep(ts);
+
+    m_outRect = m2::AnyRectD(m_curCenter, m_curAngle, m2::RectD(-m_curSizeX / 2, -m_curSizeY / 2, m_curSizeX / 2, m_curSizeY / 2));
+
+    anim::Task::OnStep(ts);
+  }
+
+  void AnyRectInterpolation::OnEnd(double ts)
+  {
+    m_angleInt.OnEnd(ts);
+    m_segmentInt.OnEnd(ts);
+    m_sizeXInt.OnEnd(ts);
+    m_sizeYInt.OnEnd(ts);
+
+    m_outRect = m_endRect;
+
+    anim::Task::OnEnd(ts);
+  }
+}

anim/anyrect_interpolation.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "../geometry/any_rect2d.hpp"
+#include "angle_interpolation.hpp"
+#include "segment_interpolation.hpp"
+#include "value_interpolation.hpp"
+
+namespace anim
+{
+  class AnyRectInterpolation : public Task
+  {
+  private:
+
+    double m_interval;
+
+    AngleInterpolation m_angleInt;
+    double m_curAngle;
+
+    SegmentInterpolation m_segmentInt;
+    m2::PointD m_curCenter;
+
+    ValueInterpolation m_sizeXInt;
+    double m_curSizeX;
+
+    ValueInterpolation m_sizeYInt;
+    double m_curSizeY;
+
+    m2::AnyRectD m_startRect;
+    m2::AnyRectD m_endRect;
+    m2::AnyRectD & m_outRect;
+
+    double m_startTime;
+
+  public:
+
+    AnyRectInterpolation(m2::AnyRectD const & startRect,
+                         m2::AnyRectD const & endRect,
+                         double rotationSpeed,
+                         m2::AnyRectD & outRect);
+
+    void OnStart(double ts);
+    void OnStep(double ts);
+    void OnEnd(double ts);
+  };
+}

anim/segment_interpolation.cpp

@@ -8,8 +8,8 @@ namespace anim
                                              m2::PointD & outPt)
     : m_startPt(startPt),
       m_endPt(endPt),
-      m_interval(interval),
-      m_outPt(outPt)
+      m_outPt(outPt),
+      m_interval(interval)
   {
     m_deltaPt = m_endPt - m_startPt;
   }
@@ -23,7 +23,7 @@ namespace anim
 
   void SegmentInterpolation::OnStep(double ts)
   {
-    if (ts - m_startTime > m_interval)
+    if (ts - m_startTime >= m_interval)
     {
       End();
       return;

anim/value_interpolation.cpp

@@ -0,0 +1,48 @@
+#include "value_interpolation.hpp"
+
+namespace anim
+{
+  ValueInterpolation::ValueInterpolation(double start,
+                                         double end,
+                                         double interval,
+                                         double & out)
+    : m_startValue(start),
+      m_outValue(out),
+      m_endValue(end)
+  {
+    m_dist = end - start;
+    m_interval = interval;
+  }
+
+  void ValueInterpolation::OnStart(double ts)
+  {
+    m_startTime = ts;
+    m_outValue = m_startValue;
+    Task::OnStart(ts);
+  }
+
+  void ValueInterpolation::OnStep(double ts)
+  {
+    if (ts - m_startTime >= m_interval)
+    {
+      End();
+      return;
+    }
+
+    if (!IsRunning())
+      return;
+
+    double elapsedSec = ts - m_startTime;
+    m_outValue = m_startValue + m_dist * elapsedSec / m_interval;
+
+    Task::OnStep(ts);
+  }
+
+  void ValueInterpolation::OnEnd(double ts)
+  {
+    // ensuring that the final value was reached
+    m_outValue = m_endValue;
+    Task::OnEnd(ts);
+  }
+}
+

anim/value_interpolation.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "task.hpp"
+
+namespace anim
+{
+  class ValueInterpolation : public Task
+  {
+  private:
+
+    double m_startValue;
+    double m_curValue;
+    double & m_outValue;
+    double m_endValue;
+
+    double m_startTime;
+    double m_interval;
+    double m_dist;
+
+  public:
+
+    ValueInterpolation(double start,
+                       double end,
+                       double interval,
+                       double & out);
+
+    void OnStart(double ts);
+    void OnStep(double ts);
+    void OnEnd(double ts);
+  };
+}