Ramp.h

#pragma once
 
#include "Engine/Core/Types.h"
#include <algorithm>
#include <vector>
 
namespace enzo::prm {
 
class Parameter;
 
// The full set also includes catmull rom, monotone cubic, bezier, and hermite.
// Only constant, linear, and b spline are sampled today.
enum class Interpolation
{
    CONSTANT,
    LINEAR,
    BSPLINE
};
 
class Ramp
{
  public:
    struct Key
    {
        floatT position;
        floatT value;
        Interpolation interp;
    };
 
    Ramp() = default;
    explicit Ramp(std::vector<Key> keys);
 
    explicit Ramp(const Parameter& rampParameter);
 
    floatT sample(floatT position) const
    {
        if (lookupTable_.empty()) return 0;
 
        // Map the position onto the table as a fractional step index.
        const floatT tableEndPosition = tableStartPosition_ + tablePositionSpan_;
        const floatT clampedPosition = std::clamp(position, tableStartPosition_, tableEndPosition);
        const floatT stepIndex = tablePositionSpan_ > 0 ? (clampedPosition - tableStartPosition_) /
                                                              tablePositionSpan_ * lookupTableSteps
                                                        : 0;
 
        // Blend the two table samples bracketing that step.
        int lowerStep = static_cast<int>(stepIndex);
        if (lowerStep >= lookupTableSteps) lowerStep = lookupTableSteps - 1;
        const floatT blend = stepIndex - static_cast<floatT>(lowerStep);
        return lookupTable_[lowerStep] +
               (lookupTable_[lowerStep + 1] - lookupTable_[lowerStep]) * blend;
    }
 
    bool empty() const;
    size_t size() const;
    const Key& key(size_t index) const;
 
  private:
    void bake();
 
    static constexpr int lookupTableSteps = 4096;
 
    std::vector<Key> keys_;
    std::vector<floatT> lookupTable_;
    floatT tableStartPosition_ = 0;
    floatT tablePositionSpan_ = 0;
};
 
} // namespace enzo::prm