code-samples/Tweener/TweenEquation.h at master · mwgray/code-samples · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
// Copyright 2006-12 HumaNature Studios Inc.

#ifndef __TWEENEQUATION_H__
#define __TWEENEQUATION_H__

#include "TweenType.h"

namespace core {

    class TweenEquation
    {
    public:
        // Easing equation general parameters
        // @param t     Current time (in frames or seconds).
        // @param b     Starting value.
        // @param c     Change needed in value.
        // @param d     Expected easing duration (in frames or seconds).
        typedef float(*Signature)(float t, float b, float c, float d);

        static Signature getEquation(TweenType type);

        // Easing equation function for a simple linear tweening, with no easing.
        static float easeNone (float t, float b, float c, float d);

        // Easing equation function for a quadratic (t^2) easing in: accelerating from zero velocity.
        static float easeInQuad (float t, float b, float c, float d);

        // Easing equation function for a quadratic (t^2) easing out: decelerating to zero velocity.
        static float easeOutQuad (float t, float b, float c, float d);

        // Easing equation function for a quadratic (t^2) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutQuad (float t, float b, float c, float d);

        // Easing equation function for a quadratic (t^2) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInQuad (float t, float b, float c, float d);

        // Easing equation function for a cubic (t^3) easing in: accelerating from zero velocity.
        static float easeInCubic (float t, float b, float c, float d);

        // Easing equation function for a cubic (t^3) easing out: decelerating from zero velocity.
        static float easeOutCubic (float t, float b, float c, float d);

        // Easing equation function for a cubic (t^3) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutCubic (float t, float b, float c, float d);

        // Easing equation function for a cubic (t^3) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInCubic (float t, float b, float c, float d);

        // Easing equation function for a quartic (t^4) easing in: accelerating from zero velocity.
        static float easeInQuart (float t, float b, float c, float d);

        // Easing equation function for a quartic (t^4) easing out: decelerating from zero velocity.
        static float easeOutQuart (float t, float b, float c, float d);

        // Easing equation function for a quartic (t^4) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutQuart (float t, float b, float c, float d);

        // Easing equation function for a quartic (t^4) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInQuart (float t, float b, float c, float d);

        // Easing equation function for a quintic (t^5) easing in: accelerating from zero velocity.
        static float easeInQuint (float t, float b, float c, float d);

        // Easing equation function for a quintic (t^5) easing out: decelerating from zero velocity.
        static float easeOutQuint (float t, float b, float c, float d);

        // Easing equation function for a quintic (t^5) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutQuint (float t, float b, float c, float d);

        // Easing equation function for a quintic (t^5) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInQuint (float t, float b, float c, float d);

        // Easing equation function for a sinusoidal (sin(t)) easing in: accelerating from zero velocity.
        static float easeInSine (float t, float b, float c, float d);

        // Easing equation function for a sinusoidal (sin(t)) easing out: decelerating from zero velocity.
        static float easeOutSine (float t, float b, float c, float d);

        // Easing equation function for a sinusoidal (sin(t)) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutSine (float t, float b, float c, float d);

        // Easing equation function for a sinusoidal (sin(t)) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInSine (float t, float b, float c, float d);

        // Easing equation function for an exponential (2^t) easing in: accelerating from zero velocity.
        static float easeInExpo (float t, float b, float c, float d);

        // Easing equation function for an exponential (2^t) easing out: decelerating from zero velocity.
        static float easeOutExpo (float t, float b, float c, float d);

        // Easing equation function for an exponential (2^t) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutExpo (float t, float b, float c, float d);

        // Easing equation function for an exponential (2^t) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInExpo (float t, float b, float c, float d);

        // Easing equation function for a circular (sqrt(1-t^2)) easing in: accelerating from zero velocity.
        static float easeInCirc (float t, float b, float c, float d);

        // Easing equation function for a circular (sqrt(1-t^2)) easing out: decelerating from zero velocity.
        static float easeOutCirc (float t, float b, float c, float d);

        // Easing equation function for a circular (sqrt(1-t^2)) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutCirc (float t, float b, float c, float d);

        // Easing equation function for a circular (sqrt(1-t^2)) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInCirc (float t, float b, float c, float d);

        // Easing equation function for an elastic (exponentially decaying sine wave) easing in: accelerating from zero velocity.
        static float easeInElastic (float t, float b, float c, float d);

        // Easing equation function for an elastic (exponentially decaying sine wave) easing out: decelerating from zero velocity.
        static float easeOutElastic (float t, float b, float c, float d);

        // Easing equation function for an elastic (exponentially decaying sine wave) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutElastic (float t, float b, float c, float d);

        // Easing equation function for an elastic (exponentially decaying sine wave) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInElastic (float t, float b, float c, float d);

        // Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in: accelerating from zero velocity.
        static float easeInBack (float t, float b, float c, float d);

        // Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out: decelerating from zero velocity.
        static float easeOutBack (float t, float b, float c, float d);

        // Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutBack (float t, float b, float c, float d);

        // Easing equation function for a back (overshooting cubic easing: (s+1)*t^3 - s*t^2) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInBack (float t, float b, float c, float d);

        // Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out: decelerating from zero velocity.
        static float easeOutBounce (float t, float b, float c, float d);

        // Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in: accelerating from zero velocity.
        static float easeInBounce (float t, float b, float c, float d);

        // Easing equation function for a bounce (exponentially decaying parabolic bounce) easing in/out: acceleration until halfway, then deceleration.
        static float easeInOutBounce (float t, float b, float c, float d);

        // Easing equation function for a bounce (exponentially decaying parabolic bounce) easing out/in: deceleration until halfway, then acceleration.
        static float easeOutInBounce (float t, float b, float c, float d);
    };

} // namespace core

#endif // __TWEENEQUATION_H__