Spline.hpp

#pragma once
 
#include <Infinity/api.h>
#include <Infinity/Types/Core/Data.hpp>
#include <Infinity/Types/Core/Value.hpp>
#include <Infinity/Types/Containers/Array.hpp>
#include <Infinity/Types/Math/Vector2.hpp>
#include <Infinity/Types/Math/Vector3.hpp>
#include <Infinity/Types/Math/Vector4.hpp>
 
namespace Infinity::Types::Spatial
{
    enum class INFINITY_API_TEMPLATE SplineKind : uint32_t
    {
        Bezier     = 0,
        
        CatmullRom = 1,
        
        BSpline    = 2,
        
        Linear     = 3
    };
 
    template<typename T>
    class SplineImplBase;
 
    class INFINITY_API_PUBLIC Spline2D : public Core::Data
    {
        public:
            using Vec = Math::Vector2;
 
            Containers::Array<Vec> points;
 
            Spline2D();
            
            explicit Spline2D(SplineKind kind);
            
            Spline2D(const Spline2D& other);
            
            virtual ~Spline2D();
 
            std::unique_ptr<Core::Base> clone() const override;
 
            Spline2D& operator=(const Spline2D& other);
 
            Vec evaluate(float t) const;
 
            Vec tangent(float t) const;
 
            void setCurveKind(SplineKind kind);
            
            SplineKind type() const;
 
            const Infinity::Types::TypeID& typeId() const override;
 
        private:
            std::unique_ptr<SplineImplBase<Vec>> _impl;
    };
 
    class INFINITY_API_PUBLIC Spline3D : public Core::Data
    {
        public:
            using Vec = Math::Vector3;
 
            Containers::Array<Vec> points;
 
            Spline3D();
            
            explicit Spline3D(SplineKind kind);
            
            Spline3D(const Spline3D& other);
            
            virtual ~Spline3D();
 
            std::unique_ptr<Core::Base> clone() const override;
 
            Spline3D& operator=(const Spline3D& other);
 
            Vec evaluate(float t) const;
 
            Vec tangent(float t) const;
 
            void setCurveKind(SplineKind kind);
            
            SplineKind type() const;
 
            const Infinity::Types::TypeID& typeId() const override;
 
        private:
            std::unique_ptr<SplineImplBase<Vec>> _impl;
    };
 
    class INFINITY_API_PUBLIC Spline4D : public Core::Data
    {
        public:
            using Vec = Math::Vector4;
 
            Containers::Array<Vec> points;
 
            Spline4D();
            
            explicit Spline4D(SplineKind kind);
            
            Spline4D(const Spline4D& other);
            
            ~Spline4D();
 
            Spline4D& operator=(const Spline4D& other);
 
            Vec evaluate(float t) const;
 
            Vec tangent(float t) const;
 
            void setCurveKind(SplineKind kind);
            
            SplineKind type() const;
 
            const Infinity::Types::TypeID& typeId() const override;
 
        private:
            std::unique_ptr<SplineImplBase<Vec>> _impl;
    };
 
}
 
INFINITY_TYPE(Infinity::Types::Spatial::Spline2D)
INFINITY_TYPE(Infinity::Types::Spatial::Spline3D)
INFINITY_TYPE(Infinity::Types::Spatial::Spline4D)
 
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Spatial::Spline2D>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Spatial::Spline3D>)
INFINITY_TYPE(Infinity::Types::Containers::Array<Infinity::Types::Spatial::Spline4D>)