ASPiK SDK
pluginparameter.h
1 // -----------------------------------------------------------------------------
2 // ASPiK Plugin Kernel File: pluginparameter.h
3 //
12 // -----------------------------------------------------------------------------
13 #ifndef _PluginParameter_H_
14 #define _PluginParameter_H_
15 
16 #include <string>
17 #include <vector>
18 #include <sstream>
19 #include <atomic>
20 #include <map>
21 #include <iomanip>
22 #include <iostream>
23 
24 #include <math.h>
25 #include "pluginstructures.h"
26 #include "guiconstants.h"
27 
28 
52 {
53 public:
55  PluginParameter(int _controlID, const char* _controlName, const char* _controlUnits,
56  controlVariableType _controlType, double _minValue, double _maxValue, double _defaultValue,
57  taper _controlTaper = taper::kLinearTaper, uint32_t _displayPrecision = 2);
58 
60  PluginParameter(int _controlID, const char* _controlName, std::vector<std::string> _stringList, std::string _defaultString);
61 
63  PluginParameter(int _controlID, const char* _controlName, const char* _commaSeparatedList, std::string _defaultString);
64 
66  PluginParameter(int _controlID, const char* _controlName, double _meterAttack_ms, double _meterRelease_ms,
67  uint32_t _detectorMode, meterCal _meterCal = meterCal::kLinearMeter);
68 
70  PluginParameter(int _controlID, const char* _controlName = "", controlVariableType _controlType = controlVariableType::kNonVariableBoundControl);
71 
74 
76  PluginParameter(const PluginParameter& initGuiControl);
77 
79  virtual ~PluginParameter();
80 
81  uint32_t getControlID() { return controlID; }
82  void setControlID(uint32_t cid) { controlID = cid; }
83 
84  const char* getControlName() { return controlName.c_str(); }
85  void setControlName(const char* name) { controlName.assign(name); }
86 
87  const char* getControlUnits() { return controlUnits.c_str(); }
88  void setControlUnits(const char* units) { controlUnits.assign(units); }
89 
91  void setControlVariableType(controlVariableType ctrlVarType) { controlType = ctrlVarType; }
92 
93  double getMinValue() { return minValue; }
94  void setMinValue(double value) { minValue = value; }
95 
96  double getMaxValue() { return maxValue; }
97  void setMaxValue(double value) { maxValue = value; }
98 
99  double getDefaultValue() { return defaultValue; }
100  void setDefaultValue(double value) { defaultValue = value; }
101 
103  void setIsDiscreteSwitch(bool _isDiscreteSwitch) { isDiscreteSwitch = _isDiscreteSwitch; }
104 
106  void setControlTaper(taper ctrlTaper) { controlTaper = ctrlTaper; }
107 
108  // -- taper getters
109  bool isLinearTaper() { return controlTaper == taper::kLinearTaper ? true : false; }
110  bool isLogTaper() { return controlTaper == taper::kLogTaper ? true : false; }
111  bool isAntiLogTaper() { return controlTaper == taper::kAntiLogTaper ? true : false; }
112  bool isVoltOctaveTaper() { return controlTaper == taper::kVoltOctaveTaper ? true : false; }
113 
114  // --- control type getters
115  bool isMeterParam() { return controlType == controlVariableType::kMeter ? true : false; }
116  bool isStringListParam() { return controlType == controlVariableType::kTypedEnumStringList ? true : false; }
117  bool isFloatParam() { return controlType == controlVariableType::kFloat ? true : false; }
118  bool isDoubleParam() { return controlType == controlVariableType::kDouble ? true : false; }
119  bool isIntParam() { return controlType == controlVariableType::kInt ? true : false; }
120  bool isNonVariableBoundParam() { return controlType == controlVariableType::kNonVariableBoundControl ? true : false; }
121 
122  uint32_t getDisplayPrecision() { return displayPrecision; }
123  void setDisplayPrecision(uint32_t precision) { displayPrecision = precision; }
124 
125  double getMeterAttack_ms() { return meterAttack_ms;}
126  void setMeterAttack_ms(double value) { meterAttack_ms = value; }
127 
128  double getMeterRelease_ms() { return meterRelease_ms; }
129  void setMeterRelease_ms(double value) { meterRelease_ms = value; }
130 
131  uint32_t getDetectorMode() { return detectorMode; }
132  void setMeterDetectorMode(uint32_t value) { detectorMode = value; }
133 
134  bool getLogMeter() { return logMeter; }
135  void setLogMeter(bool value) { logMeter = value; }
136 
137  bool getInvertedMeter() { return invertedMeter; }
138  void setInvertedMeter(bool value) { invertedMeter = value; }
139 
140  bool isProtoolsGRMeter() { return protoolsGRMeter; }
141  void setIsProtoolsGRMeter(bool value) { protoolsGRMeter = value; }
142 
144  void setParameterSmoothing(bool value) { useParameterSmoothing = value; }
145 
147  void setSmoothingTimeMsec(double value) { smoothingTimeMsec = value; }
148 
151 
152  bool getIsWritable() { return isWritable; }
153  void setIsWritable(bool value) { isWritable = value; }
154 
157 
158  // --- for aux attributes
159  AuxParameterAttribute* getAuxAttribute(uint32_t attributeID);
160  uint32_t setAuxAttribute(uint32_t attributeID, const AuxParameterAttribute& auxParameterAtribute);
161 
167  inline double getControlValue() { return getAtomicControlValueDouble(); }
168 
175  inline void setControlValue(double actualParamValue, bool ignoreSmoothing = false)
176  {
177  if (controlType == controlVariableType::kDouble ||
178  controlType == controlVariableType::kFloat)
179  {
180  if (useParameterSmoothing && !ignoreSmoothing)
181  setSmoothedTargetValue(actualParamValue);
182  else
183  setAtomicControlValueDouble(actualParamValue);
184  }
185  else
186  setAtomicControlValueDouble(actualParamValue);
187  }
188 
196  inline double setControlValueNormalized(double normalizedValue, bool applyTaper = true, bool ignoreParameterSmoothing = false)
197  {
198  // --- set according to smoothing option
199  double actualParamValue = getControlValueWithNormalizedValue(normalizedValue, applyTaper);
200 
201  if (controlType == controlVariableType::kDouble ||
202  controlType == controlVariableType::kFloat)
203  {
204  if (useParameterSmoothing && !ignoreParameterSmoothing)
205  setSmoothedTargetValue(actualParamValue);
206  else
207  setAtomicControlValueDouble(actualParamValue);
208  }
209  else
210  setAtomicControlValueDouble(actualParamValue);
211 
212  return actualParamValue;
213  }
214 
220  std::string getControlValueAsString();
221 
227  size_t getStringCount(){return stringList.size();}
228 
235 
240 
244  void setStringList(std::vector<std::string> _stringList) {stringList = _stringList;}
245 
247  std::string getStringByIndex(uint32_t index);
248 
254  {
255  // --- apply taper as needed
256  switch (controlTaper)
257  {
258  case taper::kLinearTaper:
259  return getNormalizedDefaultValue();
260 
261  case taper::kLogTaper:
263 
264  case taper::kAntiLogTaper:
266 
267  case taper::kVoltOctaveTaper:
269 
270  default:
271  return 0.0;
272  }
273  }
274 
279  inline double getControlValueNormalized(bool applyTaper = true)
280  {
281  // --- for edit controls specifically
282  if(!applyTaper)
283  return getNormalizedControlValue();
284 
285  // --- apply taper as needed
286  switch (controlTaper)
287  {
288  case taper::kLinearTaper:
289  return getNormalizedControlValue();
290 
291  case taper::kLogTaper:
293 
294  case taper::kAntiLogTaper:
296 
297  case taper::kVoltOctaveTaper:
299 
300  default:
301  return 0.0;
302  }
303  }
304 
309  inline double getControlValueWithNormalizedValue(double normalizedValue, bool applyTaper = true)
310  {
311  if(!applyTaper)
312  return getControlValueFromNormalizedValue(normalizedValue);
313 
314  double newValue = 0;
315 
316  // --- apply taper as needed
317  switch (controlTaper)
318  {
319  case taper::kLinearTaper:
320  newValue = getControlValueFromNormalizedValue(normalizedValue);
321  break;
322 
323  case taper::kLogTaper:
324  newValue = getControlValueFromNormalizedValue(normToLogNorm(normalizedValue));
325  break;
326 
327  case taper::kAntiLogTaper:
328  newValue = getControlValueFromNormalizedValue(normToAntiLogNorm(normalizedValue));
329  break;
330 
331  case taper::kVoltOctaveTaper:
332  newValue = getVoltOctaveControlValueFromNormValue(normalizedValue);
333  break;
334 
335  default:
336  break; // --- no update
337  }
338 
339  return newValue;
340  }
341 
346  inline double getNormalizedControlValueWithActualValue(double actualValue) { return getNormalizedControlValueWithActual(actualValue); }
347 
349  double getGUIMin() { return 0.0; }
350 
352  double getGUIMax()
353  {
354  if(controlType == controlVariableType::kTypedEnumStringList)
355  return (double)getStringCount() - 1;
356 
357  return 1.0;
358  }
359 
365  int findStringIndex(std::string searchString)
366  {
367  auto it = std::find(stringList.begin (), stringList.end (), searchString);
368 
369  if (it == stringList.end())
370  {
371  return -1;
372  }
373  else
374  {
375  return (int)std::distance(stringList.begin(), it);
376  }
377 
378  return -1;
379  }
380 
382  inline double normToLogNorm(double normalizedValue)
383  {
384  return 1.0 + kCTCoefficient*log10(normalizedValue);
385  }
386 
388  inline double logNormToNorm(double logNormalizedValue)
389  {
390  return pow(10.0, (logNormalizedValue - 1.0) / kCTCoefficient);
391  }
392 
394  inline double normToAntiLogNorm(double normalizedValue)
395  {
396  if (normalizedValue == 1.0)
397  return 1.0;
398 
399  double aln = -kCTCoefficient*log10(1.0 - normalizedValue);
400  aln = fmin(1.0, aln);
401  return aln;
402  }
403 
405  inline double antiLogNormToNorm(double aLogNormalizedValue)
406  {
407  return -pow(10.0, (-aLogNormalizedValue / kCTCoefficient)) + 1.0;
408  }
409 
415  void initParamSmoother(double sampleRate)
416  {
418  sampleRate,
420  minValue,
421  maxValue,
422  smoothingType);
423  }
424 
430  void updateSampleRate(double sampleRate)
431  {
432  paramSmoother.setSampleRate(sampleRate);
433  }
434 
441  {
442  if(!useParameterSmoothing) return false;
443  double smoothedValue = 0.0;
444  bool smoothed = paramSmoother.smoothParameter(getSmoothedTargetValue(), smoothedValue);
445  if(smoothed)
446  setAtomicControlValueDouble(smoothedValue);
447  return smoothed;
448  }
449 
456  void setBoundVariable(void* boundVariable, boundVariableType dataType)
457  {
458  boundVariableDataType = dataType;
459 
460  if(dataType == boundVariableType::kDouble)
461  boundVariableDouble = (double*)boundVariable;
462  else if(dataType == boundVariableType::kFloat)
463  boundVariableFloat = (float*)boundVariable;
464  else if(dataType == boundVariableType::kInt)
465  boundVariableInt = (int*)boundVariable;
466  else if(dataType == boundVariableType::kUInt)
467  boundVariableUInt = (uint32_t*)boundVariableUInt;
468 
469  // --- initialize it
471  }
472 
479 
486  {
487  if (boundVariableUInt)
488  {
489  *boundVariableUInt = (uint32_t)getControlValue();
490  return true;
491  }
492  else if (boundVariableInt)
493  {
494  *boundVariableInt = (int)getControlValue();
495  return true;
496  }
497  else if (boundVariableFloat)
498  {
499  *boundVariableFloat = (float)getControlValue();
500  return true;
501  }
502  else if (boundVariableDouble)
503  {
504  *boundVariableDouble = getControlValue();
505  return true;
506  }
507  return false;
508  }
509 
516  {
517  if (boundVariableUInt)
518  {
519  setControlValue((double)*boundVariableUInt);
520  return true;
521  }
522  else if (boundVariableInt)
523  {
524  setControlValue((double)*boundVariableInt);
525  return true;
526  }
527  else if (boundVariableFloat)
528  {
529  setControlValue((double)*boundVariableFloat);
530  return true;
531  }
532  else if (boundVariableDouble)
533  {
534  setControlValue(*boundVariableDouble);
535  return true;
536  }
537  return false;
538  }
539 
545  void setParameterUpdateQueue(IParameterUpdateQueue* _parameterUpdateQueue) { parameterUpdateQueue = _parameterUpdateQueue; }
546 
552  IParameterUpdateQueue* getParameterUpdateQueue() { return parameterUpdateQueue; } // may be NULL - that is OK
553 
555  PluginParameter& operator=(const PluginParameter& aPluginParameter) // need this override for collections to work
556  {
557  if (this == &aPluginParameter)
558  return *this;
559 
560  controlID = aPluginParameter.controlID;
561  controlName = aPluginParameter.controlName;
562  controlUnits = aPluginParameter.controlUnits;
564  controlType = aPluginParameter.controlType;
565  minValue = aPluginParameter.minValue;
566  maxValue = aPluginParameter.maxValue;
567  defaultValue = aPluginParameter.defaultValue;
568  controlTaper = aPluginParameter.controlTaper;
569  controlValueAtomic = aPluginParameter.getAtomicControlValueFloat();
570  displayPrecision = aPluginParameter.displayPrecision;
571  stringList = aPluginParameter.stringList;
572  useParameterSmoothing = aPluginParameter.useParameterSmoothing;
573  smoothingType = aPluginParameter.smoothingType;
574  smoothingTimeMsec = aPluginParameter.smoothingTimeMsec;
575  meterAttack_ms = aPluginParameter.meterAttack_ms;
576  meterRelease_ms = aPluginParameter.meterRelease_ms;
577  detectorMode = aPluginParameter.detectorMode;
578  logMeter = aPluginParameter.logMeter;
579  isWritable = aPluginParameter.isWritable;
580  isDiscreteSwitch = aPluginParameter.isDiscreteSwitch;
581  invertedMeter = aPluginParameter.invertedMeter;
582 
583  return *this;
584  }
585 
586 protected:
587  int controlID = -1;
588  std::string controlName = "ControlName";
589  std::string controlUnits = "Units";
590  controlVariableType controlType = controlVariableType::kDouble;
591 
592  // --- min/max/def
593  double minValue = 0.0;
594  double maxValue = 1.0;
595  double defaultValue = 0.0;
596 
597  // --- *the* control value
598  // --- atomic float as control value
599  // atomic double will not behave properly between 32/64 bit
600  std::atomic<float> controlValueAtomic;
601 
602  float getAtomicControlValueFloat() const { return controlValueAtomic.load(std::memory_order_relaxed); }
603  void setAtomicControlValueFloat(float value) { controlValueAtomic.store(value, std::memory_order_relaxed); }
604 
605  double getAtomicControlValueDouble() const { return (double)controlValueAtomic.load(std::memory_order_relaxed); }
606  void setAtomicControlValueDouble(double value) { controlValueAtomic.store((float)value, std::memory_order_relaxed); }
607 
608  std::atomic<float> smoothedTargetValueAtomic;
609  void setSmoothedTargetValue(double value){ smoothedTargetValueAtomic.store((float)value); }
610  double getSmoothedTargetValue() const { return (double)smoothedTargetValueAtomic.load(); }
611 
612  // --- control tweakers
613  taper controlTaper = taper::kLinearTaper;
614  uint32_t displayPrecision = 2;
615 
616  // --- for enumerated string list
617  std::vector<std::string> stringList;
619 
620  // --- gui specific
621  bool appendUnits = true;
622  bool isWritable = false;
623  bool isDiscreteSwitch = false;
624 
625  // --- for VU meters
626  double meterAttack_ms = 10.0;
627  double meterRelease_ms = 500.0;
629  bool logMeter = false;
630  bool invertedMeter = false;
631  bool protoolsGRMeter = false;
632 
633  // --- parameter smoothing
634  bool useParameterSmoothing = false;
635  smoothingMethod smoothingType = smoothingMethod::kLPFSmoother;
636  double smoothingTimeMsec = 100.0;
638 
639  // --- variable binding
640  boundVariableType boundVariableDataType = boundVariableType::kFloat;
641 
642  // --- our sample accurate interface for VST3
644 
645  // --- default is enabled; you can disable this for controls that have a long postUpdate cooking time
647 
654  inline double getVoltOctaveControlValueFromNormValue(double normalizedValue)
655  {
656  double octaves = log2(maxValue / minValue);
657  if (normalizedValue == 0)
658  return minValue;
659 
660  return minValue*pow(2.0, normalizedValue*octaves);
661  }
662 
668  {
670  }
671 
677  {
679  }
680 
686  {
687  if (minValue == 0)
689 
690  return log2(getAtomicControlValueDouble() / minValue) / (log2(maxValue / minValue));
691  }
692 
699  inline double getNormalizedControlValueWithActual(double actualValue)
700  {
701  // --- calculate normalized value from actual
702  return (actualValue - minValue) / (maxValue - minValue);
703  }
704 
710  {
711  // --- calculate normalized value from actual
712  //double d = (getAtomicControlValueDouble() - minValue) / (maxValue - minValue);
714  }
715 
722  inline double getControlValueFromNormalizedValue(double normalizedValue)
723  {
724  // --- calculate the control Value using normalized input
725  //double d = (maxValue - minValue)*normalizedValue + minValue;
726  return (maxValue - minValue)*normalizedValue + minValue;
727  }
728 
735  {
736  // --- calculate normalized value from actual
737  //double d = (defaultValue - minValue) / (maxValue - minValue);
738  return (defaultValue - minValue) / (maxValue - minValue);
739  }
740 
747  {
749  }
750 
757  {
759  }
760 
767  {
768  if (minValue == 0)
769  return defaultValue;
770 
771  return log2(defaultValue / minValue) / (log2(maxValue / minValue));
772  }
773 
774 private:
775  // --- for variable-binding support
776  uint32_t* boundVariableUInt = nullptr;
777  int* boundVariableInt = nullptr;
778  float* boundVariableFloat = nullptr;
779  double* boundVariableDouble = nullptr;
780 
781  typedef std::map<uint32_t, AuxParameterAttribute*> auxParameterAttributeMap;
782  auxParameterAttributeMap auxAttributeMap;
783 
784 };
785 
786 #endif
787 
void setAtomicControlValueFloat(float value)
get atomic variable as float
Definition: pluginparameter.h:603
double getNormalizedVoltOctaveDefaultValue()
get volt/octave default value in normalized form
Definition: pluginparameter.h:766
bool getParameterSmoothing()
query parameter smoothing flag
Definition: pluginparameter.h:143
double getControlValue()
the main function to access the underlying atomic double value
Definition: pluginparameter.h:167
bool isMeterParam()
query: meter param?
Definition: pluginparameter.h:115
void setParameterSmoothing(bool value)
set inverted meter flag
Definition: pluginparameter.h:144
void setSmoothedTargetValue(double value)
set atomic TARGET smoothing variable with double
Definition: pluginparameter.h:609
void setControlVariableType(controlVariableType ctrlVarType)
set variable type associated with parameter
Definition: pluginparameter.h:91
uint32_t detectorMode
meter detector mode
Definition: pluginparameter.h:628
double setControlValueNormalized(double normalizedValue, bool applyTaper=true, bool ignoreParameterSmoothing=false)
the main function to set the underlying atomic double value using a normalized value; this is the ope...
Definition: pluginparameter.h:196
double minValue
the min for the parameter
Definition: pluginparameter.h:593
bool isDiscreteSwitch
flag for switches (not currently used in ASPiK)
Definition: pluginparameter.h:623
AuxParameterAttribute * getAuxAttribute(uint32_t attributeID)
get aux data
Definition: pluginparameter.cpp:331
double getVoltOctaveControlValueFromNormValue(double normalizedValue)
get volt/octave control value from a normalized value
Definition: pluginparameter.h:654
std::vector< std::string > stringList
string list
Definition: pluginparameter.h:617
double getSmoothingTimeMsec()
query smoothing time
Definition: pluginparameter.h:146
bool protoolsGRMeter
meter is a Pro Tools gain reduction meter
Definition: pluginparameter.h:631
Interface for VST3 parameter value update queue (sample accurate automation)
Definition: pluginstructures.h:1584
bool isLinearTaper()
query: linear taper
Definition: pluginparameter.h:109
void initParamSmoother(T smoothingTimeInMs, T samplingRate, T initValue, T minControlValue, T maxControlValue, smoothingMethod smoother=smoothingMethod::kLPFSmoother)
Definition: guiconstants.h:347
double getMaxValue()
get maximum value
Definition: pluginparameter.h:96
bool smoothParameter(T in, T &out)
Definition: guiconstants.h:371
bool getInvertedMeter()
query inverted meter flag
Definition: pluginparameter.h:137
void setEnableVSTSampleAccurateAutomation(bool value)
set VST3 sample accurate automation
Definition: pluginparameter.h:156
smoothingMethod smoothingType
param smoothing type
Definition: pluginparameter.h:635
ParamSmoother< double > paramSmoother
param smoothing object
Definition: pluginparameter.h:637
double antiLogNormToNorm(double aLogNormalizedValue)
Definition: pluginparameter.h:405
int findStringIndex(std::string searchString)
find a string in the list of a string-list parameter
Definition: pluginparameter.h:365
bool getIsWritable()
query writable control (meter)
Definition: pluginparameter.h:152
void setBoundVariable(void *boundVariable, boundVariableType dataType)
save the variable for binding operation
Definition: pluginparameter.h:456
void setIsDiscreteSwitch(bool _isDiscreteSwitch)
get is switch (not used)
Definition: pluginparameter.h:103
double logNormToNorm(double logNormalizedValue)
Definition: pluginparameter.h:388
std::string controlUnits
the units string for the parameter
Definition: pluginparameter.h:589
double getNormalizedVoltOctaveControlValue()
get get volt/octave control value in normalized form
Definition: pluginparameter.h:685
double getControlValueNormalized(bool applyTaper=true)
get control value as normalied value
Definition: pluginparameter.h:279
uint32_t getControlID()
get ID value
Definition: pluginparameter.h:81
bool appendUnits
flag to append units in GUI controls (use with several built-in custom views)
Definition: pluginparameter.h:621
smoothingMethod
Use this strongly typed enum to easily set the smoothing type.
Definition: guiconstants.h:240
bool isLogTaper()
query: log taper
Definition: pluginparameter.h:110
std::string getControlValueAsString()
the main function to access the underlying atomic double value as a string
Definition: pluginparameter.cpp:227
bool getIsDiscreteSwitch()
set is switch (not used)
Definition: pluginparameter.h:102
uint32_t displayPrecision
sig digits for display
Definition: pluginparameter.h:614
double getGUIMin()
Definition: pluginparameter.h:349
void setSmoothingTimeMsec(double value)
set inverted meter flag
Definition: pluginparameter.h:147
void setMeterAttack_ms(double value)
set meter attack time (ballistics)
Definition: pluginparameter.h:126
PluginParameter()
simple constructor - you can always use this and then use the massive number of get/set functions to ...
Definition: pluginparameter.cpp:169
double normToAntiLogNorm(double normalizedValue)
Definition: pluginparameter.h:394
void setControlID(uint32_t cid)
set ID value
Definition: pluginparameter.h:82
double normToLogNorm(double normalizedValue)
Definition: pluginparameter.h:382
boundVariableType boundVariableDataType
bound data type
Definition: pluginparameter.h:640
meterCal
Use this strongly typed enum to easily set meter calibration.
Definition: guiconstants.h:270
bool updateInBoundVariable()
perform the variable binding update (change the value)
Definition: pluginparameter.h:485
uint32_t getDetectorMode()
get meter detect mode
Definition: pluginparameter.h:131
bool isAntiLogTaper()
query: antilog taper
Definition: pluginparameter.h:111
void setDisplayPrecision(uint32_t precision)
set sig digits
Definition: pluginparameter.h:123
double getSmoothedTargetValue() const
set atomic TARGET smoothing variable with double
Definition: pluginparameter.h:610
void setControlTaper(taper ctrlTaper)
set taper
Definition: pluginparameter.h:106
double getNormalizedControlValue()
get control value as normalized value (helper)
Definition: pluginparameter.h:709
bool isDoubleParam()
query: double param?
Definition: pluginparameter.h:118
PluginParameter & operator=(const PluginParameter &aPluginParameter)
Definition: pluginparameter.h:555
void initParamSmoother(double sampleRate)
initialize or reset the parameter smoother object
Definition: pluginparameter.h:415
uint32_t setAuxAttribute(uint32_t attributeID, const AuxParameterAttribute &auxParameterAtribute)
set aux data
Definition: pluginparameter.cpp:314
double getNormalizedDefaultValue()
get default value as a normalized value (helper)
Definition: pluginparameter.h:734
bool isVoltOctaveTaper()
query: volt/octave taper
Definition: pluginparameter.h:112
void setControlUnits(const char *units)
set units as const char*
Definition: pluginparameter.h:88
std::string getStringByIndex(uint32_t index)
get string-list string by index
Definition: pluginparameter.cpp:281
bool enableVSTSampleAccurateAutomation
VST3 sample accurate flag.
Definition: pluginparameter.h:646
double getDefaultValue()
get default value
Definition: pluginparameter.h:99
void setCommaSeparatedStringList()
convert the string-list into a comma-separated list (during construction)
Definition: pluginparameter.cpp:293
controlVariableType
Use this strongly typed enum to easily set the control&#39;s behavior; this tells the PluginParameter obj...
Definition: guiconstants.h:288
double getMinValue()
get minimum value
Definition: pluginparameter.h:93
double getNormalizedAntiLogDefaultValue()
get anti-log default value in normalized form
Definition: pluginparameter.h:756
boundVariableType getBoundVariableType()
get the datatype of the bound variable
Definition: pluginparameter.h:478
bool isProtoolsGRMeter()
query pro tools GR meter flag
Definition: pluginparameter.h:140
double getControlValueWithNormalizedValue(double normalizedValue, bool applyTaper=true)
get the new control value as if it were set with a normalized value
Definition: pluginparameter.h:309
bool logMeter
meter is log
Definition: pluginparameter.h:629
bool updateOutBoundVariable()
perform the variable binding update on meter data
Definition: pluginparameter.h:515
double meterAttack_ms
meter attack time in milliseconds
Definition: pluginparameter.h:626
smoothingMethod getSmoothingMethod()
query smoothing method
Definition: pluginparameter.h:149
void setInvertedMeter(bool value)
set inverted meter flag
Definition: pluginparameter.h:138
bool useParameterSmoothing
enable param smoothing
Definition: pluginparameter.h:634
double getMeterRelease_ms()
get meter release time (ballistics)
Definition: pluginparameter.h:128
std::atomic< float > smoothedTargetValueAtomic
the underlying atomic variable TARGET for smoothing
Definition: pluginparameter.h:608
IParameterUpdateQueue * getParameterUpdateQueue()
retrieves the update queue for VST3 sample accuate automation; note this is only used during actual D...
Definition: pluginparameter.h:552
double getControlValueFromNormalizedValue(double normalizedValue)
get control value with a normalized value (helper)
Definition: pluginparameter.h:722
bool isFloatParam()
query: float param?
Definition: pluginparameter.h:117
const double kCTCoefficient
concave and/or convex transform correction factor
Definition: guiconstants.h:135
const char * getControlName()
get name as const char*
Definition: pluginparameter.h:84
bool isNonVariableBoundParam()
query: non-bound param?
Definition: pluginparameter.h:120
size_t getStringCount()
get the number of individual strings in a string-list control
Definition: pluginparameter.h:227
std::string commaSeparatedStringList
string list a somma separated string
Definition: pluginparameter.h:618
void setControlValue(double actualParamValue, bool ignoreSmoothing=false)
the main function to set the underlying atomic double value
Definition: pluginparameter.h:175
bool invertedMeter
meter is inverted
Definition: pluginparameter.h:630
double getGUIMax()
Definition: pluginparameter.h:352
taper getControlTaper()
get taper
Definition: pluginparameter.h:105
void setParameterUpdateQueue(IParameterUpdateQueue *_parameterUpdateQueue)
stores the update queue for VST3 sample accuate automation; note this is only used during actual DAW ...
Definition: pluginparameter.h:545
double getDefaultValueNormalized()
get default value as normalied value
Definition: pluginparameter.h:253
void updateSampleRate(double sampleRate)
change any sample-rate dependent members
Definition: pluginparameter.h:430
bool isIntParam()
query: int param?
Definition: pluginparameter.h:119
boundVariableType
Use this strongly typed enum to easily set the control&#39;s linked variable datatype (for automatic vari...
Definition: guiconstants.h:304
controlVariableType getControlVariableType()
get variable type associated with parameter
Definition: pluginparameter.h:90
void setIsProtoolsGRMeter(bool value)
set inverted meter flag
Definition: pluginparameter.h:141
double maxValue
the max for the parameter
Definition: pluginparameter.h:594
void setDefaultValue(double value)
set default value
Definition: pluginparameter.h:100
double getAtomicControlValueDouble() const
set atomic variable with double
Definition: pluginparameter.h:605
void setAtomicControlValueDouble(double value)
get atomic variable as double
Definition: pluginparameter.h:606
Information about auxilliary parameter details - purely customizeable. This uses the attributeValue u...
Definition: pluginstructures.h:922
void setStringList(std::vector< std::string > _stringList)
set the string-list using a vector of strings
Definition: pluginparameter.h:244
virtual ~PluginParameter()
only need to clean out the aux parameters - everything else is self deleting
Definition: pluginparameter.cpp:211
void setSmoothingMethod(smoothingMethod smoothingMethod)
set smoothing method
Definition: pluginparameter.h:150
controlVariableType controlType
the control type
Definition: pluginparameter.h:590
bool smoothParameterValue()
perform smoothing operation on data
Definition: pluginparameter.h:440
void setMinValue(double value)
set minimum value
Definition: pluginparameter.h:94
The PluginParameter object stores all of the data needed for any type of plugin parameter. It is a large object, but it is not complex as it really just stores LOTS of information about plugin parameters.
Definition: pluginparameter.h:51
int controlID
the ID value for the parameter
Definition: pluginparameter.h:587
void setMaxValue(double value)
set maximum value
Definition: pluginparameter.h:97
IParameterUpdateQueue * parameterUpdateQueue
interface for VST3 sample accurate updates
Definition: pluginparameter.h:643
double getNormalizedControlValueWithActual(double actualValue)
convert actual control value into normalized value (helper)
Definition: pluginparameter.h:699
const char * getControlUnits()
get units as const char*
Definition: pluginparameter.h:87
float getAtomicControlValueFloat() const
set atomic variable with float
Definition: pluginparameter.h:602
std::string controlName
the name string for the parameter
Definition: pluginparameter.h:588
const char * getCommaSeparatedStringList()
get the strings in a string-list control as a comma separated list
Definition: pluginparameter.h:234
bool isStringListParam()
query: string list para,?
Definition: pluginparameter.h:116
double getNormalizedControlValueWithActualValue(double actualValue)
get the new normalized control value as if it were set with an actual value
Definition: pluginparameter.h:346
double getNormalizedLogDefaultValue()
get log default value in normalized form
Definition: pluginparameter.h:746
double getNormalizedAntiLogControlValue()
get get anti-log control value in normalized form
Definition: pluginparameter.h:676
void setControlName(const char *name)
set name as const char*
Definition: pluginparameter.h:85
void setLogMeter(bool value)
set log meter flag
Definition: pluginparameter.h:135
double getMeterAttack_ms()
get meter attack time (ballistics)
Definition: pluginparameter.h:125
bool getLogMeter()
query log meter flag
Definition: pluginparameter.h:134
void setSampleRate(T samplingRate)
Definition: guiconstants.h:327
double getNormalizedLogControlValue()
get get log control value in normalized form
Definition: pluginparameter.h:667
const uint32_t ENVELOPE_DETECT_MODE_RMS
SQRT((1/N)|x|^2)
Definition: guiconstants.h:201
bool getEnableVSTSampleAccurateAutomation()
query VST3 sample accurate automation
Definition: pluginparameter.h:155
void setMeterRelease_ms(double value)
set meter release time (ballistics)
Definition: pluginparameter.h:129
std::atomic< float > controlValueAtomic
the underlying atomic variable
Definition: pluginparameter.h:600
double smoothingTimeMsec
param smoothing time
Definition: pluginparameter.h:636
void setIsWritable(bool value)
set writable control (meter)
Definition: pluginparameter.h:153
bool isWritable
flag for meter variables
Definition: pluginparameter.h:622
uint32_t getDisplayPrecision()
get sig digits
Definition: pluginparameter.h:122
void setMeterDetectorMode(uint32_t value)
set meter detect mode
Definition: pluginparameter.h:132
taper controlTaper
the taper
Definition: pluginparameter.h:613
double defaultValue
the default value for the parameter
Definition: pluginparameter.h:595
double meterRelease_ms
meter release time in milliseconds
Definition: pluginparameter.h:627
taper
Use this strongly typed enum to easily set the control taper.
Definition: guiconstants.h:255