Curve.hh

#ifndef GRAIL_CURVE_H
#define GRAIL_CURVE_H
 
#include "../../libs/vector2/vector2.h"
#include "../Evaluator.hh"
 
#include <utility>
#include <vector>
 
namespace grail
{
    namespace curves
    {
 
        template <typename ContextType>
        class Curve : public utility::Evaluator<ContextType>
        {
        public:
            explicit Curve(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator)
                : childEvaluator{childEvaluator}
            {
            }
 
            Curve(const Curve<ContextType>& other) = default;
            Curve(Curve<ContextType>&& other) = default;
            virtual ~Curve() = default;
 
            virtual float Sample(float argument) const = 0;
 
            virtual float Evaluate(const ContextType& context, UtilityEvaluatorSnapshot* const snapshot) const override final
            {
                return Sample(childEvaluator->EvaluateContext(context, snapshot));
            }
            
        protected:
            virtual void DebugDump(const std::map<const void*, std::size_t>& nodeMapping, EvaluationDebugData& debugData) const override final
            {
                debugData.AddChildNode(nodeMapping.at(childEvaluator.get()));
            }
 
        private:
            std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator{};
        };
 
        template <typename ContextType>
        class LowerBound final : public Curve<ContextType>
        {
        public:
            LowerBound(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator, float lowerBound)
                : Curve<ContextType>(childEvaluator), lowerBound{ lowerBound }
            {
            }
 
            virtual float Sample(float argument) const override final
            {
                return std::max(lowerBound, argument);
            }
 
            EvaluatorType GetEvaluatorType() const override final { return EvaluatorType::CURVE_LOWER_BOUND; }
 
        private:
            float lowerBound = 0.0f;
        };
 
        template <typename ContextType>
        class UpperBound final : public Curve<ContextType>
        {
        public:
            UpperBound(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator, float upperBound)
                : Curve<ContextType>(childEvaluator), upperBound{ upperBound }
            {
            }
 
            virtual float Sample(float argument) const override final
            {
                return std::min(upperBound, argument);
            }
 
            EvaluatorType GetEvaluatorType() const override final { return EvaluatorType::CURVE_UPPER_BOUND; }
 
        private:
            float upperBound = 0.0f;
        };
 
        template <typename ContextType>
        class DoubleSidedBound final : public Curve<ContextType>
        {
        public:
            DoubleSidedBound(std::shared_ptr<utility::Evaluator<ContextType>> childEvaluator,
                             float lowerBound,
                             float upperBound)
                : Curve<ContextType>{childEvaluator}, lowerBound{lowerBound}, upperBound{upperBound}
            {
            }
 
            virtual float Sample(float argument) const override final
            {
                return std::min(upperBound, std::max(lowerBound, argument));
            }
 
            EvaluatorType GetEvaluatorType() const override final { return EvaluatorType::CURVE_DOUBLE_SIDED_BOUND; }
 
        private:
            float lowerBound = 0.0f;
            float upperBound = 0.0f;
        };
 
        template<typename ContextType>
        std::vector<Vector2> DiscretizeCurve(const Curve<ContextType>& curve, std::size_t samplesQuantity)
        {
            std::vector<Vector2> controlPoints;
            float increment = 1.0f / (samplesQuantity - 1);
            for (float i = 0; i <= 1; i += increment)
            {
                controlPoints.push_back({ i, curve.Sample(i) });
            }
            return controlPoints;
        }
    }
}
#endif  //GRAIL_CURVE_H