feat: adding lfo to filter

plugins/SquidgeFilter/DistrhoPluginInfo.h

@@ -11,6 +11,8 @@
 
 #define DISTRHO_PLUGIN_NUM_PARAMETERS 3
 
+#define DISTRHO_PLUGIN_WANT_TIMEPOS 1
+
 #define DISTRHO_PLUGIN_WANT_PROGRAMS 0
 #define DISTRHO_PLUGIN_WANT_STATE 0
 

plugins/SquidgeFilter/SquidgeFilter.cpp

@@ -16,12 +16,14 @@ public:
     kParamFreq,
     kParamResonance,
     kParamType,
+    kParamLFOSyncMode,
+    kParamLFOAmount,
     kParameterCount // must be last
   };
 
-  SquidgeFilter() // Note: Constructor name must match class name
+  SquidgeFilter()
       : Plugin(kParameterCount, 0, 0), filter_(1000.0f, 0.707f, 48000.0f),
-        lfo_(4.0f) { // Default: 1kHz, Q=0.707
+        lfo_(4.0f) {
     filter_.setType(Filter::kLowPass);
   }
 
@@ -73,6 +75,34 @@ protected:
       parameter.enumValues.values =
           const_cast<ParameterEnumerationValue *>(sTypes);
       break;
+    case kParamLFOAmount:
+      parameter.name = "LFO Amount";
+      parameter.symbol = "lfoamount";
+      parameter.ranges.min = 0.0f;
+      parameter.ranges.def = 0.0f;
+      parameter.ranges.max = 1000.0f;
+
+      parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
+      break;
+    case kParamLFOSyncMode:
+      parameter.name = "LFO Sync";
+      parameter.symbol = "lfosync";
+      parameter.ranges.min = 0.0f;
+      parameter.ranges.def = 3.0f;
+      parameter.ranges.max = 6.0f;
+
+      parameter.hints = kParameterIsAutomatable | kParameterIsInteger;
+
+      static const ParameterEnumerationValue sModes[] = {
+          {0.0f, "1/1 Bar"}, {1.0f, "1/2 Bar"},  {2.0f, "1/4 Bar"},
+          {3.0f, "1/8 Bar"}, {4.0f, "1/16 Bar"}, {5.0f, "1/32 Bar"},
+          {6.0f, "1/64 Bar"}};
+
+      parameter.enumValues.count = 7;
+      parameter.enumValues.restrictedMode = true;
+      parameter.enumValues.values =
+          const_cast<ParameterEnumerationValue *>(sModes);
+      break;
     }
   }
 
@@ -84,7 +114,12 @@ protected:
       return filter_.getQ();
     case kParamType:
       return static_cast<float>(filter_.getType());
-    }
+    case kParamLFOAmount:
+      return lfo_.getGain();
+      break;
+    case kParamLFOSyncMode:
+      return lfoSync_;
+    };
     return 0.0f;
   }
 
@@ -96,6 +131,12 @@ protected:
     case kParamResonance:
       filter_.setQ(value);
       break;
+    case kParamLFOAmount:
+      lfo_.setGain(value);
+      break;
+    case kParamLFOSyncMode:
+      lfoSync_ = value;
+      break;
     case kParamType:
       int typeIdx = static_cast<int>(std::fmin(std::fmax(value, 0.0f), 3.0f));
       filter_.setType(static_cast<Filter::FilterType>(typeIdx));
@@ -104,6 +145,39 @@ protected:
   }
 
   void run(const float **inputs, float **outputs, uint32_t frames) override {
+
+    const TimePosition &timePos = getTimePosition();
+
+    float targetFreq = 4.0f;
+    int syncIndex = static_cast<int>(lfoSync_);
+
+    if (syncIndex < 0)
+      syncIndex = 0;
+    if (syncIndex > 6)
+      syncIndex = 6;
+
+    if (timePos.bbt.valid && timePos.playing &&
+        timePos.bbt.beatsPerMinute > 0.0) {
+      float bpm = static_cast<float>(timePos.bbt.beatsPerMinute);
+
+      float baseFreq = (bpm / 60.0f) * 4.0f;
+
+      static const float multipliers[] = {1.0f,  2.0f,  4.0f, 8.0f,
+                                          16.0f, 32.0f, 64.0f};
+
+      targetFreq = baseFreq * multipliers[syncIndex];
+
+      static int lastBar = -1;
+      if (timePos.bbt.bar != lastBar) {
+        lfo_.reset();
+        lastBar = timePos.bbt.bar;
+      }
+    } else {
+
+      targetFreq = 1.0f;
+    }
+
+    lfo_.setFrequency(targetFreq);
     lfo_.process(lfoBuffer_, frames);
 
     filter_.processStereo(inputs[0], inputs[1], outputs[0], outputs[1], frames,
@@ -118,6 +192,7 @@ protected:
 private:
   Filter filter_;
   Oscillator lfo_;
+  float lfoSync_;
   float lfoBuffer_[BUFFER_SIZE];
 
   DISTRHO_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(SquidgeFilter);