Ramp.hpp

// INFINITY_API_PUBLIC
 
#pragma once
 
#include <Infinity/Types/Core/Data.hpp>
#include <Infinity/Types/Math/Stop.hpp>
 
#include <vector>
#include <algorithm>
 
namespace Infinity::Types::Math
{
    enum class INFINITY_API_TEMPLATE Interpolation
    {
        Linear,  
        Cubic    
    };
 
    template<typename T>
    class INFINITY_API_TEMPLATE Ramp : public Core::Data
    {
        public:
            std::vector<Stop<T>> stops;
 
            Interpolation interpolation = Interpolation::Linear;
 
            Ramp() = default;
 
            std::unique_ptr<Core::Base> clone() const override
            {
                return std::make_unique<Ramp<T>>(*this);
            }
 
            Ramp(std::vector<Stop<T>> inputStops, Interpolation interp = Interpolation::Linear) : interpolation(interp)
            {
                stops = std::move(inputStops);
                std::sort(stops.begin(), stops.end(), [](const Stop<T>& a, const Stop<T>& b) {
                    return a.position < b.position;
                });
            }
 
            bool operator==(const Ramp<T>& other) const
            {
                return stops == other.stops && interpolation == other.interpolation;
            }
        
            bool operator!=(const Ramp<T>& other) const
            {
                return !(*this == other);
            }
 
            const Infinity::Types::TypeID& typeId() const override { return Infinity::Types::getTypeID<Ramp<T>>(); }
 
            T sample(float position) const
            {
                if (stops.empty())
                {
                    return T(); // Default constructed value
                }
        
                if (position <= stops.front().position)
                {
                    return stops.front().value;
                }
        
                if (position >= stops.back().position)
                {
                    return stops.back().value;
                }
        
                for (size_t i = 0; i < stops.size() - 1; ++i)
                {
                    const auto& a = stops[i];
                    const auto& b = stops[i + 1];
        
                    if (position >= a.position && position <= b.position) 
                    {
                        float t = (position - a.position) / (b.position - a.position);
                        return (interpolation == Interpolation::Linear)
                            ? lerp(a.value, b.value, t)
                            : cubicInterp(a.value, b.value, t);
                    }
                }
        
                return T(); // this should never happen
            }
 
        private:
            T lerp(const T& a, const T& b, float t) const
            {
                return a + (b - a) * t;
            }
        
            T cubicInterp(const T& a, const T& b, float t) const {
                float t2 = t * t;
                float t3 = t2 * t;
                return a * (2.0f * t3 - 3.0f * t2 + 1.0f) +
                    b * (-2.0f * t3 + 3.0f * t2);
            }
    };
 
    using ValueRamp = Ramp<float>;
 
    using Value2Ramp = Ramp<Vector2>;
 
    using Value3Ramp = Ramp<Vector3>;
 
    using Value4Ramp = Ramp<Vector4>;
}
 
// Register Ramp specializations in the type system
INFINITY_TYPE(Infinity::Types::Math::Ramp<float>)
INFINITY_TYPE(Infinity::Types::Math::Ramp<Infinity::Types::Math::Vector2>)
INFINITY_TYPE(Infinity::Types::Math::Ramp<Infinity::Types::Math::Vector3>)
INFINITY_TYPE(Infinity::Types::Math::Ramp<Infinity::Types::Math::Vector4>)