dali/public-api/animation/alpha-function.h

   1 #ifndef __DALI_ALPHA_FUNCTION_H__
   2 #define __DALI_ALPHA_FUNCTION_H__
   3
   4 /*
   5  * Copyright (c) 2015 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/common/dali-common.h>
  23 #include <dali/public-api/common/constants.h>
  24 #include <dali/public-api/math/compile-time-math.h>
  25 #include <dali/public-api/math/math-utils.h>
  26 #include <dali/public-api/math/vector2.h>
  27 #include <dali/public-api/math/vector4.h>
  28
  29 namespace Dali
  30 {
  31 /**
  32  * @addtogroup dali_core_animation
  33  * @{
  34  */
  35
  36 typedef float (*AlphaFunctionPrototype)(float progress); ///< Prototype of an alpha function @SINCE_1_0.0
  37
  38   /*
  39    * @brief Alpha functions are used in animations to specify the rate of change of the animation parameter over time.
  40    * Understanding an animation as a parametric function over time, the alpha function is applied to the parameter of
  41    * the animation before computing the final animation value.
  42    */
  43 class DALI_IMPORT_API AlphaFunction
  44 {
  45 public:
  46
  47   /**
  48    * @brief Built-in alpha functions
  49    * @SINCE_1_0.0
  50    */
  51   enum BuiltinFunction
  52   {
  53     DEFAULT,            ///< Linear @SINCE_1_0.0
  54     LINEAR,             ///< No transformation @SINCE_1_0.0
  55     REVERSE,            ///< Reverse linear @SINCE_1_0.0
  56
  57     EASE_IN_SQUARE,     ///< Speeds up and comes to a sudden stop (Square) @SINCE_1_0.0
  58     EASE_OUT_SQUARE,    ///< Sudden start and slows to a gradual stop (Square) @SINCE_1_0.0
  59
  60     EASE_IN,            ///< Speeds up and comes to a sudden stop (Cubic) @SINCE_1_0.0
  61     EASE_OUT,           ///< Sudden start and slows to a gradual stop (Cubic) @SINCE_1_0.0
  62     EASE_IN_OUT,        ///< Speeds up and slows to a gradual stop (Cubic) @SINCE_1_0.0
  63
  64     EASE_IN_SINE,       ///< Speeds up and comes to a sudden stop (sinusoidal) @SINCE_1_0.0
  65     EASE_OUT_SINE,      ///< Sudden start and slows to a gradual stop (sinusoidal) @SINCE_1_0.0
  66     EASE_IN_OUT_SINE,   ///< Speeds up and slows to a gradual stop (sinusoidal) @SINCE_1_0.0
  67
  68     BOUNCE,             ///< Sudden start, loses momentum and returns to start position @SINCE_1_0.0
  69     SIN,                ///< Single revolution @SINCE_1_0.0
  70     EASE_OUT_BACK,      ///< Sudden start, exceed end position and return to a gradual stop @SINCE_1_0.0
  71
  72     COUNT
  73   };
  74
  75   /**
  76    * @brief All possible functioning modes for the alpha function
  77    * @SINCE_1_0.0
  78    */
  79   enum Mode
  80   {
  81     BUILTIN_FUNCTION,  //< The user has specified a built-in function
  82     CUSTOM_FUNCTION,   //< The user has provided a custom function
  83     BEZIER             //< The user has provided the control points of a bezier curve
  84   };
  85
  86   /**
  87    * @brief Default constructor.
  88    * Creates an alpha function object with the default built-in alpha function
  89    * @SINCE_1_0.0
  90    * @return The alpha function
  91    */
  92   AlphaFunction();
  93
  94   /**
  95    * @brief Constructor.
  96    * Creates an alpha function object with the built-in alpha function passed as a parameter
  97    * to the constructor
  98    * @SINCE_1_0.0
  99    * @param[in] function One of the built-in alpha functions
 100    * @return The alpha function
 101    */
 102   AlphaFunction( BuiltinFunction function);
 103
 104   /**
 105    * @brief Constructor.
 106    * Creates an alpha function object using a pointer to an alpha function passed as a paramter
 107    * to the constructor
 108    * @SINCE_1_0.0
 109    * @param[in] function A pointer to an alpha function
 110    * @return The alpha function
 111    */
 112   AlphaFunction( AlphaFunctionPrototype function);
 113
 114   /**
 115    * @brief Constructor.
 116    * Creates a bezier alpha function. The bezier will have the first point at (0,0) and
 117    * the end point at (1,1).
 118    * @SINCE_1_0.0
 119    * @param[in] controlPoint0 A Vector2 which will be used as the first control point of the curve
 120    * @param[in] controlPoint1 A Vector2 which will be used as the second control point of the curve
 121    * @return The alpha function
 122    * @note The x components of the control points will be clamped to the range [0,1] to prevent
 123    * non monotonic curves.
 124    */
 125   AlphaFunction( const Dali::Vector2& controlPoint0, const Dali::Vector2& controlPoint1 );
 126
 127   /**
 128    * @brief Return the control points of the alpha function
 129    * @SINCE_1_0.0
 130    * @return Vector4 containing the two control points of the curve.
 131    * (xy for the first point and zw for the second)
 132    */
 133   Vector4 GetBezierControlPoints() const;
 134
 135   /**
 136    * @brief Returns the pointer to the custom function
 137    * @SINCE_1_0.0
 138    * @return A pointer to a custom alpha function or 0 if not defined
 139    */
 140   AlphaFunctionPrototype GetCustomFunction() const;
 141
 142   /**
 143    * @brief Returns the built0in function used by the alpha function
 144    * @SINCE_1_0.0
 145    * @return One of the built-in alpha functions. In case no built-in function
 146    * has been specified, it will return AlphaFunction::DEfAULT
 147    */
 148   BuiltinFunction GetBuiltinFunction() const;
 149
 150   /**
 151    * @brief Returns the functioning mode of the alpha function
 152    * @SINCE_1_0.0
 153    * @return The functioning mode of the alpha function
 154    */
 155   Mode GetMode() const;
 156
 157 private:
 158
 159   Vector4                 mBezierControlPoints;   //< Control points for the bezier alpha function
 160   AlphaFunctionPrototype  mCustom;                //< Pointer to an alpha function
 161   BuiltinFunction         mBuiltin : Log<COUNT>::value+1; //< Enum indicating the built-in alpha function
 162   Mode                    mMode    : 2;                   //< Enum indicating the functioning mode of the AlphaFunction
 163 };
 164
 165 /**
 166  * @}
 167  */
 168 } // namespace Dali
 169
 170 #endif // __DALI_ALPHA_FUNCTION_H__