curve.h

#ifndef OE_UTIL_CURVE_H
#define OE_UTIL_CURVE_H
 
#include <glm/gtx/easing.hpp>
 
namespace oe::util
{
    template <typename T>
    concept CurveValueConcept = requires(T t)
    {
       {0.5f * t} -> std::convertible_to<T>;
       {t + t} -> std::convertible_to<T>;
    };
 
    template <typename T>
    concept CurvePositionConcept = requires(T t)
    {
        {t} -> std::convertible_to<float>;
    };
 
    template <typename T, typename V, typename P>
    concept CurvePointConcept = requires(T t)
    {
        {t.value} -> std::convertible_to<V>;
        {t.position} -> std::convertible_to<P>;
    };
 
    enum class CurveInterpolation
    {
        DIRECT, 
        HOLD_LAST, 
        LINEAR, 
        CUBIC 
    };
 
    template <CurveValueConcept V, CurvePositionConcept P = float>
    struct CurvePoint
    {
        P position; 
        V value; 
        CurveInterpolation interpolation; 
 
        constexpr auto operator<=>(const CurvePoint& other) const
        {
            return position <=> other.position;
        }
 
        [[nodiscard]] constexpr static V interpolate(const CurvePoint& begin_point, const CurvePoint& end_point, const P ratio) noexcept
        {
            if (end_point.interpolation == CurveInterpolation::HOLD_LAST)
            {
                return begin_point.value;
            }
            else if (end_point.interpolation == CurveInterpolation::DIRECT)
            {
                return end_point.value;
            }
 
            P factor = (end_point.position != begin_point.position)
                ? (ratio - begin_point.position) / (end_point.position - begin_point.position)
                : 1.0f
            ;
 
            if (end_point.interpolation == CurveInterpolation::CUBIC)
            {
                factor = glm::cubicEaseInOut(factor);
            }
 
            return glm::mix(begin_point.value, end_point.value, factor);
        };
    };
 
    struct CurveSettings
    {
        template<CurveValueConcept V, CurvePositionConcept T>
        using PointType = CurvePoint<V, T>;
 
        template <typename Type>
        using PointStorageType = std::vector<Type>;
    };
 
    template <CurveValueConcept V, CurvePositionConcept T = float, typename CurveSettingsType = CurveSettings>
    struct Curve
    {
        using PointType = typename CurveSettingsType::PointType<V, T>; 
        using ContainerType = typename CurveSettingsType::PointStorageType<PointType>; 
 
        // We expect to have PointType.position and PointType.value
        static_assert(CurvePointConcept<PointType, V, T>);
 
        [[nodiscard]] constexpr V eval(const T x) const noexcept
        {
            assert(std::is_sorted(control_points.cbegin(), control_points.cend()));
 
            if (control_points.size() == 0)
            {
                return {};
            }
 
            if (control_points.size() == 1)
            {
                return control_points.at(0).value;
            }
 
            const auto pos_final = std::find_if(control_points.cbegin(), control_points.cend(), [&x](const PointType& point)
            {
                return point.position > x;
            });
 
            // Position is before the first element, return first element
            if (pos_final == control_points.cbegin())
            {
                return pos_final->value;
            }
 
            // Position not found (considered after last element), return last element
            if (pos_final == control_points.cend())
            {
                return (pos_final-1)->value;
            }
 
            const auto pos_begin = pos_final-1;
 
            return PointType::interpolate(*pos_begin, *pos_final, x);
        }
 
        ContainerType control_points; 
    };
}
 
#endif