💿🐜 Antkeeper source code
https://antkeeper.com
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
390 lines
7.6 KiB
390 lines
7.6 KiB
/*
|
|
* Copyright (C) 2017 Christopher J. Howard
|
|
*
|
|
* This file is part of Antkeeper Source Code.
|
|
*
|
|
* Antkeeper Source Code is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Antkeeper Source Code is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with Antkeeper Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "tween.hpp"
|
|
#include <cmath>
|
|
|
|
const TweenBase::EaseFunctionPointer TweenBase::easeFunctionPointers[] =
|
|
{
|
|
&TweenBase::easeLinear,
|
|
&TweenBase::easeInSine,
|
|
&TweenBase::easeOutSine,
|
|
&TweenBase::easeInOutSine,
|
|
&TweenBase::easeInQuad,
|
|
&TweenBase::easeOutQuad,
|
|
&TweenBase::easeInOutQuad,
|
|
&TweenBase::easeInCubic,
|
|
&TweenBase::easeOutCubic,
|
|
&TweenBase::easeInOutCubic,
|
|
&TweenBase::easeInQuart,
|
|
&TweenBase::easeOutQuart,
|
|
&TweenBase::easeInOutQuart,
|
|
&TweenBase::easeInQuint,
|
|
&TweenBase::easeOutQuint,
|
|
&TweenBase::easeInOutQuint,
|
|
&TweenBase::easeInExpo,
|
|
&TweenBase::easeOutExpo,
|
|
&TweenBase::easeInOutExpo,
|
|
&TweenBase::easeInCirc,
|
|
&TweenBase::easeOutCirc,
|
|
&TweenBase::easeInOutCirc,
|
|
&TweenBase::easeInBack,
|
|
&TweenBase::easeOutBack,
|
|
&TweenBase::easeInOutBack,
|
|
&TweenBase::easeInBounce,
|
|
&TweenBase::easeOutBounce,
|
|
&TweenBase::easeInOutBounce,
|
|
};
|
|
|
|
TweenBase::TweenBase(EaseFunction function, float time, float duration):
|
|
time(time),
|
|
duration(duration),
|
|
stopped(true),
|
|
oldStopped(true),
|
|
paused(false)
|
|
{
|
|
setEaseFunction(function);
|
|
}
|
|
|
|
TweenBase::TweenBase():
|
|
time(0.0f),
|
|
duration(0.0f),
|
|
stopped(true),
|
|
oldStopped(true),
|
|
paused(false)
|
|
{
|
|
setEaseFunction(EaseFunction::LINEAR);
|
|
}
|
|
|
|
TweenBase::~TweenBase()
|
|
{}
|
|
|
|
void TweenBase::start()
|
|
{
|
|
if (stopped)
|
|
{
|
|
stopped = false;
|
|
oldStopped = true;
|
|
time = 0.0f;
|
|
}
|
|
else if (paused)
|
|
{
|
|
paused = false;
|
|
}
|
|
}
|
|
|
|
void TweenBase::stop()
|
|
{
|
|
if (!stopped)
|
|
{
|
|
stopped = true;
|
|
oldStopped = false;
|
|
paused = false;
|
|
}
|
|
}
|
|
|
|
void TweenBase::pause()
|
|
{
|
|
if (!stopped && !paused)
|
|
{
|
|
paused = true;
|
|
oldStopped = false;
|
|
}
|
|
}
|
|
|
|
void TweenBase::reset()
|
|
{
|
|
time = 0.0f;
|
|
}
|
|
|
|
inline void TweenBase::setEaseFunction(EaseFunction function)
|
|
{
|
|
easeFunction = function;
|
|
easeFunctionPointer = easeFunctionPointers[static_cast<std::size_t>(easeFunction)];
|
|
}
|
|
|
|
void TweenBase::setTime(float time)
|
|
{
|
|
this->time = time;
|
|
}
|
|
|
|
void TweenBase::setDuration(float duration)
|
|
{
|
|
this->duration = duration;
|
|
}
|
|
|
|
float TweenBase::easeLinear(float t, float b, float c, float d)
|
|
{
|
|
return c * t / d + b;
|
|
}
|
|
|
|
float TweenBase::easeInSine(float t, float b, float c, float d)
|
|
{
|
|
return -c * std::cos(t / d * glm::half_pi<float>()) + c + b;
|
|
}
|
|
|
|
float TweenBase::easeOutSine(float t, float b, float c, float d)
|
|
{
|
|
return c * std::sin(t / d * glm::half_pi<float>()) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutSine(float t, float b, float c, float d)
|
|
{
|
|
return -c * 0.5f * (std::cos(glm::pi<float>() * t / d) - 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInQuad(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
return c * t * t + b;
|
|
}
|
|
|
|
float TweenBase::easeOutQuad(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
return -c * t * (t - 2.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutQuad(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
if ((t * 0.5f) < 1.0f)
|
|
{
|
|
return c * 0.5f * t * t + b;
|
|
}
|
|
|
|
t -= 1.0f;
|
|
return -c * 0.5f * (t * (t - 2.0f) - 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInCubic(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
return c * t * t * t + b;
|
|
}
|
|
|
|
float TweenBase::easeOutCubic(float t, float b, float c, float d)
|
|
{
|
|
t = t / d - 1.0f;
|
|
return c * (t * t * t + 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutCubic(float t, float b, float c, float d)
|
|
{
|
|
t /= d * 0.5f;
|
|
if (t < 1.0f)
|
|
{
|
|
return c * 0.5f * t * t * t + b;
|
|
}
|
|
|
|
t -= 2.0f;
|
|
return c * 0.5f * (t * t * t + 2.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInQuart(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
return c * t * t * t * t + b;
|
|
}
|
|
|
|
float TweenBase::easeOutQuart(float t, float b, float c, float d)
|
|
{
|
|
t = t / d - 1.0f;
|
|
return -c * (t * t * t * t - 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutQuart(float t, float b, float c, float d)
|
|
{
|
|
t /= d * 0.5f;
|
|
if (t < 1.0f)
|
|
{
|
|
return c * 0.5f * t * t * t * t + b;
|
|
}
|
|
|
|
t -= 2.0f;
|
|
return -c * 0.5f * (t * t * t * t - 2.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInQuint(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
return c * t * t * t * t * t + b;
|
|
}
|
|
|
|
float TweenBase::easeOutQuint(float t, float b, float c, float d)
|
|
{
|
|
t = t / d - 1.0f;
|
|
return c * (t * t * t * t * t + 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutQuint(float t, float b, float c, float d)
|
|
{
|
|
t /= d * 0.5f;
|
|
if (t < 1.0f)
|
|
{
|
|
return c * 0.5f * t * t * t * t * t + b;
|
|
}
|
|
|
|
t -= 2.0f;
|
|
return c * 0.5f * (t * t * t * t * t + 2.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInExpo(float t, float b, float c, float d)
|
|
{
|
|
return (t == 0.0f) ? b : c * std::pow(2.0f, 10.0f * (t / d - 1.0f)) + b - c * 0.001f;
|
|
}
|
|
|
|
float TweenBase::easeOutExpo(float t, float b, float c, float d)
|
|
{
|
|
return (t == d) ? b + c : c * 1.001f * (-std::pow(2.0f, -10.0f * t / d) + 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutExpo(float t, float b, float c, float d)
|
|
{
|
|
if (t == 0.0f)
|
|
{
|
|
return b;
|
|
}
|
|
|
|
if (t == d)
|
|
{
|
|
return b + c;
|
|
}
|
|
|
|
t /= d * 0.5f;
|
|
if (t < 1.0f)
|
|
{
|
|
return c * 0.5f * std::pow(2.0f, 10.0f * (t - 1.0f)) + b - c * 0.0005f;
|
|
}
|
|
|
|
t -= 1.0f;
|
|
return c * 0.5f * 1.0005f * (-std::pow(2.0f, -10.0f * t) + 2.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInCirc(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
return -c * (std::sqrt(1.0f - t * t) - 1.0f) + b;
|
|
}
|
|
float TweenBase::easeOutCirc(float t, float b, float c, float d)
|
|
{
|
|
t = t / d - 1.0f;
|
|
return c * std::sqrt(1.0f - t * t) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutCirc(float t, float b, float c, float d)
|
|
{
|
|
t /= d * 0.5f;
|
|
if (t < 1.0f)
|
|
{
|
|
return -c * 0.5f * (std::sqrt(1.0f - t * t) - 1.0f) + b;
|
|
}
|
|
|
|
t -= 2.0f;
|
|
return c * 0.5f * (std::sqrt(1.0f - t * t) + 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInBack(float t, float b, float c, float d)
|
|
{
|
|
float s = 1.70158f;
|
|
t /= d;
|
|
return c * t * t * ((s + 1.0f) * t - s) + b;
|
|
}
|
|
|
|
float TweenBase::easeOutBack(float t, float b, float c, float d)
|
|
{
|
|
float s = 1.70158f;
|
|
t = t / d - 1.0f;
|
|
return c * (t * t * ((s + 1.0f) * t + s) + 1.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutBack(float t, float b, float c, float d)
|
|
{
|
|
float s = 1.70158f;
|
|
t /= d * 0.5f;
|
|
if (t < 1.0f)
|
|
{
|
|
s *= 1.525f;
|
|
return c * 0.5f * (t * t * ((s + 1.0f) * t - s)) + b;
|
|
}
|
|
|
|
t -= 2.0f;
|
|
s *= 1.525f;
|
|
return c * 0.5f * (t * t * ((s + 1.0f) * t + s) + 2.0f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInBounce(float t, float b, float c, float d)
|
|
{
|
|
return c - easeOutBounce(d - t, 0.0f, c, d) + b;
|
|
}
|
|
|
|
float TweenBase::easeOutBounce(float t, float b, float c, float d)
|
|
{
|
|
t /= d;
|
|
if (t < (1.0f / 2.75f))
|
|
{
|
|
return c * (7.5625f * t * t) + b;
|
|
}
|
|
else if (t < (2.0f / 2.75f))
|
|
{
|
|
t -= (1.5f / 2.75f);
|
|
return c * (7.5625f * t * t + 0.75f) + b;
|
|
}
|
|
else if (t < (2.5f / 2.75f))
|
|
{
|
|
t -= (2.25f / 2.75f);
|
|
return c * (7.5625f * t * t + 0.9375f) + b;
|
|
}
|
|
|
|
t -= (2.625f / 2.75f);
|
|
return c * (7.5625f * t * t + 0.984375f) + b;
|
|
}
|
|
|
|
float TweenBase::easeInOutBounce(float t, float b, float c, float d)
|
|
{
|
|
if (t < d * 0.5f)
|
|
{
|
|
return easeInBounce(t * 2.0f, 0.0f, c, d) * 0.5f + b;
|
|
}
|
|
|
|
return easeOutBounce(t * 2.0f - d, 0.0f, c, d) * 0.5f + c * 0.5f + b;
|
|
}
|
|
|
|
void Tweener::update(float dt)
|
|
{
|
|
for (TweenBase* tween: tweens)
|
|
{
|
|
tween->update(dt);
|
|
}
|
|
}
|
|
|
|
void Tweener::addTween(TweenBase* tween)
|
|
{
|
|
tweens.push_back(tween);
|
|
}
|
|
|
|
void Tweener::removeTween(TweenBase* tween)
|
|
{
|
|
tweens.remove(tween);
|
|
}
|
|
|
|
void Tweener::removeTweens()
|
|
{
|
|
tweens.clear();
|
|
}
|