[refactor]: trigger-process-release therms

inc/ADSR.h

@@ -10,7 +10,7 @@ struct ADSRParameters {
     float release_time;
 };
 
-enum ADSRState { Off, Attack, Decay, Sustain, Release };
+enum ADSRState { sOff, sAttack, sDecay, sSustain, sRelease };
 
 class ADSR : public Effect {
   private:
@@ -28,8 +28,8 @@ class ADSR : public Effect {
     ADSR(/* args */);
     ADSR(ADSRParameters param);
     ~ADSR();
-    void OnSetNote() override;
-    void OnUnsetNote() override;
+    void Trigger() override;
+    void Release() override;
     // void RetriggerState() override;
     void Process(std::vector<float>& samples) override;
     void Reset();

inc/Effect.h

@@ -6,8 +6,8 @@ class Effect {
   public:
     Effect(/* args */){};
     ~Effect(){};
-    virtual void OnSetNote(){};
-    virtual void OnUnsetNote(){};
+    virtual void Trigger(){};
+    virtual void Release(){};
     // virtual void RetriggerState(){};
     virtual void Process(std::vector<float>& samples){};
 };

inc/Synth.h

@@ -25,9 +25,9 @@ class Synth {
   public:
     Synth(/* args */);
     ~Synth();
-    void TriggerNote(Note input);
-    void ProduceSound();
-    void StopSound();
+    void Trigger(Note input);
+    void Process();
+    void Release();
     void AddOscillator();
     void AddEffect(Effect* fx);
     const std::vector<float>& GetOutSignal() { return m_out_signal; }

src/ADSR.cpp

@@ -15,34 +15,34 @@ ADSR::ADSR(ADSRParameters param) { m_parameters = param; }
 ADSR::~ADSR() { delete m_ramp; }
 
 bool ADSR::is_attack_elapsed() {
-    return m_state == Attack && m_ramp->IsCompleted();
+    return m_state == sAttack && m_ramp->IsCompleted();
 }
 
 bool ADSR::is_decay_elapsed() {
-    return m_state == Decay && m_ramp->IsCompleted();
+    return m_state == sDecay && m_ramp->IsCompleted();
 }
 
 bool ADSR::is_release_elapsed() {
-    return m_state == Release && m_ramp->IsCompleted();
+    return m_state == sRelease && m_ramp->IsCompleted();
 }
 
 void ADSR::recheck_state() {
     switch (m_state) {
-        case Attack:
+        case sAttack:
             if (is_attack_elapsed()) {
-                m_state = Decay;
+                m_state = sDecay;
                 m_ramp->RampTo(m_parameters.sustain_level,
                                m_parameters.decay_time);
             }
             break;
-        case Decay:
+        case sDecay:
             if (is_decay_elapsed()) {
-                m_state = Sustain;
+                m_state = sSustain;
             }
             break;
-        case Release:
+        case sRelease:
             if (is_release_elapsed()) {
-                m_state = Off;
+                m_state = sOff;
             }
             break;
         default:
@@ -51,33 +51,33 @@ void ADSR::recheck_state() {
 }
 
 void ADSR::process_sample(float* sample) {
-    if (m_state == Off) {
+    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) {
+    } else if (m_state == sSustain) {
         (*sample) = (*sample) * m_parameters.sustain_level;
-    } else if (m_state == Release) {
+    } 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);
 }
 
-void ADSR::OnUnsetNote() {
+void ADSR::Release() {
     write_log("Unset ADSR\n");
-    m_state = Release;
+    m_state = sRelease;
     m_ramp->RampTo(0, m_parameters.release_time);
 }
 

src/Application.cpp

@@ -96,16 +96,16 @@ void Application::update_on_note_input() {
     if (detect_note_pressed(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());
     } 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

src/Synth.cpp

@@ -41,17 +41,17 @@ void Synth::apply_effects() {
 
 void Synth::trigger_note_on_effects() {
     for (Effect* effect : m_effects) {
-        effect->OnSetNote();
+        effect->Trigger();
     }
 }
 
 void Synth::untrigger_note_on_effects() {
     for (Effect* effect : m_effects) {
-        effect->OnUnsetNote();
+        effect->Release();
     }
 }
 
-void Synth::TriggerNote(Note input) {
+void Synth::Trigger(Note input) {
     int semitone_shift = KeyBoard::GetSemitoneShift(input.name);
     float hz = KeyBoard::GetHzBySemitone(semitone_shift);
 
@@ -63,13 +63,13 @@ void Synth::TriggerNote(Note input) {
     trigger_note_on_effects();
 }
 
-void Synth::ProduceSound() {
+void Synth::Process() {
     get_note();
     apply_effects();
 }
 
 // todo: rename to something like untrigger note
-void Synth::StopSound() {
+void Synth::Release() {
     zero_signal();
     is_note_triggered = false;
     untrigger_note_on_effects();