Adding the cubic-bezier curve to edje transitions

Summary: Adding an option to use a cubic-bezier curve in edje transitions.

Reviewers: Sachiel, cedric, raster

Reviewed By: raster

CC: raster

Differential Revision: https://phab.enlightenment.org/D319

2 files changed, 176 insertions, 12 deletions

diff --git a/src/lib/ecore/Ecore_Common.h b/src/lib/ecore/Ecore_Common.h
index bf6d1de8ed..39feead947 100644
--- a/src/lib/ecore/Ecore_Common.h
+++ b/src/lib/ecore/Ecore_Common.h
@@ -1899,7 +1899,8 @@ enum _Ecore_Pos_Map    /* Position mappings */
    ECORE_POS_MAP_SINUSOIDAL_FACTOR, /**< Start slow, speed up then slow down at end, v1 being a power factor, 0.0 being linear, 1.0 being normal sinusoidal, 2.0 being much more pronounced sinusoidal (squared), 3.0 being cubed, etc. */
    ECORE_POS_MAP_DIVISOR_INTERP, /**< Start at gradient * v1, interpolated via power of v2 curve */
    ECORE_POS_MAP_BOUNCE, /**< Start at 0.0 then "drop" like a ball bouncing to the ground at 1.0, and bounce v2 times, with decay factor of v1 */
-   ECORE_POS_MAP_SPRING /**< Start at 0.0 then "wobble" like a spring rest position 1.0, and wobble v2 times, with decay factor of v1 */
+   ECORE_POS_MAP_SPRING, /**< Start at 0.0 then "wobble" like a spring rest position 1.0, and wobble v2 times, with decay factor of v1 */
+   ECORE_POS_MAP_CUBIC_BEZIER /**< Follow the cubic-bezier curve calculated with the points (x1, y1), (x2, y2) */
 };
 typedef enum _Ecore_Pos_Map Ecore_Pos_Map;
 
@@ -2010,6 +2011,71 @@ EAPI double ecore_animator_frametime_get(void);
  * @since 1.1.0
  */
 EAPI double ecore_animator_pos_map(double pos, Ecore_Pos_Map map, double v1, double v2);
+
+/**
+ * @brief Maps an input position from 0.0 to 1.0 along a timeline to a
+ * position in a different curve.
+ *
+ * @param pos The input position to map
+ * @param map The mapping to use
+ * @param v_size The size of the v array.
+ * @param v An array with the double parameters to be used by the mapping.
+ * NULL if not used.
+ * @return The mapped value
+ *
+ * Takes an input position (0.0 to 1.0) and maps to a new position (normally
+ * between 0.0 and 1.0, but it may go above/below 0.0 or 1.0 to show that it
+ * has "overshot" the mark) using some interpolation (mapping) algorithm.
+ *
+ * This function useful to create non-linear animations. It offers a variety
+ * of possible animation curves to be used:
+ * @li ECORE_POS_MAP_LINEAR - Linear, returns @p pos
+ * @li ECORE_POS_MAP_ACCELERATE - Start slow then speed up
+ * @li ECORE_POS_MAP_DECELERATE - Start fast then slow down
+ * @li ECORE_POS_MAP_SINUSOIDAL - Start slow, speed up then slow down at end
+ * @li ECORE_POS_MAP_ACCELERATE_FACTOR - Start slow then speed up, v[0] being a
+ * power factor, 0.0 being linear, 1.0 being ECORE_POS_MAP_ACCELERATE, 2.0
+ * being much more pronounced accelerate (squared), 3.0 being cubed, etc.
+ * @li ECORE_POS_MAP_DECELERATE_FACTOR - Start fast then slow down, v[0] being a
+ * power factor, 0.0 being linear, 1.0 being ECORE_POS_MAP_DECELERATE, 2.0
+ * being much more pronounced decelerate (squared), 3.0 being cubed, etc.
+ * @li ECORE_POS_MAP_SINUSOIDAL_FACTOR - Start slow, speed up then slow down
+ * at end, v[0] being a power factor, 0.0 being linear, 1.0 being
+ * ECORE_POS_MAP_SINUSOIDAL, 2.0 being much more pronounced sinusoidal
+ * (squared), 3.0 being cubed, etc.
+ * @li ECORE_POS_MAP_DIVISOR_INTERP - Start at gradient * v[0], interpolated via
+ * power of v2 curve
+ * @li ECORE_POS_MAP_BOUNCE - Start at 0.0 then "drop" like a ball bouncing to
+ * the ground at 1.0, and bounce v2 times, with decay factor of v[0]
+ * @li ECORE_POS_MAP_SPRING - Start at 0.0 then "wobble" like a spring rest
+ * position 1.0, and wobble v2 times, with decay factor of v[0]
+ * @li ECORE_POS_MAP_CUBIC_BEZIER - Use an interpolated cubic-bezier curve
+ * ajusted with parameters from v[0] to v[3].
+ * @note When not listed v has no effect.
+ *
+ * @image html ecore-pos-map.png
+ * @image latex ecore-pos-map.eps width=\textwidth
+ *
+ * One way to use this would be:
+ * @code
+ * double pos; // input position in a timeline from 0.0 to 1.0
+ * double out; // output position after mapping
+ * int x1, y1, x2, y2; // x1 & y1 are start position, x2 & y2 are end position
+ * int x, y; // x & y are the calculated position
+ * double v[2] = {1.8, 7};
+ *
+ * out = ecore_animator_pos_map(pos, ECORE_POS_MAP_BOUNCE, 2, v);
+ * x = (x1 * out) + (x2 * (1.0 - out));
+ * y = (y1 * out) + (y2 * (1.0 - out));
+ * move_my_object_to(myobject, x, y);
+ * @endcode
+ * This will make an animation that bounces 7 each times diminishing by a
+ * factor of 1.8.
+ *
+ * @see _Ecore_Pos_Map
+ */
+EAPI double ecore_animator_pos_map_n(double pos, Ecore_Pos_Map map, int v_size, double v[]);
+
 /**
  * @brief Set the source of animator ticks for the mainloop
  *
diff --git a/src/lib/ecore/ecore_anim.c b/src/lib/ecore/ecore_anim.c
index 7b33f71385..dd76dafcbf 100644
--- a/src/lib/ecore/ecore_anim.c
+++ b/src/lib/ecore/ecore_anim.c
@@ -313,6 +313,72 @@ _pos_map_spring(double pos,
    return _pos_map_sin((M_PI / 2.0) + (p2 * len)) * decay;
 }
 
+static double
+_cubic_bezier_a (double a1, double a2)
+{
+    return 1.0 - 3.0 * a2 + 3.0 * a1;
+}
+
+static double
+_cubic_bezier_b (double a1, double a2)
+{
+    return 3.0 * a2 - 6.0 * a1;
+}
+
+static double
+_cubic_bezier_c(double a1)
+{
+    return 3.0 * a1;
+}
+
+static double
+_cubic_bezier_calc(double t,
+                   double a1,
+                   double a2)
+{
+    return ((_cubic_bezier_a(a1, a2) * t +
+             _cubic_bezier_b(a1, a2)) * t +
+            _cubic_bezier_c(a1)) * t;
+}
+
+static double
+_cubic_bezier_slope_get(double t,
+                        double a1,
+                        double a2)
+{
+    return 3.0 * _cubic_bezier_a(a1, a2) * t * t +
+           2.0 * _cubic_bezier_b(a1, a2) * t +
+           _cubic_bezier_c(a1);
+}
+
+static double
+_cubic_bezier_t_get(double a,
+                        double x1,
+                        double x2)
+{
+    double guess_t = a;
+    for (int i = 0; i < 4; ++i)
+    {
+        double current_slope = _cubic_bezier_slope_get(a, x1, x2);
+        if (current_slope == 0.0)
+            return guess_t;
+        double current_x = _cubic_bezier_calc(guess_t, x1, x2) - a;
+        guess_t -= current_x / current_slope;
+    }
+    return guess_t;
+}
+
+static double
+_pos_map_cubic_bezier(double pos,
+                      double x1,
+                      double y1,
+                      double x2,
+                      double y2)
+{
+    if (x1 == y1 && x2 == y2) return pos;
+    return _cubic_bezier_calc(_cubic_bezier_t_get(pos, x1, x2), y1, y2);
+}
+
 #define DBL_TO(Fp) eina_f32p32_double_to(Fp)
 #define DBL_FROM(D) eina_f32p32_double_from(D)
 #define INT_FROM(I) eina_f32p32_int_from(I)
@@ -323,11 +389,13 @@ _pos_map_spring(double pos,
 #define MUL(A, B) eina_f32p32_mul(A, B)
 
 EAPI double
-ecore_animator_pos_map(double        pos,
-                       Ecore_Pos_Map map,
-                       double        v1,
-                       double        v2)
+ecore_animator_pos_map_n(double        pos,
+                         Ecore_Pos_Map map,
+                         int v_size,
+                         double v[])
 {
+    double v0 = 0, v1 = 0, v2 = 0, v3 = 0;
+
    /* purely functional - locking not required */
     if (pos >= 1.0) return 1.0;
     else if (pos <= 0.0)
@@ -353,30 +421,47 @@ ecore_animator_pos_map(double        pos,
          return pos;
 
        case ECORE_POS_MAP_ACCELERATE_FACTOR:
-         pos = _pos_map_accel_factor(pos, v1);
+         if (v_size > 0) v0 = v[0];
+         pos = _pos_map_accel_factor(pos, v0);
          return pos;
 
        case ECORE_POS_MAP_DECELERATE_FACTOR:
-         pos = 1.0 - _pos_map_accel_factor(1.0 - pos, v1);
+         if (v_size > 0) v0 = v[0];
+         pos = 1.0 - _pos_map_accel_factor(1.0 - pos, v0);
          return pos;
 
        case ECORE_POS_MAP_SINUSOIDAL_FACTOR:
-         if (pos < 0.5) pos = _pos_map_accel_factor(pos * 2.0, v1) / 2.0;
-         else pos = 1.0 - (_pos_map_accel_factor((1.0 - pos) * 2.0, v1) / 2.0);
+         if (v_size > 0) v0 = v[0];
+         if (pos < 0.5) pos = _pos_map_accel_factor(pos * 2.0, v0) / 2.0;
+         else pos = 1.0 - (_pos_map_accel_factor((1.0 - pos) * 2.0, v0) / 2.0);
          return pos;
 
        case ECORE_POS_MAP_DIVISOR_INTERP:
-         pos = _pos_map_pow(pos, v1, (int)v2);
+         if (v_size > 0) v0 = v[0];
+         if (v_size > 1) v1 = v[1];
+         pos = _pos_map_pow(pos, v0, (int)v1);
          return pos;
 
        case ECORE_POS_MAP_BOUNCE:
-         pos = _pos_map_spring(pos, (int)v2, v1);
+         if (v_size > 0) v0 = v[0];
+         if (v_size > 1) v1 = v[1];
+         pos = _pos_map_spring(pos, (int)v1, v0);
          if (pos < 0.0) pos = -pos;
          pos = 1.0 - pos;
          return pos;
 
        case ECORE_POS_MAP_SPRING:
-         pos = 1.0 - _pos_map_spring(pos, (int)v2, v1);
+         if (v_size > 0) v0 = v[0];
+         if (v_size > 1) v1 = v[1];
+         pos = 1.0 - _pos_map_spring(pos, (int)v1, v0);
+         return pos;
+
+       case ECORE_POS_MAP_CUBIC_BEZIER:
+         if (v_size > 0) v0 = v[0];
+         if (v_size > 1) v1 = v[1];
+         if (v_size > 2) v2 = v[2];
+         if (v_size > 3) v3 = v[3];
+         pos = _pos_map_cubic_bezier(pos, v0, v1, v2, v3);
          return pos;
 
        default:
@@ -386,6 +471,19 @@ ecore_animator_pos_map(double        pos,
     return pos;
 }
 
+EAPI double
+ecore_animator_pos_map(double        pos,
+                       Ecore_Pos_Map map,
+                       double        v1,
+                       double        v2)
+{
+    double v[2];
+
+    v[0] = v1;
+    v[1] = v2;
+    return ecore_animator_pos_map_n(pos, map, 2, v);
+}
+
 EAPI void *
 ecore_animator_del(Ecore_Animator *obj)
 {