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,
  };
  
  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; }
 
  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