guiconstants.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//    ASPiK Plugin Kernel File:  guiconstants.h
//
// -----------------------------------------------------------------------------
#ifndef _guiconstants_h
#define _guiconstants_h

#define _MATH_DEFINES_DEFINED

#include <stdint.h>
#include <stdlib.h>
#include <vector>
#include <string>
#include <math.h>

// --- RESERVED PARAMETER ID VALUES
const unsigned int PLUGIN_SIDE_BYPASS = 131072; 
const unsigned int XY_TRACKPAD = 131073;        
const unsigned int VECTOR_JOYSTICK = 131074;    
const unsigned int PRESET_NAME = 131075;        
const unsigned int WRITE_PRESET_FILE = 131076;  
const unsigned int SCALE_GUI_SIZE = 131077;     
// --- 131078 -through- 131999 are RESERVED     ///<RESERVED PARAMETER ID VALUE

// --- custom views may be added using the base here: e.g.
//     const unsigned int CUSTOM_SPECTRUM_VIEW = CUSTOM_VIEW_BASE + 1;
const unsigned int CUSTOM_VIEW_BASE = 132000;   

// --- enum for the GUI object's message processing
enum { tinyGUI, verySmallGUI, smallGUI, normalGUI, largeGUI, veryLargeGUI };    

inline bool isReservedTag(int tag)
{
    if (tag == PLUGIN_SIDE_BYPASS ||
        tag == XY_TRACKPAD ||
        tag == VECTOR_JOYSTICK ||
        tag == PRESET_NAME ||
        tag == WRITE_PRESET_FILE ||
        tag == SCALE_GUI_SIZE)
        return true;

    return false;
}

// --- typed enumeration helpers
#define enumToInt(ENUM) static_cast<int>(ENUM)

#define compareEnumToInt(ENUM,INT) (static_cast<int>(ENUM) == (INT))

#define compareIntToEnum(INT,ENUM) ((INT) == static_cast<int>(ENUM))

#define convertIntToEnum(INT,ENUM) static_cast<ENUM>(INT)

const double kCTCoefficient = 5.0 / 12.0;

const double kCTCorrFactorZero = pow(10.0, (-1.0/kCTCoefficient));

const double kCTCorrFactorAnitZero = 1.0 / (1.0 - kCTCorrFactorZero);

const double kCTCorrFactorUnity = 1.0 / (1.0 + kCTCoefficient*log10(1.0 + kCTCorrFactorZero));

const double kCTCorrFactorAntiUnity = 1.0 / (1.0 + (-pow(10.0, (-1.0/kCTCoefficient))));

const double kCTCorrFactorAntiLog = kCTCoefficient*log10(1.0 + kCTCorrFactorZero);

const double kCTCorrFactorAntiLogScale = 1.0 / (-kCTCoefficient*log10(kCTCorrFactorZero) + kCTCorrFactorAntiLog);

const double kPi = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899;

const double kTwoPi = 2.0*3.14159265358979323846264338327950288419716939937510582097494459230781640628620899;

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// ---
const uint32_t ENVELOPE_DETECT_MODE_PEAK = 0;   
const uint32_t ENVELOPE_DETECT_MODE_MS = 1;     
const uint32_t ENVELOPE_DETECT_MODE_RMS = 2;    
const uint32_t ENVELOPE_DETECT_MODE_NONE = 3;   

const float ENVELOPE_DIGITAL_TC = -4.6051701859880913680359829093687;
const float ENVELOPE_ANALOG_TC = -1.0023934309275667804345424248947; 

// ---
const float GUI_METER_UPDATE_INTERVAL_MSEC = 50.f;  
const float GUI_METER_MIN_DB = -60.f;               

#define FLT_EPSILON_PLUS      1.192092896e-07        

#define FLT_EPSILON_MINUS    -1.192092896e-07        

#define FLT_MIN_PLUS          1.175494351e-38        

#define FLT_MIN_MINUS        -1.175494351e-38        

// --- for math.h constants
#define _MATH_DEFINES_DEFINED

enum class smoothingMethod { kLinearSmoother, kLPFSmoother };

enum class taper { kLinearTaper, kLogTaper, kAntiLogTaper, kVoltOctaveTaper };

enum class meterCal { kLinearMeter, kLogMeter };

enum class controlVariableType { kFloat, kDouble, kInt, kTypedEnumStringList, kMeter, kNonVariableBoundControl };


enum class boundVariableType { kFloat, kDouble, kInt, kUInt };

template <class T>
class ParamSmoother
{
public:
    ParamSmoother() { a = 0.0; b = 0.0; z = 0.0; z2 = 0.0; }

    void setSampleRate(T samplingRate)
    {
        sampleRate = samplingRate;

        // --- for LPF smoother
        a = exp(-kTwoPi / (smoothingTimeInMSec * 0.001 * sampleRate));
        b = 1.0 - a;

        // --- for linear smoother
        linInc = (maxVal - minVal) / (smoothingTimeInMSec * 0.001 * sampleRate);
    }

    void initParamSmoother(T smoothingTimeInMs,
        T samplingRate,
        T initValue,
        T minControlValue,
        T maxControlValue,
        smoothingMethod smoother = smoothingMethod::kLPFSmoother)
    {
        minVal = minControlValue;
        maxVal = maxControlValue;
        sampleRate = samplingRate;
        smoothingTimeInMSec = smoothingTimeInMs;

        setSampleRate(samplingRate);

        // --- storage
        z = initValue;
        z2 = initValue;
    }

    inline bool smoothParameter(T in, T& out)
    {
        if (smootherType == smoothingMethod::kLPFSmoother)
        {
            z = (in * b) + (z * a);
            if (z == z2)
            {
                out = in;
                return false;
            }
            z2 = z;
            out = z2;
            return true;
        }
        else // if (smootherType == smoothingMethod::kLinearSmoother)
        {
            if (in == z)
            {
                out = in;
                return false;
            }
            if (in > z)
            {
                z += linInc;
                if (z > in) z = in;
            }
            else if (in < z)
            {
                z -= linInc;
                if (z < in) z = in;
            }
            out = z;
            return true;
        }
    }

private:
    T a = 0.0;      
    T b = 0.0;      
    T z = 0.0;      
    T z2 = 0.0;     

    T linInc = 0.0; 

    T minVal = 0.0; 
    T maxVal = 1.0; 

    T sampleRate = 44100;   
    T smoothingTimeInMSec = 100.0; 

    smoothingMethod smootherType = smoothingMethod::kLPFSmoother; 
};


#endif