1/*******************************************************************************************
2*
3* raylib easings (header only file)
4*
5* Useful easing functions for values animation
6*
7* This header uses:
8* #define EASINGS_STATIC_INLINE // Inlines all functions code, so it runs faster.
9* // This requires lots of memory on system.
10* How to use:
11* The four inputs t,b,c,d are defined as follows:
12* t = current time (in any unit measure, but same unit as duration)
13* b = starting value to interpolate
14* c = the total change in value of b that needs to occur
15* d = total time it should take to complete (duration)
16*
17* Example:
18*
19* int currentTime = 0;
20* int duration = 100;
21* float startPositionX = 0.0f;
22* float finalPositionX = 30.0f;
23* float currentPositionX = startPositionX;
24*
25* while (currentPositionX < finalPositionX)
26* {
27* currentPositionX = EaseSineIn(currentTime, startPositionX, finalPositionX - startPositionX, duration);
28* currentTime++;
29* }
30*
31* A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
32*
33* Robert Penner License
34* ---------------------------------------------------------------------------------
35* Open source under the BSD License.
36*
37* Copyright (c) 2001 Robert Penner. All rights reserved.
38*
39* Redistribution and use in source and binary forms, with or without modification,
40* are permitted provided that the following conditions are met:
41*
42* - Redistributions of source code must retain the above copyright notice,
43* this list of conditions and the following disclaimer.
44* - Redistributions in binary form must reproduce the above copyright notice,
45* this list of conditions and the following disclaimer in the documentation
46* and/or other materials provided with the distribution.
47* - Neither the name of the author nor the names of contributors may be used
48* to endorse or promote products derived from this software without specific
49* prior written permission.
50*
51* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
52* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
53* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
54* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
55* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
56* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
58* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
59* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
60* OF THE POSSIBILITY OF SUCH DAMAGE.
61* ---------------------------------------------------------------------------------
62*
63* Copyright (c) 2015 Ramon Santamaria
64*
65* This software is provided "as-is", without any express or implied warranty. In no event
66* will the authors be held liable for any damages arising from the use of this software.
67*
68* Permission is granted to anyone to use this software for any purpose, including commercial
69* applications, and to alter it and redistribute it freely, subject to the following restrictions:
70*
71* 1. The origin of this software must not be misrepresented; you must not claim that you
72* wrote the original software. If you use this software in a product, an acknowledgment
73* in the product documentation would be appreciated but is not required.
74*
75* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
76* as being the original software.
77*
78* 3. This notice may not be removed or altered from any source distribution.
79*
80**********************************************************************************************/
81
82#ifndef EASINGS_H
83#define EASINGS_H
84
85#define EASINGS_STATIC_INLINE // NOTE: By default, compile functions as static inline
86
87#if defined(EASINGS_STATIC_INLINE)
88 #define EASEDEF static inline
89#else
90 #define EASEDEF extern
91#endif
92
93#include <math.h> // Required for: sinf(), cosf(), sqrt(), pow()
94
95#ifndef PI
96 #define PI 3.14159265358979323846f //Required as PI is not always defined in math.h
97#endif
98
99#ifdef __cplusplus
100extern "C" { // Prevents name mangling of functions
101#endif
102
103// Linear Easing functions
104EASEDEF float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }
105EASEDEF float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }
106EASEDEF float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }
107EASEDEF float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); }
108
109// Sine Easing functions
110EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); }
111EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); }
112EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); }
113
114// Circular Easing functions
115EASEDEF float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrt(1.0f - t*t) - 1.0f) + b); }
116EASEDEF float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrt(1.0f - t*t) + b); }
117EASEDEF float EaseCircInOut(float t, float b, float c, float d)
118{
119 if ((t/=d/2.0f) < 1.0f) return (-c/2.0f*(sqrt(1.0f - t*t) - 1.0f) + b);
120 t -= 2.0f; return (c/2.0f*(sqrt(1.0f - t*t) + 1.0f) + b);
121}
122
123// Cubic Easing functions
124EASEDEF float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }
125EASEDEF float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); }
126EASEDEF float EaseCubicInOut(float t, float b, float c, float d)
127{
128 if ((t/=d/2.0f) < 1.0f) return (c/2.0f*t*t*t + b);
129 t -= 2.0f; return (c/2.0f*(t*t*t + 2.0f) + b);
130}
131
132// Quadratic Easing functions
133EASEDEF float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }
134EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); }
135EASEDEF float EaseQuadInOut(float t, float b, float c, float d)
136{
137 if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b);
138 return (-c/2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b);
139}
140
141// Exponential Easing functions
142EASEDEF float EaseExpoIn(float t, float b, float c, float d) { return (t == 0.0f) ? b : (c*pow(2.0f, 10.0f*(t/d - 1.0f)) + b); }
143EASEDEF float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-pow(2.0f, -10.0f*t/d) + 1.0f) + b); }
144EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
145{
146 if (t == 0.0f) return b;
147 if (t == d) return (b + c);
148 if ((t/=d/2.0f) < 1.0f) return (c/2.0f*pow(2.0f, 10.0f*(t - 1.0f)) + b);
149
150 return (c/2.0f*(-pow(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b);
151}
152
153// Back Easing functions
154EASEDEF float EaseBackIn(float t, float b, float c, float d)
155{
156 float s = 1.70158f;
157 float postFix = t/=d;
158 return (c*(postFix)*t*((s + 1.0f)*t - s) + b);
159}
160
161EASEDEF float EaseBackOut(float t, float b, float c, float d)
162{
163 float s = 1.70158f;
164 t = t/d - 1.0f;
165 return (c*(t*t*((s + 1.0f)*t + s) + 1.0f) + b);
166}
167
168EASEDEF float EaseBackInOut(float t, float b, float c, float d)
169{
170 float s = 1.70158f;
171 if ((t/=d/2.0f) < 1.0f)
172 {
173 s *= 1.525f;
174 return (c/2.0f*(t*t*((s + 1.0f)*t - s)) + b);
175 }
176
177 float postFix = t-=2.0f;
178 s *= 1.525f;
179 return (c/2.0f*((postFix)*t*((s + 1.0f)*t + s) + 2.0f) + b);
180}
181
182// Bounce Easing functions
183EASEDEF float EaseBounceOut(float t, float b, float c, float d)
184{
185 if ((t/=d) < (1.0f/2.75f))
186 {
187 return (c*(7.5625f*t*t) + b);
188 }
189 else if (t < (2.0f/2.75f))
190 {
191 float postFix = t-=(1.5f/2.75f);
192 return (c*(7.5625f*(postFix)*t + 0.75f) + b);
193 }
194 else if (t < (2.5/2.75))
195 {
196 float postFix = t-=(2.25f/2.75f);
197 return (c*(7.5625f*(postFix)*t + 0.9375f) + b);
198 }
199 else
200 {
201 float postFix = t-=(2.625f/2.75f);
202 return (c*(7.5625f*(postFix)*t + 0.984375f) + b);
203 }
204}
205
206EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); }
207EASEDEF float EaseBounceInOut(float t, float b, float c, float d)
208{
209 if (t < d/2.0f) return (EaseBounceIn(t*2.0f, 0.0f, c, d)*0.5f + b);
210 else return (EaseBounceOut(t*2.0f - d, 0.0f, c, d)*0.5f + c*0.5f + b);
211}
212
213// Elastic Easing functions
214EASEDEF float EaseElasticIn(float t, float b, float c, float d)
215{
216 if (t == 0.0f) return b;
217 if ((t/=d) == 1.0f) return (b + c);
218
219 float p = d*0.3f;
220 float a = c;
221 float s = p/4.0f;
222 float postFix = a*pow(2.0f, 10.0f*(t-=1.0f));
223
224 return (-(postFix*sinf((t*d-s)*(2.0f*PI)/p )) + b);
225}
226
227EASEDEF float EaseElasticOut(float t, float b, float c, float d)
228{
229 if (t == 0.0f) return b;
230 if ((t/=d) == 1.0f) return (b + c);
231
232 float p = d*0.3f;
233 float a = c;
234 float s = p/4.0f;
235
236 return (a*pow(2.0f,-10.0f*t)*sinf((t*d-s)*(2.0f*PI)/p) + c + b);
237}
238
239EASEDEF float EaseElasticInOut(float t, float b, float c, float d)
240{
241 if (t == 0.0f) return b;
242 if ((t/=d/2.0f) == 2.0f) return (b + c);
243
244 float p = d*(0.3f*1.5f);
245 float a = c;
246 float s = p/4.0f;
247
248 if (t < 1.0f)
249 {
250 float postFix = a*pow(2.0f, 10.0f*(t-=1.0f));
251 return -0.5f*(postFix*sinf((t*d-s)*(2.0f*PI)/p)) + b;
252 }
253
254 float postFix = a*pow(2.0f, -10.0f*(t-=1.0f));
255
256 return (postFix*sinf((t*d-s)*(2.0f*PI)/p)*0.5f + c + b);
257}
258
259#ifdef __cplusplus
260}
261#endif
262
263#endif // EASINGS_H
264