EasingFn.cpp

#include "EasingFn.h"
 
#include "Setup.hpp"
 
#include <glm/glm.hpp>
#include <glm/gtc/constants.hpp>
#include <cmath>
 
float Cogs::EasingFn::linear(float t) {
  return t;
}
 
float Cogs::EasingFn::quadraticIn(float t) {
  return t * t;
}
 
float Cogs::EasingFn::quadraticOut(float t) {
  return t * (2.0f - t);
}
 
float Cogs::EasingFn::quadraticInOut(float t) {
  t *= 2.0f;
 
  if (t < 1.0f) {
    return 0.5f * t * t;
  }
 
  t -= 1.0f;
  return -0.5f * (t * (t - 2.0f) - 1.0f);
}
 
float Cogs::EasingFn::cubicIn(float t) {
  return t * t * t;
}
 
float Cogs::EasingFn::cubicOut(float t) {
  t -= 1.0f;
  return (t * t * t) + 1.0f;
}
 
float Cogs::EasingFn::cubicInOut(float t) {
  t *= 2.0f;
 
  if (t < 1.0f) {
    return 0.5f * t * t * t;
  }
 
  t -= 2.0f;
  return 0.5f * ((t * t * t) + 2.0f);
}
 
float Cogs::EasingFn::quarticIn(float t) {
  return t * t * t * t;
}
 
float Cogs::EasingFn::quarticOut(float t) {
  t -= 1;
  return 1 - (t * t * t * t);
}
 
float Cogs::EasingFn::quarticInOut(float t) {
  t *= 2.0f;
 
  if (t < 1.0f) {
    return 0.5f * t * t * t * t;
  }
 
  t -= 2.0f;
  return -0.5f * ((t * t * t * t) - 2.0f);
}
 
float Cogs::EasingFn::quinticIn(float t) {
  return t * t * t * t * t;
}
 
float Cogs::EasingFn::quinticOut(float t) {
  t -= 1.0f;
  return (t * t * t * t * t) + 1.0f;
}
 
float Cogs::EasingFn::quinticInOut(float t) {
  t *= 2.0f;
 
  if (t < 1.0f) {
    return 0.5f * t * t * t * t * t;
  }
 
  t -= 2.0f;
  return 0.5f * ((t * t * t * t * t) + 2.0f);
}
 
float Cogs::EasingFn::sinusoidalIn(float t) {
  return 1.0f - std::cos(t * glm::pi<float>() * 0.5f);
}
 
float Cogs::EasingFn::sinusoidalOut(float t) {
  return std::sin(t * glm::pi<float>() * 0.5f);
}
 
float Cogs::EasingFn::sinusoidalInOut(float t) {
  return 0.5f * (1.0f - std::cos(glm::pi<float>() * t));
}
 
float Cogs::EasingFn::exponentialIn(float t) {
  return (t == 0.0f) ? 0.0f : std::pow(1024.0f, t - 1.0f);
}
 
float Cogs::EasingFn::exponentialOut(float t) {
  return (t == 1.0f) ? 1.0f : (1.0f - std::pow(2.0f, -10.0f * t));
}
 
float Cogs::EasingFn::exponentialInOut(float t) {
  if (t == 0.0f) {
    return 0.0f;
  }
  else if (t == 1.0f) {
    return 1.0f;
  }
 
  t *= 2.0f;
 
  if (t < 1.0f) {
    return 0.5f * std::pow(1024.0f, t - 1.0f);
  }
  return 0.5f * (-std::pow(2.0f, -10.0f * (t - 1.0f)) + 2.0f);
}
 
float Cogs::EasingFn::circularIn(float t) {
  return 1.0f - std::sqrt(1.0f - (t * t));
}
 
float Cogs::EasingFn::circularOut(float t) {
  t -= 1.0f;
  return std::sqrt(1.0f - (t * t));
}
 
float Cogs::EasingFn::circularInOut(float t) {
  t *= 2.0f;
 
  if (t < 1.0f) {
    return -0.5f * (std::sqrt(1.0f - (t * t)) - 1.0f);
  }
  t -= 2.0f;
  return 0.5f * (std::sqrt(1.0f - (t * t)) + 1.0f);
}
 
float Cogs::EasingFn::elasticIn(float t) {
  if (t == 0.0f) {
    return 0.0f;
  }
  else if (t == 1.0f) {
    return 1.0f;
  }
 
  t -= 1.0f;
  return -std::pow(2.0f, 10.0f * t) * std::sin((t - 0.1f) * (2.0f * glm::pi<float>()) * 2.5f);
}
 
float Cogs::EasingFn::elasticOut(float t) {
  if (t == 0.0f) {
    return 0.0f;
  }
  else if (t == 1.0f) {
    return 1.0f;
  }
 
  return (std::pow(2.0f, -10.0f * t) * std::sin((t - 0.1f) * (2.0f * glm::pi<float>()) * 2.5f)) + 1.0f;
}
 
float Cogs::EasingFn::elasticInOut(float t) {
  if (t == 0.0f) {
    return 0.0f;
  }
  else if (t == 1.0f) {
    return 1.0f;
  }
 
  t = (t * 2.0f) - 1.0f;
 
  if (t < 0.0f) {
    return -0.5f * std::pow(2.0f, 10.0f * t) * std::sin((t - 0.1f) * (2.0f * glm::pi<float>()) * 2.5f);
  }
 
  return (std::pow(2.0f, -10.0f * t) * std::sin((t - 0.1f) * (2.0f * glm::pi<float>()) * 2.5f) * 0.5f) + 1.0f;
}
 
float Cogs::EasingFn::backIn(float t) {
  return t * t * ((2.70158f * t) - 1.70158f);
}
 
float Cogs::EasingFn::backOut(float t) {
  t -= 1.0f;
  return (t * t * ((2.70158f * t) + 1.70158f)) + 1.0f;
}
 
float Cogs::EasingFn::backInOut(float t) {
  float s = 1.70158f * 1.525f;
 
  t *= 2.0f;
 
  if (t < 1.0f) {
    return 0.5f * (t * t * (((s + 1.0f) * t) - s));
  }
 
  t -= 2.0f;
  return 0.5f * (t * t * (((s + 1.0f) * t) + s) + 2.0f);
}
 
float Cogs::EasingFn::bounceIn(float t) {
  return 1.0f - bounceOut(1.0f - t);
}
 
float Cogs::EasingFn::bounceOut(float t) {
  if (t < (1.0f / 2.75f)) {
    return 7.5625f * t * t;
  }
  else if (t < (2.0f / 2.75f)) {
    t -= 1.5f / 2.75f;
    return (7.5625f * t * t) + 0.75f;
  }
  else if (t < (2.5f / 2.75f)) {
    t -= 2.25f / 2.75f;
    return (7.562f * t * t) + 0.9375f;
  }
  else {
    t -= 2.625f / 2.75f;
    return (7.5625f * t * t) + 0.984375f;
  }
}
 
float Cogs::EasingFn::bounceInOut(float t) {
  if (t < 0.5f) {
    return bounceIn(t * 2.0f) * 0.5f;
  }
  return (bounceOut((t * 2.0f) - 1.0f) * 0.5f) + 0.5f;
}