easing.h

Go to the documentation of this file.

 
 
#ifndef ASW_EASING_H
#define ASW_EASING_H
 
#include <algorithm>
#include <concepts>
#include <functional>
#include <limits>
#include <type_traits>
 
#include "./types.h"
 
namespace asw::easing {
 
namespace detail {
 
    template <typename T> T mix(const T& a, const T& b, float f)
    {
        if constexpr (std::is_integral_v<T>) {
            const auto lo = static_cast<double>(std::numeric_limits<T>::lowest());
            const auto hi = static_cast<double>(std::numeric_limits<T>::max());
            const double v = static_cast<double>(a)
                + ((static_cast<double>(b) - static_cast<double>(a)) * static_cast<double>(f));
            if (v <= lo) {
                return std::numeric_limits<T>::lowest();
            }
            if (v >= hi) {
                return std::numeric_limits<T>::max();
            }
            return static_cast<T>(v);
        } else {
            return a + (b - a) * f;
        }
    }
 
} // namespace detail
 
// --- Linear ---
float linear(float t);
 
// --- Smoothstep ---
 
float smoothstep(float t);
 
// --- Quadratic ---
float ease_in_quad(float t);
float ease_out_quad(float t);
float ease_in_out_quad(float t);
 
// --- Cubic ---
float ease_in_cubic(float t);
float ease_out_cubic(float t);
float ease_in_out_cubic(float t);
 
// --- Sine ---
float ease_in_sine(float t);
float ease_out_sine(float t);
float ease_in_out_sine(float t);
 
// --- Exponential ---
float ease_in_expo(float t);
float ease_out_expo(float t);
float ease_in_out_expo(float t);
 
// --- Elastic ---
float ease_in_elastic(float t);
float ease_out_elastic(float t);
 
// --- Bounce ---
float ease_in_bounce(float t);
float ease_out_bounce(float t);
 
// --- Back (overshoot) ---
float ease_in_back(float t);
float ease_out_back(float t);
 
// --- Convenience ---
 
float falloff(float t, asw::Falloff mode);
 
template <typename T, typename Func> T ease(const T& a, const T& b, float t, Func func)
{
    static_assert(std::is_arithmetic_v<T>, "T must be an arithmetic type");
    static_assert(std::is_invocable_r_v<float, Func, float>,
        "Func must be a callable that takes a float and returns a float");
 
    return detail::mix(a, b, func(std::clamp(t, 0.0F, 1.0F)));
}
 
} // namespace asw::easing
 
#endif // ASW_EASING_H