1 /*******************************************************************************************
3 * raylib easings (header only file)
5 * Useful easing functions for values animation
8 * #define EASINGS_STATIC_INLINE // Inlines all functions code, so it runs faster.
9 * // This requires lots of memory on system.
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)
19 * int currentTime = 0;
21 * float startPositionX = 0.0f;
22 * float finalPositionX = 30.0f;
23 * float currentPositionX = startPositionX;
25 * while (currentPositionX < finalPositionX)
27 * currentPositionX = EaseSineIn(currentTime, startPositionX, finalPositionX - startPositionX, duration);
31 * A port of Robert Penner's easing equations to C (http://robertpenner.com/easing/)
33 * Robert Penner License
34 * ---------------------------------------------------------------------------------
35 * Open source under the BSD License.
37 * Copyright (c) 2001 Robert Penner. All rights reserved.
39 * Redistribution and use in source and binary forms, with or without modification,
40 * are permitted provided that the following conditions are met:
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.
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 * ---------------------------------------------------------------------------------
63 * Copyright (c) 2015 Ramon Santamaria
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.
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:
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.
75 * 2. Altered source versions must be plainly marked as such, and must not be misrepresented
76 * as being the original software.
78 * 3. This notice may not be removed or altered from any source distribution.
80 **********************************************************************************************/
85 #define EASINGS_STATIC_INLINE // NOTE: By default, compile functions as static inline
87 #if defined(EASINGS_STATIC_INLINE)
88 #define EASEDEF static inline
90 #define EASEDEF extern
93 #include <math.h> // Required for: sinf(), cosf(), sqrtf(), powf()
96 #define PI 3.14159265358979323846f //Required as PI is not always defined in math.h
100 extern "C" { // Prevents name mangling of functions
103 // Linear Easing functions
104 EASEDEF float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); }
105 EASEDEF float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); }
106 EASEDEF float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); }
107 EASEDEF float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); }
109 // Sine Easing functions
110 EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); }
111 EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); }
112 EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); }
114 // Circular Easing functions
115 EASEDEF float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrtf(1.0f - t*t) - 1.0f) + b); }
116 EASEDEF float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrtf(1.0f - t*t) + b); }
117 EASEDEF float EaseCircInOut(float t, float b, float c, float d)
119 if ((t/=d/2.0f) < 1.0f) return (-c/2.0f*(sqrtf(1.0f - t*t) - 1.0f) + b);
120 t -= 2.0f; return (c/2.0f*(sqrtf(1.0f - t*t) + 1.0f) + b);
123 // Cubic Easing functions
124 EASEDEF float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }
125 EASEDEF float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); }
126 EASEDEF float EaseCubicInOut(float t, float b, float c, float d)
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);
132 // Quadratic Easing functions
133 EASEDEF float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }
134 EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); }
135 EASEDEF float EaseQuadInOut(float t, float b, float c, float d)
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);
141 // Exponential Easing functions
142 EASEDEF float EaseExpoIn(float t, float b, float c, float d) { return (t == 0.0f) ? b : (c*powf(2.0f, 10.0f*(t/d - 1.0f)) + b); }
143 EASEDEF float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-powf(2.0f, -10.0f*t/d) + 1.0f) + b); }
144 EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
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*powf(2.0f, 10.0f*(t - 1.0f)) + b);
150 return (c/2.0f*(-powf(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b);
153 // Back Easing functions
154 EASEDEF float EaseBackIn(float t, float b, float c, float d)
157 float postFix = t/=d;
158 return (c*(postFix)*t*((s + 1.0f)*t - s) + b);
161 EASEDEF float EaseBackOut(float t, float b, float c, float d)
165 return (c*(t*t*((s + 1.0f)*t + s) + 1.0f) + b);
168 EASEDEF float EaseBackInOut(float t, float b, float c, float d)
171 if ((t/=d/2.0f) < 1.0f)
174 return (c/2.0f*(t*t*((s + 1.0f)*t - s)) + b);
177 float postFix = t-=2.0f;
179 return (c/2.0f*((postFix)*t*((s + 1.0f)*t + s) + 2.0f) + b);
182 // Bounce Easing functions
183 EASEDEF float EaseBounceOut(float t, float b, float c, float d)
185 if ((t/=d) < (1.0f/2.75f))
187 return (c*(7.5625f*t*t) + b);
189 else if (t < (2.0f/2.75f))
191 float postFix = t-=(1.5f/2.75f);
192 return (c*(7.5625f*(postFix)*t + 0.75f) + b);
194 else if (t < (2.5/2.75))
196 float postFix = t-=(2.25f/2.75f);
197 return (c*(7.5625f*(postFix)*t + 0.9375f) + b);
201 float postFix = t-=(2.625f/2.75f);
202 return (c*(7.5625f*(postFix)*t + 0.984375f) + b);
206 EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); }
207 EASEDEF float EaseBounceInOut(float t, float b, float c, float d)
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);
213 // Elastic Easing functions
214 EASEDEF float EaseElasticIn(float t, float b, float c, float d)
216 if (t == 0.0f) return b;
217 if ((t/=d) == 1.0f) return (b + c);
222 float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
224 return (-(postFix*sinf((t*d-s)*(2.0f*PI)/p )) + b);
227 EASEDEF float EaseElasticOut(float t, float b, float c, float d)
229 if (t == 0.0f) return b;
230 if ((t/=d) == 1.0f) return (b + c);
236 return (a*powf(2.0f,-10.0f*t)*sinf((t*d-s)*(2.0f*PI)/p) + c + b);
239 EASEDEF float EaseElasticInOut(float t, float b, float c, float d)
241 if (t == 0.0f) return b;
242 if ((t/=d/2.0f) == 2.0f) return (b + c);
244 float p = d*(0.3f*1.5f);
250 float postFix = a*powf(2.0f, 10.0f*(t-=1.0f));
251 return -0.5f*(postFix*sinf((t*d-s)*(2.0f*PI)/p)) + b;
254 float postFix = a*powf(2.0f, -10.0f*(t-=1.0f));
256 return (postFix*sinf((t*d-s)*(2.0f*PI)/p)*0.5f + c + b);