1 /******************************************************************************************* 2 * 3 * reasings - raylib easings library, based on Robert Penner library 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-2022 Ramon Santamaria (@raysan5) 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 module raylib.reasings; 82 83 extern (C) nothrow @nogc: 84 pragma(inline, true): // NOTE: By default, compile functions as static inline 85 86 import core.stdc.math; // Required for: sinf(), cosf(), sqrt(), pow() 87 88 enum PI = 3.14159265358979323846f; //Required as PI is not always defined in math.h 89 90 // Linear Easing functions 91 static float EaseLinearNone(float t, float b, float c, float d) { return (c*t/d + b); } 92 static float EaseLinearIn(float t, float b, float c, float d) { return (c*t/d + b); } 93 static float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d + b); } 94 static float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); } 95 96 // Sine Easing functions 97 static float EaseSineIn(float t, float b, float c, float d) { return (-c*cosf(t/d*(PI/2.0f)) + c + b); } 98 static float EaseSineOut(float t, float b, float c, float d) { return (c*sinf(t/d*(PI/2.0f)) + b); } 99 static float EaseSineInOut(float t, float b, float c, float d) { return (-c/2.0f*(cosf(PI*t/d) - 1.0f) + b); } 100 101 // Circular Easing functions 102 static float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrtf(1.0f - t*t) - 1.0f) + b); } 103 static float EaseCircOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*sqrtf(1.0f - t*t) + b); } 104 static float EaseCircInOut(float t, float b, float c, float d) 105 { 106 if ((t/=d/2.0f) < 1.0f) return (-c/2.0f*(sqrtf(1.0f - t*t) - 1.0f) + b); 107 t -= 2.0f; return (c/2.0f*(sqrtf(1.0f - t*t) + 1.0f) + b); 108 } 109 110 // Cubic Easing functions 111 static float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); } 112 static float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + 1.0f) + b); } 113 static float EaseCubicInOut(float t, float b, float c, float d) 114 { 115 if ((t/=d/2.0f) < 1.0f) return (c/2.0f*t*t*t + b); 116 t -= 2.0f; return (c/2.0f*(t*t*t + 2.0f) + b); 117 } 118 119 // Quadratic Easing functions 120 static float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); } 121 static float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - 2.0f) + b); } 122 static float EaseQuadInOut(float t, float b, float c, float d) 123 { 124 if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b); 125 return (-c/2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b); 126 } 127 128 // Exponential Easing functions 129 static 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); } 130 static 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); } 131 static float EaseExpoInOut(float t, float b, float c, float d) 132 { 133 if (t == 0.0f) return b; 134 if (t == d) return (b + c); 135 if ((t/=d/2.0f) < 1.0f) return (c/2.0f*powf(2.0f, 10.0f*(t - 1.0f)) + b); 136 137 return (c/2.0f*(-powf(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b); 138 } 139 140 // Back Easing functions 141 static float EaseBackIn(float t, float b, float c, float d) 142 { 143 float s = 1.70158f; 144 float postFix = t/=d; 145 return (c*(postFix)*t*((s + 1.0f)*t - s) + b); 146 } 147 148 static float EaseBackOut(float t, float b, float c, float d) 149 { 150 float s = 1.70158f; 151 t = t/d - 1.0f; 152 return (c*(t*t*((s + 1.0f)*t + s) + 1.0f) + b); 153 } 154 155 static float EaseBackInOut(float t, float b, float c, float d) 156 { 157 float s = 1.70158f; 158 if ((t/=d/2.0f) < 1.0f) 159 { 160 s *= 1.525f; 161 return (c/2.0f*(t*t*((s + 1.0f)*t - s)) + b); 162 } 163 164 float postFix = t-=2.0f; 165 s *= 1.525f; 166 return (c/2.0f*((postFix)*t*((s + 1.0f)*t + s) + 2.0f) + b); 167 } 168 169 // Bounce Easing functions 170 static float EaseBounceOut(float t, float b, float c, float d) 171 { 172 if ((t/=d) < (1.0f/2.75f)) 173 { 174 return (c*(7.5625f*t*t) + b); 175 } 176 else if (t < (2.0f/2.75f)) 177 { 178 float postFix = t-=(1.5f/2.75f); 179 return (c*(7.5625f*(postFix)*t + 0.75f) + b); 180 } 181 else if (t < (2.5/2.75)) 182 { 183 float postFix = t-=(2.25f/2.75f); 184 return (c*(7.5625f*(postFix)*t + 0.9375f) + b); 185 } 186 else 187 { 188 float postFix = t-=(2.625f/2.75f); 189 return (c*(7.5625f*(postFix)*t + 0.984375f) + b); 190 } 191 } 192 193 static float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, 0.0f, c, d) + b); } 194 static float EaseBounceInOut(float t, float b, float c, float d) 195 { 196 if (t < d/2.0f) return (EaseBounceIn(t*2.0f, 0.0f, c, d)*0.5f + b); 197 else return (EaseBounceOut(t*2.0f - d, 0.0f, c, d)*0.5f + c*0.5f + b); 198 } 199 200 // Elastic Easing functions 201 static float EaseElasticIn(float t, float b, float c, float d) 202 { 203 if (t == 0.0f) return b; 204 if ((t/=d) == 1.0f) return (b + c); 205 206 float p = d*0.3f; 207 float a = c; 208 float s = p/4.0f; 209 float postFix = a*powf(2.0f, 10.0f*(t-=1.0f)); 210 211 return (-(postFix*sinf((t*d-s)*(2.0f*PI)/p )) + b); 212 } 213 214 static float EaseElasticOut(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 223 return (a*powf(2.0f,-10.0f*t)*sinf((t*d-s)*(2.0f*PI)/p) + c + b); 224 } 225 226 static float EaseElasticInOut(float t, float b, float c, float d) 227 { 228 if (t == 0.0f) return b; 229 if ((t/=d/2.0f) == 2.0f) return (b + c); 230 231 float p = d*(0.3f*1.5f); 232 float a = c; 233 float s = p/4.0f; 234 235 if (t < 1.0f) 236 { 237 float postFix = a*powf(2.0f, 10.0f*(t-=1.0f)); 238 return -0.5f*(postFix*sinf((t*d-s)*(2.0f*PI)/p)) + b; 239 } 240 241 float postFix = a*powf(2.0f, -10.0f*(t-=1.0f)); 242 243 return (postFix*sinf((t*d-s)*(2.0f*PI)/p)*0.5f + c + b); 244 }