feat: add stk link to explore in the future

Reviewed-on: #23
Co-authored-by: HiveBeats <e1lama@protonmail.com>
Co-committed-by: HiveBeats <e1lama@protonmail.com>

.gitignore

@@ -4,3 +4,4 @@
 *.wav
 *.dSYM
 /lib
+/build

CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.5)
+project(SeeSynth)
+#set(CMAKE_C_STANDARD 99)
+
+# Adding Raylib
+include(FetchContent)
+set(FETCHCONTENT_QUIET FALSE)
+set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) # don't build the supplied examples
+set(BUILD_GAMES    OFF CACHE BOOL "" FORCE) # don't build the supplied example games
+
+FetchContent_Declare(
+    raylib
+    GIT_REPOSITORY "https://github.com/raysan5/raylib.git"
+    GIT_TAG "4.5.0"
+    GIT_PROGRESS TRUE
+)
+
+FetchContent_MakeAvailable(raylib)
+
+# Adding our source files
+file(GLOB_RECURSE PROJECT_SOURCES CONFIGURE_DEPENDS "${CMAKE_CURRENT_LIST_DIR}/src/*.cpp") # Define PROJECT_SOURCES as a list of all source files
+set(PROJECT_INCLUDE "${CMAKE_CURRENT_LIST_DIR}/inc/") # Define PROJECT_INCLUDE to be the path to the include directory of the project
+
+
+# Declaring our executable
+add_executable(${PROJECT_NAME})
+set_target_properties(
+    ${PROJECT_NAME} PROPERTIES
+    CXX_STANDARD 17
+    CXX_STANDARD_REQUIRED ON)
+target_sources(${PROJECT_NAME} PRIVATE ${PROJECT_SOURCES})
+target_include_directories(${PROJECT_NAME} PRIVATE ${PROJECT_INCLUDE})
+target_link_libraries(${PROJECT_NAME} PRIVATE raylib)
+
+# Setting ASSETS_PATH
+target_compile_definitions(${PROJECT_NAME} PUBLIC ASSETS_PATH="${CMAKE_CURRENT_SOURCE_DIR}/assets/") # Set the asset path macro to the absolute path on the dev machine
+#target_compile_definitions(${PROJECT_NAME} PUBLIC ASSETS_PATH="./assets") # Set the asset path macro in release mode to a relative path that assumes the assets folder is in the same directory as the game executable

docs/Resources.md

@@ -36,3 +36,6 @@ for (n = 0; n < totalSamples; n++) {
  
 
 We can replace the sin function with any periodic function that returns an amplitude for a given phase angle. Thus, this small piece of code can be used to produce a very wide range of sounds. Functionally, it is the software equivalent of an oscillator, the basic building block of almost all synthesizers.
+
+
+https://ccrma.stanford.edu/software/stk/index.html

docs/StateVariableFilter.md

@@ -0,0 +1,214 @@
+https://www.earlevel.com/main/2003/03/02/the-digital-state-variable-filter/
+
+The frequency control coefficient, f, is defined as
+
+![Alt text](image.png)
+
+where Fs is the sample rate and Fc is the filter’s corner frequency you want to set. The q coefficient is defined as
+
+![Alt text](image-1.png)
+
+where Q normally ranges from 0.5 to inifinity (where the filter oscillates).
+
+
+The main drawback of the digital state variable is that it becomes unstable at higher frequencies. It depends on the Q setting, but basically the upper bound of stability is about where f reaches 1, which is at one-sixth of the sample rate (8 kHz at 48 kHz). The only way around this is to oversample. A simple way to double the filter’s sample rate (and thereby double the filter’s frequency range) is to run the filter twice with the same input sample, and discard one output sample.
+
+
+
+example with double-sampling
+
+```
+input  = input buffer;
+output = output buffer;
+fs     = sampling frequency;
+fc     = cutoff frequency normally something like:
+         440.0*pow(2.0, (midi_note - 69.0)/12.0);
+res    = resonance 0 to 1;
+drive  = internal distortion 0 to 0.1
+freq   = 2.0*sin(PI*MIN(0.25, fc/(fs*2)));  // the fs*2 is because it's double sampled
+damp   = MIN(2.0*(1.0 - pow(res, 0.25)), MIN(2.0, 2.0/freq - freq*0.5));
+notch  = notch output
+low    = low pass output
+high   = high pass output
+band   = band pass output
+peak   = peaking output = low - high
+--
+double sampled svf loop:
+for (i=0; i<numSamples; i++)
+{
+  in    = input[i];
+  notch = in - damp*band;
+  low   = low + freq*band;
+  high  = notch - low;
+  band  = freq*high + band - drive*band*band*band;
+  out   = 0.5*(notch or low or high or band or peak);
+  notch = in - damp*band;
+  low   = low + freq*band;
+  high  = notch - low;
+  band  = freq*high + band - drive*band*band*band;
+  out  += 0.5*(same out as above);
+  output[i] = out;
+}
+```
+
+
+Also that could work as it's a voltage-controlled filter
+https://www.musicdsp.org/en/latest/Filters/24-moog-vcf.html
+
+```
+//Init
+cutoff = cutoff freq in Hz
+fs = sampling frequency //(e.g. 44100Hz)
+res = resonance [0 - 1] //(minimum - maximum)
+
+f = 2 * cutoff / fs; //[0 - 1]
+k = 3.6*f - 1.6*f*f -1; //(Empirical tunning)
+p = (k+1)*0.5;
+scale = e^((1-p)*1.386249;
+r = res*scale;
+y4 = output;
+
+y1=y2=y3=y4=oldx=oldy1=oldy2=oldy3=0;
+
+//Loop
+//--Inverted feed back for corner peaking
+x = input - r*y4;
+
+//Four cascaded onepole filters (bilinear transform)
+y1=x*p + oldx*p - k*y1;
+y2=y1*p+oldy1*p - k*y2;
+y3=y2*p+oldy2*p - k*y3;
+y4=y3*p+oldy3*p - k*y4;
+
+//Clipper band limited sigmoid
+y4 = y4 - (y4^3)/6;
+
+oldx = x;
+oldy1 = y1;
+oldy2 = y2;
+oldy3 = y3;
+```
+
+
+```
+#pragma once
+
+namespace DistoCore
+{
+  template<class T>
+  class MoogFilter
+  {
+  public:
+    MoogFilter();
+    ~MoogFilter() {};
+
+    T getSampleRate() const { return sampleRate; }
+    void setSampleRate(T fs) { sampleRate = fs; calc(); }
+    T getResonance() const { return resonance; }
+    void setResonance(T filterRezo) { resonance = filterRezo; calc(); }
+    T getCutoff() const { return cutoff; }
+    T getCutoffHz() const { return cutoff * sampleRate * 0.5; }
+    void setCutoff(T filterCutoff) { cutoff = filterCutoff; calc(); }
+
+    void init();
+    void calc();
+    T process(T input);
+    // filter an input sample using normalized params
+    T filter(T input, T cutoff, T resonance);
+
+  protected:
+    // cutoff and resonance [0 - 1]
+    T cutoff;
+    T resonance;
+    T sampleRate;
+    T fs;
+    T y1,y2,y3,y4;
+    T oldx;
+    T oldy1,oldy2,oldy3;
+    T x;
+    T r;
+    T p;
+    T k;
+  };
+
+    /**
+     * Construct Moog-filter.
+     */
+  template<class T>
+  MoogFilter<T>::MoogFilter()
+  : sampleRate(T(44100.0))
+  , cutoff(T(1.0))
+  , resonance(T(0.0))
+  {
+    init();
+  }
+
+    /**
+     * Initialize filter buffers.
+     */
+  template<class T>
+  void MoogFilter<T>::init()
+  {
+    // initialize values
+    y1=y2=y3=y4=oldx=oldy1=oldy2=oldy3=T(0.0);
+    calc();
+  }
+
+    /**
+     * Calculate coefficients.
+     */
+  template<class T>
+  void MoogFilter<T>::calc()
+  {
+    // TODO: replace with your constant
+    const double kPi = 3.1415926535897931;
+
+    // empirical tuning
+    p = cutoff * (T(1.8) - T(0.8) * cutoff);
+    // k = p + p - T(1.0);
+    // A much better tuning seems to be:
+    k = T(2.0) * sin(cutoff * kPi * T(0.5)) - T(1.0);
+
+    T t1 = (T(1.0) - p) * T(1.386249);
+    T t2 = T(12.0) + t1 * t1;
+    r = resonance * (t2 + T(6.0) * t1) / (t2 - T(6.0) * t1);
+  };
+
+    /**
+     * Process single sample.
+     */
+  template<class T>
+  T MoogFilter<T>::process(T input)
+  {
+    // process input
+    x = input - r * y4;
+
+    // four cascaded one-pole filters (bilinear transform)
+    y1 =  x * p + oldx  * p - k * y1;
+    y2 = y1 * p + oldy1 * p - k * y2;
+    y3 = y2 * p + oldy2 * p - k * y3;
+    y4 = y3 * p + oldy3 * p - k * y4;
+
+    // clipper band limited sigmoid
+    y4 -= (y4 * y4 * y4) / T(6.0);
+
+    oldx = x; oldy1 = y1; oldy2 = y2; oldy3 = y3;
+
+    return y4;
+  }
+
+    /**
+     * Filter single sample using specified params.
+     */
+  template<class T>
+  T MoogFilter<T>::filter(T input, T filterCutoff, T filterRezo)
+  {
+    // set params first
+    cutoff = filterCutoff;
+    resonance = filterRezo;
+    calc();
+
+    return process(input);
+  }
+}
+```

docs/matrix.md

@@ -0,0 +1,19 @@
+
+//  signal -> adsr -> filter
+//    ^         ^       ^
+//    |         |       |
+//     can be modulated
+//      by lfo, or adsr
+
+
+
+у каждого из них должна быть ручка для изменения состояния
+на каждом семпле?????
+
+
+
+багует сам алгоритм изменения частоты, либо алгоритм пересчета коэфициентов фильтра
+
+
+
+

inc/ADSR.h

@@ -1,37 +1,30 @@
 #pragma once
-#include "Effect.h"
+#include "IEffect.h"
 #include "Ramp.h"
 #include <cstddef>
 
-struct ADSRParameters {
-    float attack_time;   // Attack time in seconds
-    float decay_time;    // Decay time in seconds
-    float sustain_level; // Sustain level (0 to 1)
-    float release_time;
-};
+class ADSR : public IEffect {
+    enum ADSRState { sOff, sAttack, sDecay, sSustain, sRelease };
 
-enum ADSRState { Off, Attack, Decay, Sustain, Release };
-
-class ADSR : public Effect {
   private:
-    ADSRParameters m_parameters;
+    float m_attack_time;
+    float m_decay_time;
+    float m_sustain_level;
+    float m_release_time;
     ADSRState m_state;
     Ramp* m_ramp;
 
-    void process_sample(float* sample);
-    bool is_attack_elapsed();
-    bool is_decay_elapsed();
-    bool is_release_elapsed();
-    void recheck_state();
+    void ProcessSample(float* sample);
+    bool IsAttackElapsed();
+    bool IsDecayElapsed();
+    bool IsReleaseElapsed();
+    void RecheckState();
 
   public:
     ADSR(/* args */);
-    ADSR(ADSRParameters param);
     ~ADSR();
-    void OnSetNote() override;
-    void OnUnsetNote() override;
-    // void RetriggerState() override;
+    void Trigger() override;
+    void Release() override;
     void Process(std::vector<float>& samples) override;
-    void Reset();
     void SetParameters(float attack, float decay, float sustain, float release);
 };

inc/Adder.h

@@ -8,16 +8,12 @@
 struct Adder {
     static void SumOscillators(const std::vector<Oscillator*>& oscillators,
                                std::vector<float>& signal) {
-        size_t sample_count =
-            STREAM_BUFFER_SIZE; //(size_t)(1.f/FPS * SAMPLE_RATE);
-
-        // std::vector<float>* output = new std::vector<float>();
-        // output->reserve(sample_count);
+        size_t sample_count = STREAM_BUFFER_SIZE;
 
         for (size_t i = 0; i < sample_count; i++) {
             float sample = 0.0f;
             for (Oscillator* osc : oscillators) {
-                sample += osc->GenerateSample(1.f);
+                sample += osc->Process();
             }
 
             signal[i] = sample;

inc/Application.h

@@ -13,11 +13,11 @@ class Application {
     int m_sound_played_count;
     Note* m_current_note;
     Renderer m_renderer;
-    bool detect_note_pressed(Note* note);
-    void init_synth();
-    void init_audio();
-    void update_on_note_input();
-    void play_buffered_audio();
+    bool DetectNotePressed(Note* note);
+    void InitSynth();
+    void InitAudio();
+    void UpdateOnNoteInput();
+    void PlayBufferedAudio();
 
   public:
     Application(/* args */);

inc/Effect.h

@@ -1,13 +0,0 @@
-#pragma once
-#include <vector>
-class Effect {
-  private:
-    /* data */
-  public:
-    Effect(/* args */){};
-    ~Effect(){};
-    virtual void OnSetNote(){};
-    virtual void OnUnsetNote(){};
-    // virtual void RetriggerState(){};
-    virtual void Process(std::vector<float>& samples){};
-};

inc/Filter.h

@@ -0,0 +1,72 @@
+#pragma once
+#include "IEffect.h"
+#include "Settings.h"
+
+enum FilterType { LowPass, BandPass, HighPass };
+
+class Filter : public IEffect {
+  protected:
+    // float* m_output; // output buffer
+    float m_fs = SAMPLE_RATE; // sampling frequency;
+    float m_fc;    // cutoff frequency normally something like: 440.0*pow(2.0,
+                   // (midi_note - 69.0)/12.0);
+    float m_res;   // resonance 0 to 1;
+    float m_drive; // internal distortion 0 to 0.1
+    float m_freq;  
+    float m_damp; 
+    float m_notcho; // notch output
+    float m_lowo;   // low pass output
+    float m_higho;  // high pass output
+    float m_bando;  // band pass output
+    float m_peako;  // peaking output = low - high
+    virtual float GetSampleForFilterType(){ return 0.0; };
+
+  public:
+    Filter(/* args */);
+    virtual ~Filter();
+    void Trigger() override final;
+    void Release() override final;
+    float Process(float in);
+    void Process(std::vector<float>& samples) override final;
+    void SetParameters(float freq, float res, float drive);
+    float GetFreq() { return m_fc; }
+    float GetRes() { return m_res; }
+    float GetPeakGain() { return m_drive; }
+    virtual bool IsSameFilterType(FilterType type) { return false; };
+};
+
+class BandPassFilter : public Filter {
+  protected:
+    float GetSampleForFilterType() override;
+
+  public:
+    BandPassFilter();
+    BandPassFilter(Filter* filter);
+    BandPassFilter(float freq, float res, float q);
+    ~BandPassFilter();
+    bool IsSameFilterType(FilterType type) override { return type == BandPass; };
+};
+
+class HighPassFilter : public Filter {
+  protected:
+    float GetSampleForFilterType() override;
+
+  public:
+    HighPassFilter();
+    HighPassFilter(Filter* filter);
+    HighPassFilter(float freq, float res, float q);
+    ~HighPassFilter();
+    bool IsSameFilterType(FilterType type) override { return type == HighPass; };
+};
+
+class LowPassFilter : public Filter {
+  protected:
+    float GetSampleForFilterType() override;
+
+  public:
+    LowPassFilter();
+    LowPassFilter(Filter* filter);
+    LowPassFilter(float freq, float res, float q);
+    ~LowPassFilter();
+    bool IsSameFilterType(FilterType type) override { return type == LowPass; };
+};

inc/FilterFactory.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "Filter.h"
+
+struct FilterFactory {
+    static Filter* CreateFilter(Filter* old_filter, FilterType new_type) {
+        Filter* new_filter;
+        switch (new_type) {
+        case LowPass:
+            new_filter = new LowPassFilter(old_filter);
+            break;
+        case BandPass:
+            new_filter = new BandPassFilter(old_filter);
+            break;
+        case HighPass:
+            new_filter = new HighPassFilter(old_filter);
+            break;
+        default:
+            break;
+        }
+        return new_filter;
+    }
+
+    static Filter* GetDefaultFilter() {
+        return new LowPassFilter();
+    }
+};

inc/IEffect.h

@@ -0,0 +1,10 @@
+#pragma once
+#include <vector>
+class IEffect {
+  private:
+    /* data */
+  public:
+    virtual void Trigger() = 0;
+    virtual void Release() = 0;
+    virtual void Process(std::vector<float>& samples) = 0;
+};

inc/KeyBoard.h

@@ -7,8 +7,7 @@
 
 class KeyBoard {
   private:
-    /* data */
-    static int get_semitone_shift_internal(const char* root_note,
+    static int GetSemitoneShiftInternal(const char* root_note,
                                            char* target_note) {
         const char* pitch_classes[12] = {"C",  "C#", "D",  "D#", "E",  "F",
                                          "F#", "G",  "G#", "A",  "A#", "B"};
@@ -55,10 +54,9 @@ class KeyBoard {
     }
 
   public:
-    KeyBoard(/* args */);
-    ~KeyBoard();
 
-    static float GetHzBySemitone(int semitone) {
+    static float GetHzBySemitone(float semitone) {
+        //440 * Math.Pow(2, (note - 69) / 12.0) would it be better?
         return PITCH_STANDARD * powf(powf(2.f, (1.f / 12.f)), semitone);
     }
 
@@ -66,13 +64,9 @@ class KeyBoard {
         char* target_note_cstr = new char[target_note.length() + 1];
         strcpy(target_note_cstr, target_note.c_str());
 
-        int result = get_semitone_shift_internal("A4", target_note_cstr);
+        int result = GetSemitoneShiftInternal("A4", target_note_cstr);
 
         delete[] target_note_cstr;
         return result;
     }
 };
-
-KeyBoard::KeyBoard(/* args */) {}
-
-KeyBoard::~KeyBoard() {}

inc/LFO.h

@@ -0,0 +1,13 @@
+#pragma once
+#include "Oscillator.h"
+
+class LFO: public Oscillator
+{
+private:
+    /* data */
+public:
+    LFO(/* args */);
+    ~LFO();
+    void SetFreq(float freq) { m_phase_dt = (this->*m_dt_function)(freq); }
+};
+

inc/Logger.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "cstdio"
 
-#define write_log(format,args...) do { \
+#define write_log(format, args...)                                             \
+    do {                                                                       \
         printf(format, ##args);                                                \
     } while (0)

inc/Oscillator.h

@@ -5,31 +5,41 @@
 class Oscillator {
   private:
     OscillatorType m_osc;
-    float m_freq;
+    float m_fine;
+    float m_key;
     float m_volume;
     float m_phase;
-    float m_phase_dt;
     float (Oscillator::*m_osc_function)(void);
+    void SineOscPhaseIncr();
+    void SawOscPhaseIncr();
+    float CalcSawPhaseDelta(float freq);
+    float CalcSinePhaseDelta(float freq);
+    float SawOsc();
+    float TriangleOsc();
+    float SquareOsc();
+    float Sign(float v);
+    float SineOsc();
+
+  protected:
+    float m_phase_dt;
     float (Oscillator::*m_dt_function)(float freq);
-    void sine_osc_phase_incr();
-    void saw_osc_phase_incr();
-    float calc_saw_phase_delta(float freq);
-    float calc_sine_phase_delta(float freq);
-    float sawosc();
-    float triangleosc();
-    float squareosc();
-    float sign(float v);
-    float sineosc();
 
   public:
-    Oscillator(OscillatorType osc, float freq, float volume);
+    Oscillator(OscillatorType osc, float fine, float volume);
     ~Oscillator();
     OscillatorType GetType() { return m_osc; }
     void SetType(OscillatorType osc);
     float GetVolume() { return m_volume; }
     void SetVolume(float volume) { m_volume = volume; }
-    float GetFreq() { return m_freq; }
-    void SetFreq(float freq);
+    float GetKey() { return m_key; }
+    void SetKey(float key);
+    float GetFine() { return m_fine; }
+    void SetFine(float fine) {
+        if (fine != m_fine) {
+            assert(fine >= -2.f && fine <= 2.f);
+            m_fine = fine;
+        }
+    }
     void Reset();
-    float GenerateSample(float duration);
+    float Process();
 };

inc/Renderer.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "ADSR.h"
+#include "Filter.h"
 #include "Synth.h"
 #include "SynthGuiState.h"
 #include "raylib.h"
@@ -8,8 +9,6 @@
 class Renderer {
   private:
     void draw_main_panel(const Rectangle& panel_bounds);
-    void draw_add_oscillator_button(Synth& synth, SynthGuiState& synth_gui,
-                                    Rectangle panel_bounds);
     float draw_oscillators_panels(
         const std::vector<Oscillator*>& oscillators,
         const std::vector<OscillatorGuiState*>& gui_oscillators,
@@ -21,6 +20,9 @@ class Renderer {
     void draw_signal(Synth& synth, SynthGuiState& synth_gui);
     void draw_adsr_panel(ADSR* adsr, ADSRGuiState& gui_adsr,
                          const Rectangle& panel_bounds, float panel_y_offset);
+    void draw_second_panel(Rectangle& bounds);
+    float DrawFilterPanel(Synth& synth, FilterGuiState& gui_filter,
+                            const Rectangle& panel_bounds);
 
   public:
     Renderer(/* args */);

inc/Synth.h

@@ -1,37 +1,40 @@
 #pragma once
 
 #include "ADSR.h"
+#include "Filter.h"
 #include "Adder.h"
-#include "Effect.h"
+#include "IEffect.h"
 #include "Note.h"
 #include "Oscillator.h"
 #include "Settings.h"
 #include <vector>
+#include "LFO.h"
 
 class Synth {
   private:
     bool is_note_triggered;
     std::vector<Oscillator*> m_oscillators;
-    std::vector<Effect*> m_effects;
-    // OscillatorUI* ui_oscillators;
-    // Note m_current_note;
+    std::vector<IEffect*> m_effects;
     std::vector<float> m_out_signal;
-    void zero_signal();
-    void get_note();
-    void trigger_note_on_effects();
-    void untrigger_note_on_effects();
-    void apply_effects();
-
+    LFO* m_lfo;
+    void ZeroSignal();
+    void GetNote();
+    void TriggerNoteOnEffects();
+    void UntriggerNoteOnEffects();
+    void ApplyEffects();
+    void AddOscillator();
+    void ApplyFilterLfo();
   public:
     Synth(/* args */);
     ~Synth();
-    void TriggerNote(Note input);
-    void ProduceSound();
-    void StopSound();
-    void AddOscillator();
-    void AddEffect(Effect* fx);
+    void Trigger(Note input);
+    void Process();
+    void Release();
+    void AddEffect(IEffect* fx);
     const std::vector<float>& GetOutSignal() { return m_out_signal; }
     const std::vector<Oscillator*>& GetOscillators() { return m_oscillators; }
     const bool& GetIsNoteTriggered() { return is_note_triggered; }
     ADSR* GetADSR() { return (ADSR*)m_effects[0]; }
+    Filter* GetFilter() { return (Filter*)m_effects[1]; }
+    void SetFilter(FilterType type);
 };

inc/SynthGuiState.h

@@ -2,10 +2,11 @@
 #include "OscillatorType.h"
 #include "raygui.h"
 #include <vector>
+#include "Filter.h"
 
 struct OscillatorGuiState {
     float volume;
-    float freq; // todo: remove or change to pitch shift
+    float fine;
     OscillatorType waveshape;
     bool is_dropdown_open;
     Rectangle shape_dropdown_rect;
@@ -18,7 +19,15 @@ struct ADSRGuiState {
     float release;
 };
 
+struct FilterGuiState {
+    float freq;
+    float res; //todo: res
+    FilterType type;
+    bool is_dropdown_open;
+};
+
 struct SynthGuiState {
     std::vector<OscillatorGuiState*> oscillators;
     ADSRGuiState adsr;
+    FilterGuiState filter;
 };

src/ADSR.cpp

@@ -3,46 +3,43 @@
 #include "Settings.h"
 
 ADSR::ADSR(/* args */) {
-    m_parameters.attack_time = 1.f;
-    m_parameters.decay_time = 0.4f;
-    m_parameters.sustain_level = 0.6f;
-    m_parameters.release_time = 0.8f;
+    m_attack_time = 1.f;
+    m_decay_time = 0.4f;
+    m_sustain_level = 0.6f;
+    m_release_time = 0.8f;
     m_ramp = new Ramp(0, SAMPLE_RATE);
 }
 
-ADSR::ADSR(ADSRParameters param) { m_parameters = param; }
-
 ADSR::~ADSR() { delete m_ramp; }
 
-bool ADSR::is_attack_elapsed() {
-    return m_state == Attack && m_ramp->IsCompleted();
+bool ADSR::IsAttackElapsed() {
+    return m_state == sAttack && m_ramp->IsCompleted();
 }
 
-bool ADSR::is_decay_elapsed() {
-    return m_state == Decay && m_ramp->IsCompleted();
+bool ADSR::IsDecayElapsed() {
+    return m_state == sDecay && m_ramp->IsCompleted();
 }
 
-bool ADSR::is_release_elapsed() {
-    return m_state == Release && m_ramp->IsCompleted();
+bool ADSR::IsReleaseElapsed() {
+    return m_state == sRelease && m_ramp->IsCompleted();
 }
 
-void ADSR::recheck_state() {
+void ADSR::RecheckState() {
     switch (m_state) {
-        case Attack:
-            if (is_attack_elapsed()) {
-                m_state = Decay;
-                m_ramp->RampTo(m_parameters.sustain_level,
-                               m_parameters.decay_time);
+        case sAttack:
+            if (IsAttackElapsed()) {
+                m_state = sDecay;
+                m_ramp->RampTo(m_sustain_level, m_decay_time);
             }
             break;
-        case Decay:
-            if (is_decay_elapsed()) {
-                m_state = Sustain;
+        case sDecay:
+            if (IsDecayElapsed()) {
+                m_state = sSustain;
             }
             break;
-        case Release:
-            if (is_release_elapsed()) {
-                m_state = Off;
+        case sRelease:
+            if (IsReleaseElapsed()) {
+                m_state = sOff;
             }
             break;
         default:
@@ -50,48 +47,48 @@ void ADSR::recheck_state() {
     }
 }
 
-void ADSR::process_sample(float* sample) {
-    if (m_state == Off) {
+void ADSR::ProcessSample(float* sample) {
+    if (m_state == sOff) {
         (*sample) = 0;
-    } else if (m_state == Attack) {
+    } else if (m_state == sAttack) {
         (*sample) = (*sample) * m_ramp->Process();
-    } else if (m_state == Decay) {
+    } else if (m_state == sDecay) {
         (*sample) = (*sample) * m_ramp->Process();
-    } else if (m_state == Sustain) {
-        (*sample) = (*sample) * m_parameters.sustain_level;
-    } else if (m_state == Release) {
+    } else if (m_state == sSustain) {
+        (*sample) = (*sample) * m_sustain_level;
+    } else if (m_state == sRelease) {
         (*sample) = (*sample) * m_ramp->Process();
     }
 }
 
-void ADSR::OnSetNote() {
+void ADSR::Trigger() {
     write_log("Set ADSR\n");
-    if (m_state == Off) {
-        m_state = Attack;
-    } else if (m_state == Release) {
-        m_state = Attack;
+    if (m_state == sOff) {
+        m_state = sAttack;
+    } else if (m_state == sRelease) {
+        m_state = sAttack;
     };
 
-    m_ramp->RampTo(1, m_parameters.attack_time);
+    m_ramp->RampTo(1, m_attack_time);
 }
 
-void ADSR::OnUnsetNote() {
+void ADSR::Release() {
     write_log("Unset ADSR\n");
-    m_state = Release;
-    m_ramp->RampTo(0, m_parameters.release_time);
+    m_state = sRelease;
+    m_ramp->RampTo(0, m_release_time);
 }
 
 void ADSR::Process(std::vector<float>& samples) {
     for (std::size_t i = 0; i < samples.size(); i++) {
-        recheck_state();
-        process_sample(&samples[i]);
+        RecheckState();
+        ProcessSample(&samples[i]);
     }
 }
 
 void ADSR::SetParameters(float attack, float decay, float sustain,
                          float release) {
-    m_parameters.attack_time = attack;
-    m_parameters.decay_time = decay;
-    m_parameters.sustain_level = sustain;
-    m_parameters.release_time = release;
+    m_attack_time = attack;
+    m_decay_time = decay;
+    m_sustain_level = sustain;
+    m_release_time = release;
 }

src/Application.cpp

@@ -4,8 +4,8 @@
 #include <string>
 
 Application::Application(/* args */) {
-    init_synth();
-    init_audio();
+    InitSynth();
+    InitAudio();
 }
 
 Application::~Application() {
@@ -19,7 +19,7 @@ Application::~Application() {
     }
 }
 
-void Application::init_audio() {
+void Application::InitAudio() {
     m_sound_played_count = 0;
 
     InitAudioDevice();
@@ -31,12 +31,11 @@ void Application::init_audio() {
     PlayAudioStream(m_synth_stream);
 }
 
-void Application::init_synth() {
-    // todo: move that variables to Synth declaration
+void Application::InitSynth() {
     std::string* nameString = new std::string(std::string(new char[3]));
     m_current_note = new Note{.length = 1, .name = (*nameString)};
     m_current_note->name.assign("G4");
-    // todo: move somewhere in initialization
+
     std::vector<Oscillator*> oscillators = m_synth.GetOscillators();
     m_synth_gui_state.oscillators.reserve(oscillators.size());
     for (size_t i = 0; i < oscillators.size(); i++) {
@@ -44,14 +43,14 @@ void Application::init_synth() {
         assert(osc);
 
         OscillatorGuiState* ui =
-            new OscillatorGuiState{.freq = osc->GetFreq(),
+            new OscillatorGuiState{.fine = osc->GetFine(),
                                    .waveshape = osc->GetType(),
                                    .volume = osc->GetVolume()};
         m_synth_gui_state.oscillators.push_back(ui);
     }
 }
 
-bool Application::detect_note_pressed(Note* note) {
+bool Application::DetectNotePressed(Note* note) {
     std::size_t is_pressed = 0;
     note->length = 8;
     if (IsKeyDown(KEY_A)) {
@@ -86,46 +85,36 @@ bool Application::detect_note_pressed(Note* note) {
 }
 
 bool is_note_up() {
-    return IsKeyUp(KEY_A) || IsKeyUp(KEY_B) ||
-           IsKeyUp(KEY_C) || IsKeyUp(KEY_D) ||
-           IsKeyUp(KEY_E) || IsKeyUp(KEY_F) || IsKeyUp(KEY_G);
+    return IsKeyUp(KEY_A) || IsKeyUp(KEY_B) || IsKeyUp(KEY_C) ||
+           IsKeyUp(KEY_D) || IsKeyUp(KEY_E) || IsKeyUp(KEY_F) || IsKeyUp(KEY_G);
 }
 
-// Update On Input
-void Application::update_on_note_input() {
-    if (detect_note_pressed(m_current_note)) {
-
+void Application::UpdateOnNoteInput() {
+    if (DetectNotePressed(m_current_note)) {
         if (!m_synth.GetIsNoteTriggered()) {
-            m_synth.TriggerNote((*m_current_note));
+            m_synth.Trigger((*m_current_note));
         }
-
-        // m_sound_played_count = 0;
-        write_log("Note played: %s\n", m_current_note->name.c_str());
+        //write_log("Note played: %s\n", m_current_note->name.c_str());
     } else if (is_note_up() && m_synth.GetIsNoteTriggered()) {
-        m_synth.StopSound();
+        m_synth.Release();
     }
     // will produce 0 signal if ADSR is in off state
-    m_synth.ProduceSound();
+    m_synth.Process();
 }
 
 // Play ring-buffered audio
-void Application::play_buffered_audio() {
+void Application::PlayBufferedAudio() {
     if (IsAudioStreamProcessed(m_synth_stream)) {
-        // const float audio_frame_start_time = GetTime();
-        update_on_note_input();
+        UpdateOnNoteInput();
         UpdateAudioStream(m_synth_stream, m_synth.GetOutSignal().data(),
                           STREAM_BUFFER_SIZE);
-        // const float audio_freme_duration = GetTime() -
-        // audio_frame_start_time; write_log("Frame time: %.3f%% \n", 100.0f /
-        // ((1.0f / audio_freme_duration) /
-        // ((float)SAMPLE_RATE/STREAM_BUFFER_SIZE)));
     }
 }
 
 void Application::Run() {
     // Main game loop
     while (!WindowShouldClose()) {
-        play_buffered_audio();
+        PlayBufferedAudio();
         m_renderer.Draw(m_synth, m_synth_gui_state);
     }
 }

src/BandPassFilter.cpp

@@ -0,0 +1,22 @@
+#include "Filter.h"
+#include "Settings.h"
+
+BandPassFilter::BandPassFilter() {
+    SetParameters(200, 0.1, 0.001);
+}
+
+BandPassFilter::BandPassFilter(
+    Filter* filter) {
+    SetParameters(filter->GetFreq(), filter->GetRes(), filter->GetPeakGain());
+}
+
+BandPassFilter::BandPassFilter(float freq, float res,
+                                                       float q) {
+    SetParameters(freq, res, q);
+}
+
+BandPassFilter::~BandPassFilter() {}
+
+float BandPassFilter::GetSampleForFilterType() {
+    return m_lowo;
+}

src/Filter.cpp

@@ -0,0 +1,50 @@
+#include "Filter.h"
+#include "Settings.h"
+#include <algorithm>
+#include <cmath>
+
+Filter::Filter(/* args */) {}
+
+Filter::~Filter() {}
+
+void Filter::Trigger() {}
+
+void Filter::Release() {}
+
+void Filter::Process(std::vector<float>& samples) {
+    for (std::size_t i = 0; i < samples.size(); i++) {
+        samples[i] = Process(samples[i]);
+    }
+}
+
+
+float Filter::Process(float in) {
+    m_notcho = in - m_damp * m_bando;
+    m_lowo = m_lowo + m_freq * m_bando;
+    m_higho = m_notcho - m_lowo;
+    m_bando =
+        m_freq * m_higho + m_bando - m_drive * m_bando * m_bando * m_bando;
+    // (m_notcho or m_lowo or m_higho or m_bando or m_peako)
+    float out = 0.5 * GetSampleForFilterType();
+    m_notcho = in - m_damp * m_bando;
+    m_lowo = m_lowo + m_freq * m_bando;
+    m_higho = m_notcho - m_lowo;
+    m_bando =
+        m_freq * m_higho + m_bando - m_drive * m_bando * m_bando * m_bando;
+    out += 0.5 * GetSampleForFilterType();
+
+    return out;
+}
+
+void Filter::SetParameters(float freq, float res, float drive) {
+    m_fc = freq;
+    m_res = res;
+    m_drive = drive;
+
+    // the fs*2 is because it's double sampled
+    m_freq =
+        2.0 * std::sinf(SYNTH_PI * std::min(0.25f, m_fc / (m_fs * 2)));
+
+    m_damp = std::min(2.0f * (1.0f - std::powf(m_res, 0.25f)),
+                            std::min(2.0f, 2.0f / m_freq - m_freq * 0.5f));
+}

src/HighPassFilter.cpp

@@ -0,0 +1,22 @@
+#include "Filter.h"
+#include "Settings.h"
+
+HighPassFilter::HighPassFilter() {
+    SetParameters(200, 0.1, 0.001);
+}
+
+HighPassFilter::HighPassFilter(
+    Filter* filter) {
+    SetParameters(filter->GetFreq(), filter->GetRes(), filter->GetPeakGain());
+}
+
+HighPassFilter::HighPassFilter(float freq, float res,
+                                                       float q) {
+    SetParameters(freq, res, q);
+}
+
+HighPassFilter::~HighPassFilter() {}
+
+float HighPassFilter::GetSampleForFilterType() {
+    return m_higho;
+}

src/LFO.cpp

@@ -0,0 +1,10 @@
+#include "LFO.h"
+
+
+LFO::LFO(/* args */): Oscillator(Sine, 0.f, 0.5f)
+{
+}
+
+LFO::~LFO()
+{
+}

src/LowPassFilter.cpp

@@ -0,0 +1,22 @@
+#include "Filter.h"
+#include "Settings.h"
+
+LowPassFilter::LowPassFilter() {
+    SetParameters(200, 0.1, 0.001);
+}
+
+LowPassFilter::LowPassFilter(
+    Filter* filter) {
+    SetParameters(filter->GetFreq(), filter->GetRes(), filter->GetPeakGain());
+}
+
+LowPassFilter::LowPassFilter(float freq, float res,
+                                                       float q) {
+    SetParameters(freq, res, q);
+}
+
+LowPassFilter::~LowPassFilter() {}
+
+float LowPassFilter::GetSampleForFilterType() {
+    return m_lowo;
+}

src/Oscillator.cpp

@@ -1,11 +1,15 @@
 #include "Oscillator.h"
 #include "Settings.h"
+#include "KeyBoard.h"
+#include "Logger.h"
 
 #define TWO_PI 2 * SYNTH_PI
 
-Oscillator::Oscillator(OscillatorType osc, float freq, float volume) {
+Oscillator::Oscillator(OscillatorType osc, float fine, float volume) {
+    assert(fine >= -2.f && fine <= 2.f);
+    assert(volume >= 0.f && volume <= 1.f);
     SetType(osc);
-    m_freq = freq;
+    m_fine = fine;
     m_volume = volume;
 }
 
@@ -21,72 +25,73 @@ void Oscillator::SetType(OscillatorType osc) {
     m_osc = osc;
     switch (m_osc) {
         case Sine:
-            m_osc_function = &Oscillator::sineosc;
-            m_dt_function = &Oscillator::calc_sine_phase_delta;
+            m_osc_function = &Oscillator::SineOsc;
+            m_dt_function = &Oscillator::CalcSinePhaseDelta;
             break;
         case Triangle:
-            m_osc_function = &Oscillator::triangleosc;
-            m_dt_function = &Oscillator::calc_saw_phase_delta;
+            m_osc_function = &Oscillator::TriangleOsc;
+            m_dt_function = &Oscillator::CalcSawPhaseDelta;
             break;
         case Square:
-            m_osc_function = &Oscillator::squareosc;
-            m_dt_function = &Oscillator::calc_sine_phase_delta;
+            m_osc_function = &Oscillator::SquareOsc;
+            m_dt_function = &Oscillator::CalcSinePhaseDelta;
             break;
         case Saw:
-            m_osc_function = &Oscillator::sawosc;
-            m_dt_function = &Oscillator::calc_saw_phase_delta;
+            m_osc_function = &Oscillator::SawOsc;
+            m_dt_function = &Oscillator::CalcSawPhaseDelta;
             break;
     }
 }
 
-void Oscillator::SetFreq(float freq) {
-    m_freq = freq;
+void Oscillator::SetKey(float key) {
+    m_key = key;
+    float freq = KeyBoard::GetHzBySemitone(m_key + m_fine);
     m_phase = 0;
     m_phase_dt = (this->*m_dt_function)(freq);
 }
 
-float Oscillator::GenerateSample(float duration) {
+float Oscillator::Process() {
     return (this->*m_osc_function)() * m_volume;
 }
 
-void Oscillator::sine_osc_phase_incr() {
+void Oscillator::SineOscPhaseIncr() {
     m_phase += m_phase_dt;
     if (m_phase >= TWO_PI)
         m_phase -= TWO_PI;
 }
 
-void Oscillator::saw_osc_phase_incr() {
+void Oscillator::SawOscPhaseIncr() {
     m_phase += m_phase_dt;
     if (m_phase >= 1.0f)
         m_phase -= 1.0f;
 }
 
-float Oscillator::calc_saw_phase_delta(float freq) {
+float Oscillator::CalcSawPhaseDelta(float freq) {
     return freq / SAMPLE_RATE;
 }
 
-float Oscillator::calc_sine_phase_delta(float freq) {
+float Oscillator::CalcSinePhaseDelta(float freq) {
     return (TWO_PI * freq) / SAMPLE_RATE;
 }
 
-float Oscillator::sineosc() {
+float Oscillator::SineOsc() {
     float result = sinf(m_phase);
-    sine_osc_phase_incr();
+    SineOscPhaseIncr();
     return result;
 }
 
-float Oscillator::sign(float v) { return (v > 0.0) ? 1.f : -1.f; }
+float Oscillator::Sign(float v) { return (v > 0.0) ? 1.f : -1.f; }
 
-float Oscillator::squareosc() { return sign(sineosc()); }
+float Oscillator::SquareOsc() { return Sign(SineOsc()); }
 
-float Oscillator::triangleosc() {
+float Oscillator::TriangleOsc() {
     float result = 1.f - fabsf(m_phase - 0.5f) * 4.f;
-    saw_osc_phase_incr();
+    SawOscPhaseIncr();
     return result;
 }
 
-float Oscillator::sawosc() {
+float Oscillator::SawOsc() {
     float result = m_phase * 2.f - 1.f;
-    saw_osc_phase_incr();
+    SawOscPhaseIncr();
     return result;
 }

src/Renderer.cpp

@@ -19,13 +19,10 @@ Renderer::~Renderer() {}
 
 void Renderer::Draw(Synth& synth, SynthGuiState& synth_gui) {
     BeginDrawing();
-
     ClearBackground(RAYWHITE);
-    // todo: implement renderer
+
     draw_ui(synth, synth_gui);
     draw_signal(synth, synth_gui);
-    // DrawText("Congrats! You created your first window!", 190, 200, 20,
-    // LIGHTGRAY); DrawFPS(0,0);
 
     EndDrawing();
 }
@@ -92,7 +89,7 @@ float Renderer::draw_oscillators_panels(
 
         // Draw Oscillator Panel
         const int osc_panel_width = panel_bounds.width - 20;
-        const int osc_panel_height = has_shape_param ? 130 : 100;
+        const int osc_panel_height = has_shape_param ? 150 : 120;
         const int osc_panel_x = panel_bounds.x + 10;
         const int osc_panel_y = panel_bounds.y + 50 + panel_y_offset;
         panel_y_offset += osc_panel_height + 5;
@@ -115,28 +112,23 @@ float Renderer::draw_oscillators_panels(
         decibels =
             GuiSlider(el_rect, amp_slider_label, "", decibels, -60.0f, 0.0f);
         ui_osc->volume = powf(10.f, decibels * (1.f / 20.f));
-        osc->SetVolume(ui_osc->volume);
+        el_rect.y += el_rect.height + el_spacing;
 
+        // Fine slider
+        float fine = osc->GetFine();
+        char fine_slider_label[10];
+        snprintf(fine_slider_label, 9, "%.3f u", fine);
+        fine = GuiSlider(el_rect, fine_slider_label, "", fine, -2.f, 2.f);
+        ui_osc->fine = fine;
         el_rect.y += el_rect.height + el_spacing;
 
         // Defer shape drop-down box.
         ui_osc->shape_dropdown_rect = el_rect;
         el_rect.y += el_rect.height + el_spacing;
 
-        Rectangle delete_button_rect = el_rect;
-        delete_button_rect.x = osc_panel_x + 5;
-        delete_button_rect.y -= el_rect.height + el_spacing;
-        delete_button_rect.width = 30;
-        bool is_delete_button_pressed = GuiButton(delete_button_rect, "X");
-        if (is_delete_button_pressed) {
-            //     memmove(
-            //             synth->ui_oscillator + ui_osc_i,
-            //             synth->ui_oscillator + ui_osc_i + 1,
-            //             (synth->ui_oscillator_count - ui_osc_i) *
-            // sizeof(UiOscillator)
-            //             );
-            //     synth->ui_oscillator_count -= 1;
-        }
+        // Apply values to real
+        osc->SetVolume(ui_osc->volume);
+        osc->SetFine(ui_osc->fine);
     }
 
     return panel_y_offset;
@@ -146,47 +138,6 @@ void Renderer::draw_main_panel(const Rectangle& panel_bounds) {
     GuiPanel(panel_bounds, "");
 }
 
-void Renderer::draw_add_oscillator_button(Synth& synth,
-                                          SynthGuiState& synth_gui,
-                                          Rectangle panel_bounds) {
-    //clang-format off
-    bool click_add_oscillator =
-        GuiButton((Rectangle){panel_bounds.x + 10, panel_bounds.y + 10,
-                              panel_bounds.width - 20, 25.f},
-                  "Add Oscillator");
-    //clang-format on
-
-    if (click_add_oscillator) {
-        synth.AddOscillator();
-        Oscillator* osc = synth.GetOscillators().back();
-
-        OscillatorGuiState* ui =
-            new OscillatorGuiState{.freq = osc->GetFreq(),
-                                   .waveshape = osc->GetType(),
-                                   .volume = osc->GetVolume()};
-        synth_gui.oscillators.push_back(ui);
-    }
-}
-
-void Renderer::draw_ui(Synth& synth, SynthGuiState& synth_gui) {
-    Rectangle panel_bounds = {.x = 0,
-                              .y = 0,
-                              .width = OSCILLATOR_PANEL_WIDTH,
-                              .height = WINDOW_HEIGHT};
-    draw_main_panel(panel_bounds);
-    draw_add_oscillator_button(synth, synth_gui, panel_bounds);
-    // Draw Oscillators
-    std::vector<Oscillator*> oscillators = synth.GetOscillators();
-    std::vector<OscillatorGuiState*> gui_oscillators = synth_gui.oscillators;
-
-    float panel_y_offset =
-        draw_oscillators_panels(oscillators, gui_oscillators, panel_bounds);
-    draw_oscillators_shape_inputs(oscillators, gui_oscillators);
-
-    draw_adsr_panel(synth.GetADSR(), synth_gui.adsr, panel_bounds,
-                    panel_y_offset);
-}
-
 void Renderer::draw_adsr_panel(ADSR* adsr, ADSRGuiState& gui_adsr,
                                const Rectangle& panel_bounds,
                                float panel_y_offset) {
@@ -243,3 +194,95 @@ void Renderer::draw_adsr_panel(ADSR* adsr, ADSRGuiState& gui_adsr,
     adsr->SetParameters(gui_adsr.attack, gui_adsr.decay, gui_adsr.sustain,
                         gui_adsr.release);
 }
+
+void Renderer::draw_second_panel(Rectangle& bounds) {
+    bounds.x += bounds.width;
+    GuiPanel(bounds, "");
+}
+
+float Renderer::DrawFilterPanel(Synth& synth, FilterGuiState& gui_filter,
+                                const Rectangle& panel_bounds) {
+#define FILTER_TYPE_OPTIONS "LP;BP;HP"
+    Filter* filter = synth.GetFilter();
+    float panel_y_offset = 0;
+
+    // Draw Filter Panel
+    const int osc_panel_width = panel_bounds.width - 20;
+    const int osc_panel_height = 100;
+    const int osc_panel_x = panel_bounds.x + 10;
+    const int osc_panel_y = panel_bounds.y + 50;
+    panel_y_offset += osc_panel_height + 5;
+    GuiPanel((Rectangle){(float)osc_panel_x, (float)osc_panel_y,
+                         (float)osc_panel_width, (float)osc_panel_height},
+             "Filter");
+
+    const float slider_padding = 50.f;
+    const float el_spacing = 5.f;
+    Rectangle el_rect = {.x = (float)osc_panel_x + slider_padding + 30,
+                         .y = (float)osc_panel_y + 10,
+                         .width = (float)osc_panel_width - (slider_padding * 2),
+                         .height = 25.f};
+
+    // Frequency slider
+    float freq = log10f(gui_filter.freq);
+    char freq_slider_label[32];
+    snprintf(freq_slider_label, 10, "%.1f hz", powf(10.f, freq));
+    freq = GuiSlider(el_rect, freq_slider_label, "", freq, 0.f, 4.f);
+    gui_filter.freq = powf(10.f, freq);
+    el_rect.y += el_rect.height + el_spacing;
+
+    // todo: implement that when Res will be fixed
+    //  Resonance slider
+    //  float res = gui_filter.res;
+    //  char res_slider_label[32];
+    //  snprintf(res_slider_label, 7, "%.1f u", res);
+    //  res = GuiSlider(el_rect, res_slider_label, "", res, 0.0f, 1.0f);
+    //  gui_filter.res = res;
+    //  el_rect.y += el_rect.height + el_spacing;
+
+    // Shape select
+    int shape_index = (int)(gui_filter.type);
+    bool is_dropdown_click =
+        GuiDropdownBox(el_rect, FILTER_TYPE_OPTIONS, &shape_index,
+                       gui_filter.is_dropdown_open);
+
+    if (is_dropdown_click) {
+        write_log("Dropdown clicked!\n");
+        gui_filter.is_dropdown_open = !gui_filter.is_dropdown_open;
+        gui_filter.type = (FilterType)(shape_index);
+        // APPLY STATE TO REAL SYNTH
+        synth.SetFilter(gui_filter.type);
+    }
+
+    // apply values to real one
+    // todo: thrid (order) parameter
+    // todo: why resonance changing does not work?
+    // todo: limit filter lowest frequency  to ~40 hz
+    if (gui_filter.freq < 40.0) {
+        gui_filter.freq = 50.0;
+    }
+    filter->SetParameters(gui_filter.freq, filter->GetRes(),
+                          filter->GetPeakGain());
+
+    return panel_y_offset;
+}
+
+void Renderer::draw_ui(Synth& synth, SynthGuiState& synth_gui) {
+    Rectangle panel_bounds = {.x = 0,
+                              .y = 0,
+                              .width = OSCILLATOR_PANEL_WIDTH,
+                              .height = WINDOW_HEIGHT};
+    draw_main_panel(panel_bounds);
+
+    std::vector<Oscillator*> oscillators = synth.GetOscillators();
+    std::vector<OscillatorGuiState*> gui_oscillators = synth_gui.oscillators;
+
+    float panel_y_offset =
+        draw_oscillators_panels(oscillators, gui_oscillators, panel_bounds);
+    draw_adsr_panel(synth.GetADSR(), synth_gui.adsr, panel_bounds,
+                    panel_y_offset);
+    draw_oscillators_shape_inputs(oscillators, gui_oscillators);
+
+    draw_second_panel(panel_bounds);
+    DrawFilterPanel(synth, synth_gui.filter, panel_bounds);
+}

src/Synth.cpp

@@ -1,18 +1,22 @@
 #include "Synth.h"
-#include "ADSR.h"
+#include "FilterFactory.h"
 #include "KeyBoard.h"
 #include "Logger.h"
 #include "OscillatorType.h"
 #include "Settings.h"
 
 Synth::Synth(/* args */) {
+    m_lfo = new LFO();
+    m_lfo->SetFreq(5.0);
+    AddOscillator();
     AddOscillator();
     AddEffect(new ADSR());
+    AddEffect(FilterFactory::GetDefaultFilter());
     for (size_t i = 0; i < STREAM_BUFFER_SIZE; i++) {
         float sample = 0.0f;
         m_out_signal.push_back(sample);
     }
-    zero_signal();
+    ZeroSignal();
 }
 
 Synth::~Synth() {
@@ -21,63 +25,82 @@ Synth::~Synth() {
     m_out_signal.clear();
 }
 
-void Synth::zero_signal() {
+void Synth::ZeroSignal() {
     float sample = 0.0f;
     for (size_t i = 0; i < STREAM_BUFFER_SIZE; i++) {
         m_out_signal[i] = sample;
     }
 }
 
-void Synth::get_note() {
-    zero_signal();
+void Synth::GetNote() {
+    ZeroSignal();
     Adder::SumOscillators(m_oscillators, m_out_signal);
 }
 
-void Synth::apply_effects() {
-    for (Effect* effect : m_effects) {
-        effect->Process(m_out_signal);
+void Synth::ApplyEffects() {
+    auto* adsr = m_effects[0];
+    adsr->Process(m_out_signal);
+
+    Filter* filter = (Filter*)m_effects[1];
+
+    for (std::size_t i = 0; i < m_out_signal.size(); i++) {
+        ApplyFilterLfo();
+        m_out_signal[i] = filter->Process(m_out_signal[i]);
     }
 }
 
-void Synth::trigger_note_on_effects() {
-    for (Effect* effect : m_effects) {
-        effect->OnSetNote();
+void Synth::TriggerNoteOnEffects() {
+    for (IEffect* effect : m_effects) {
+        effect->Trigger();
     }
 }
 
-void Synth::untrigger_note_on_effects() {
-    for (Effect* effect : m_effects) {
-        effect->OnUnsetNote();
+void Synth::UntriggerNoteOnEffects() {
+    for (IEffect* effect : m_effects) {
+        effect->Release();
     }
 }
 
-void Synth::TriggerNote(Note input) {
-    int semitone_shift = KeyBoard::GetSemitoneShift(input.name);
-    float hz = KeyBoard::GetHzBySemitone(semitone_shift);
-
-    // will change after oscillator starts to be more autonomous
-    for (Oscillator* osc : m_oscillators) {
-        osc->SetFreq(hz);
-    }
-    is_note_triggered = true;
-    trigger_note_on_effects();
-}
-
-void Synth::ProduceSound() {
-    get_note();
-    apply_effects();
-}
-
-// todo: rename to something like untrigger note
-void Synth::StopSound() {
-    zero_signal();
-    is_note_triggered = false;
-    untrigger_note_on_effects();
-}
-
 void Synth::AddOscillator() {
-    m_oscillators.push_back(
-        new Oscillator(OscillatorType::Sine, 440.f, VOLUME));
+    m_oscillators.push_back(new Oscillator(OscillatorType::Sine, 0.0f, VOLUME));
 }
 
-void Synth::AddEffect(Effect* fx) { m_effects.push_back(fx); }
+void Synth::Trigger(Note input) {
+    int semitone_shift = KeyBoard::GetSemitoneShift(input.name);
+
+    for (Oscillator* osc : m_oscillators) {
+        osc->SetKey(semitone_shift);
+    }
+    is_note_triggered = true;
+    TriggerNoteOnEffects();
+}
+
+void Synth::ApplyFilterLfo() {
+    float dt = m_lfo->Process();
+    Filter* filter = (Filter*)m_effects[1];
+    float freq = filter->GetFreq();
+    filter->SetParameters(freq + dt, filter->GetRes(), filter->GetPeakGain());
+}
+
+void Synth::Process() {
+    GetNote();
+    ApplyEffects();
+}
+
+void Synth::Release() {
+    ZeroSignal();
+    is_note_triggered = false;
+    UntriggerNoteOnEffects();
+}
+
+void Synth::AddEffect(IEffect* fx) { m_effects.push_back(fx); }
+
+void Synth::SetFilter(FilterType type) {
+    Filter* old_filter = this->GetFilter();
+    if (!old_filter->IsSameFilterType(type)) {
+        // todo: implement other types of state variable filters;
+        Filter* new_filter = FilterFactory::CreateFilter(old_filter, type);
+        delete old_filter;
+        m_effects[1] = new_filter;
+    }
+}