Archivist
/
raylib-src
дзеркало https://github.com/raysan5/raylib
1
0
Форк 0
Код Проблеми 0 Релізи 24 Вікі Активність
Переглянути джерело

Use tgmath.h and float constants in easings.h

pull/852/head
flashback-fx 5 роки тому
джерело
2eb280e836
коміт
d4487bcfa7
1 змінених файлів з 90 додано та 90 видалено
Розділений перегляд
Параметри порівняння
Показати статистику Завантажити патч Завантажити файл різниці
  1. +90
    -90
      src/easings.h

+ 90
- 90
src/easings.h Переглянути файл

@ -1,7 +1,7 @@
/*******************************************************************************************
*
* raylib easings (header only file)
*
*
* Useful easing functions for values animation
*
* This header uses:
@ -32,31 +32,31 @@
*
* Robert Penner License
* ---------------------------------------------------------------------------------
* Open source under the BSD License.
* Open source under the BSD License.
*
* Copyright (c) 2001 Robert Penner. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without modification,
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* - Neither the name of the author nor the names of contributors may be used
* to endorse or promote products derived from this software without specific
* - Neither the name of the author nor the names of contributors may be used
* to endorse or promote products derived from this software without specific
* prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ---------------------------------------------------------------------------------
*
@ -90,7 +90,7 @@
#define EASEDEF extern
#endif
#include <math.h> // Required for: sin(), cos(), sqrt(), pow()
#include <tgmath.h> // Required for: sin(), cos(), sqrt(), pow()
#ifndef PI
#define PI 3.14159265358979323846f //Required as PI is not always defined in math.h
@ -107,153 +107,153 @@ EASEDEF float EaseLinearOut(float t, float b, float c, float d) { return (c*t/d
EASEDEF float EaseLinearInOut(float t,float b, float c, float d) { return (c*t/d + b); }
// Sine Easing functions
EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cos(t/d*(PI/i">2)) + c + b); }
EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sin(t/d*(PI/i">2)) + b); }
EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/i">2*(cos(PI*t/d) - i">1) + b); }
EASEDEF float EaseSineIn(float t, float b, float c, float d) { return (-c*cos(t/d*(PI/f">2.0f)) + c + b); }
EASEDEF float EaseSineOut(float t, float b, float c, float d) { return (c*sin(t/d*(PI/f">2.0f)) + b); }
EASEDEF float EaseSineInOut(float t, float b, float c, float d) { return (-c/f">2.0f*(cos(PI*t/d) - f">1.0f) + b); }
// Circular Easing functions
EASEDEF float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrt(i">1 - t*t) - i">1) + b); }
EASEDEF float EaseCircOut(float t, float b, float c, float d) { t = t/d - i">1; return (c*sqrt(i">1 - t*t) + b); }
EASEDEF float EaseCircInOut(float t, float b, float c, float d)
EASEDEF float EaseCircIn(float t, float b, float c, float d) { t /= d; return (-c*(sqrt(f">1.0f - t*t) - f">1.0f) + b); }
EASEDEF float EaseCircOut(float t, float b, float c, float d) { t = t/d - f">1.0f; return (c*sqrt(f">1.0f - t*t) + b); }
EASEDEF float EaseCircInOut(float t, float b, float c, float d)
{
if ((t/=d/i">2) < 1) return (-c/i">2*(sqrt(i">1 - t*t) - i">1) + b);
t -= i">2; return (c/i">2*(sqrt(i">1 - t*t) + i">1) + b);
if ((t/=d/f">2.0f) < 1.0f) return (-c/f">2.0f*(sqrt(f">1.0f - t*t) - f">1.0f) + b);
t -= f">2.0f; return (c/f">2.0f*(sqrt(f">1.0f - t*t) + f">1.0f) + b);
}
// Cubic Easing functions
EASEDEF float EaseCubicIn(float t, float b, float c, float d) { t /= d; return (c*t*t*t + b); }
EASEDEF float EaseCubicOut(float t, float b, float c, float d) { t = t/d-1; return (c*(t*t*t + i">1) + b); }
EASEDEF float EaseCubicInOut(float t, float b, float c, float d)
{
if ((t/=d/i">2) < 1) return (c/i">2*t*t*t + b);
t -= i">2; return (c/i">2*(t*t*t + i">2) + b);
EASEDEF float EaseCubicOut(float t, float b, float c, float d) { t = t/d - 1.0f; return (c*(t*t*t + f">1.0f) + b); }
EASEDEF float EaseCubicInOut(float t, float b, float c, float d)
{
if ((t/=d/f">2.0f) < 1.0f) return (c/f">2.0f*t*t*t + b);
t -= f">2.0f; return (c/f">2.0f*(t*t*t + f">2.0f) + b);
}
// Quadratic Easing functions
EASEDEF float EaseQuadIn(float t, float b, float c, float d) { t /= d; return (c*t*t + b); }
EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - i">2) + b); }
EASEDEF float EaseQuadInOut(float t, float b, float c, float d)
EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (-c*t*(t - f">2.0f) + b); }
EASEDEF float EaseQuadInOut(float t, float b, float c, float d)
{
if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b);
t--; return (-c/i">2*(((t - 2)*t) - 1) + b);
return (-c/f">2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b);
}
// Exponential Easing functions
EASEDEF float EaseExpoIn(float t, float b, float c, float d) { return (t == i">0) ? b : (c*pow(i">2, 10*(t/d - i">1)) + b); }
EASEDEF float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-pow(i">2, -10*t/d) + i">1) + b); }
EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
EASEDEF float EaseExpoIn(float t, float b, float c, float d) { return (t == f">0.0f) ? b : (c*pow(f">2.0f, 10.0f*(t/d - f">1.0f)) + b); }
EASEDEF float EaseExpoOut(float t, float b, float c, float d) { return (t == d) ? (b + c) : (c*(-pow(f">2.0f, -10.0f*t/d) + f">1.0f) + b); }
EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
{
if (t == i">0) return b;
if (t == f">0.0f) return b;
if (t == d) return (b + c);
if ((t/=d/i">2) < 1) return (c/i">2*pow(2, 10*(t - i">1)) + b);
return (c/i">2*(-pow(i">2, -10*--t) + 2) + b);
if ((t/=d/f">2.0f) < 1.0f) return (c/f">2.0f*pow(2.0f, 10.0f*(t - f">1.0f)) + b);
return (c/f">2.0f*(-pow(f">2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b);
}
// Back Easing functions
EASEDEF float EaseBackIn(float t, float b, float c, float d)
EASEDEF float EaseBackIn(float t, float b, float c, float d)
{
float s = 1.70158f;
float postFix = t/=d;
return (c*(postFix)*t*((s + i">1)*t - s) + b);
return (c*(postFix)*t*((s + f">1.0f)*t - s) + b);
}
EASEDEF float EaseBackOut(float t, float b, float c, float d)
{
{
float s = 1.70158f;
t = t/d - i">1;
return (c*(t*t*((s + i">1)*t + s) + i">1) + b);
t = t/d - f">1.0f;
return (c*(t*t*((s + f">1.0f)*t + s) + f">1.0f) + b);
}
EASEDEF float EaseBackInOut(float t, float b, float c, float d)
{
float s = 1.70158f;
if ((t/=d/i">2) < 1)
if ((t/=d/f">2.0f) < 1.0f)
{
s *= 1.525f;
return (c/i">2*(t*t*((s + i">1)*t - s)) + b);
return (c/f">2.0f*(t*t*((s + f">1.0f)*t - s)) + b);
}
float postFix = t-=i">2;
float postFix = t-=f">2.0f;
s *= 1.525f;
return (c/i">2*((postFix)*t*((s + i">1)*t + s) + i">2) + b);
return (c/f">2.0f*((postFix)*t*((s + f">1.0f)*t + s) + f">2.0f) + b);
}
// Bounce Easing functions
EASEDEF float EaseBounceOut(float t, float b, float c, float d)
EASEDEF float EaseBounceOut(float t, float b, float c, float d)
{
if ((t/=d) < (i">1/2.75f))
if ((t/=d) < (f">1.0f/2.75f))
{
return (c*(7.5625f*t*t) + b);
}
else if (t < (i">2/2.75f))
}
else if (t < (f">2.0f/2.75f))
{
float postFix = t-=(1.5f/2.75f);
return (c*(7.5625f*(postFix)*t + 0.75f) + b);
}
else if (t < (2.5/2.75))
}
else if (t < (2.5/2.75))
{
float postFix = t-=(2.25f/2.75f);
return (c*(7.5625f*(postFix)*t + 0.9375f) + b);
}
else
}
else
{
float postFix = t-=(2.625f/2.75f);
return (c*(7.5625f*(postFix)*t + 0.984375f) + b);
}
}
EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d-t, i">0, c, d) + b); }
EASEDEF float EaseBounceInOut(float t, float b, float c, float d)
EASEDEF float EaseBounceIn(float t, float b, float c, float d) { return (c - EaseBounceOut(d - t, f">0.0f, c, d) + b); }
EASEDEF float EaseBounceInOut(float t, float b, float c, float d)
{
if (t < d/i">2) return (EaseBounceIn(t*i">2, 0, c, d)*0.5f + b);
else return (EaseBounceOut(t*i">2-d, 0, c, d)*0.5f + c*0.5f + b);
if (t < d/f">2.0f) return (EaseBounceIn(t*f">2.0f, 0.0f, c, d)*0.5f + b);
else return (EaseBounceOut(t*f">2.0f - d, 0.0f, c, d)*0.5f + c*0.5f + b);
}
// Elastic Easing functions
EASEDEF float EaseElasticIn(float t, float b, float c, float d)
EASEDEF float EaseElasticIn(float t, float b, float c, float d)
{
if (t == i">0) return b;
if ((t/=d) == i">1) return (b + c);
if (t == f">0.0f) return b;
if ((t/=d) == f">1.0f) return (b + c);
float p = d*0.3f;
float a = c;
float s = p/i">4;
float postFix = a*pow(i">2, 10*(t-=i">1));
return (-(postFix*sin((t*d-s)*(i">2*PI)/p )) + b);
float a = c;
float s = p/f">4.0f;
float postFix = a*pow(f">2.0f, 10.0f*(t-=f">1.0f));
return (-(postFix*sin((t*d-s)*(f">2.0f*PI)/p )) + b);
}
EASEDEF float EaseElasticOut(float t, float b, float c, float d)
{
if (t == i">0) return b;
if ((t/=d) == i">1) return (b + c);
if (t == f">0.0f) return b;
if ((t/=d) == f">1.0f) return (b + c);
float p = d*0.3f;
float a = c;
float s = p/i">4;
return (a*pow(i">2,-10*t)*sin((t*d-s)*(i">2*PI)/p) + c + b);
float a = c;
float s = p/f">4.0f;
return (a*pow(f">2.0f,-10.0f*t)*sin((t*d-s)*(f">2.0f*PI)/p) + c + b);
}
EASEDEF float EaseElasticInOut(float t, float b, float c, float d)
{
if (t == i">0) return b;
if ((t/=d/i">2) == 2) return (b + c);
if (t == f">0.0f) return b;
if ((t/=d/f">2.0f) == 2.0f) return (b + c);
float p = d*(0.3f*1.5f);
float a = c;
float s = p/i">4;
float s = p/f">4.0f;
if (t < i">1)
if (t < f">1.0f)
{
float postFix = a*pow(i">2, 10*(t-=i">1));
return -0.5f*(postFix*sin((t*d-s)*(i">2*PI)/p)) + b;
float postFix = a*pow(f">2.0f, 10.0f*(t-=f">1.0f));
return -0.5f*(postFix*sin((t*d-s)*(f">2.0f*PI)/p)) + b;
}
float postFix = a*pow(i">2, -10*(t-=i">1));
return (postFix*sin((t*d-s)*(i">2*PI)/p)*0.5f + c + b);
float postFix = a*pow(f">2.0f, -10.0f*(t-=f">1.0f));
return (postFix*sin((t*d-s)*(f">2.0f*PI)/p)*0.5f + c + b);
}
#ifdef __cplusplus

Писати Попередній перегляд
Завантаження…
Відмінити
Зберегти