src/easing.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * Contact:
   4  *   Moonlight List (moonlight-list@lists.ximian.com)
   5  *
   6  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   7  *
   8  * See the LICENSE file included with the distribution for details.
   9  *
  10  */
  11
  12 #include <config.h>
  13
  14 #include <glib.h>
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <malloc.h>
  20 #include <math.h>
  21
  22 #include <runtime.h>
  23 #include <timemanager.h>
  24 #include <timesource.h>
  25
  26 #include "easing.h"
  27
  28 // base
  29
  30 EasingFunctionBase::EasingFunctionBase ()
  31 {
  32         SetObjectType (Type::EASINGFUNCTIONBASE);
  33         easing_function_callback = NULL;
  34 }
  35
  36 EasingFunctionBase::~EasingFunctionBase ()
  37 {
  38 }
  39
  40
  41 double
  42 EasingFunctionBase::Ease (double normalizedTime)
  43 {
  44         if (easing_function_callback)
  45                 return easing_function_callback (normalizedTime);
  46
  47         switch (GetEasingMode()) {
  48         case EasingModeIn:
  49                 return EaseInCore (normalizedTime);
  50         case EasingModeOut:
  51                 return 1.0 - EaseInCore (1 - normalizedTime);
  52         case EasingModeInOut:
  53                 return (normalizedTime <= 0.5
  54                         ? EaseInCore (normalizedTime * 2) * 0.5
  55                         : 1.0 - EaseInCore ((1 - normalizedTime) * 2) * 0.5);
  56         default:
  57                 // XXX
  58                 return 0.0;
  59         }
  60 }
  61
  62 void
  63 EasingFunctionBase::SetEasingFunction (EasingFunction easing_function)
  64 {
  65         easing_function_callback = easing_function;
  66 }
  67
  68 // Back
  69
  70 BackEase::BackEase ()
  71 {
  72         SetObjectType (Type::BACKEASE);
  73 }
  74
  75 BackEase::~BackEase ()
  76 {
  77 }
  78
  79 double
  80 BackEase::EaseInCore (double normalizedTime)
  81 {
  82         double t_cubed = normalizedTime * normalizedTime * normalizedTime;
  83
  84         return t_cubed - normalizedTime * GetAmplitude () * sin (normalizedTime * M_PI);
  85 }
  86
  87 // Bounce
  88
  89 BounceEase::BounceEase ()
  90 {
  91         SetObjectType (Type::BOUNCEEASE);
  92 }
  93
  94 BounceEase::~BounceEase ()
  95 {
  96 }
  97
  98 double
  99 BounceEase::EaseInCore (double normalizedTime)
 100 {
 101         g_warning ("BounceEase::EaseInCore not implemented");
 102         return EasingFunctionBase::EaseInCore (normalizedTime);
 103 }
 104
 105 // Circle
 106
 107 CircleEase::CircleEase ()
 108 {
 109         SetObjectType (Type::CIRCLEEASE);
 110 }
 111
 112 CircleEase::~CircleEase ()
 113 {
 114 }
 115
 116 double
 117 CircleEase::EaseInCore (double normalizedTime)
 118 {
 119         return 1 - sqrt (1 - normalizedTime * normalizedTime);
 120 }
 121
 122 // Cubic
 123
 124 CubicEase::CubicEase ()
 125 {
 126         SetObjectType (Type::CUBICEASE);
 127 }
 128
 129 CubicEase::~CubicEase ()
 130 {
 131 }
 132
 133 double
 134 CubicEase::EaseInCore (double normalizedTime)
 135 {
 136         return normalizedTime * normalizedTime * normalizedTime;
 137 }
 138
 139 // Elastic
 140
 141 ElasticEase::ElasticEase ()
 142 {
 143         SetObjectType (Type::ELASTICEASE);
 144 }
 145
 146 ElasticEase::~ElasticEase ()
 147 {
 148 }
 149
 150 double
 151 ElasticEase::EaseInCore (double normalizedTime)
 152 {
 153         g_warning ("ElasticEase::EaseInCore not implemented");
 154         return EasingFunctionBase::EaseInCore (normalizedTime);
 155 }
 156
 157 // Exponential
 158
 159 ExponentialEase::ExponentialEase ()
 160 {
 161         SetObjectType (Type::EXPONENTIALEASE);
 162 }
 163
 164 ExponentialEase::~ExponentialEase ()
 165 {
 166 }
 167
 168 double
 169 ExponentialEase::EaseInCore (double normalizedTime)
 170 {
 171         return (exp (GetExponent () * normalizedTime) - 1) /  (exp (GetExponent ()) - 1);
 172 }
 173
 174 // Power
 175
 176 PowerEase::PowerEase ()
 177 {
 178         SetObjectType (Type::POWEREASE);
 179 }
 180
 181 PowerEase::~PowerEase ()
 182 {
 183 }
 184
 185 double
 186 PowerEase::EaseInCore (double normalizedTime)
 187 {
 188         return pow (normalizedTime, GetPower ());
 189 }
 190
 191 // Quadratic
 192
 193 QuadraticEase::QuadraticEase ()
 194 {
 195         SetObjectType (Type::QUADRATICEASE);
 196 }
 197
 198 QuadraticEase::~QuadraticEase ()
 199 {
 200 }
 201
 202 double
 203 QuadraticEase::EaseInCore (double normalizedTime)
 204 {
 205         return normalizedTime * normalizedTime;
 206 }
 207
 208
 209 // Quartic
 210
 211 QuarticEase::QuarticEase ()
 212 {
 213         SetObjectType (Type::QUARTICEASE);
 214 }
 215
 216 QuarticEase::~QuarticEase ()
 217 {
 218 }
 219
 220 double
 221 QuarticEase::EaseInCore (double normalizedTime)
 222 {
 223         return normalizedTime * normalizedTime * normalizedTime * normalizedTime;
 224 }
 225
 226
 227 // Quintic
 228
 229 QuinticEase::QuinticEase ()
 230 {
 231         SetObjectType (Type::QUINTICEASE);
 232 }
 233
 234 QuinticEase::~QuinticEase ()
 235 {
 236 }
 237
 238 double
 239 QuinticEase::EaseInCore (double normalizedTime)
 240 {
 241         return normalizedTime * normalizedTime * normalizedTime * normalizedTime * normalizedTime;
 242 }
 243
 244
 245 // Sine
 246
 247 SineEase::SineEase ()
 248 {
 249         SetObjectType (Type::SINEEASE);
 250 }
 251
 252 SineEase::~SineEase ()
 253 {
 254 }
 255
 256 double
 257 SineEase::EaseInCore (double normalizedTime)
 258 {
 259         return 1.0 - sin ((1.0 - normalizedTime) * M_PI_2);
 260 }
 261