FormSwep.h

#ifndef STK_FORMSWEP_H
#define STK_FORMSWEP_H
 
#include "Filter.h"
 
namespace stk {
 
/***************************************************/
/***************************************************/
 
class FormSwep : public Filter
{
 public:
 
  FormSwep( void );
 
  ~FormSwep();
 
  void ignoreSampleRateChange( bool ignore = true ) { ignoreSampleRateChange_ = ignore; };
 
 
  void setResonance( StkFloat frequency, StkFloat radius );
 
  void setStates( StkFloat frequency, StkFloat radius, StkFloat gain = 1.0 );
 
  void setTargets( StkFloat frequency, StkFloat radius, StkFloat gain = 1.0 );
 
 
  void setSweepRate( StkFloat rate );
 
 
  void setSweepTime( StkFloat time );
 
  StkFloat lastOut( void ) const { return lastFrame_[0]; };
 
  StkFloat tick( StkFloat input );
 
 
  StkFrames& tick( StkFrames& frames, unsigned int channel = 0 );
 
 
  StkFrames& tick( StkFrames& iFrames, StkFrames &oFrames, unsigned int iChannel = 0, unsigned int oChannel = 0 );
 
 protected:
 
  virtual void sampleRateChanged( StkFloat newRate, StkFloat oldRate );
 
  bool dirty_;
  StkFloat frequency_;
  StkFloat radius_;
  StkFloat startFrequency_;
  StkFloat startRadius_;
  StkFloat startGain_;
  StkFloat targetFrequency_;
  StkFloat targetRadius_;
  StkFloat targetGain_;
  StkFloat deltaFrequency_;
  StkFloat deltaRadius_;
  StkFloat deltaGain_;
  StkFloat sweepState_;
  StkFloat sweepRate_;
 
};
 
inline StkFloat FormSwep :: tick( StkFloat input )
{                                     
  if ( dirty_ )  {
    sweepState_ += sweepRate_;
    if ( sweepState_ >= 1.0 )   {
      sweepState_ = 1.0;
      dirty_ = false;
      radius_ = targetRadius_;
      frequency_ = targetFrequency_;
      gain_ = targetGain_;
    }
    else {
      radius_ = startRadius_ + (deltaRadius_ * sweepState_);
      frequency_ = startFrequency_ + (deltaFrequency_ * sweepState_);
      gain_ = startGain_ + (deltaGain_ * sweepState_);
    }
    this->setResonance( frequency_, radius_ );
  }
 
  inputs_[0] = gain_ * input;
  lastFrame_[0] = b_[0] * inputs_[0] + b_[1] * inputs_[1] + b_[2] * inputs_[2];
  lastFrame_[0] -= a_[2] * outputs_[2] + a_[1] * outputs_[1];
  inputs_[2] = inputs_[1];
  inputs_[1] = inputs_[0];
  outputs_[2] = outputs_[1];
  outputs_[1] = lastFrame_[0];
 
  return lastFrame_[0];
}
 
inline StkFrames& FormSwep :: tick( StkFrames& frames, unsigned int channel )
{
#if defined(_STK_DEBUG_)
  if ( channel >= frames.channels() ) {
    oStream_ << "FormSwep::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 = tick( *samples );
 
  return frames;
}
 
inline StkFrames& FormSwep :: tick( StkFrames& iFrames, StkFrames& oFrames, unsigned int iChannel, unsigned int oChannel )
{
#if defined(_STK_DEBUG_)
  if ( iChannel >= iFrames.channels() || oChannel >= oFrames.channels() ) {
    oStream_ << "FormSwep::tick(): channel and StkFrames arguments are incompatible!";
    handleError( StkError::FUNCTION_ARGUMENT );
  }
#endif
 
  StkFloat *iSamples = &iFrames[iChannel];
  StkFloat *oSamples = &oFrames[oChannel];
  unsigned int iHop = iFrames.channels(), oHop = oFrames.channels();
  for ( unsigned int i=0; i<iFrames.frames(); i++, iSamples += iHop, oSamples += oHop )
    *oSamples = tick( *iSamples );
 
  return iFrames;
}
 
} // stk namespace
 
#endif