Curve1D.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Math/Color.h>
#include <Foundation/Math/Vec2.h>
#include <Foundation/Types/Enum.h>
 
class plStreamWriter;
class plStreamReader;
 
struct PL_FOUNDATION_DLL plCurveTangentMode
{
  using StorageType = plUInt8;
 
  enum Enum
  {
    Bezier,
    FixedLength,
    Linear,
    // Constant,
    Auto,
    Default = Auto
  };
};
 
class PL_FOUNDATION_DLL plCurve1D
{
public:
  struct ControlPoint
  {
    PL_DECLARE_POD_TYPE();
 
    ControlPoint();
 
    plVec2d m_Position;
 
    plVec2 m_LeftTangent;
    plVec2 m_RightTangent;
 
    plEnum<plCurveTangentMode> m_TangentModeLeft;
    plEnum<plCurveTangentMode> m_TangentModeRight;
 
    plUInt16 m_uiOriginalIndex;
 
    PL_ALWAYS_INLINE bool operator<(const ControlPoint& rhs) const { return m_Position.x < rhs.m_Position.x; }
  };
 
public:
  plCurve1D();
 
  void Clear();
 
  bool IsEmpty() const;
 
  ControlPoint& AddControlPoint(double fPos);
 
  void RecomputeExtents();
 
  void QueryExtents(double& ref_fMinx, double& ref_fMaxx) const;
 
  void QueryExtremeValues(double& ref_fMinVal, double& ref_fMaxVal) const;
 
  plUInt32 GetNumControlPoints() const;
 
  const ControlPoint& GetControlPoint(plUInt32 uiIdx) const { return m_ControlPoints[uiIdx]; }
 
  ControlPoint& ModifyControlPoint(plUInt32 uiIdx) { return m_ControlPoints[uiIdx]; }
 
  void SortControlPoints();
 
  double Evaluate(double fPosition) const;
 
  double ConvertNormalizedPos(double fPos) const;
 
  double NormalizeValue(double value) const;
 
  plUInt64 GetHeapMemoryUsage() const;
 
  void Save(plStreamWriter& inout_stream) const;
 
  void Load(plStreamReader& inout_stream);
 
  void CreateLinearApproximation(double fMaxError = 0.01, plUInt8 uiMaxSubDivs = 8);
 
  const plHybridArray<plVec2d, 24>& GetLinearApproximation() const { return m_LinearApproximation; }
 
  void ClampTangents();
 
  void ApplyTangentModes();
 
  void MakeFixedLengthTangentLeft(plUInt32 uiCpIdx);
  void MakeFixedLengthTangentRight(plUInt32 uiCpIdx);
  void MakeLinearTangentLeft(plUInt32 uiCpIdx);
  void MakeLinearTangentRight(plUInt32 uiCpIdx);
 
  void MakeAutoTangentLeft(plUInt32 uiCpIdx);
  void MakeAutoTangentRight(plUInt32 uiCpIdx);
 
private:
  void RecomputeLinearApproxExtremes();
  void ApproximateMinMaxValues(const ControlPoint& lhs, const ControlPoint& rhs, double& fMinY, double& fMaxY);
  void ApproximateCurve(
    const plVec2d& p0, const plVec2d& p1, const plVec2d& p2, const plVec2d& p3, double fMaxErrorX, double fMaxErrorY, plInt32 iSubDivLeft);
  void ApproximateCurvePiece(const plVec2d& p0, const plVec2d& p1, const plVec2d& p2, const plVec2d& p3, double tLeft, const plVec2d& pLeft,
    double tRight, const plVec2d& pRight, double fMaxErrorX, double fMaxErrorY, plInt32 iSubDivLeft);
  plInt32 FindApproxControlPoint(double x) const;
 
  double m_fMinX, m_fMaxX;
  double m_fMinY, m_fMaxY;
  plHybridArray<ControlPoint, 8> m_ControlPoints;
  plHybridArray<plVec2d, 24> m_LinearApproximation;
};