src/swfc-interpolation.c

   1 /* swfc- Compiles swf code (.sc) files into .swf files.
   2
   3    Part of the swftools package.
   4
   5    Copyright (c) 2007 Huub Schaeks <huub@h-schaeks.speedlinq.nl>
   6    Copyright (c) 2007 Matthias Kramm <kramm@quiss.org>
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  21
  22 #include <stdlib.h>
  23 #include <math.h>
  24 #include <memory.h>
  25 #include "swfc-interpolation.h"
  26
  27 static inline float poly(float fraction, float start, float delta, float slope, int degree)
  28 {
  29     return delta * ((1 - slope) * pow(fraction, degree) + slope * fraction) + start;
  30 }
  31
  32 float linear(float fraction, float start, float delta)
  33 {
  34         return poly(fraction, start, delta, 0, 1);
  35 }
  36
  37 float quadIn(float fraction, float start, float delta, float slope)
  38 {
  39         return poly(fraction, start, delta, slope, 2);
  40 }
  41
  42 float quadOut(float fraction, float start, float delta, float slope)
  43 {
  44         return quadIn(1 - fraction, start + delta, -delta, slope);
  45 }
  46
  47 float quadInOut(float fraction, float start, float delta, float slope)
  48 {
  49         if (fraction < 0.5)
  50                 return quadIn(2 * fraction, start, delta / 2, slope);
  51         return quadOut(2 * fraction - 1, start + delta / 2, delta / 2, slope);
  52 }
  53
  54 float cubicIn(float fraction, float start, float delta, float slope)
  55 {
  56         return poly(fraction, start, delta, slope, 3);
  57 }
  58
  59 float cubicOut(float fraction, float start, float delta, float slope)
  60 {
  61         return cubicIn(1 - fraction, start + delta, -delta, slope);
  62 }
  63
  64 float cubicInOut(float fraction, float start, float delta, float slope)
  65 {
  66         if (fraction < 0.5)
  67                 return cubicIn(2 * fraction, start, delta / 2, slope);
  68         return cubicOut(2 * fraction - 1, start + delta / 2, delta / 2, slope);
  69 }
  70
  71 float quartIn(float fraction, float start, float delta, float slope)
  72 {
  73         return poly(fraction, start, delta, slope, 4);
  74 }
  75
  76 float quartOut(float fraction, float start, float delta, float slope)
  77 {
  78         return quartIn(1 - fraction, start + delta, -delta, slope);
  79 }
  80
  81 float quartInOut(float fraction, float start, float delta, float slope)
  82 {
  83         if (fraction < 0.5)
  84                 return quartIn(2 * fraction, start, delta / 2, slope);
  85         return quartOut(2 * fraction - 1, start + delta / 2, delta / 2, slope);
  86 }
  87
  88 float quintIn(float fraction, float start, float delta, float slope)
  89 {
  90         return poly(fraction, start, delta, slope, 5);
  91 }
  92
  93 float quintOut(float fraction, float start, float delta, float slope)
  94 {
  95         return quintIn(1 - fraction, start + delta, -delta, slope);
  96 }
  97
  98 float quintInOut(float fraction, float start, float delta, float slope)
  99 {
 100         if (fraction < 0.5)
 101                 return quintIn(2 * fraction, start, delta / 2, slope);
 102         return quintOut(2 * fraction - 1, start + delta / 2, delta / 2, slope);
 103 }
 104
 105 float circleIn(float fraction, float start, float delta, float slope)
 106 {
 107     return delta * (1 - sqrt(1 - (1 - 2 * slope) * fraction * fraction - 2 * slope * fraction)) + start;
 108 }
 109
 110 float circleOut(float fraction, float start, float delta, float slope)
 111 {
 112         return circleIn(1 - fraction, start + delta, -delta, slope);
 113 }
 114
 115 float circleInOut(float fraction, float start, float delta, float slope)
 116 {
 117         if (fraction < 0.5)
 118                 return circleIn(2 * fraction, start, delta / 2, slope);
 119         return circleOut(2 * fraction - 1, start + delta / 2, delta / 2, slope);
 120 }
 121
 122 float exponentialIn(float fraction, float start, float delta)
 123 {
 124         if (fraction == 0)
 125                 return start;
 126         return delta * pow(2, 10 * (fraction - 1)) + start;
 127 }
 128
 129 float exponentialOut(float fraction, float start, float delta)
 130 {
 131         return exponentialIn(1 - fraction, start + delta, -delta);
 132 }
 133
 134 float exponentialInOut(float fraction, float start, float delta)
 135 {
 136         if (fraction < 0.5)
 137                 return exponentialIn(2 * fraction, start, delta / 2);
 138         return exponentialOut(2 * fraction - 1, start + delta / 2, delta / 2);
 139 }
 140
 141 float sineIn(float fraction, float start, float delta)
 142 {
 143         return delta * (1 - cos(fraction * M_PI/2)) + start;
 144 }
 145
 146 float sineOut(float fraction, float start, float delta)
 147 {
 148         return sineIn(1 - fraction, start + delta, -delta);
 149 }
 150
 151 float sineInOut(float fraction, float start, float delta)
 152 {
 153         if (fraction < 0.5)
 154                 return sineIn(2 * fraction, start, delta / 2);
 155         return sineOut(2 * fraction - 1, start + delta / 2, delta / 2);
 156 }
 157
 158 float elasticIn(float fraction, float start, float delta, float amplitude, int bounces, float damping)
 159 {
 160         if (fraction == 0 || delta == 0)
 161                 return start;
 162         if (fraction == 1)
 163                 return start + delta;
 164         if (amplitude < fabs(delta))
 165                 amplitude = delta;
 166         float period = 1 / (bounces + 0.25);
 167         return amplitude * pow(2, damping * (fraction - 1)) * sin(fraction * (2 * M_PI) / period) + start;
 168 }
 169
 170 float elasticOut(float fraction, float start, float delta, float amplitude, int bounces, float damping)
 171 {
 172         return elasticIn(1 - fraction, start + delta, -delta, amplitude, bounces, damping);
 173 }
 174
 175 float elasticInOut(float fraction, float start, float delta, float amplitude, int bounces, float damping)
 176 {
 177         if (fraction < 0.5)
 178                 return elasticIn(2 * fraction, start, delta / 2, amplitude, bounces, damping);
 179         return elasticOut(2 * fraction - 1, start + delta / 2, delta / 2, amplitude, bounces, damping);
 180 }
 181
 182 float backIn(float fraction, float start, float delta, float speed)
 183 {
 184         return delta * fraction * fraction * ((speed + 1) * fraction - speed) + start;
 185 }
 186
 187 float backOut(float fraction, float start, float delta, float speed)
 188 {
 189         return backIn(1 - fraction, start + delta, -delta, speed);
 190 }
 191
 192 float backInOut(float fraction, float start, float delta, float speed)
 193 {
 194         if (fraction < 0.5)
 195                 return backIn(2 * fraction, start, delta / 2, speed);
 196         return backOut(2 * fraction - 1, start + delta / 2, delta / 2, speed);
 197 }
 198
 199 /* when applied to movement bounceIn the object 'hits the floor' bounces times
 200  * (after leaving the floor first) before gently reaching the final position at the top of the final bounce
 201  * Each bounce takes growth times a long as the previous, except for the last one which lasts only half
 202  * that time. The heights of the intermediate bounces are determined by the damping parameter.
 203  * Set damping to 0 for an undamped movement.*/
 204
 205 float bounceIn(float fraction, float start, float delta, int bounces, float growth, float damping)
 206 {
 207         if (fraction == 0 || delta == 0)
 208                 return start;
 209         if (fraction == 1)
 210                 return start + delta;
 211         float w0;
 212         if (growth == 1.0)
 213                 w0 = 1 / (bounces + 0.5);
 214         else
 215         {
 216                 float gN = pow(growth, bounces);
 217                 w0 = 1 / ((gN - 1) / (growth - 1) + gN / 2 );
 218         }
 219         float bounceStart = 0;
 220         int i;
 221         float w = w0;
 222         for (i = 0; i <= bounces; i++)
 223         {
 224                 float bounceEnd = bounceStart + w;
 225                 if (fraction >= bounceStart && fraction < bounceEnd)
 226                 {
 227                         float half = (bounceEnd + bounceStart) / 2;
 228                         float top = delta / pow(2, damping * ((bounces - i)));
 229                         fraction -= half;
 230                         fraction /= (w / 2);
 231                         return (1 - fraction * fraction) * top + start;
 232                 }
 233                 bounceStart = bounceEnd;
 234                 w = w * growth;
 235         }
 236 }
 237
 238 /* bounceOut is a time-reversed bounceIn; therefore each bounce takes 1/growth times as long as
 239  * the previous, which I think fits the idea when applied to movement */
 240
 241 float bounceOut(float fraction, float start, float delta, int bounces, float growth, float damping)
 242 {
 243         return bounceIn(1 - fraction, start + delta, -delta, bounces, growth, damping);
 244 }
 245
 246 /* since bounceIn and bounceOut are combined, if growth > 1 then the bounce-times will increase in
 247  * the first half and decrease in the second half */
 248
 249 float bounceInOut(float fraction, float start, float delta, int bounces, float growth, float damping)
 250 {
 251         if (fraction < 0.5)
 252                 return bounceIn(2 * fraction, start, delta / 2, bounces, growth, damping);
 253         return bounceOut(2 * fraction - 1, start + delta / 2, delta / 2, bounces, growth, damping);
 254 }
 255 /* fastBounce(In/Out) doesn't end or start in a horizontal slope (= gentle end or start) as
 256  * bounce(In/Out) do which means fastBounceInOut doesn't have the 'delay' in the middle */
 257 float fastBounceIn(float fraction, float start, float delta, int bounces, float growth, float damping)
 258 {
 259         if (fraction == 0 || delta == 0)
 260                 return start;
 261         if (fraction == 1)
 262                 return start + delta;
 263         float w0;
 264         if (growth == 1.0)
 265                 w0 = 1 / (bounces + 0.25); /* in general (bounces + 1 / (2 * f)) */
 266         else
 267         {
 268                 float gN = pow(growth, bounces);
 269                 w0 = 1 / ((gN - 1) / (growth - 1) + gN / 4 /* in general: gN / (2 * f) */ );
 270         }
 271         float bounceStart = 0;
 272         int i;
 273         float w = w0;
 274         for (i = 0; i <= bounces; i++)
 275         {
 276                 float bounceEnd = bounceStart + w;
 277                 if (fraction >= bounceStart && fraction < bounceEnd)
 278                 {
 279                         float half = (bounceEnd + bounceStart) / 2;
 280                         float top = delta / 0.75/* in general: (1 - (1 / f) * (1 / f)) */ / pow(2, damping * ((bounces - i)));
 281                         fraction -= half;
 282                         fraction /= (w / 2);
 283                         return (1 - fraction * fraction) * top + start;
 284                 }
 285                 bounceStart = bounceEnd;
 286                 w = w * growth;
 287         }
 288 }
 289
 290 float fastBounceOut(float fraction, float start, float delta, int bounces, float growth, float damping)
 291 {
 292         return fastBounceIn(1 - fraction, start + delta, -delta, bounces, growth, damping);
 293 }
 294
 295 float fastBounceInOut(float fraction, float start, float delta, int bounces, float growth, float damping)
 296 {
 297         if (fraction < 0.5)
 298                 return fastBounceIn(2 * fraction, start, delta / 2, bounces, growth, damping);
 299         return fastBounceOut(2 * fraction - 1, start + delta / 2, delta / 2, bounces, growth, damping);
 300 }