Asymp.h

#ifndef STK_ASYMP_H
#define STK_ASYMP_H
 
#include "Generator.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
const StkFloat TARGET_THRESHOLD = 0.000001;
 
class Asymp : public Generator
{
 public:
 
  Asymp( void );
 
  ~Asymp( void );
 
  void keyOn( void );
 
  void keyOff( void );
 
 
  void setTau( StkFloat tau );
 
  void setTime( StkFloat time );
 
  void setT60( StkFloat t60 );
 
  void setTarget( StkFloat target );
 
  void setValue( StkFloat value );
 
  int getState( void ) const { return state_; };
 
  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
  StkFloat tick( void );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
 protected:
 
  void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
  StkFloat value_;
  StkFloat target_;
  StkFloat factor_;
  StkFloat constant_;
  int state_;
};
 
inline StkFloat Asymp :: tick( void )
{
  if ( state_ ) {
 
    value_ = factor_ * value_ + constant_;
 
    // Check threshold.
    if ( target_ > value_ ) {
      if ( target_ - value_ <= TARGET_THRESHOLD ) {
        value_ = target_;
        state_ = 0;
      }
    }
    else {
      if ( value_ - target_ <= TARGET_THRESHOLD ) {
        value_ = target_;
        state_ = 0;
      }
    }
    lastFrame_[0] = value_;
  }
 
  return value_;
}
 
inline StkFrames& Asymp :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "Asymp::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *samples = &frames[channel];
  unsigned int hop = frames.channels();
  for ( unsigned int i=0; i<frames.frames(); i++, samples += hop )
    *samples = Asymp::tick();
 
  return frames;
}
 
} // stk namespace
 
#endif