dali/internal/event/animation/progress-value.h

   1 #ifndef __DALI_INTERNAL_PROGRESS_VALUE_H__
   2 #define __DALI_INTERNAL_PROGRESS_VALUE_H__
   3
   4 /*
   5  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 // INTERNAL INCLUDES
  22 #include <dali/public-api/math/angle-axis.h>
  23 #include <dali/public-api/math/quaternion.h>
  24 #include <dali/public-api/math/vector2.h>
  25 #include <dali/public-api/math/vector3.h>
  26 #include <dali/public-api/math/vector4.h>
  27
  28 namespace Dali
  29 {
  30
  31 namespace Internal
  32 {
  33
  34 /**
  35  * Progress / value pair for animating channels (properties) with keyframes
  36  */
  37 template <typename T>
  38 class ProgressValue
  39 {
  40 public:
  41   ProgressValue (float progress, T value)
  42   : mProgress(progress),
  43     mValue (value)
  44   {
  45   }
  46
  47   ~ProgressValue ()
  48   {
  49   }
  50
  51   float GetProgress () const
  52   {
  53     return mProgress;
  54   }
  55
  56   const T& GetValue () const
  57   {
  58     return mValue;
  59   }
  60
  61 public:
  62   float mProgress;   ///< Progress this value applies to animation channel
  63   T mValue;          ///< value this animation channel should take
  64 };
  65
  66 inline void Interpolate (Quaternion& result, const Quaternion& a, const Quaternion& b, float progress)
  67 {
  68   result = Quaternion::Slerp(a, b, progress);
  69 }
  70
  71 inline void Interpolate (AngleAxis& result, const AngleAxis& a, const AngleAxis& b, float progress)
  72 {
  73   Quaternion q1(a.angle, a.axis);
  74   Quaternion q2(b.angle, b.axis);
  75
  76   Quaternion iq = Quaternion::Slerp(q1, q2, progress);
  77   iq.ToAxisAngle(result.axis, result.angle);
  78 }
  79
  80
  81 inline void Interpolate (bool& result, bool a, bool b, float progress)
  82 {
  83   result = progress < 0.5f ? a : b;
  84 }
  85
  86 inline void Interpolate (int32_t& result, int a, int b, float progress)
  87 {
  88   result = static_cast<int>(static_cast<float>( a ) + static_cast<float>(b - a) * progress + 0.5f);
  89 }
  90
  91 inline void Interpolate (float& result, float a, float b, float progress)
  92 {
  93   result = a + (b-a) * progress;
  94 }
  95
  96 inline void Interpolate (Vector2& result, const Vector2& a,  const Vector2& b, float progress)
  97 {
  98   result = a + (b-a) * progress;
  99 }
 100
 101 inline void Interpolate (Vector3& result, const Vector3& a, const Vector3& b, float progress)
 102 {
 103   result = a + (b-a) * progress;
 104 }
 105
 106 inline void Interpolate (Vector4& result, const Vector4& a, const Vector4& b, float progress)
 107 {
 108   result = a + (b-a) * progress;
 109 }
 110
 111 /* Cubic Interpolation (Catmull-Rom spline) between values p1 and p2. p0 and p3 are prev and next values
 112  * and are used as control points to calculate tangent of the curve at interpolation points.
 113  *
 114  * f(t) = a3*t^3 + a2*t^2 + a1*t + a0
 115  * Restrictions: f(0)=p1   f(1)=p2   f'(0)=(p2-p0)*0.5   f'(1)=(p3-p1)*0.5
 116  */
 117
 118 inline void CubicInterpolate( int32_t& result, int32_t p0, int32_t p1, int32_t p2, int32_t p3, float progress )
 119 {
 120   float a3 = static_cast<float>( p3 ) * 0.5f - static_cast<float>( p2 ) * 1.5f + static_cast<float>( p1 ) * 1.5f - static_cast<float>( p0 ) * 0.5f;
 121   float a2 = static_cast<float>( p0 ) - static_cast<float>( p1 ) * 2.5f + static_cast<float>( p2 ) * 2.0f - static_cast<float>( p3 ) * 0.5f;
 122   float a1 = static_cast<float>( p2 - p0 ) * 0.5f;
 123
 124   result = static_cast<int>( a3*progress*progress*progress + a2*progress*progress + a1*progress + static_cast<float>( p1 ) + 0.5f );
 125 }
 126
 127 inline void CubicInterpolate( float& result, float p0, float p1, float  p2, float  p3, float progress )
 128 {
 129   float a3 = p3*0.5f - p2*1.5f + p1*1.5f - p0*0.5f;
 130   float a2 = p0 - p1*2.5f + p2*2.0f - p3*0.5f;
 131   float a1 = (p2-p0)*0.5f;
 132
 133   result = a3*progress*progress*progress + a2*progress*progress + a1*progress + p1;
 134 }
 135
 136 inline void CubicInterpolate( Vector2& result, const Vector2& p0, const Vector2& p1, const Vector2&  p2, const Vector2&  p3, float progress )
 137 {
 138   Vector2 a3 = p3*0.5f - p2*1.5f + p1*1.5f - p0*0.5f;
 139   Vector2 a2 = p0 - p1*2.5f + p2*2.0f - p3*0.5f;
 140   Vector2 a1 = (p2-p0)*0.5f;
 141
 142   result = a3*progress*progress*progress + a2*progress*progress + a1*progress + p1;
 143 }
 144
 145 inline void CubicInterpolate( Vector3& result, const Vector3& p0, const Vector3& p1, const Vector3&  p2, const Vector3&  p3, float progress )
 146 {
 147   Vector3 a3 = p3*0.5f - p2*1.5f + p1*1.5f - p0*0.5f;
 148   Vector3 a2 = p0 - p1*2.5f + p2*2.0f - p3*0.5f;
 149   Vector3 a1 = (p2-p0)*0.5f;
 150
 151   result = a3*progress*progress*progress + a2*progress*progress + a1*progress + p1;
 152 }
 153
 154 inline void CubicInterpolate( Vector4& result, const Vector4& p0, const Vector4& p1, const Vector4&  p2, const Vector4&  p3, float progress )
 155 {
 156   Vector4 a3 = p3*0.5f - p2*1.5f + p1*1.5f - p0*0.5f;
 157   Vector4 a2 = p0 - p1*2.5f + p2*2.0f - p3*0.5f;
 158   Vector4 a1 = (p2-p0)*0.5f;
 159
 160   result = a3*progress*progress*progress + a2*progress*progress + a1*progress + p1;
 161 }
 162
 163 inline void CubicInterpolate( bool& result, bool p0, bool p1, bool  p2, bool  p3, float progress )
 164 {
 165   Interpolate( result, p1, p2, progress);
 166 }
 167
 168 inline void CubicInterpolate( Quaternion& result, const Quaternion& p0, const Quaternion& p1, const Quaternion& p2, const Quaternion& p3, float progress )
 169 {
 170   Interpolate( result, p1, p2, progress);
 171 }
 172
 173 inline void CubicInterpolate( AngleAxis& result, const AngleAxis& p0, const AngleAxis& p1, const AngleAxis& p2, const AngleAxis& p3, float progress )
 174 {
 175   Interpolate( result, p1, p2, progress);
 176 }
 177
 178 } // namespace Internal
 179
 180 } // namespace Dali
 181
 182 #endif //__DALI_PROGRESS_VALUE_H__