IPlugParameter.h

Go to the documentation of this file.

/*
 ==============================================================================
 
 This file is part of the iPlug 2 library. Copyright (C) the iPlug 2 developers. 
 
 See LICENSE.txt for  more info.
 
 ==============================================================================
*/
 
#pragma once
 
#include <atomic>
#include <cstring>
#include <functional>
#include <memory>
 
#include "wdlstring.h"
 
#include "IPlugUtilities.h"
 
BEGIN_IPLUG_NAMESPACE
 
class IParam
{
public:
 
  enum EParamType { kTypeNone, kTypeBool, kTypeInt, kTypeEnum, kTypeDouble };
 
  enum EParamUnit { kUnitPercentage, kUnitSeconds, kUnitMilliseconds, kUnitSamples, kUnitDB, kUnitLinearGain, kUnitPan, kUnitPhase, kUnitDegrees, kUnitMeters, kUnitRate, kUnitRatio, kUnitFrequency, kUnitOctaves, kUnitCents, kUnitAbsCents, kUnitSemitones, kUnitMIDINote, kUnitMIDICtrlNum, kUnitBPM, kUnitBeats, kUnitCustom };
 
  enum EDisplayType { kDisplayLinear, kDisplayLog, kDisplayExp, kDisplaySquared, kDisplaySquareRoot, kDisplayCubed, kDisplayCubeRoot };
 
  enum EFlags
  {
    kFlagsNone            = 0,
    kFlagCannotAutomate   = 0x1,
    kFlagStepped          = 0x2,
    kFlagNegateDisplay    = 0x4,
    kFlagSignDisplay      = 0x8,
    kFlagMeta             = 0x10,
  };
  
  enum EShapeIDs
  {
    kShapeLinear = 0,
    kShapePowCurve = 1,
    kShapeExponential = 2,
    kShapeUnknown,
  };
  
  using DisplayFunc = std::function<void(double, WDL_String&)>;
 
#pragma mark - Shape
 
  struct Shape
  {
    virtual ~Shape() {}
 
    virtual Shape* Clone() const = 0;
 
    virtual void Init(const IParam& param) {}
 
    virtual EDisplayType GetDisplayType() const = 0;
 
    virtual double NormalizedToValue(double value, const IParam& param) const = 0;
 
    virtual double ValueToNormalized(double value, const IParam& param) const = 0;
  };
 
  struct ShapeLinear : public Shape
  {
    Shape* Clone() const override { return new ShapeLinear(*this); }
    IParam::EDisplayType GetDisplayType() const override { return kDisplayLinear; }
    double NormalizedToValue(double value, const IParam& param) const override;
    double ValueToNormalized(double value, const IParam& param) const override;
  
    double mShape;
  };
  
  struct ShapePowCurve : public Shape
  {
    ShapePowCurve(double shape);
    Shape* Clone() const override { return new ShapePowCurve(*this); }
    IParam::EDisplayType GetDisplayType() const override;
    double NormalizedToValue(double value, const IParam& param) const override;
    double ValueToNormalized(double value, const IParam& param) const override;
    
    double mShape;
  };
  
  struct ShapeExp : public Shape
  {
    void Init(const IParam& param) override;
    Shape* Clone() const override { return new ShapeExp(*this); }
    IParam::EDisplayType GetDisplayType() const override { return kDisplayLog; }
    double NormalizedToValue(double value, const IParam& param) const override;
    double ValueToNormalized(double value, const IParam& param) const override;
    
    double mMul = 1.0;
    double mAdd = 1.0;
  };
 
#pragma mark -
 
  IParam();
 
  IParam(const IParam&) = delete;
  IParam& operator=(const IParam&) = delete;
 
  void InitBool(const char* name, bool defaultValue, const char* label = "", int flags = 0, const char* group = "", const char* offText = "off", const char* onText = "on");
  
  void InitEnum(const char* name, int defaultValue, int nEnums, const char* label = "", int flags = 0, const char* group = "", const char* listItems = 0, ...);
 
  void InitEnum(const char* name, int defaultValue, const std::initializer_list<const char*>& listItems, int flags = 0, const char* group = "");
 
  void InitInt(const char* name, int defaultValue, int minVal, int maxVal, const char* label = "", int flags = 0, const char* group = "");
  
  void InitDouble(const char* name, double defaultVal, double minVal, double maxVal, double step, const char* label = "", int flags = 0, const char* group = "", const Shape& shape = ShapeLinear(), EParamUnit unit = kUnitCustom, DisplayFunc displayFunc = nullptr);
 
  void InitSeconds(const char* name, double defaultVal = 1., double minVal = 0., double maxVal = 10., double step = 0.1, int flags = 0, const char* group = "");
  
  void InitMilliseconds(const char* name, double defaultVal = 1., double minVal = 0., double maxVal = 100., int flags = 0, const char* group = "");
 
  void InitFrequency(const char* name, double defaultVal = 1000., double minVal = 0.1, double maxVal = 10000., double step = 0.1, int flags = 0, const char* group = "");
  
  void InitPitch(const char* name, int defaultVal = 60, int minVal = 0, int maxVal = 128, int flags = 0, const char* group = "", bool middleCisC4 = false);
  
  void InitGain(const char* name, double defaultVal = 0., double minVal = -70., double maxVal = 24., double step = 0.5, int flags = 0, const char* group = "");
  
  void InitPercentage(const char* name, double defaultVal = 0., double minVal = 0., double maxVal = 100., int flags = 0, const char* group = "");
 
  void InitAngleDegrees(const char* name, double defaultVal = 0., double minVal = 0., double maxVal = 360., int flags = 0, const char* group = "");
 
  void Init(const IParam& p, const char* searchStr = "", const char* replaceStr = "", const char* newGroup = "");
  
  double StringToValue(const char* str) const;
 
  inline double Constrain(double value) const
  {
    return Clip((mFlags & kFlagStepped ? std::round(value / mStep) * mStep : value), mMin, mMax);
  }
 
  inline double ConstrainNormalized(double normalizedValue) const
  {
    return ToNormalized(mShape->NormalizedToValue(normalizedValue, *this));
  }
  
  inline double ToNormalized(double nonNormalizedValue) const
  {
    return Clip(mShape->ValueToNormalized(Constrain(nonNormalizedValue), *this), 0., 1.);
  }
 
  inline double FromNormalized(double normalizedValue) const
  {
    return Constrain(mShape->NormalizedToValue(normalizedValue, *this));
  }
 
  void Set(double value) { mValue.store(Constrain(value)); }
 
  void SetNormalized(double normalizedValue) { Set(FromNormalized(normalizedValue)); }
 
  void SetString(const char* str) { mValue.store(StringToValue(str)); }
 
  void SetToDefault() { mValue.store(mDefault); }
 
  void SetDefault(double value) { mDefault = value; SetToDefault(); }
 
  void SetDisplayText(double value, const char* str);
 
  void SetDisplayPrecision(int precision);
 
  void SetLabel(const char* label) { strcpy(mLabel, label); }
  
  void SetDisplayFunc(DisplayFunc func) { mDisplayFunction = func; }
 
  double Value() const { return mValue.load(); }
 
  bool Bool() const { return (mValue.load() >= 0.5); }
 
  int Int() const { return static_cast<int>(mValue.load()); }
  
  double DBToAmp() const { return iplug::DBToAmp(mValue.load()); }
 
  double GetNormalized() const { return ToNormalized(mValue.load()); }
 
  void GetDisplay(WDL_String& display, bool withDisplayText = true) const { GetDisplay(mValue.load(), false, display, withDisplayText); }
 
  void GetDisplay(double value, bool normalized, WDL_String& display, bool withDisplayText = true) const;
 
  void GetDisplayWithLabel(WDL_String& display, bool withDisplayText = true) const
  {
    GetDisplay(mValue.load(), false, display, withDisplayText);
    const char* hostlabel = GetLabel();
    if (CStringHasContents(hostlabel))
    {
      display.Append(" ");
      display.Append(hostlabel);
    }
  }
  
  const char* GetName() const;
 
  const char* GetLabel() const;
 
  const char* GetGroup() const;
 
  const char* GetCustomUnit() const { return mUnit == kUnitCustom ? mLabel : nullptr; }
  
  int NDisplayTexts() const;
 
  const char* GetDisplayText(double value) const;
 
  const char* GetDisplayTextAtIdx(int idx, double* pValue = nullptr) const;
 
  bool MapDisplayText(const char* str, double* pValue) const;
  
  EParamType Type() const { return mType; }
 
  EParamUnit Unit() const { return mUnit; }
 
  EDisplayType DisplayType() const { return mShape->GetDisplayType(); }
  
  double GetDefault(bool normalized = false) const { return normalized ? ToNormalized(GetDefault()) : mDefault; }
  
  double GetMin() const { return mMin; }
 
  double GetMax() const { return mMax; }
  
  void GetBounds(double& lo, double& hi) const;
 
  double GetRange() const { return mMax - mMin; }
 
  double GetStep() const { return mStep; }
 
  int GetDisplayPrecision() const {return mDisplayPrecision;}
  
  int GetFlags() const { return mFlags; }
 
  bool GetCanAutomate() const { return !(mFlags & kFlagCannotAutomate); }
 
  bool GetStepped() const { return mFlags & kFlagStepped; }
 
  bool GetNegateDisplay() const { return mFlags & kFlagNegateDisplay; }
 
  bool GetSignDisplay() const { return mFlags & kFlagSignDisplay; }
 
  bool GetMeta() const { return mFlags & kFlagMeta; }
  
  EShapeIDs GetShapeID() const;
  
  double GetShapeValue() const;
 
  void GetJSON(WDL_String& json, int idx) const;
 
  void PrintDetails() const;
private:
  struct DisplayText
  {
    double mValue;
    char mText[MAX_PARAM_DISPLAY_LEN];
  };
 
  EParamType mType = kTypeNone;
  EParamUnit mUnit = kUnitCustom;
  std::atomic<double> mValue{0.0};
  double mMin = 0.0;
  double mMax = 1.0;
  double mStep = 1.0;
  double mDefault = 0.0;
  int mDisplayPrecision = 0;
  int mFlags = 0;
 
  char mName[MAX_PARAM_NAME_LEN];
  char mLabel[MAX_PARAM_LABEL_LEN];
  char mParamGroup[MAX_PARAM_GROUP_LEN];
  
  std::unique_ptr<Shape> mShape;
  DisplayFunc mDisplayFunction = nullptr;
 
  WDL_TypedBuf<DisplayText> mDisplayTexts;
} WDL_FIXALIGN;
 
END_IPLUG_NAMESPACE