LFOProcessor: allowed configuration as function generator or LFO.

Added some docs for clarity.

Author: jrlanglois

modules/squarepine_audio/effects/LFOProcessor.cpp

@@ -3,7 +3,7 @@ class LFOProcessor::TypeParameter final : public AudioParameterChoice
 {
 public:
     TypeParameter() :
-        AudioParameterChoice ("type", TRANS ("Type"), getChoices(),
+        AudioParameterChoice (ParameterID ("type", 1), TRANS ("Type"), getChoices(),
                               static_cast<int> (LFOProcessor::LFOType::sine))
     {
     }
@@ -26,20 +26,24 @@ class LFOProcessor::TypeParameter final : public AudioParameterChoice
 };
 
 //==============================================================================
-LFOProcessor::LFOProcessor() :
-    InternalProcessor (false)
+LFOProcessor::LFOProcessor (double minFreqHz, double maxFreqHz,
+                            double defaultFreqHz, bool isMult) :
+    InternalProcessor (false),
+    isMultiplying (isMult)
 {
     auto layout = createDefaultParameterLayout();
 
     auto tp = std::make_unique<TypeParameter>();
     type = tp.get();
     layout.add (std::move (tp));
 
-    auto pf = std::make_unique<AudioParameterFloat> ("frequency", "Frequency", 0.1f, 10.0f, 0.5f);
+    auto pf = std::make_unique<AudioParameterFloat> (ParameterID ("frequency", 1), "Frequency", minFreqHz, maxFreqHz, defaultFreqHz);
     frequency = pf.get();
     layout.add (std::move (pf));
 
     resetAPVTSWithLayout (std::move (layout));
+
+    setLFOType (LFOType::sine);
 }
 
 //==============================================================================
@@ -84,9 +88,6 @@ void LFOProcessor::setLFOType (LFOType lfoType)
 void LFOProcessor::setFrequencyHz (const double newFrequency)
 {
     *frequency = (float) newFrequency;
-
-    floatOsc.setFrequency ((float) newFrequency);
-    doubleOsc.setFrequency (newFrequency);
 }
 
 void LFOProcessor::setFrequencyFromMidiNote (const int midiNote)
@@ -119,10 +120,8 @@ void LFOProcessor::prepareToPlay (const double newSampleRate, const int samplesP
 
     if (isFirstRun)
     {
-        isFirstRun = false;
-
-        setFrequencyHz (*frequency);
         setLFOType (static_cast<LFOType> (type->getIndex()), true);
+        isFirstRun = false;
     }
 }
 
@@ -132,23 +131,35 @@ void LFOProcessor::process (dsp::Oscillator<FloatType>& osc,
                             juce::AudioBuffer<FloatType>& multer,
                             juce::AudioBuffer<FloatType>& buffer)
 {
-    if (isBypassed())
-        return;
+    {
+        auto v = getFrequency();
+        floatOsc.setFrequency ((float) v);
+        doubleOsc.setFrequency (v);
+    }
 
-    setFrequencyHz (getFrequency());
+    if (isMultiplying)
+    {
+        multer.setSize (buffer.getNumChannels(), buffer.getNumSamples(), false, true, true);
+        multer.clear();
 
-    multer.setSize (buffer.getNumChannels(), buffer.getNumSamples(), false, true, true);
-    multer.clear();
+        dsp::AudioBlock<FloatType> abMulter (multer);
 
-    dsp::AudioBlock<FloatType> abMulter (multer);
+        {
+            dsp::ProcessContextReplacing<FloatType> context (abMulter);
+            context.isBypassed = isBypassed();
+            osc.process (context);
+        }
 
+        dsp::AudioBlock<FloatType> (buffer)
+            .multiplyBy (abMulter);
+    }
+    else
     {
-        dsp::ProcessContextReplacing<FloatType> context (abMulter);
+        dsp::AudioBlock<FloatType> audioBlock (buffer);
+        dsp::ProcessContextReplacing<FloatType> context (audioBlock);
+        context.isBypassed = isBypassed();
         osc.process (context);
     }
-
-    dsp::AudioBlock<FloatType> (buffer)
-        .multiplyBy (abMulter);
 }
 
 void LFOProcessor::processBlock (juce::AudioBuffer<float>& buffer, MidiBuffer&)     { process (floatOsc, floatMulter, buffer); }

modules/squarepine_audio/effects/LFOProcessor.h

@@ -31,15 +31,32 @@ namespace oscillatorFunctions
     }
 }
 
-/** */
+/** A processor that can act as an LFO or a function generator.
+
+    This acts as an LFO by default. You may want to use its
+    identical functionality and properties for generator purposes;
+    to do so, change the values in the constructor to something suitable
+    for your needs.
+*/
 class LFOProcessor final : public InternalProcessor
 {
 public:
-    /** Constructor. */
-    LFOProcessor();
+    /** Constructor.
+
+        @param minFreqHz        The minimum frequency, in Hz.
+        @param maxFreqHz        The maximum frequency, in Hz.
+        @param defaultFreqHz    The default frequency, in Hz.
+        @param isLFO            Whether this processor is constructed
+                                to act as an LFO. Flip this to 'off'
+                                if you require a function generator instead.
+    */
+    LFOProcessor (double minFreqHz = 0.1f,
+                  double maxFreqHz = 10.0f,
+                  double defaultFreqHz = 0.5f,
+                  bool isLFO = true);
 
     //==============================================================================
-    /** */
+    /** The type of wave generator function you want to use. */
     enum class LFOType
     {
         sine,
@@ -80,6 +97,7 @@ class LFOProcessor final : public InternalProcessor
 
 private:
     //==============================================================================
+    const bool isMultiplying = true;
     bool isFirstRun = true;
 
     juce::AudioBuffer<float> floatMulter;