bezier_curve.h

#ifndef OE_UTIL_BEZIER_CURVE_H
#define OE_UTIL_BEZIER_CURVE_H
 
#include <span>
 
namespace oe::util
{
    enum class BezierCurveType
    {
        Quadratic = 3, //< Each curve is made using 3 control points
        Cubic = 4, //< Each curve is made using 4 control points
    };
 
    template <typename T>
    concept CurveValueConcept = requires(T t)
    {
       {0.5f * t} -> std::convertible_to<T>;
       {t + t} -> std::convertible_to<T>;
    };
 
    struct Bezier
    {
        template <BezierCurveType Type, CurveValueConcept T>
        inline static T evaluateCurve(std::span<const T> P, const float t)
        {
            if constexpr (Type == BezierCurveType::Quadratic)
            {
                assert(P.size() == 3);
 
                float b0 = (1 - t) * (1 - t);
                float b1 = 2 * (1 - t) * t;
                float b2 = t * t;
 
                return P[0] * b0 + P[1] * b1 + P[2] * b2;
            }
            else if constexpr (Type == BezierCurveType::Cubic)
            {
                assert(P.size() == 4);
 
                float b0 = (1 - t) * (1 - t) * (1 - t);
                float b1 = 3 * t * (1 - t) * (1 - t);
                float b2 = 3 * t * t * (1 - t);
                float b3 = t * t * t;
 
                return P[0] * b0 + P[1] * b1 + P[2] * b2 + P[3] * b3;
            }
 
            static_assert("Unknown curve type");
        }
 
        template <BezierCurveType Type, CurveValueConcept T>
        inline static T evaluateDerivativeCurve(std::span<const T> P, const float t)
        {
            if constexpr (Type == BezierCurveType::Quadratic)
            {
                assert(P.size() == 3);
 
                float b0 = -2 * (1 - t);
                float b1 = 2 * (1 - t) -2 * t;
                float b2 = 2 * t;
 
                return P[0] * b0 + P[1] * b1 + P[2] * b2;
            }
            else if constexpr (Type == BezierCurveType::Cubic)
            {
                assert(P.size() == 4);
 
                float b0 = -3 * (1 - t) * (1 - t);
                float b1 = 3 * (1 - t) * (1 - t) - 6 * t * (1 - t);
                float b2 = 6 * t * (1 - t) - 3 * t * t;
                float b3 = 3 * t * t;
 
                return P[0] * b0 + P[1] * b1 + P[2] * b2 + P[3] * b3;
            }
 
            static_assert("Unknown curve type");
        }
    };
}
 
 
#endif