ColorGradient.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Math/Declarations.h>
 
class plStreamWriter;
class plStreamReader;
 
class PL_FOUNDATION_DLL plColorGradient
{
public:
  struct ColorCP
  {
    PL_DECLARE_POD_TYPE();
 
    double m_PosX;
    plUInt8 m_GammaRed;
    plUInt8 m_GammaGreen;
    plUInt8 m_GammaBlue;
    float m_fInvDistToNextCp; 
 
    PL_ALWAYS_INLINE bool operator<(const ColorCP& rhs) const { return m_PosX < rhs.m_PosX; }
  };
 
  struct AlphaCP
  {
    PL_DECLARE_POD_TYPE();
 
    double m_PosX;
    plUInt8 m_Alpha;
    float m_fInvDistToNextCp; 
 
    PL_ALWAYS_INLINE bool operator<(const AlphaCP& rhs) const { return m_PosX < rhs.m_PosX; }
  };
 
  struct IntensityCP
  {
    PL_DECLARE_POD_TYPE();
 
    double m_PosX;
    float m_Intensity;
    float m_fInvDistToNextCp; 
 
    PL_ALWAYS_INLINE bool operator<(const IntensityCP& rhs) const { return m_PosX < rhs.m_PosX; }
  };
 
public:
  plColorGradient();
 
  void Clear();
 
  bool IsEmpty() const;
 
  void AddColorControlPoint(double x, const plColorGammaUB& rgb);
 
  void AddAlphaControlPoint(double x, plUInt8 uiAlpha);
 
  void AddIntensityControlPoint(double x, float fIntensity);
 
  bool GetExtents(double& ref_fMinx, double& ref_fMaxx) const;
 
  void GetNumControlPoints(plUInt32& ref_uiRgb, plUInt32& ref_uiAlpha, plUInt32& ref_uiIntensity) const;
 
  const ColorCP& GetColorControlPoint(plUInt32 uiIdx) const { return m_ColorCPs[uiIdx]; }
  const AlphaCP& GetAlphaControlPoint(plUInt32 uiIdx) const { return m_AlphaCPs[uiIdx]; }
  const IntensityCP& GetIntensityControlPoint(plUInt32 uiIdx) const { return m_IntensityCPs[uiIdx]; }
 
  ColorCP& ModifyColorControlPoint(plUInt32 uiIdx) { return m_ColorCPs[uiIdx]; }
  AlphaCP& ModifyAlphaControlPoint(plUInt32 uiIdx) { return m_AlphaCPs[uiIdx]; }
  IntensityCP& ModifyIntensityControlPoint(plUInt32 uiIdx) { return m_IntensityCPs[uiIdx]; }
 
  void SortControlPoints();
 
  void Evaluate(double x, plColorGammaUB& ref_rgba, float& ref_fIntensity) const;
 
  void Evaluate(double x, plColor& ref_hdr) const;
 
  void EvaluateColor(double x, plColorGammaUB& ref_rgb) const;
  void EvaluateColor(double x, plColor& ref_rgb) const;
  void EvaluateAlpha(double x, plUInt8& ref_uiAlpha) const;
  void EvaluateIntensity(double x, float& ref_fIntensity) const;
 
  plUInt64 GetHeapMemoryUsage() const;
 
  void Save(plStreamWriter& inout_stream) const;
 
  void Load(plStreamReader& inout_stream);
 
private:
  void PrecomputeLerpNormalizer();
 
  plHybridArray<ColorCP, 8> m_ColorCPs;
  plHybridArray<AlphaCP, 8> m_AlphaCPs;
  plHybridArray<IntensityCP, 8> m_IntensityCPs;
};