AHR.h

// AHR.h
// ofxPDSP
// Nicola Pisanti, MIT License, 2016

#ifndef PDSP_ENV_AHR_H_INCLUDED
#define PDSP_ENV_AHR_H_INCLUDED


#include "../pdspCore.h"
#include "stages/EnvelopeStage.h"
#include "stages/AttackStage.h"
#include "stages/HoldStage.h"
#include "stages/ReleaseStage.h"

namespace pdsp{

class AHR : public Unit,
            public virtual EnvelopeStage,
            public virtual AttackStage,
            public virtual HoldStage,
            public virtual ReleaseStage 
{

public:
    AHR();

    Patchable& set(float attackTimeMs, float holdTimeMs, float releaseTimeMs, float velocity = 1.0f );
    
  
    void setAttackCurve(float hardness); 
 
    void setReleaseCurve(float hardness); 

    void setCurve(float hardness);
    
    
    void enableDBTriggering(float dBmin, float dBmax=0.0f);
    
    void disableDBTriggering();
    
    
    
    Patchable& in_trig();
    
    Patchable& in_attack();
    
    Patchable& in_hold();
    
    Patchable& in_release();
    
    Patchable& in_velocity();    

    Patchable& out_signal();

    float meter_output() const;
    
    int meter_triggers() const;
private:
    void process(int bufferSize) noexcept override;
    void prepareUnit( int expectedBufferSize, double sampleRate) override;
    void releaseResources() override;

    inline_f void doEnvelope() {
            switch (stageSwitch){
            case off          : envelopeOutput = 0.0; break;
            case attackStage  : Attack(stageSwitch, holdStage); break;
            case holdStage    : Hold(stageSwitch, releaseStage); break;
            case releaseStage : Release(stageSwitch, off); break;
            }
    };

    void onRetrigger(float triggerValue, int n);
    
    void process_run(int bufferSize);
    void process_T( const float* &trigBuffer, const int &bufferSize);
    
    InputNode input_trig;
    OutputNode output;
    InputNode input_attack;
    InputNode input_hold;
    InputNode input_release;
    InputNode input_velocity;
    
    std::atomic<bool> dBtrig;
    float dBmin;
    float dBmax;
    
    
    int              stageSwitch;
    
    static const int off          = 0;
    static const int attackStage  = 1;
    static const int holdStage    = 2;
    static const int releaseStage = 3;
    
    std::atomic<float> meter;
    std::atomic<int>   trigcount;
};

} // pdsp end namespace


#endif  // PDSP_ENV_AHR_H_INCLUDED