FCurve.h

Go to the documentation of this file.

//-
// =============================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// =============================================================================
//+
 
 
#ifndef BIFROST_MATH_FCURVE_H
#define BIFROST_MATH_FCURVE_H
 
#include <Bifrost/Math/MathExport.h>
 
#include <Amino/Core/Array.h>
#include <Amino/Core/Ptr.h>
#include <Amino/Core/internal/ConfigMacros.h>
 
#include <Amino/Cpp/Annotate.h>
#include <Amino/Cpp/ClassDeclare.h>
 
namespace Amino {
class FCurveSerializer;
}
 
#define BIFROST_IGNORE_NAMESPACE AMINO_ANNOTATE("Amino::Namespace ignore")
namespace Bifrost BIFROST_IGNORE_NAMESPACE {
#undef BIFROST_IGNORE_NAMESPACE
 
namespace Math {
 
//==============================================================================
// CLASS FCurve
//==============================================================================
 
class AMINO_ANNOTATE("Amino::Class") BIFROST_MATH_SHARED_DECL FCurve {
    friend class Amino::FCurveSerializer;
 
public:
    /*----- types -----*/
 
    enum class SpanInterpolationMethod : uint8_t {
        Constant, 
        Linear,   
        Curve     
    };
 
    enum class CurveInterpolationMethod : uint8_t {
        Bezier,    
        Hermite,   
        Sine,      
        Parabolic, 
        TangentLog 
    };
 
    enum class ExtrapolationMode {
        Constant,
 
        Linear,
 
        Cycle,
 
        RelativeRepeat,
 
        Oscillate
    };
 
    struct ControlPoints {
        double xp = 0;
        double yp = 0;
        double x  = 0;
        double y  = 0;
        double xn = 0;
        double yn = 0;
    };
 
    class SegmentPoint {
    public:
        constexpr SegmentPoint() = default;
 
        constexpr explicit SegmentPoint(ControlPoints const& coords)
            : m_coords(coords) {}
 
        constexpr SegmentPoint(
            ControlPoints const&     coords,
            SpanInterpolationMethod  spanInterpolation,
            CurveInterpolationMethod curveInterpolation,
            bool                     locked)
            : m_coords(coords),
              m_spanInterpolation(spanInterpolation),
              m_curveInterpolation(curveInterpolation),
              m_locked(locked) {}
 
        ControlPoints const& getControlPoints() const { return m_coords; }
 
        SpanInterpolationMethod getSpanInterpolation() const {
            return m_spanInterpolation;
        }
 
        CurveInterpolationMethod getCurveInterpolation() const {
            return m_curveInterpolation;
        }
 
        bool isLocked() const { return m_locked; }
 
    private:
        friend FCurve;
 
        ControlPoints m_coords;
 
        SpanInterpolationMethod m_spanInterpolation =
            SpanInterpolationMethod::Curve;
 
        CurveInterpolationMethod m_curveInterpolation =
            CurveInterpolationMethod::Bezier;
 
        bool m_locked = true;
    };
 
    using FCurvePoints = Amino::Array<SegmentPoint>;
 
    /*----- member functions -----*/
 
    explicit FCurve(bool createDefaultValue = true);
 
    ~FCurve();
 
    FCurve(FCurve const& other);
 
    bool defaultValue();
 
    static double evaluateCurveSegment(
        CurveInterpolationMethod interpolation,
        double                   x0,
        double                   y0,
        double                   x1,
        double                   y1,
        double                   x2,
        double                   y2,
        double                   x3,
        double                   y3,
        double                   x);
 
    static double evalBezier(
        double x0,
        double y0,
        double x1,
        double y1,
        double x2,
        double y2,
        double x3,
        double y3,
        double x) {
        return evaluateCurveSegment(
            CurveInterpolationMethod::Bezier, //
            x0, y0, x1, y1, x2, y2, x3, y3, x);
    }
 
    FCurvePoints const& getPoints() const { return m_points; }
 
    ExtrapolationMode getPreExtrapolation() const { return m_preExtrapolation; }
 
    ExtrapolationMode getPostExtrapolation() const {
        return m_postExtrapolation;
    }
 
    int numPoints() const;
 
    double evalFCurve(double x) const;
 
    void setPoints(FCurvePoints points) { m_points = std::move(points); }
 
    void setExtrapolationModes(
        ExtrapolationMode preExtrapolation,
        ExtrapolationMode postExtrapolation) {
        m_preExtrapolation  = preExtrapolation;
        m_postExtrapolation = postExtrapolation;
    }
 
private:
    AMINO_INTERNAL_WARNING_PUSH
    AMINO_INTERNAL_WARNING_DISABLE_MSC(4251)
    FCurvePoints      m_points;
    ExtrapolationMode m_preExtrapolation  = ExtrapolationMode::Constant;
    ExtrapolationMode m_postExtrapolation = ExtrapolationMode::Constant;
    AMINO_INTERNAL_WARNING_POP
};
 
} // namespace Math
} // namespace BIFROST_IGNORE_NAMESPACE
 
AMINO_DECLARE_DEFAULT_CLASS(BIFROST_MATH_SHARED_DECL, Bifrost::Math::FCurve);
 
#endif