Skip to content

Update easing formula #9

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
thnhmai06 wants to merge 2 commits into
base: master
Choose a base branch
from
Open

Update easing formula #9

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
30b6e46
fix: update easeInCirc, easeOutCirc, easeInOutCirc formula
thnhmai06 May 9, 2025
b60c8d2
fix: update all easing formula
thnhmai06 May 14, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
283 changes: 143 additions & 140 deletions src/easing.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,214 +1,217 @@
#pragma once
#include <cmath>
#include <map>

#include "easing.h"

#ifndef PI
#define PI 3.1415926545
#endif
constexpr double PI = 3.14159265359;
constexpr double c1 = 1.70158;
constexpr double c2 = c1 * 1.525;
constexpr double c3 = c1 + 1;
constexpr double c4 = (2 * PI) / 3;
constexpr double c5 = (2 * PI) / 4.5;
constexpr double n1 = 7.5625;
constexpr double d1 = 2.75;

double easeInSine( double t ) {
return sin( 1.5707963 * t );
double easeInSine(double x) {
return 1 - cos((PI * x) / 2);
}

double easeOutSine( double t ) {
return 1 + sin( 1.5707963 * (--t) );
double easeOutSine(double x) {
return sin((PI * x) / 2);
}

double easeInOutSine( double t ) {
return 0.5 * (1 + sin( 3.1415926 * (t - 0.5) ) );
double easeInOutSine(double x) {
return -(cos(PI * x) - 1) / 2;
}

double easeInQuad( double t ) {
return t * t;
double easeInQuad(double x) {
return x * x;
}

double easeOutQuad( double t ) {
return t * (2 - t);
double easeOutQuad(double x) {
return 1 - pow(1 - x, 2);
}

double easeInOutQuad( double t ) {
return t < 0.5 ? 2 * t * t : t * (4 - 2 * t) - 1;
double easeInOutQuad(double x) {
if (x < 0.5) {
return 2 * x * x;
}
else {
return 1 - pow(-2 * x + 2, 2) / 2;
}
}

double easeInCubic( double t ) {
return t * t * t;
double easeInCubic(double x) {
return x * x * x;
}

double easeOutCubic( double t ) {
return 1 + (--t) * t * t;
double easeOutCubic(double x) {
return 1 - pow(1 - x, 3);
}

double easeInOutCubic( double t ) {
return t < 0.5 ? 4 * t * t * t : 1 + (--t) * (2 * (--t)) * (2 * t);
double easeInOutCubic(double x) {
return x < 0.5 ? 4 * x * x * x : 1 - pow(-2 * x + 2, 3) / 2;
}

double easeInQuart( double t ) {
t *= t;
return t * t;
double easeInQuart(double x) {
return pow(x, 4);
}

double easeOutQuart( double t ) {
t = (--t) * t;
return 1 - t * t;
double easeOutQuart(double x) {
return 1 - pow(1 - x, 4);
}

double easeInOutQuart( double t ) {
if( t < 0.5 ) {
t *= t;
return 8 * t * t;
} else {
t = (--t) * t;
return 1 - 8 * t * t;
}
double easeInOutQuart(double x) {
return x < 0.5 ? 8 * x * x * x * x : 1 - pow(-2 * x + 2, 4) / 2;
}

double easeInQuint( double t ) {
double t2 = t * t;
return t * t2 * t2;
double easeInQuint(double x) {
return pow(x, 5);
}

double easeOutQuint( double t ) {
double t2 = (--t) * t;
return 1 + t * t2 * t2;
double easeOutQuint(double x) {
return 1 - pow(1 - x, 5);
}

double easeInOutQuint( double t ) {
double t2;
if( t < 0.5 ) {
t2 = t * t;
return 16 * t * t2 * t2;
} else {
t2 = (--t) * t;
return 1 + 16 * t * t2 * t2;
}
double easeInOutQuint(double x) {
return x < 0.5 ? 16 * x * x * x * x * x : 1 - pow(-2 * x + 2, 5) / 2;
}

double easeInExpo( double t ) {
return (pow( 2, 8 * t ) - 1) / 255;
double easeInExpo(double x) {
return x == 0 ? 0 : pow(2, 10 * x - 10);
}

double easeOutExpo( double t ) {
return 1 - pow( 2, -8 * t );
double easeOutExpo(double x) {
return x == 1 ? 1 : 1 - pow(2, -10 * x);
}

double easeInOutExpo( double t ) {
if( t < 0.5 ) {
return (pow( 2, 16 * t ) - 1) / 510;
} else {
return 1 - 0.5 * pow( 2, -16 * (t - 0.5) );
}
double easeInOutExpo(double x) {
return x == 0
? 0
: x == 1
? 1
: x < 0.5 ? pow(2, 20 * x - 10) / 2
: (2 - pow(2, -20 * x + 10)) / 2;
}

double easeInCirc( double t ) {
return 1 - sqrt( 1 - t );
double easeInCirc(double x) {
return 1 - sqrt(1 - pow(x, 2));
}

double easeOutCirc( double t ) {
return sqrt( t );
double easeOutCirc(double x) {
return sqrt(1 - pow(x - 1, 2));
}

double easeInOutCirc( double t ) {
if( t < 0.5 ) {
return (1 - sqrt( 1 - 2 * t )) * 0.5;
} else {
return (1 + sqrt( 2 * t - 1 )) * 0.5;
}
double easeInOutCirc(double x) {
return x < 0.5
? (1 - sqrt(1 - pow(2 * x, 2))) / 2
: (sqrt(1 - pow(-2 * x + 2, 2)) + 1) / 2;
}

double easeInBack( double t ) {
return t * t * (2.70158 * t - 1.70158);
double easeInBack(double x) {
return c3 * x * x * x - c1 * x * x;
}

double easeOutBack( double t ) {
return 1 + (--t) * t * (2.70158 * t + 1.70158);
double easeOutBack(double x) {
return 1 + c3 * pow(x - 1, 3) + c1 * pow(x - 1, 2);
}

double easeInOutBack( double t ) {
if( t < 0.5 ) {
return t * t * (7 * t - 2.5) * 2;
} else {
return 1 + (--t) * t * 2 * (7 * t + 2.5);
}
double easeInOutBack(double x) {
return x < 0.5
? (pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2
: (pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
}

double easeInElastic( double t ) {
double t2 = t * t;
return t2 * t2 * sin( t * PI * 4.5 );
double easeInElastic(double x) {
return x == 0
? 0
: x == 1
? 1
: -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4);
}

double easeOutElastic( double t ) {
double t2 = (t - 1) * (t - 1);
return 1 - t2 * t2 * cos( t * PI * 4.5 );
double easeOutElastic(double x) {
return x == 0
? 0
: x == 1
? 1
: pow(2, -10 * x) * sin((x * 10 - 0.75) * c4) + 1;
}

double easeInOutElastic( double t ) {
double t2;
if( t < 0.45 ) {
t2 = t * t;
return 8 * t2 * t2 * sin( t * PI * 9 );
} else if( t < 0.55 ) {
return 0.5 + 0.75 * sin( t * PI * 4 );
} else {
t2 = (t - 1) * (t - 1);
return 1 - 8 * t2 * t2 * sin( t * PI * 9 );
}
double easeInOutElastic(double x) {
return x == 0
? 0
: x == 1
? 1
: x < 0.5
? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2
: (pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5)) / 2 + 1;
}

double easeInBounce( double t ) {
return pow( 2, 6 * (t - 1) ) * abs( sin( t * PI * 3.5 ) );
double easeOutBounce(double x) {
if (x < 1 / d1) {
return n1 * x * x;
}
else if (x < 2 / d1) {
return n1 * (x -= 1.5 / d1) * x + 0.75;
}
else if (x < 2.5 / d1) {
return n1 * (x -= 2.25 / d1) * x + 0.9375;
}
else {
return n1 * (x -= 2.625 / d1) * x + 0.984375;
}
}

double easeOutBounce( double t ) {
return 1 - pow( 2, -6 * t ) * abs( cos( t * PI * 3.5 ) );
double easeInBounce(double x) {
return 1 - easeOutBounce(1 - x);
}

double easeInOutBounce( double t ) {
if( t < 0.5 ) {
return 8 * pow( 2, 8 * (t - 1) ) * abs( sin( t * PI * 7 ) );
} else {
return 1 - 8 * pow( 2, -8 * t ) * abs( sin( t * PI * 7 ) );
}
double easeInOutBounce(double x) {
return x < 0.5
? (1 - easeOutBounce(1 - 2 * x)) / 2
: (1 + easeOutBounce(2 * x - 1)) / 2;
}

easingFunction getEasingFunction( easing_functions function )
easingFunction getEasingFunction(easing_functions function)
{
static std::map< easing_functions, easingFunction > easingFunctions;
if( easingFunctions.empty() )
if (easingFunctions.empty())
{
easingFunctions.insert( std::make_pair( EaseInSine, easeInSine ) );
easingFunctions.insert( std::make_pair( EaseOutSine, easeOutSine ) );
easingFunctions.insert( std::make_pair( EaseInOutSine, easeInOutSine ) );
easingFunctions.insert( std::make_pair( EaseInQuad, easeInQuad ) );
easingFunctions.insert( std::make_pair( EaseOutQuad, easeOutQuad ) );
easingFunctions.insert( std::make_pair( EaseInOutQuad, easeInOutQuad ) );
easingFunctions.insert( std::make_pair( EaseInCubic, easeInCubic ) );
easingFunctions.insert( std::make_pair( EaseOutCubic, easeOutCubic ) );
easingFunctions.insert( std::make_pair( EaseInOutCubic, easeInOutCubic ) );
easingFunctions.insert( std::make_pair( EaseInQuart, easeInQuart ) );
easingFunctions.insert( std::make_pair( EaseOutQuart, easeOutQuart ) );
easingFunctions.insert( std::make_pair( EaseInOutQuart, easeInOutQuart) );
easingFunctions.insert( std::make_pair( EaseInQuint, easeInQuint ) );
easingFunctions.insert( std::make_pair( EaseOutQuint, easeOutQuint ) );
easingFunctions.insert( std::make_pair( EaseInOutQuint, easeInOutQuint ) );
easingFunctions.insert( std::make_pair( EaseInExpo, easeInExpo ) );
easingFunctions.insert( std::make_pair( EaseOutExpo, easeOutExpo ) );
easingFunctions.insert( std::make_pair( EaseInOutExpo, easeInOutExpo ) );
easingFunctions.insert( std::make_pair( EaseInCirc, easeInCirc ) );
easingFunctions.insert( std::make_pair( EaseOutCirc, easeOutCirc ) );
easingFunctions.insert( std::make_pair( EaseInOutCirc, easeInOutCirc ) );
easingFunctions.insert( std::make_pair( EaseInBack, easeInBack ) );
easingFunctions.insert( std::make_pair( EaseOutBack, easeOutBack ) );
easingFunctions.insert( std::make_pair( EaseInOutBack, easeInOutBack ) );
easingFunctions.insert( std::make_pair( EaseInElastic, easeInElastic ) );
easingFunctions.insert( std::make_pair( EaseOutElastic, easeOutElastic ) );
easingFunctions.insert( std::make_pair( EaseInOutElastic, easeInOutElastic ) );
easingFunctions.insert( std::make_pair( EaseInBounce, easeInBounce ) );
easingFunctions.insert( std::make_pair( EaseOutBounce, easeOutBounce ) );
easingFunctions.insert( std::make_pair( EaseInOutBounce, easeInOutBounce ) );
easingFunctions.insert(std::make_pair(EaseInSine, easeInSine));
easingFunctions.insert(std::make_pair(EaseOutSine, easeOutSine));
easingFunctions.insert(std::make_pair(EaseInOutSine, easeInOutSine));
easingFunctions.insert(std::make_pair(EaseInQuad, easeInQuad));
easingFunctions.insert(std::make_pair(EaseOutQuad, easeOutQuad));
easingFunctions.insert(std::make_pair(EaseInOutQuad, easeInOutQuad));
easingFunctions.insert(std::make_pair(EaseInCubic, easeInCubic));
easingFunctions.insert(std::make_pair(EaseOutCubic, easeOutCubic));
easingFunctions.insert(std::make_pair(EaseInOutCubic, easeInOutCubic));
easingFunctions.insert(std::make_pair(EaseInQuart, easeInQuart));
easingFunctions.insert(std::make_pair(EaseOutQuart, easeOutQuart));
easingFunctions.insert(std::make_pair(EaseInOutQuart, easeInOutQuart));
easingFunctions.insert(std::make_pair(EaseInQuint, easeInQuint));
easingFunctions.insert(std::make_pair(EaseOutQuint, easeOutQuint));
easingFunctions.insert(std::make_pair(EaseInOutQuint, easeInOutQuint));
easingFunctions.insert(std::make_pair(EaseInExpo, easeInExpo));
easingFunctions.insert(std::make_pair(EaseOutExpo, easeOutExpo));
easingFunctions.insert(std::make_pair(EaseInOutExpo, easeInOutExpo));
easingFunctions.insert(std::make_pair(EaseInCirc, easeInCirc));
easingFunctions.insert(std::make_pair(EaseOutCirc, easeOutCirc));
easingFunctions.insert(std::make_pair(EaseInOutCirc, easeInOutCirc));
easingFunctions.insert(std::make_pair(EaseInBack, easeInBack));
easingFunctions.insert(std::make_pair(EaseOutBack, easeOutBack));
easingFunctions.insert(std::make_pair(EaseInOutBack, easeInOutBack));
easingFunctions.insert(std::make_pair(EaseInElastic, easeInElastic));
easingFunctions.insert(std::make_pair(EaseOutElastic, easeOutElastic));
easingFunctions.insert(std::make_pair(EaseInOutElastic, easeInOutElastic));
easingFunctions.insert(std::make_pair(EaseInBounce, easeInBounce));
easingFunctions.insert(std::make_pair(EaseOutBounce, easeOutBounce));
easingFunctions.insert(std::make_pair(EaseInOutBounce, easeInOutBounce));

}

auto it = easingFunctions.find( function );
auto it = easingFunctions.find(function);
return it == easingFunctions.end() ? nullptr : it->second;
}