refactor: formatting

implemented in c++ to improve readability and simplify maintenance

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

.clang-format

@@ -0,0 +1,216 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignArrayOfStructures: None
+AlignConsecutiveAssignments:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    true
+AlignConsecutiveBitFields:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignConsecutiveDeclarations:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignConsecutiveMacros:
+  Enabled:         false
+  AcrossEmptyLines: false
+  AcrossComments:  false
+  AlignCompound:   false
+  PadOperators:    false
+AlignEscapedNewlines: Right
+AlignOperands:   Align
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortEnumsOnASingleLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+AttributeMacros:
+  - __capability
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: Never
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeConceptDeclarations: Always
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+QualifierAlignment: Leave
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+EmptyLineAfterAccessModifier: Never
+EmptyLineBeforeAccessModifier: LogicalBlock
+ExperimentalAutoDetectBinPacking: false
+PackConstructorInitializers: BinPack
+BasedOnStyle:    ''
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+AllowAllConstructorInitializersOnNextLine: true
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IfMacros:
+  - KJ_IF_MAYBE
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+    CaseSensitive:   false
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+    CaseSensitive:   false
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentAccessModifiers: false
+IndentCaseLabels: true
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentExternBlock: AfterExternBlock
+IndentRequiresClause: true
+IndentWidth: 4
+IndentWrappedFunctionNames: false
+InsertBraces:    false
+InsertTrailingCommas: None
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+LambdaBodyIndentation: Signature
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCBreakBeforeNestedBlockParam: true
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakOpenParenthesis: 0
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Left
+PPIndentWidth:   -1
+ReferenceAlignment: Pointer
+ReflowComments:  true
+RemoveBracesLLVM: false
+RequiresClausePosition: OwnLine
+SeparateDefinitionBlocks: Leave
+ShortNamespaceLines: 1
+SortIncludes:    CaseSensitive
+SortJavaStaticImport: Before
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCaseColon: false
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeParensOptions:
+  AfterControlStatements: true
+  AfterForeachMacros: true
+  AfterFunctionDefinitionName: false
+  AfterFunctionDeclarationName: false
+  AfterIfMacros:   true
+  AfterOverloadedOperator: false
+  AfterRequiresInClause: false
+  AfterRequiresInExpression: false
+  BeforeNonEmptyParentheses: false
+SpaceAroundPointerQualifiers: Default
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  Never
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInLineCommentPrefix:
+  Minimum:         1
+  Maximum:         -1
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+BitFieldColonSpacing: Both
+Standard:        Latest
+StatementAttributeLikeMacros:
+  - Q_EMIT
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseCRLF:         false
+UseTab:          Never
+WhitespaceSensitiveMacros:
+  - STRINGIZE
+  - PP_STRINGIZE
+  - BOOST_PP_STRINGIZE
+  - NS_SWIFT_NAME
+  - CF_SWIFT_NAME
+...
+

.gitignore

@@ -2,4 +2,5 @@
 .DS_Store
 /Debug/
 *.wav
-*.dSYM
+*.dSYM
+/lib

.vscode/launch.json

@@ -0,0 +1,16 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug",
+            "program": "${workspaceFolder}/bin/main",
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

.vscode/settings.json

@@ -3,7 +3,68 @@
         "readability/casting"
     ],
     "files.associations": {
-        "algorithm": "c"
+        "algorithm": "c",
+        "__bit_reference": "c",
+        "bitset": "c",
+        "chrono": "c",
+        "unordered_map": "c",
+        "__bits": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__errc": "cpp",
+        "__hash_table": "cpp",
+        "__locale": "cpp",
+        "__mutex_base": "cpp",
+        "__node_handle": "cpp",
+        "__split_buffer": "cpp",
+        "__threading_support": "cpp",
+        "__tuple": "cpp",
+        "__verbose_abort": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "complex": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "exception": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "locale": "cpp",
+        "memory": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp",
+        "vector": "cpp",
+        "__nullptr": "cpp",
+        "__string": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "numeric": "cpp"
     },
     "FSharp.suggestGitignore": false,
 }

.vscode/tasks.json

@@ -3,20 +3,12 @@
         {
             "type": "cppbuild",
             "label": "C/C++: clang сборка активного файла",
-            "command": "/usr/bin/clang",
+            "command": "sh",
             "args": [
-                "-fcolor-diagnostics",
-                "-fansi-escape-codes",
-                "-g",
-                "${file}",
-                "${fileDirname}/parser.c",
-                "-lm",
-                "-lraylib",
-                "-o",
-                "${fileDirname}/bin/${fileBasenameNoExtension}"
+                "${workspaceFolder}/build.sh"
             ],
             "options": {
-                "cwd": "${fileDirname}"
+                "cwd": "${workspaceFolder}"
             },
             "problemMatcher": [
                 "$gcc"

build.sh

@@ -1,3 +1,5 @@
 #!/bin/bash
-CC="${CXX:-cc}"
-$CC -Wall -std=c11 ./main.c ./parser.c -lm -lraylib -o ./bin/main
+CC="${CXX:-c++}"
+LL="-lm -lraylib"
+FLAGS="-Wall -std=c++17 -I./inc/ -g"
+$CC $FLAGS $(find ./src -type f -iregex ".*\.cpp") $LL -o ./bin/main

docs/ADSR.md

@@ -26,6 +26,7 @@ release_samples = int(release_time * sample_rate)
 
 # Attack phase
 envelope[:attack_samples] = np.linspace(0, 1, num=attack_samples)
+# 1/n * count;
 
 # Decay phase
 decay_slope = (1 - sustain_level) / decay_samples

docs/Resources.md

@@ -0,0 +1,38 @@
+http://basicsynth.com/index.php?page=basic
+
+Signal Generator
+The most straightforward method of sound generation in software is to evaluate a periodic function for each sample time. A periodic function is any function that repeats at a constant interval, called the period. Consider the circle in the figure below. Starting at the 3:00 position and then sweeping around the circle counter-clockwise, we make a complete cycle in 2π radians and then the movement repeats. Thus the period is 2π radians. If we plot the points on the circumference over time we produce the waveform as shown below.
+
+
+
+For audio signals, the period is the time it takes for the waveform to repeat and is thus the inverse of the frequency. In other words, a frequency of 100Hz repeats every 1/100 second. We need to generate an amplitude value for every sample time, thus the number of samples in one period is equal to the time of the period divided by the time of one sample. Since the time of one sample is the inverse of the sample rate, and the period is the inverse of the frequency, the number of samples is also the sample rate divided by the frequency: ((1/f) / (1/fs)) = (fs/f). Since our period is also equal to 2π radians, the phase increment for one sample time (φ) is 2π divided by the number of samples in one period:
+
+ 
+
+where the frequency of the signal is f and the sample rate fs. The amplitude for any given sample is the y value of the phase at that point in time multiplied by the radius of the circle. In other words, the amplitude is the sine of the phase angle and we can also derive the phase increment from the sine function.
+
+Signal Generation Equation
+
+The value sn  is the nth sample, An the peak amplitude (volume) at sample n, and θn the phase at sample n. To calculate θn for any sample n, we can multiply the phase increment for one sample time (φ) by the sample number. To calculate φ we need to determine the radians for one sample time at a given frequency. As there are 2π radians per cycle, we multiply the frequency by 2π to get the radians per second. The phase increment for one sample time is then the radians per second multiplied by the time for one sample. Substiting for θn in the original equation yields:
+
+Signal Generation Equation
+
+We can implement this as a program loop.
+
+totalSamples = duration * sampleRate;
+for (n = 0; n < totalSamples; n++)
+    sample[n] = sin((twoPI/sampleRate) * frequency * n);
+Since  2π/fs is constant through the loop, we can calculate it once. We can also replace the multiplication of the phase with a repeated addition.  
+
+phaseIncr = (twoPI/sampleRate) * frequency;
+phase = 0;
+totalSamples = duration * sampleRate;
+for (n = 0; n < totalSamples; n++) {
+    sample[n] = sin(phase);
+    phase += phaseIncr;
+    if (phase >= twoPI)
+        phase -= twoPI;
+}
+ 
+
+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.

inc/ADSR.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "Effect.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;
+};
+
+enum ADSRState { Off, Attack, Decay, Sustain, Release };
+
+class ADSR : public Effect {
+  private:
+    ADSRParameters m_parameters;
+    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();
+
+  public:
+    ADSR(/* args */);
+    ADSR(ADSRParameters param);
+    ~ADSR();
+    void OnSetNote() override;
+    void OnUnsetNote() override;
+    // void RetriggerState() override;
+    void Process(std::vector<float>& samples) override;
+    void Reset();
+    void SetParameters(float attack, float decay, float sustain, float release);
+};

inc/Adder.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "Oscillator.h"
+#include "Settings.h"
+#include <numeric>
+#include <vector>
+
+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);
+
+        for (size_t i = 0; i < sample_count; i++) {
+            float sample = 0.0f;
+            for (Oscillator* osc : oscillators) {
+                sample += osc->GenerateSample(1.f);
+            }
+
+            signal[i] = sample;
+        }
+    }
+};

inc/Application.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "Note.h"
+#include "Renderer.h"
+#include "Synth.h"
+#include "SynthGuiState.h"
+#include "raylib.h"
+
+class Application {
+  private:
+    Synth m_synth;
+    SynthGuiState m_synth_gui_state;
+    AudioStream m_synth_stream;
+    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();
+
+  public:
+    Application(/* args */);
+    ~Application();
+    void Run();
+};

inc/Effect.h

@@ -0,0 +1,13 @@
+#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/KeyBoard.h

@@ -0,0 +1,78 @@
+#pragma once
+#include "Settings.h"
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+class KeyBoard {
+  private:
+    /* data */
+    static int get_semitone_shift_internal(const char* root_note,
+                                           char* target_note) {
+        const char* pitch_classes[12] = {"C",  "C#", "D",  "D#", "E",  "F",
+                                         "F#", "G",  "G#", "A",  "A#", "B"};
+
+        // Extract the note number and pitch class for the root note
+        int root_note_num = (int)root_note[strlen(root_note) - 1] - '0';
+
+        char* root_pitch_class_str =
+            (char*)malloc((strlen(root_note) - 1) * sizeof(char));
+        strncpy(root_pitch_class_str, root_note, strlen(root_note) - 1);
+
+        int root_pitch_class = -1;
+
+        for (int i = 0; i < 12; i++) {
+            if (strcmp(pitch_classes[i], root_pitch_class_str) == 0) {
+                root_pitch_class = i;
+                break;
+            }
+        }
+
+        free(root_pitch_class_str);
+
+        // Extract the note number and pitch class for the target note
+        int target_note_num = (int)target_note[strlen(target_note) - 1] - '0';
+
+        char* target_pitch_class_str =
+            (char*)malloc((strlen(target_note) - 1) * sizeof(char));
+        strncpy(target_pitch_class_str, target_note, strlen(target_note) - 1);
+
+        int target_pitch_class = -1;
+
+        for (int i = 0; i < 12; i++) {
+            if (strcmp(pitch_classes[i], target_pitch_class_str) == 0) {
+                target_pitch_class = i;
+                break;
+            }
+        }
+
+        free(target_pitch_class_str);
+
+        // Calculate the semitone shift using the formula
+        return (target_note_num - root_note_num) * 12 +
+               (target_pitch_class - root_pitch_class);
+    }
+
+  public:
+    KeyBoard(/* args */);
+    ~KeyBoard();
+
+    static float GetHzBySemitone(int semitone) {
+        return PITCH_STANDARD * powf(powf(2.f, (1.f / 12.f)), semitone);
+    }
+
+    static int GetSemitoneShift(const std::string& target_note) {
+        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);
+
+        delete[] target_note_cstr;
+        return result;
+    }
+};
+
+KeyBoard::KeyBoard(/* args */) {}
+
+KeyBoard::~KeyBoard() {}

inc/Logger.h

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

inc/Note.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <string>
+
+struct Note {
+    std::string& name;
+    int length;
+};

inc/Oscillator.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "OscillatorType.h"
+#include <vector>
+
+class Oscillator {
+  private:
+    OscillatorType m_osc;
+    float m_freq;
+    float m_volume;
+    float m_phase;
+    float m_phase_dt;
+    float (Oscillator::*m_osc_function)(void);
+    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 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);
+    void Reset();
+    float GenerateSample(float duration);
+};

inc/OscillatorType.h

@@ -0,0 +1,2 @@
+#pragma once
+typedef enum { Sine, Triangle, Saw, Square } OscillatorType;

inc/Ramp.h

@@ -0,0 +1,16 @@
+#pragma once
+
+class Ramp {
+  private:
+    float m_level;
+    float m_sample_rate;
+    float m_increment;
+    int m_counter;
+
+  public:
+    Ramp(float starting_level, float sample_rate);
+    ~Ramp();
+    void RampTo(float value, float time);
+    float Process();
+    bool IsCompleted();
+};

inc/Renderer.h

@@ -0,0 +1,29 @@
+#pragma once
+#include "ADSR.h"
+#include "Synth.h"
+#include "SynthGuiState.h"
+#include "raylib.h"
+#include <vector>
+
+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,
+        const Rectangle& panel_bounds);
+    void draw_oscillators_shape_inputs(
+        const std::vector<Oscillator*>& oscillators,
+        const std::vector<OscillatorGuiState*>& guiOscillators);
+    void draw_ui(Synth& synth, SynthGuiState& synth_gui);
+    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);
+
+  public:
+    Renderer(/* args */);
+    ~Renderer();
+    void Draw(Synth& synth, SynthGuiState& synth_gui);
+};

inc/RingBuffer.h

@@ -0,0 +1,115 @@
+#pragma once
+#include "Logger.h"
+#include <cstddef>
+template <typename T> class RingBuffer {
+  private:
+    T* m_items; /* data */
+    std::size_t m_head;
+    std::size_t m_tail;
+    bool m_is_full;
+    bool m_is_empty;
+    std::size_t m_size;
+    void advance_pointer();
+    void retreat_pointer();
+
+  public:
+    RingBuffer(std::size_t size);
+    ~RingBuffer();
+    bool IsFull() { return m_is_full; }
+    bool IsEmpty() { return m_is_empty; }
+    std::size_t GetSize();
+    std::size_t GetCapacity() { return m_size; }
+    void Reset();
+    void Write(T* data, size_t count);
+    bool Read(T* output, size_t count);
+    void Print();
+};
+
+template <typename T> RingBuffer<T>::RingBuffer(std::size_t size) {
+    m_items = new T[size];
+    m_head = 0;
+    m_tail = 0;
+    m_is_full = 0;
+    m_is_empty = 1;
+    m_size = size;
+}
+
+template <typename T> RingBuffer<T>::~RingBuffer() { delete[] m_items; }
+
+template <typename T> void RingBuffer<T>::Reset() {
+    m_head = 0;
+    m_tail = 0;
+    m_is_full = 0;
+}
+
+template <typename T> void RingBuffer<T>::advance_pointer() {
+    if (m_is_full) {
+        m_tail++;
+        if (m_tail == m_size) {
+            m_tail = 0;
+        }
+    }
+    m_head++;
+    if (m_head == m_size) {
+        m_head = 0;
+    }
+    std::size_t p_is_full = m_head == m_tail ? 1 : 0;
+    m_is_full = p_is_full;
+}
+
+template <typename T> void RingBuffer<T>::retreat_pointer() {
+    m_is_full = 0;
+    m_tail++;
+    if (m_tail == m_size) {
+        m_tail = 0;
+    }
+}
+
+template <typename T> void RingBuffer<T>::Write(T* data, std::size_t count) {
+    if (m_is_full || m_head + count > m_size) {
+        write_log("[WARN] Trying to overfill the ring buffer: "
+                  "\n\tIsFull:%d\n\tHead:%zu\n\tCount:%zu\n\t",
+                  m_is_full, m_head, count);
+        return;
+    }
+    m_is_empty = 0;
+
+    for (std::size_t i = 0; i < count; i++) {
+        m_items[m_head] = data[i];
+        advance_pointer();
+    }
+    // m_is_empty = m_is_full && (m_head == m_tail);
+}
+
+template <typename T> bool RingBuffer<T>::Read(T* output, std::size_t count) {
+    if (m_is_empty) {
+        write_log("[WARN] Trying to read empty buffer");
+        return 0;
+    }
+
+    for (std::size_t i = 0; i < count; i++) {
+        output[i] = m_items[m_tail];
+        retreat_pointer();
+    }
+    m_is_empty = !m_is_full && (m_head == m_tail);
+    return 1;
+}
+
+template <typename T> std::size_t RingBuffer<T>::GetSize() {
+    size_t p_size = m_size;
+    if (!m_is_full) {
+        if (m_head >= m_tail) {
+            p_size = (m_head - m_tail);
+        } else {
+            p_size = (m_size + m_head - m_tail);
+        }
+    }
+
+    return p_size;
+}
+
+template <typename T> void RingBuffer<T>::Print() {
+    write_log("[INFO] The ring buffer: "
+              "\n\tIsFull:%d\n\tIsEmpty:%d\n\tHead:%zu\n\tTail:%zu\n\t",
+              m_is_full, m_is_empty, m_head, m_tail);
+}

inc/Settings.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#define SAMPLE_RATE 44100.f
+#define BPM 120.f
+#define BEAT_DURATION 60.f / BPM
+#define PITCH_STANDARD 440.f
+#define VOLUME 0.5f
+#define ATTACK_MS 100.f
+#define STREAM_BUFFER_SIZE 1024
+#define FPS 60
+
+#define SYNTH_PI 3.1415926535f
+#define SYNTH_VOLUME 0.5f
+
+#define WINDOW_WIDTH 640
+#define WINDOW_HEIGHT 480
+#define OSCILLATOR_PANEL_WIDTH 200

inc/Synth.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "ADSR.h"
+#include "Adder.h"
+#include "Effect.h"
+#include "Note.h"
+#include "Oscillator.h"
+#include "Settings.h"
+#include <vector>
+
+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<float> m_out_signal;
+    void zero_signal();
+    void get_note();
+    void trigger_note_on_effects();
+    void untrigger_note_on_effects();
+    void apply_effects();
+
+  public:
+    Synth(/* args */);
+    ~Synth();
+    void TriggerNote(Note input);
+    void ProduceSound();
+    void StopSound();
+    void AddOscillator();
+    void AddEffect(Effect* 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]; }
+};

inc/SynthGuiState.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "OscillatorType.h"
+#include "raygui.h"
+#include <vector>
+
+struct OscillatorGuiState {
+    float volume;
+    float freq; // todo: remove or change to pitch shift
+    OscillatorType waveshape;
+    bool is_dropdown_open;
+    Rectangle shape_dropdown_rect;
+};
+
+struct ADSRGuiState {
+    float attack;
+    float decay;
+    float sustain;
+    float release;
+};
+
+struct SynthGuiState {
+    std::vector<OscillatorGuiState*> oscillators;
+    ADSRGuiState adsr;
+};

main.c

@@ -1,712 +0,0 @@
-#include "stdlib.h"
-#include "stdio.h"
-#include "string.h"
-#include "math.h"
-#include "parser.h"
-
-#include "raylib.h"
-
-#define SAMPLE_RATE 48000.f
-#define BPM 120.f
-#define BEAT_DURATION 60.f/BPM
-#define PITCH_STANDARD 440.f
-#define VOLUME 0.5f
-#define ATTACK_MS 100.f
-#define STREAM_BUFFER_SIZE 4096
-
-#define SYNTH_PI 3.1415926535f
-#define SYNTH_VOLUME 0.5f
-
-#define WINDOW_WIDTH 640
-#define WINDOW_HEIGHT 480
-
-#define write_log(format,args...) do { \
-        printf(format, ## args); \
-    } while(0)
-
-//------------------------------------------------------------------------------------
-// Ring Buffer
-//------------------------------------------------------------------------------------
-
-typedef struct RingBuffer {
-    float* items;
-    size_t head;
-    size_t tail;
-    int is_full;
-    int is_empty;
-    size_t size;
-} RingBuffer;
-
-RingBuffer ring_buffer_init(size_t buffer_size) {
-    RingBuffer buffer = {
-        .items = calloc(buffer_size, sizeof(float)),
-        .head = 0,
-        .tail = 0,
-        .is_full = 0,
-        .is_empty = 1,
-        .size = buffer_size
-    };
-
-    return buffer;
-}
-
-void ring_buffer_reset(RingBuffer* me) {
-    me->head = 0;
-    me->tail = 0;
-    me->is_full = 0;
-}
-
-// +
-static void advance_pointer(RingBuffer* me) {
-    if(me->is_full) {
-        me->tail++;
-		if (me->tail == me->size) { 
-			me->tail = 0;
-		}
-	}
-    me->head++;
-	if (me->head == me->size) { 
-		me->head = 0;
-	}
-    size_t is_full = me->head == me->tail ? 1 : 0;
-	me->is_full = is_full;
-}
-
-// -
-static void retreat_pointer(RingBuffer* me) {
-	me->is_full = 0;
-    me->tail++;
-	if (me->tail == me->size) { 
-		me->tail = 0;
-	}
-}
-
-void ring_buffer_write(RingBuffer* buffer, float* data, size_t count) {
-    if (buffer->is_full || buffer->head + count > buffer->size) {
-        write_log("[WARN] Trying to overfill the ring buffer: \n\tIsFull:%d\n\tHead:%zu\n\tCount:%zu\n\t", 
-            buffer->is_full,
-            buffer->head, 
-            count);
-        return;
-    }
-    buffer->is_empty = 0;
-
-    for (size_t i = 0; i < count; i++) {
-        buffer->items[buffer->head] = data[i];
-        advance_pointer(buffer);
-    }
-    //me->is_empty = is_full && (me->head == me->tail);
-}
-
-int ring_buffer_read(RingBuffer* buffer, float* output, size_t count) {
-    if (buffer->is_empty) {
-        write_log("[WARN] Trying to read empty buffer");
-        return 0;
-    }
-
-    for (size_t i = 0; i < count; i++) {
-        output[i] = buffer->items[buffer->tail];
-        retreat_pointer(buffer);
-    }
-    buffer->is_empty = !buffer->is_full && (buffer->head == buffer->tail);
-    return 1;
-}
-
-size_t ring_buffer_size(RingBuffer* buffer) {
-	size_t size = buffer->size;
-	if(!buffer->is_full) {
-		if(buffer->head >= buffer->tail) {
-			size = (buffer->head - buffer->tail);
-		}
-		else {
-			size = (buffer->size + buffer->head - buffer->tail);
-		}
-	}
-
-	return size;
-}
-
-void ring_buffer_print(RingBuffer* me) {
-    write_log("[INFO] The ring buffer: \n\tIsFull:%d\n\tIsEmpty:%d\n\tHead:%zu\n\tTail:%zu\n\t", 
-                me->is_full, 
-                me->is_empty, 
-                me->head, 
-                me->tail);
-}
-
-
-//------------------------------------------------------------------------------------
-// General SynthSound
-//------------------------------------------------------------------------------------
-
-typedef struct SynthSound {
-    float* samples;
-    size_t sample_count;
-} SynthSound;
-
-// frees the original sounds
-SynthSound concat_sounds(SynthSound* sounds, size_t count) {
-    size_t total_count = 0;
-    for (size_t i = 0; i < count; i++) {
-        total_count += sounds[i].sample_count;
-    }
-    // array to hold the result
-    float* total = malloc(total_count * sizeof(float));
-
-    size_t current_count = 0;
-    for (size_t i = 0; i < count; i++) {
-        memcpy(total + current_count,
-            sounds[i].samples,
-            sounds[i].sample_count * sizeof(float));
-        current_count += sounds[i].sample_count;
-
-        free(sounds[i].samples);
-    }
-
-    SynthSound result = {
-        .samples = total,
-        .sample_count = total_count
-    };
-
-    return result;
-}
-
-//------------------------------------------------------------------------------------
-// Oscillator
-//------------------------------------------------------------------------------------
-
-typedef enum {
-    Sine,
-    Triangle,
-    Saw,
-    Square
-} OscillatorType;
-
-typedef struct OscillatorParameter {
-    OscillatorType osc;
-    float freq;
-} OscillatorParameter;
-
-typedef struct OscillatorParameterList {
-    OscillatorParameter* array;
-    size_t count;
-} OscillatorParameterList;
-
-typedef struct OscillatorGenerationParameter {
-    OscillatorParameterList oscillators;
-    float sample;
-} OscillatorGenerationParameter;
-
-static SynthSound get_init_samples(float duration) {
-    size_t sample_count = (size_t)(duration * SAMPLE_RATE);
-    float* samples = malloc(sizeof(float) * sample_count);
-
-    for (double i = 0.0; i < duration * SAMPLE_RATE; i++) {
-        samples[(int)i] = i;
-    }
-
-    SynthSound res = {
-        .samples = samples,
-        .sample_count = sample_count
-    };
-
-    return res;
-}
-
-static float pos(float hz, float x) {
-    return fmodf(hz * x / SAMPLE_RATE, 1);
-}
-
-float sineosc(float hz, float x) {
-    return sinf(x * (2.f * SYNTH_PI * hz / SAMPLE_RATE));
-}
-
-static float sign(float v) {
-    return (v > 0.0) ? 1.f : -1.f;
-}
-
-float squareosc(float hz, float x) {
-    return sign(sineosc(hz, x));
-}
-
-float triangleosc(float hz, float x) {
-    return 1.f - fabsf(pos(hz, x) - 0.5f) * 4.f;
-}
-
-float sawosc(float hz, float x) {
-    return pos(hz, x) * 2.f - 1.f;
-}
-
-float multiosc(OscillatorGenerationParameter param) {
-    float osc_sample = 0.f;
-    for (size_t i = 0; i < param.oscillators.count; i++) {
-        OscillatorParameter osc = param.oscillators.array[i];
-        switch (osc.osc) {
-            case Sine:
-                osc_sample += sineosc(osc.freq, param.sample);
-                break;
-            case Triangle:
-                osc_sample += triangleosc(osc.freq, param.sample);
-                break;
-            case Square:
-                osc_sample += squareosc(osc.freq, param.sample);
-                break;
-            case Saw:
-                osc_sample += sawosc(osc.freq, param.sample);
-                break;
-        }
-    }
-
-    return osc_sample;
-}
-
-static SynthSound freq(float duration, OscillatorParameterList osc) {
-    SynthSound samples = get_init_samples(duration);
-    // SynthSound attack = get_attack_samples();
-
-    float* output = malloc(sizeof(float) * samples.sample_count);
-    for (int i = 0; i < samples.sample_count; i++) {
-        float sample = samples.samples[i];
-        OscillatorGenerationParameter param = {
-            .oscillators = osc,
-            .sample = sample
-        };
-        output[i] = multiosc(param) * VOLUME;
-    }
-
-    // create attack and release
-    /*
-        let adsrLength = Seq.length output
-        let attackArray = attack |> Seq.take adsrLength
-        let release = Seq.rev attackArray
-    */
-    /*
-     todo: I will change the ADSR approach to an explicit ADSR module(with it's own state)
-    size_t adsr_length = samples.sample_count;
-    float *attackArray = NULL, *releaseArray = NULL;
-
-    if (adsr_length > 0) {
-        //todo: calloc
-        attackArray = malloc(sizeof(float) * adsr_length);
-        size_t attack_length = attack.sample_count < adsr_length
-                ? attack.sample_count
-                : adsr_length;
-        
-        memcpy(attackArray, attack.samples, attack_length);
-        //todo: calloc
-        releaseArray = malloc(sizeof(float) * adsr_length);
-        memcpy(releaseArray, attackArray, attack_length);
-        reverse_array(releaseArray, 0, adsr_length);
-    }
-    */
-
-    // if (samples.sample_count > 1024) {
-    //     samples.sample_count = 1024;
-    // }
-    // //todo: move to somewhere
-    // for (size_t i = 0; i < 1024; i++) {
-    //     synth_sound.samples[i] = 0.0f;
-    // }
-
-    // for (size_t i = 0; i < samples.sample_count; i++) {
-    //     synth_sound.samples[i] = output[i];
-    // }
-    // synth_sound.sample_count = samples.sample_count;
-
-
-    // return zipped array
-    SynthSound res = {
-        .samples = output,
-        .sample_count = samples.sample_count
-    };
-
-    return res;
-}
-
-/*
-static SynthSound get_attack_samples() {
-    float attack_time = 0.001 * ATTACK_MS;
-    size_t sample_count = (size_t)(attack_time * SAMPLE_RATE);
-    float* attack = malloc(sizeof(float) * sample_count);
-    float samples_to_rise = SAMPLE_RATE * attack_time;
-    float rising_delta = 1.0 / samples_to_rise;
-    float i = 0.0;
-
-    for (int j = 0; j < sample_count; j++) {
-        i += rising_delta;
-        attack[j] = fmin(i, 1.0);
-    }
-
-    SynthSound res = {
-        .samples = attack,
-        .sample_count = sample_count
-    };
-
-    return res;
-}
-*/
-
-//------------------------------------------------------------------------------------
-// Synth
-//------------------------------------------------------------------------------------
-
-static int get_semitone_shift_internal(char* root_note, char* target_note) {
-    char* pitch_classes[12] =
-        { "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B" };
-
-    // Extract the note number and pitch class for the root note
-    int root_note_num = (int)root_note[strlen(root_note) - 1] - '0';
-
-    char* root_pitch_class_str = malloc((strlen(root_note) - 1) * sizeof(char));
-    strncpy(root_pitch_class_str, root_note, strlen(root_note) - 1);
-
-    int root_pitch_class = -1;
-
-    for (int i = 0; i < 12; i++) {
-        if (strcmp(pitch_classes[i], root_pitch_class_str) == 0) {
-            root_pitch_class = i;
-            break;
-        }
-    }
-
-    free(root_pitch_class_str);
-
-    // Extract the note number and pitch class for the target note
-    int target_note_num = (int)target_note[strlen(target_note) - 1] - '0';
-
-    char* target_pitch_class_str =
-        malloc((strlen(target_note) - 1) * sizeof(char));
-    strncpy(target_pitch_class_str, target_note, strlen(target_note) - 1);
-
-    int target_pitch_class = -1;
-
-    for (int i = 0; i < 12; i++) {
-        if (strcmp(pitch_classes[i], target_pitch_class_str) == 0) {
-            target_pitch_class = i;
-            break;
-        }
-    }
-
-    free(target_pitch_class_str);
-
-    // Calculate the semitone shift using the formula
-    return (target_note_num - root_note_num) * 12 +
-        (target_pitch_class - root_pitch_class);
-}
-
-static float get_hz_by_semitone(int semitone) {
-    return PITCH_STANDARD * powf(powf(2.f, (1.f / 12.f)), semitone);
-}
-
-int get_semitone_shift(char* target_note) {
-    return get_semitone_shift_internal("A4", target_note);
-}
-
-SynthSound note(int semitone, float beats) {
-    float hz = get_hz_by_semitone(semitone);
-    float duration = beats * BEAT_DURATION;
-
-    OscillatorParameter first = {
-        .osc = Square,
-        .freq = hz
-    };
-
-    OscillatorParameter second = {
-        .osc = Saw,
-        .freq = hz + 0.5
-    };
-
-    OscillatorParameter third = {
-        .osc = Saw,
-        .freq = hz - 1.f
-    };
-
-    OscillatorParameter oscArray[] = { first/*, second, third */};
-    OscillatorParameterList parameters = {
-        .array = oscArray,
-        .count = 1
-    };
-
-    return freq(duration, parameters);
-}
-
-SynthSound get_note_sound(Note input) {
-    float length = 1.f / input.length;
-    int semitone_shift = get_semitone_shift(input.name);
-    return note(semitone_shift, length);
-}
-
-
-//------------------------------------------------------------------------------------
-// Wav File 
-//------------------------------------------------------------------------------------
-
-static uint16_t toInt16Sample(float sample) {
-    return (uint16_t)(sample * 32767.f);
-}
-
-static void write_file(char* filename, void* data, int size) {
-    FILE* fp = fopen(filename, "wb");  // open file for writing in binary mode
-    if (fp == NULL) {
-        fprintf(stderr, "Cannot open file: %s\n", filename);
-        exit(1);
-    }
-
-    fwrite(data, size, 1, fp);  // write data to file
-
-    fclose(fp);  // close file
-}
-
-void pack(uint16_t* d, size_t length) {
-    size_t dataLength = length * 2;
-
-    int bytesPerSample = 2;
-    int byteRate = SAMPLE_RATE * bytesPerSample;
-
-    size_t fileSize = 36 + dataLength;
-
-    uint8_t* buffer = (uint8_t*)malloc(fileSize);
-
-    int i = 0;
-
-    // RIFF header
-    memcpy(buffer + i, "RIFF", 4);
-    i += 4;
-    memcpy(buffer + i, &fileSize, 4);
-    i += 4;
-    memcpy(buffer + i, "WAVE", 4);
-    i += 4;
-
-    // fmt subchunk
-    memcpy(buffer + i, "fmt ", 4);
-    i += 4;
-    int fmtSize = 16;
-    memcpy(buffer + i, &fmtSize, 4);
-    i += 4;
-    uint16_t audioFormat = 1;
-    memcpy(buffer + i, &audioFormat, 2);
-    i += 2;
-    uint16_t numChannels = 1;
-    memcpy(buffer + i, &numChannels, 2);
-    i += 2;
-    int sampleRate = (int)SAMPLE_RATE;
-    memcpy(buffer + i, &sampleRate, 4);
-    i += 4;
-    memcpy(buffer + i, &byteRate, 4);
-    i += 4;
-    memcpy(buffer + i, &bytesPerSample, 2);
-    i += 2;
-    int bitsPerSample = bytesPerSample * 8;
-    memcpy(buffer + i, &bitsPerSample, 2);
-    i += 2;
-
-    // data subchunk
-    memcpy(buffer + i, "data", 4);
-    i += 4;
-    memcpy(buffer + i, &dataLength, 4);
-    i += 4;
-    memcpy(buffer + i, d, dataLength);
-
-    write_file("output.wav", buffer, fileSize);
-}
-
-size_t detect_note_pressed(Note* note) {
-    size_t is_pressed = 0;
-    note->length = 8;
-    if (IsKeyPressed(KEY_A)) {
-        strcpy(note->name, "A4");
-        is_pressed = 1;
-    }
-    if (IsKeyPressed(KEY_B)) {
-        strcpy(note->name, "B4");
-        is_pressed = 1;
-    }
-    if (IsKeyPressed(KEY_C)) {
-        strcpy(note->name, "C4");
-        is_pressed = 1;
-    }
-    if (IsKeyPressed(KEY_D)) {
-        strcpy(note->name, "D4");
-        is_pressed = 1;
-    }
-    if (IsKeyPressed(KEY_E)) {
-        strcpy(note->name, "E4");
-        is_pressed = 1;
-    }
-    if (IsKeyPressed(KEY_F)) {
-        strcpy(note->name, "F4");
-        is_pressed = 1;
-    }
-    if (IsKeyPressed(KEY_G)) {
-        strcpy(note->name, "G4");
-        is_pressed = 1;
-    }
-    return is_pressed;
-}
-
-//------------------------------------------------------------------------------------
-// UI
-//------------------------------------------------------------------------------------
-/*
-int get_zero_crossing(SynthSound* sound) {
-    int zero_crossing_index = 0;
-    for (size_t i = 1; i < sound->sample_count; i++)
-    {
-        if (sound->samples[i] >= 0.0f && sound->samples[i-1] < 0.0f) // zero-crossing
-        {
-            zero_crossing_index = i;
-            break;
-        }
-    }
-    return zero_crossing_index;
-}
-
-Vector2* GetVisualSignal(SynthSound* sound, int zero_crossing_index)
-{
-    const int signal_amp = 300;
-    
-    Vector2* signal_points = malloc(sizeof(Vector2) * STREAM_BUFFER_SIZE);
-    
-    const float screen_vertical_midpoint = (WINDOW_HEIGHT/2);
-    for (size_t point_idx = 0; point_idx < sound->sample_count; point_idx++)
-    {
-        const int signal_idx = (point_idx + zero_crossing_index) % STREAM_BUFFER_SIZE;
-        signal_points[point_idx].x = (float)point_idx + WINDOW_WIDTH;
-        signal_points[point_idx].y = screen_vertical_midpoint + (int)(sound->samples[signal_idx] * 300);
-    }
-
-    return signal_points;
-}
-
-*/
-
-//------------------------------------------------------------------------------------
-// Main
-//------------------------------------------------------------------------------------
-
-int main(int argc, char **argv) {
-    InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SeeSynth - v0.1");
-    SetTargetFPS(60);
-
-    Note current_note = {
-        .length = 1,
-        .name = malloc(sizeof(char) * 3)
-    };
-
-    SynthSound sound = {
-        .sample_count = 0
-    };
-    int sound_played_count = 0;
-    float temp_buffer[STREAM_BUFFER_SIZE];
-    RingBuffer ring_buffer = ring_buffer_init(STREAM_BUFFER_SIZE);
-
-
-    InitAudioDevice();
-    SetMasterVolume(SYNTH_VOLUME);
-    SetAudioStreamBufferSizeDefault(STREAM_BUFFER_SIZE);
-    AudioStream synth_stream = LoadAudioStream(SAMPLE_RATE, sizeof(float) * 8, 1);//float*8
-    SetAudioStreamVolume(synth_stream, 0.5f);
-
-    PlayAudioStream(synth_stream);
-    
-    // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
-    {
-        // Update Audio states
-        //----------------------------------------------------------------------------------
-        // Fill ring buffer from current sound
-        size_t size_for_buffer = 0;
-        if (!ring_buffer.is_full && sound.sample_count != sound_played_count) {
-            write_log("[INFO] IsFull:%d Samples:%zu Played:%zu\n", 
-                ring_buffer.is_full, 
-                sound.sample_count, 
-                sound_played_count);
-            
-            // how many samples need write
-            size_t size_to_fill = 0;
-            
-            if ((sound.sample_count - sound_played_count) > ring_buffer.size) {
-                size_to_fill = ring_buffer.size;
-            } else {
-                size_to_fill = sound.sample_count - sound_played_count;
-            }
-
-            write_log("[INFO] SizeToFill:%zu\n", size_to_fill);
-            for (size_t i = 0; i < size_to_fill; i++) {
-                temp_buffer[i] = sound.samples[i];
-            }
-            
-            ring_buffer_write(&ring_buffer, temp_buffer, size_to_fill);
-            sound_played_count += size_to_fill;
-        }
-
-        // Play ring-buffered audio
-        if (IsAudioStreamProcessed(synth_stream) && !ring_buffer.is_empty) {
-                size_t size_to_read = ring_buffer_size(&ring_buffer);
-                
-                write_log("Samples to play:%zu \n", size_to_read);
-                //todo: try to start reading directly from ring buffer, avoiding temp_buffer
-                ring_buffer_read(&ring_buffer, temp_buffer, size_to_read);
-                // can try the SetAudioStreamCallback
-                UpdateAudioStream(synth_stream, temp_buffer, size_to_read);
-                // can overwrite the ring buffer to avoid that
-                if (sound.sample_count == sound_played_count) {
-                    ring_buffer_reset(&ring_buffer);
-                }
-        }
-        //----------------------------------------------------------------------------------
-        
-        // Update On Input
-        //----------------------------------------------------------------------------------
-        if (detect_note_pressed(&current_note)) {
-            sound = get_note_sound(current_note);
-            sound_played_count = 0;
-            write_log("Note played: %s\n", current_note.name);
-        }
-        //----------------------------------------------------------------------------------
- 
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
- 
-            ClearBackground(RAYWHITE);
-            // int zero_crossing = get_zero_crossing(&sound);
-            // Vector2* visual_signal = GetVisualSignal(&sound, zero_crossing);
-            // DrawLineStrip(visual_signal, STREAM_BUFFER_SIZE - zero_crossing, RED);
- 
-            DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
-            DrawFPS(0,0);
- 
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-    
-    char* input = "A4-4 A4-4 A4-4 A4-4 A4-2 A4-4 A4-4 A4-4 A4-4 A4-4 A4-2 D5-4 D5-4 D5-4 D5-4 D5-4 D5-4 D5-2 C5-4 C5-4 C5-4 C5-4 C5-4 C5-4 C5-2 G4-2 ";
-    char* buf = malloc(strlen(input) + 1);
-    strcpy(buf, input);
-
-    NoteArray note_array = parse_notes(buf, strlen(buf));
-    SynthSound* sounds = malloc(sizeof(SynthSound) * note_array.count);
-    for (size_t i = 0; i < note_array.count; i++) {
-        Note note = note_array.notes[i];
-        sounds[i] = get_note_sound(note);
-    }
-
-    SynthSound song = concat_sounds(sounds, note_array.count);
-    uint16_t* song_pcm = malloc(sizeof(uint16_t) * song.sample_count);
-    for (size_t i = 0; i < song.sample_count; i++) {
-        song_pcm[i] = toInt16Sample(song.samples[i]);
-    }
-
-    pack(song_pcm, song.sample_count);
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    StopAudioStream(synth_stream);
-    UnloadAudioStream(synth_stream);    
-    CloseAudioDevice();
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}

parser.c

@@ -1,94 +0,0 @@
-#include "parser.h"
-#include "string.h"
-#include "stdio.h"
-
-struct StringArray {
-    char** array;
-    size_t count;
-};
-
-static void trim(char* str) {
-    size_t len = strlen(str);
-    while (len > 0 && (str[len - 1] == '\n' || str[len - 1] == ' ')) {
-        str[--len] = '\0';
-    }
-}
-
-static struct StringArray parse_note_parts(char* input) {
-    size_t count = 0;
-    size_t i = 0;
-    while (input[i] != '\0') {
-        if (input[i] == ' ')
-            count++;
-
-        i++;
-    }
-
-    char** array = malloc(sizeof(char*) * count);
-
-    char* sep = " ";
-    char* line = strtok(input, sep);
-    i = 0;
-    while (line != NULL) {
-        array[i] = strdup(line);
-        line = strtok(NULL, sep);
-        i++;
-    }
-
-    struct StringArray result = {
-        .array = array,
-        .count = count
-    };
-
-    return result;
-}
-
-NoteArray parse_notes(char* input, size_t len) {
-    struct StringArray note_strings = parse_note_parts(input);
-    
-    NoteArray notes;
-    notes.count = note_strings.count;
-
-    char* end;
-    for (size_t i = 0; i < note_strings.count; i++) {
-        char* line = note_strings.array[i];
-        trim(line);
-        
-        char* note_name = strtok(line, "-");
-        char* note_length_str = strtok(NULL, "-");
-
-        int note_length = strtol(note_length_str, &end, 10);
-        if (*end != '\0') {
-            fprintf(stderr,
-                "Failed to parse note length: %s\n", note_length_str);
-            return notes;
-        }
-        
-        char* buf = malloc(strlen(note_name) + 1);
-        strcpy(buf, note_name);
-        
-        Note note = {
-            .length = note_length,
-            .name = buf
-        };
-
-        notes.notes[i] = note;
-    }
-
-    return notes;
-}
-
-/*
-static int test(int argc, char **argv) {
-    char* input = "A4-4 A4-2 C5-8 C5-4 ";
-    char* buf = malloc(strlen(input) + 1);
-    strcpy(buf, input);
-
-    NoteArray note_array = parse_notes(buf, strlen(buf));
-    for (size_t i = 0; i < note_array.count; i++) {
-        Note note = note_array.notes[i];
-    }
-
-    return 0;
-}
-*/

parser.h

@@ -1,20 +0,0 @@
-#ifndef PARSER_H
-#define PARSER_H
-
-#include "stdlib.h"
-
-#define MAX_NOTES 1024
-
-typedef struct Note {
-    char* name;
-    int length;
-} Note;
-
-typedef struct NoteArray {
-    Note notes[MAX_NOTES];
-    size_t count;
-} NoteArray;
-
-NoteArray parse_notes(char* input, size_t len);
-
-#endif

src/ADSR.cpp

@@ -0,0 +1,97 @@
+#include "ADSR.h"
+#include "Logger.h"
+#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_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::is_decay_elapsed() {
+    return m_state == Decay && m_ramp->IsCompleted();
+}
+
+bool ADSR::is_release_elapsed() {
+    return m_state == Release && m_ramp->IsCompleted();
+}
+
+void ADSR::recheck_state() {
+    switch (m_state) {
+        case Attack:
+            if (is_attack_elapsed()) {
+                m_state = Decay;
+                m_ramp->RampTo(m_parameters.sustain_level,
+                               m_parameters.decay_time);
+            }
+            break;
+        case Decay:
+            if (is_decay_elapsed()) {
+                m_state = Sustain;
+            }
+            break;
+        case Release:
+            if (is_release_elapsed()) {
+                m_state = Off;
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+void ADSR::process_sample(float* sample) {
+    if (m_state == Off) {
+        (*sample) = 0;
+    } else if (m_state == Attack) {
+        (*sample) = (*sample) * m_ramp->Process();
+    } else if (m_state == Decay) {
+        (*sample) = (*sample) * m_ramp->Process();
+    } else if (m_state == Sustain) {
+        (*sample) = (*sample) * m_parameters.sustain_level;
+    } else if (m_state == Release) {
+        (*sample) = (*sample) * m_ramp->Process();
+    }
+}
+
+void ADSR::OnSetNote() {
+    write_log("Set ADSR\n");
+    if (m_state == Off) {
+        m_state = Attack;
+    } else if (m_state == Release) {
+        m_state = Attack;
+    };
+
+    m_ramp->RampTo(1, m_parameters.attack_time);
+}
+
+void ADSR::OnUnsetNote() {
+    write_log("Unset ADSR\n");
+    m_state = Release;
+    m_ramp->RampTo(0, m_parameters.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]);
+    }
+}
+
+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;
+}

src/Application.cpp

@@ -0,0 +1,131 @@
+#include "Application.h"
+#include "Logger.h"
+#include "Settings.h"
+#include <string>
+
+Application::Application(/* args */) {
+    init_synth();
+    init_audio();
+}
+
+Application::~Application() {
+    StopAudioStream(m_synth_stream);
+    UnloadAudioStream(m_synth_stream);
+    CloseAudioDevice();
+    CloseWindow();
+    // todo: move to gui state class destructor (make it a class)
+    for (int i = 0; i < m_synth_gui_state.oscillators.size(); i++) {
+        delete m_synth_gui_state.oscillators[i];
+    }
+}
+
+void Application::init_audio() {
+    m_sound_played_count = 0;
+
+    InitAudioDevice();
+    SetMasterVolume(SYNTH_VOLUME);
+    SetAudioStreamBufferSizeDefault(STREAM_BUFFER_SIZE);
+    m_synth_stream = LoadAudioStream(SAMPLE_RATE, sizeof(float) * 8, 1);
+    SetAudioStreamVolume(m_synth_stream, 0.5f);
+
+    PlayAudioStream(m_synth_stream);
+}
+
+void Application::init_synth() {
+    // todo: move that variables to Synth declaration
+    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++) {
+        Oscillator* osc = oscillators[i];
+        assert(osc);
+
+        OscillatorGuiState* ui =
+            new OscillatorGuiState{.freq = osc->GetFreq(),
+                                   .waveshape = osc->GetType(),
+                                   .volume = osc->GetVolume()};
+        m_synth_gui_state.oscillators.push_back(ui);
+    }
+}
+
+bool Application::detect_note_pressed(Note* note) {
+    std::size_t is_pressed = 0;
+    note->length = 8;
+    if (IsKeyDown(KEY_A)) {
+        note->name.assign("A2");
+        is_pressed = 1;
+    }
+    if (IsKeyDown(KEY_B)) {
+        note->name.assign("B2");
+        is_pressed = 1;
+    }
+    if (IsKeyDown(KEY_C)) {
+        note->name.assign("C2");
+        is_pressed = 1;
+    }
+    if (IsKeyDown(KEY_D)) {
+        note->name.assign("D2");
+        is_pressed = 1;
+    }
+    if (IsKeyDown(KEY_E)) {
+        note->name.assign("E2");
+        is_pressed = 1;
+    }
+    if (IsKeyDown(KEY_F)) {
+        note->name.assign("F2");
+        is_pressed = 1;
+    }
+    if (IsKeyDown(KEY_G)) {
+        note->name.assign("G2");
+        is_pressed = 1;
+    }
+    return is_pressed == 1;
+}
+
+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);
+}
+
+// Update On Input
+void Application::update_on_note_input() {
+    if (detect_note_pressed(m_current_note)) {
+
+        if (!m_synth.GetIsNoteTriggered()) {
+            m_synth.TriggerNote((*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();
+    }
+    // will produce 0 signal if ADSR is in off state
+    m_synth.ProduceSound();
+}
+
+// Play ring-buffered audio
+void Application::play_buffered_audio() {
+    if (IsAudioStreamProcessed(m_synth_stream)) {
+        // const float audio_frame_start_time = GetTime();
+        update_on_note_input();
+        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();
+        m_renderer.Draw(m_synth, m_synth_gui_state);
+    }
+}

src/Oscillator.cpp

@@ -0,0 +1,92 @@
+#include "Oscillator.h"
+#include "Settings.h"
+
+#define TWO_PI 2 * SYNTH_PI
+
+Oscillator::Oscillator(OscillatorType osc, float freq, float volume) {
+    SetType(osc);
+    m_freq = freq;
+    m_volume = volume;
+}
+
+Oscillator::~Oscillator() {}
+
+void Oscillator::Reset() {
+    m_volume = 0;
+    m_phase = 0;
+    m_phase_dt = 0;
+}
+
+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;
+            break;
+        case Triangle:
+            m_osc_function = &Oscillator::triangleosc;
+            m_dt_function = &Oscillator::calc_saw_phase_delta;
+            break;
+        case Square:
+            m_osc_function = &Oscillator::squareosc;
+            m_dt_function = &Oscillator::calc_sine_phase_delta;
+            break;
+        case Saw:
+            m_osc_function = &Oscillator::sawosc;
+            m_dt_function = &Oscillator::calc_saw_phase_delta;
+            break;
+    }
+}
+
+void Oscillator::SetFreq(float freq) {
+    m_freq = freq;
+    m_phase = 0;
+    m_phase_dt = (this->*m_dt_function)(freq);
+}
+
+float Oscillator::GenerateSample(float duration) {
+    return (this->*m_osc_function)() * m_volume;
+}
+
+void Oscillator::sine_osc_phase_incr() {
+    m_phase += m_phase_dt;
+    if (m_phase >= TWO_PI)
+        m_phase -= TWO_PI;
+}
+
+void Oscillator::saw_osc_phase_incr() {
+    m_phase += m_phase_dt;
+    if (m_phase >= 1.0f)
+        m_phase -= 1.0f;
+}
+
+float Oscillator::calc_saw_phase_delta(float freq) {
+    return freq / SAMPLE_RATE;
+}
+
+float Oscillator::calc_sine_phase_delta(float freq) {
+    return (TWO_PI * freq) / SAMPLE_RATE;
+}
+
+float Oscillator::sineosc() {
+    float result = sinf(m_phase);
+    sine_osc_phase_incr();
+    return result;
+}
+
+float Oscillator::sign(float v) { return (v > 0.0) ? 1.f : -1.f; }
+
+float Oscillator::squareosc() { return sign(sineosc()); }
+
+float Oscillator::triangleosc() {
+    float result = 1.f - fabsf(m_phase - 0.5f) * 4.f;
+    saw_osc_phase_incr();
+    return result;
+}
+
+float Oscillator::sawosc() {
+    float result = m_phase * 2.f - 1.f;
+    saw_osc_phase_incr();
+    return result;
+}

src/Ramp.cpp

@@ -0,0 +1,27 @@
+#include "Ramp.h"
+#include "Logger.h"
+
+Ramp::Ramp(float starting_level, float sample_rate) {
+    m_level = starting_level;
+    m_sample_rate = sample_rate;
+}
+
+Ramp::~Ramp() {}
+
+void Ramp::RampTo(float val, float time) {
+    m_increment = (val - m_level) / (m_sample_rate * time);
+    m_counter = (int)(m_sample_rate * time);
+    write_log("Ramping from: %.1f to: %.1f by: %lf for: %d\n", m_level, val,
+              m_increment, m_counter);
+}
+
+float Ramp::Process() {
+    if (m_counter > 0) {
+        m_counter--;
+        m_level += m_increment;
+    }
+
+    return m_level;
+}
+
+bool Ramp::IsCompleted() { return m_counter == 0; }

src/Renderer.cpp

@@ -0,0 +1,245 @@
+#include "Renderer.h"
+#define RAYGUI_IMPLEMENTATION
+#include "Logger.h"
+#include "Settings.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-but-set-variable"
+#pragma clang diagnostic ignored "-Wunused-variable"
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#include "raygui.h"
+#pragma clang diagnostic pop
+
+Renderer::Renderer(/* args */) {
+    InitWindow(WINDOW_WIDTH, WINDOW_HEIGHT, "SeeSynth - v0.2");
+    SetTargetFPS(FPS);
+}
+
+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();
+}
+
+void Renderer::draw_signal(Synth& synth, SynthGuiState& synth_gui) {
+    GuiGrid((Rectangle){0, 0, WINDOW_WIDTH, WINDOW_HEIGHT}, "",
+            WINDOW_HEIGHT / 8, 2);
+    auto signal = synth.GetOutSignal();
+    Vector2* signal_points = new Vector2[signal.size()];
+    const float screen_vertical_midpoint = (WINDOW_HEIGHT / 2);
+    for (int point_idx = 0; point_idx < signal.size(); point_idx++) {
+        signal_points[point_idx].x = (float)point_idx + OSCILLATOR_PANEL_WIDTH;
+        signal_points[point_idx].y =
+            screen_vertical_midpoint + (int)(signal[point_idx] * 300);
+    }
+    DrawLineStrip(signal_points, signal.size(), RED);
+    delete[] signal_points;
+}
+
+void Renderer::draw_oscillators_shape_inputs(
+    const std::vector<Oscillator*>& oscillators,
+    const std::vector<OscillatorGuiState*>& gui_oscillators) {
+#define WAVE_SHAPE_OPTIONS "Sine;Triangle;Sawtooth;Square"
+
+    // DRAW OSCILLATOR SHAPE INPUTS
+    for (int i = 0; i < oscillators.size(); i += 1) {
+        OscillatorGuiState* ui_osc = gui_oscillators[i];
+        assert(ui_osc);
+
+        Oscillator* osc = oscillators[i];
+        assert(osc);
+
+        // Shape select
+        int shape_index = (int)(ui_osc->waveshape);
+        bool is_dropdown_click =
+            GuiDropdownBox(ui_osc->shape_dropdown_rect, WAVE_SHAPE_OPTIONS,
+                           &shape_index, ui_osc->is_dropdown_open);
+
+        if (is_dropdown_click) {
+            write_log("Dropdown clicked!\n");
+            ui_osc->is_dropdown_open = !ui_osc->is_dropdown_open;
+            ui_osc->waveshape = (OscillatorType)(shape_index);
+            // APPLY STATE TO REAL OSC
+            osc->SetType(ui_osc->waveshape);
+        }
+        if (ui_osc->is_dropdown_open)
+            break;
+    }
+}
+
+float Renderer::draw_oscillators_panels(
+    const std::vector<Oscillator*>& oscillators,
+    const std::vector<OscillatorGuiState*>& gui_oscillators,
+    const Rectangle& panel_bounds) {
+    float panel_y_offset = 0;
+    for (int i = 0; i < oscillators.size(); i++) {
+        OscillatorGuiState* ui_osc = gui_oscillators[i];
+        assert(ui_osc);
+
+        Oscillator* osc = oscillators[i];
+        assert(osc);
+
+        const bool has_shape_param = (ui_osc->waveshape == Square);
+
+        // 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_x = panel_bounds.x + 10;
+        const int osc_panel_y = panel_bounds.y + 50 + panel_y_offset;
+        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},
+                 "");
+
+        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};
+
+        // Volume slider
+        float decibels = (20.f * log10f(osc->GetVolume()));
+        char amp_slider_label[32];
+        snprintf(amp_slider_label, 7, "%.1f dB", decibels);
+        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;
+
+        // 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;
+        }
+    }
+
+    return panel_y_offset;
+}
+
+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) {
+    // Draw ADSR Panel
+    const int osc_panel_width = panel_bounds.width - 20;
+    const int osc_panel_height = 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;
+    GuiPanel((Rectangle){(float)osc_panel_x, (float)osc_panel_y,
+                         (float)osc_panel_width, (float)osc_panel_height},
+             "ADSR");
+
+    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};
+
+    // Attack slider
+    float attack = gui_adsr.attack;
+    char attack_slider_label[32];
+    snprintf(attack_slider_label, 7, "%.1f s", attack);
+    attack = GuiSlider(el_rect, attack_slider_label, "", attack, 0.0f, 2.0f);
+    gui_adsr.attack = attack;
+    el_rect.y += el_rect.height + el_spacing;
+
+    // Decay slider
+    float decay = gui_adsr.decay;
+    char decay_slider_label[32];
+    snprintf(decay_slider_label, 7, "%.1f s", decay);
+    decay = GuiSlider(el_rect, decay_slider_label, "", decay, 0.0f, 1.0f);
+    gui_adsr.decay = decay;
+    el_rect.y += el_rect.height + el_spacing;
+
+    // Sustain slider
+    float sustain = gui_adsr.sustain;
+    char sustain_slider_label[32];
+    snprintf(sustain_slider_label, 7, "%.1f u", sustain);
+    sustain = GuiSlider(el_rect, sustain_slider_label, "", sustain, 0.0f, 1.0f);
+    gui_adsr.sustain = sustain;
+    el_rect.y += el_rect.height + el_spacing;
+
+    // Release slider
+    float release = gui_adsr.release;
+    char release_slider_label[32];
+    snprintf(release_slider_label, 7, "%.1f s", release);
+    release = GuiSlider(el_rect, release_slider_label, "", release, 0.0f, 5.0f);
+    gui_adsr.release = release;
+    el_rect.y += el_rect.height + el_spacing;
+
+    // apply values to real one
+    adsr->SetParameters(gui_adsr.attack, gui_adsr.decay, gui_adsr.sustain,
+                        gui_adsr.release);
+}

src/SeeSynth.cpp

@@ -0,0 +1,8 @@
+#include "Application.h"
+
+int main() {
+    Application* app = new Application();
+    app->Run();
+
+    delete app;
+}

src/Synth.cpp

@@ -0,0 +1,83 @@
+#include "Synth.h"
+#include "ADSR.h"
+#include "KeyBoard.h"
+#include "Logger.h"
+#include "OscillatorType.h"
+#include "Settings.h"
+
+Synth::Synth(/* args */) {
+    AddOscillator();
+    AddEffect(new ADSR());
+    for (size_t i = 0; i < STREAM_BUFFER_SIZE; i++) {
+        float sample = 0.0f;
+        m_out_signal.push_back(sample);
+    }
+    zero_signal();
+}
+
+Synth::~Synth() {
+    m_oscillators.clear();
+    m_effects.clear();
+    m_out_signal.clear();
+}
+
+void Synth::zero_signal() {
+    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();
+    Adder::SumOscillators(m_oscillators, m_out_signal);
+}
+
+void Synth::apply_effects() {
+    for (Effect* effect : m_effects) {
+        effect->Process(m_out_signal);
+    }
+}
+
+void Synth::trigger_note_on_effects() {
+    for (Effect* effect : m_effects) {
+        effect->OnSetNote();
+    }
+}
+
+void Synth::untrigger_note_on_effects() {
+    for (Effect* effect : m_effects) {
+        effect->OnUnsetNote();
+    }
+}
+
+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));
+}
+
+void Synth::AddEffect(Effect* fx) { m_effects.push_back(fx); }