curve.h

#ifndef OE_UTIL_CURVE_H
#define OE_UTIL_CURVE_H
 
namespace oe::util
{
    template <typename T>
    concept CurvePointType = requires(T t)
    {
       {0.5f * t} -> std::convertible_to<T>;
       {t + t} -> std::convertible_to<T>;
    };
 
    template <typename T>
    concept CurveAbscissaType = requires(T t)
    {
        {t} -> std::convertible_to<float>;
    };
 
    enum class CurveInterpolation
    {
        DIRECT, 
        HOLD_LAST, 
        LINEAR 
    };
 
    template <CurvePointType V, CurveAbscissaType T = float>
    struct CurvePoint
    {
        T position; 
        V value; 
        CurveInterpolation interpolation = CurveInterpolation::HOLD_LAST; 
 
        auto operator<=>(const CurvePoint& other) const
        {
            return position <=> other.position;
        }
    };
 
    template <CurvePointType V, CurveAbscissaType T = float>
    struct Curve
    {
        using Point = CurvePoint<V, T>;
 
        constexpr V eval(const T x) const
        {
            assert(std::is_sorted(control_points.cbegin(), control_points.cend()) && "The Control points must be sorted by position!");
 
            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 Point& 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;
 
            if (pos_final->interpolation == CurveInterpolation::HOLD_LAST)
            {
                return pos_begin->value;
            }
            else if (pos_final->interpolation == CurveInterpolation::LINEAR)
            {
                T factor = (pos_final->position != pos_begin->position)
                    ? (x - pos_begin->position) / (pos_final->position - pos_begin->position)
                    : 1.0f
                ;
 
                return (1.0f-factor) * pos_begin->value + factor * pos_final->value;
            }
 
            // Curve Interpolation is NONE
            return pos_final->value;
        }
 
        std::vector<Point> control_points;
    };
}
 
#endif