BCSTM-Player |

external/tween-engine/src/equations/Back.cpp

@@ -0,0 +1,34 @@
+//
+//  Back.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <TweenEngine/equations/Back.h>
+
+#define S   (1.70158f)
+
+namespace TweenEngine
+{
+    float BackIn::compute(float t) { return t*t*((S+1)*t - S); }
+    const char *BackIn::toString() { return "Back.IN"; }
+    
+    float BackOut::compute(float t) {
+        t -= 1;
+        return (t*t*((S+1)*t + S) + 1);
+    }
+    const char *BackOut::toString() { return "Back.OUT"; }
+    
+    float BackInOut::compute(float t) {
+        float s=S*1.525;
+        t*=2;
+        if (t < 1) {
+            return 0.5f*(t*t*((s+1)*t - s));
+        } else {
+            t -= 2;
+            return 0.5f*(t*t*((s+1)*t + s) + 2);
+        }
+    }
+    const char *BackInOut::toString() { return "Back.INOUT"; }
+}

external/tween-engine/src/equations/Bounce.cpp

@@ -0,0 +1,42 @@
+//
+//  Bounce.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <TweenEngine/equations/Bounce.h>
+
+namespace TweenEngine
+{
+    inline float outBounce(float t) {
+        if (t < (1/2.75)) {
+            return 7.5625f*t*t;
+        } else if (t < (2/2.75)) {
+            t = t - (1.5 / 2.75);
+            return (7.5625 * t * t + 0.75);
+        } else if (t < (2.5/2.75)) {
+            t = t - (2.25 / 2.75);
+            return (7.5625 * t * t + 0.9375);
+        } else {
+            t = t - (2.625 / 2.75);
+            return (7.5625 * t * t + 0.984375);
+        }
+    }
+
+    inline float inBounce(float t) {
+        return 1 - outBounce(1-t);
+    }
+   
+    float BounceIn::compute(float t) { return inBounce(t); }
+    const char *BounceIn::toString() { return "Bounce.IN"; }
+    
+    float BounceOut::compute(float t) { return outBounce(t); }
+    const char *BounceOut::toString() { return "Bounce.OUT"; }
+    
+    float BounceInOut::compute(float t) {
+        if (t < 0.5f) return (inBounce(t*2) * 0.5f);
+        else return (outBounce(t*2-1) * 0.5f + 0.5f);
+    }
+    const char *BounceInOut::toString() { return "Bounce.INOUT"; }
+}

external/tween-engine/src/equations/Circ.cpp

@@ -0,0 +1,30 @@
+//
+//  Circ.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <math.h>
+#include <TweenEngine/equations/Circ.h>
+
+namespace TweenEngine
+{
+    float CircIn::compute(float t) { return (float) -sqrt(1 - t*t) - 1; }
+    const char *CircIn::toString() { return "Circ.IN"; }
+    
+    float CircOut::compute(float t) { return (float) sqrt(1 - (t-1)*(t-1)); }
+    const char *CircOut::toString() { return "Circ.OUT"; }
+    
+    float CircInOut::compute(float t) {
+        t *= 2;
+        if (t < 1) {
+            return (-0.5 * (sqrt(1 - t*t) - 1));
+        } else {
+            t -= 2;
+            return (0.5 * (sqrt(1 - t*t) + 1));
+        }
+    }
+    
+    const char *CircInOut::toString() { return "Circ.INOUT"; }
+}

external/tween-engine/src/equations/Cubic.cpp

@@ -0,0 +1,31 @@
+//
+//  Cubic.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <TweenEngine/equations/Cubic.h>
+
+namespace TweenEngine
+{
+    float CubicIn::compute(float t) { return t*t*t; }
+    const char *CubicIn::toString() { return "Cubic.IN"; }
+    
+    float CubicOut::compute(float t) {
+        t -= 1;
+        return t*t*t + 1;
+    }
+    const char *CubicOut::toString() { return "Cubic.OUT"; }
+    
+    float CubicInOut::compute(float t) {
+        t *= 2;
+        if (t < 1) {
+            return 0.5f * t*t*t;
+        } else {
+            t -= 2;
+            return 0.5f * (t*t*t + 2);
+        }
+    }
+    const char *CubicInOut::toString() { return "Cubic.INOUT"; }
+}

external/tween-engine/src/equations/Elastic.cpp

@@ -0,0 +1,80 @@
+//
+//  Elastic.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <math.h>
+#include <TweenEngine/equations/Elastic.h>
+
+#define M_PI        3.14159265358979323846
+#define M_TWOPI         (M_PI * 2.0)
+
+namespace TweenEngine
+{
+    float ElasticIn::compute(float t) {
+        float a = amplitude;
+        float p = period;
+        if (t == 0) return 0;
+        if (t == 1) return 1;
+        if (!isPeriodSet) p = 0.3;
+        float s;
+        if (!isAmplitudeSet || a < 1) {
+            a = 1;
+            s = p/4.0;
+        } else {
+            s = p/(M_TWOPI) * (float)asin(1/a);
+        }
+        t -= 1;
+        return -(a*(float)pow(2,10*t) * (float)sin((t-s)*(M_TWOPI)/p ));
+    }
+    const char *ElasticIn::toString() { return "Elastic.IN"; }
+    void ElasticIn::setAmplitude(float a) { this->amplitude = a; this->isAmplitudeSet = true; }
+    void ElasticIn::setPeriod(float p) { this->period = p; this->isPeriodSet = true; }
+    
+    float ElasticOut::compute(float t) {
+        float a = amplitude;
+        float p = period;
+        if (t==0) return 0;
+        if (t==1) return 1;
+        if (!isPeriodSet) p = 0.3f;
+        float s;
+        if (!isAmplitudeSet || a < 1) {
+            a = 1;
+            s = p/4.0;
+        } else {
+            s = p/(M_TWOPI) * (float)asin(1/a);
+        }
+        return a*(float)pow(2,-10*t) * (float)sin((t-s)*(M_TWOPI)/p ) + 1;
+    }
+    const char *ElasticOut::toString() { return "Elastic.OUT"; }
+    void ElasticOut::setAmplitude(float a) { this->amplitude = a; this->isAmplitudeSet = true; }
+    void ElasticOut::setPeriod(float p) { this->period = p; this->isPeriodSet = true; }
+    
+    float ElasticInOut::compute(float t) {
+        float a = amplitude;
+        float p = period;
+        if (t==0) return 0;
+        t *= 2;
+        if (t==2) return 1;
+        if (!isPeriodSet) p = 0.3f*1.5f;
+        float s;
+        if (!isAmplitudeSet || a < 1) {
+            a = 1;
+            s = p/4.0;
+        } else {
+            s = p/(M_TWOPI) * (float)asin(1/a);
+        }
+        if (t < 1) {
+            t -= 1;
+            return -0.5f*(a*(float)pow(2,10*t) * (float)sin((t-s)*(M_TWOPI)/p));
+        } else {
+            t -= 1;
+            return a*(float)pow(2,-10*t) * (float)sin((t-s)*(M_TWOPI)/p)*0.5f + 1;
+        }
+    }
+    const char *ElasticInOut::toString() { return "Elastic.INOUT"; }
+    void ElasticInOut::setAmplitude(float a) { this->amplitude = a; this->isAmplitudeSet = true; }
+    void ElasticInOut::setPeriod(float p) { this->period = p; this->isPeriodSet = true; }
+}

external/tween-engine/src/equations/Expo.cpp

@@ -0,0 +1,35 @@
+//
+//  Expo.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <math.h>
+#include <TweenEngine/equations/Expo.h>
+
+namespace TweenEngine
+{
+    float ExpoIn::compute(float t) {
+        return (t==0) ? 0 : (float)pow(2,10*(t-1));
+    }
+    const char *ExpoIn::toString() { return "Expo.IN"; }
+    
+    float ExpoOut::compute(float t) {
+        return (t==1) ? 1 : -(float)pow(2,-10*t) + 1;
+    }
+    const char *ExpoOut::toString() { return "Expo.OUT"; }
+    
+    float ExpoInOut::compute(float t) {
+        if (t==0) return 0;
+        if (t==1) return 1;
+        t *= 2;
+        if (t < 1) {
+            return 0.5f * (float)pow(2,10*(t-1));
+        } else {
+            t -= 1;
+            return 0.5f * (-(float)pow(2,-10*t) + 2);
+        }
+    }
+    const char *ExpoInOut::toString() { return "Expo.INOUT"; }
+}

external/tween-engine/src/equations/Linear.cpp

@@ -0,0 +1,20 @@
+//
+//  Linear.cpp
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+/**
+ * Easing equation based on Robert Penner's work:
+ * http://robertpenner.com/easing/
+ * @author Aurelien Ribon | http://www.aurelienribon.com/
+ */
+
+#include <TweenEngine/equations/Linear.h>
+
+namespace TweenEngine
+{
+    float LinearInOut::compute(float t) { return t; }
+    const char *LinearInOut::toString() { return "Linear.INOUT"; }
+
+}

external/tween-engine/src/equations/Quad.cpp

@@ -0,0 +1,31 @@
+//
+//  Quad.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+/**
+ * Easing equation based on Robert Penner's work:
+ * http://robertpenner.com/easing/
+ * @author Aurelien Ribon | http://www.aurelienribon.com/
+ */
+
+#include <TweenEngine/equations/Quad.h>
+
+namespace TweenEngine
+{
+    float QuadIn::compute(float t) { return t*t; }
+    const char *QuadIn::toString() { return "Quad.IN"; }
+
+    float QuadOut::compute(float t) { return -t*(t-2); }
+    const char *QuadOut::toString() { return "Quad.OUT"; }
+
+    float QuadInOut::compute(float t)
+    {
+        t*=2;
+        if (t < 1) return 0.5f*t*t;
+        return -0.5f * ((t-1)*(t-3) - 1);
+    }
+    const char *QuadInOut::toString() { return "Quad.INOUT"; }
+}

external/tween-engine/src/equations/Quart.cpp

@@ -0,0 +1,31 @@
+//
+//  Quart.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <TweenEngine/equations/Quart.h>
+
+namespace TweenEngine
+{
+    float QuartIn::compute(float t) { return t*t*t*t; }
+    const char *QuartIn::toString() { return "Quart.IN"; }
+    
+    float QuartOut::compute(float t) {
+        t-=1;
+        return -(t*t*t*t - 1);
+    }
+    const char *QuartOut::toString() { return "Quart.OUT"; }
+    
+    float QuartInOut::compute(float t) {
+        t *= 2;
+        if (t < 1) {
+            return 0.5f*t*t*t*t;
+        } else {
+            t -= 2;
+            return -0.5f * (t*t*t*t - 2);
+        }
+    }
+    const char *QuartInOut::toString() { return "Quart.INOUT"; }
+}

external/tween-engine/src/equations/Quint.cpp

@@ -0,0 +1,31 @@
+//
+//  Quint.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <TweenEngine/equations/Quint.h>
+
+namespace TweenEngine
+{
+    float QuintIn::compute(float t) { return t*t*t*t*t; }
+    const char *QuintIn::toString() { return "Quint.IN"; }
+    
+    float QuintOut::compute(float t) {
+        t-=1;
+        return -(t*t*t*t*t - 1);
+    }
+    const char *QuintOut::toString() { return "Quint.OUT"; }
+    
+    float QuintInOut::compute(float t) {
+        t *= 2;
+        if (t < 1) {
+            return 0.5f*t*t*t*t*t;
+        } else {
+            t -= 2;
+            return -0.5f * (t*t*t*t*t - 2);
+        }
+    }
+    const char *QuintInOut::toString() { return "Quint.INOUT"; }
+}

external/tween-engine/src/equations/Sine.cpp

@@ -0,0 +1,24 @@
+//
+//  Sine.cpp
+//
+//  This code is derived from Universal Tween Engine
+//  Licensed under Apache License 2.0 - http://www.apache.org/licenses/LICENSE-2.0
+//
+
+#include <math.h>
+#include <TweenEngine/equations/Sine.h>
+
+#define M_PI		3.14159265358979323846
+#define M_PI_2		1.57079632679489661923
+
+namespace TweenEngine
+{
+    float SineIn::compute(float t) { return (float)-cos(t * (M_PI_2)) + 1; }
+    const char *SineIn::toString() { return "Sine.IN"; }
+    
+    float SineOut::compute(float t) { return (float)sin(t * (M_PI_2)); }
+    const char *SineOut::toString() { return "Sine.OUT"; }
+    
+    float SineInOut::compute(float t) { return -0.5f * ((float)cos(M_PI*t) - 1); }
+    const char *SineInOut::toString() { return "Sine.INOUT"; }
+}