easing.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <iterator>
 
#include <glm/gtx/easing.hpp>
 
#include "core/reflect.h"
 
namespace Vkm::Engine {

using EasingFunction = float (*)(float);

#define VKM_EASINGS(X)                                                    \
    X(Linear,           "linear",           linearInterpolation)          \
                                                                          \
    X(EaseInQuad,       "easeInQuad",       quadraticEaseIn)              \
    X(EaseOutQuad,      "easeOutQuad",      quadraticEaseOut)             \
    X(EaseInOutQuad,    "easeInOutQuad",    quadraticEaseInOut)           \
                                                                          \
    X(EaseInCubic,      "easeInCubic",      cubicEaseIn)                  \
    X(EaseOutCubic,     "easeOutCubic",     cubicEaseOut)                 \
    X(EaseInOutCubic,   "easeInOutCubic",   cubicEaseInOut)               \
                                                                          \
    X(EaseInQuart,      "easeInQuart",      quarticEaseIn)                \
    X(EaseOutQuart,     "easeOutQuart",     quarticEaseOut)               \
    X(EaseInOutQuart,   "easeInOutQuart",   quarticEaseInOut)             \
                                                                          \
    X(EaseInQuint,      "easeInQuint",      quinticEaseIn)                \
    X(EaseOutQuint,     "easeOutQuint",     quinticEaseOut)               \
    X(EaseInOutQuint,   "easeInOutQuint",   quinticEaseInOut)             \
                                                                          \
    X(EaseInSine,       "easeInSine",       sineEaseIn)                   \
    X(EaseOutSine,      "easeOutSine",      sineEaseOut)                  \
    X(EaseInOutSine,    "easeInOutSine",    sineEaseInOut)                \
                                                                          \
    X(EaseInExpo,       "easeInExpo",       exponentialEaseIn)            \
    X(EaseOutExpo,      "easeOutExpo",      exponentialEaseOut)           \
    X(EaseInOutExpo,    "easeInOutExpo",    exponentialEaseInOut)         \
                                                                          \
    X(EaseInCirc,       "easeInCirc",       circularEaseIn)               \
    X(EaseOutCirc,      "easeOutCirc",      circularEaseOut)              \
    X(EaseInOutCirc,    "easeInOutCirc",    circularEaseInOut)            \
                                                                          \
    X(EaseInBack,       "easeInBack",       backEaseIn)                   \
    X(EaseOutBack,      "easeOutBack",      backEaseOut)                  \
    X(EaseInOutBack,    "easeInOutBack",    backEaseInOut)                \
                                                                          \
    X(EaseInElastic,    "easeInElastic",    elasticEaseIn)                \
    X(EaseOutElastic,   "easeOutElastic",   elasticEaseOut)               \
    X(EaseInOutElastic, "easeInOutElastic", elasticEaseInOut)             \
                                                                          \
    X(EaseInBounce,     "easeInBounce",     bounceEaseIn)                 \
    X(EaseOutBounce,    "easeOutBounce",    bounceEaseOut)                \
    X(EaseInOutBounce,  "easeInOutBounce",  bounceEaseInOut)

enum class Easing : uint8_t {
#define VKM_EASING_ID(id, name, fn) id,
    VKM_EASINGS(VKM_EASING_ID)
#undef VKM_EASING_ID
    Count
};

inline EasingFunction easingFunction(Easing easing) {
    // glm's easings are templates; the unary + decays each wrapping lambda to a pointer.
    static constexpr EasingFunction FUNCTIONS[] = {
#define VKM_EASING_FN(id, name, fn) +[](float t) { return glm::fn(t); },
        VKM_EASINGS(VKM_EASING_FN)
#undef VKM_EASING_FN
    };
    static_assert(std::size(FUNCTIONS) == static_cast<std::size_t>(Easing::Count));
    const auto index = static_cast<std::size_t>(easing);
    return index < std::size(FUNCTIONS) ? FUNCTIONS[index] : FUNCTIONS[0];
}
 
} // namespace Vkm::Engine
 
#define VKM_EASING_NAME(id, name, fn) name,
VKM_ENUM_NAMES(::Vkm::Engine::Easing, VKM_EASINGS(VKM_EASING_NAME))
#undef VKM_EASING_NAME
 
#undef VKM_EASINGS