#include "LFO.h"
|
|
|
LFO::LFO()
|
{
|
|
}
|
|
LFO::LFO(int waveformType)
|
{
|
setWaveformType(waveformType);
|
}
|
|
void LFO::prepare(double sampleRate)
|
{
|
setSampleRate(sampleRate);
|
modCounter = 0.0;
|
modCounter90 = 0.25;
|
setFrequency(frequency);
|
}
|
|
double LFO::getNextOutputSample(int phaseType)
|
{
|
generateNextOutputSample();
|
|
switch(phaseType)
|
{
|
case LFOPhase::Normal:
|
return outNormal;
|
break;
|
case LFOPhase::Inverted:
|
return outInverted;
|
break;
|
case LFOPhase::QuadPhase:
|
return outQuadPhase;
|
break;
|
case LFOPhase::QuadPhaseInverted:
|
return outQuadPhaseInverted;
|
break;
|
default:
|
return outNormal;
|
break;
|
}
|
}
|
|
void LFO::setWaveformType(int waveformType)
|
{
|
switch(waveformType)
|
{
|
case Waveforms::Triangle:
|
waveformType = Waveforms::Triangle;
|
break;
|
case Waveforms::Sine:
|
waveformType = Waveforms::Sine;
|
break;
|
case Waveforms::Saw:
|
waveformType = Waveforms::Saw;
|
break;
|
}
|
}
|
|
int LFO::getWaveformType()
|
{
|
return waveformType;
|
}
|
|
void LFO::setFrequency(double freq)
|
{
|
frequency = freq;
|
phaseInc = frequency / sampleRate;
|
}
|
|
double LFO::getFrequency()
|
{
|
return frequency;
|
}
|
|
void LFO::setSampleRate(double sampleRate)
|
{
|
this->sampleRate = sampleRate;
|
}
|
|
double LFO::getSampleRate()
|
{
|
return sampleRate;
|
}
|
|
double LFO::unipolarToBipolar(double value)
|
{
|
return 2.0*value - 1.0;
|
}
|
|
void LFO::generateNextOutputSample()
|
{
|
moduloWrap(modCounter, phaseInc);
|
|
modCounter90 = modCounter;
|
|
moduloAdvanceAndWrap(modCounter90, 0.25);
|
|
outNormal = 0.0;
|
outInverted = 0.0;
|
outQuadPhase = 0.0;
|
outQuadPhaseInverted = 0.0;
|
|
switch(waveformType)
|
{
|
case Waveforms::Triangle:
|
// Normal Output
|
outNormal = unipolarToBipolar(modCounter);
|
outNormal = 2.0*fabs(outNormal) - 1.0;
|
|
// 90 Degree phase shift
|
outQuadPhase = unipolarToBipolar(modCounter90);
|
outQuadPhase = 2.0*fabs(outQuadPhase) - 1.0;
|
|
break;
|
|
case Waveforms::Sine:
|
double angle;
|
|
// Angle Calculation
|
angle = modCounter*2.0*PI - PI;
|
|
// Normal Output
|
outNormal = parabolicSine(-angle);
|
|
// 90 Degree shift angle calculation
|
angle = modCounter90*2.0*PI - PI;
|
|
// 90 Degree phase shift
|
outQuadPhase = parabolicSine(-angle);
|
|
break;
|
|
case Waveforms::Saw:
|
// Normal Output
|
outNormal = unipolarToBipolar(modCounter);
|
|
// 90 Degree Shift
|
outQuadPhase = unipolarToBipolar(modCounter90);
|
|
break;
|
|
}
|
|
// Inverted Outputs
|
|
// Inverted Normal Output
|
outInverted = -outNormal;
|
|
// Inverted 90 Degree
|
outQuadPhaseInverted = -outQuadPhase;
|
|
moduloAdvance(modCounter, phaseInc);
|
}
|
|
void LFO::moduloAdvance(double& modCounter, double phaseInc)
|
{
|
modCounter += phaseInc;
|
}
|
|
void LFO::moduloWrap(double& modCounter, double phaseInc)
|
{
|
// Positive Frequencies
|
if(phaseInc > 0 && modCounter >= 1.0)
|
modCounter -= 1.0;
|
|
// Negative Frequencies
|
if(phaseInc < 0 && modCounter <= 0.0)
|
modCounter += 1.0;
|
}
|
|
void LFO::moduloAdvanceAndWrap(double& modCounter, double phaseInc)
|
{
|
// Advance
|
modCounter += phaseInc;
|
|
// Check if Wrap is needed
|
|
// Positive Frequencies
|
if(phaseInc > 0 && modCounter >= 1.0)
|
modCounter -= 1.0;
|
|
// Negative Frequencies
|
if(phaseInc < 0 && modCounter <= 0.0)
|
modCounter += 1.0;
|
}
|
|
double LFO::parabolicSine(double angle)
|
{
|
const double B = 4.0 / PI;
|
const double C = -4.0 / (PI* PI);
|
const double P = 0.225;
|
|
double y = B * angle + C * angle * fabs(angle);
|
|
return (P * (y * fabs(y) - y) + y);
|
}
|
