Re-organize code and add base neuron class

src/abstractions/neuron.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#ifdef NEO_USE_STD_ATOMIC
+#include <atomic>
+#endif
+
+namespace neuron {
+
+    /**
+     * Describes a Neuron DSP component, capable of processing, or
+     * generating signals.
+     */
+    template<class N, typename P>
+    class Neuron {
+    public:
+        /**
+         * Frees any memory allocated by the processor.
+         */
+        ~Neuron() = default;
+
+#ifdef NEO_USE_STD_ATOMIC
+        /**
+         * Attach a source via an atomic pointer to a given parameter.
+         */
+        void AttachParameter(const P parameter, std::atomic<float>* source)
+        {
+            static_cast<N*>(this)->AttachParameterImpl(parameter, source);
+        }
+    };
+#endif
+
+}

src/audio/context.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cmath>
-
 namespace neuron {
 
     /**

src/generators/oscillator.cpp

@@ -25,6 +25,19 @@ Sample Oscillator::GenerateImpl()
     return SineToWaveform(value, m_waveform);
 }
 
+#ifdef NEO_USE_STD_ATOMIC
+void Oscillator::AttachParameterImpl(OscillatorParameter parameter, std::atomic<float>* source)
+{
+    switch (parameter) {
+        case OscillatorParameter::FREQUENCY:
+            p_frequency.AttachSource(source);
+            break;
+        default:
+            break;
+    }
+}
+#endif
+
 void Oscillator::Reset(float phase)
 {
     float clampedPhase = clamp(phase, 0.0f, (float)WAVETABLE_SIZE);
@@ -78,7 +91,7 @@ void Oscillator::IncrementPhase()
 
 Sample Oscillator::Lerp()
 {
-    size_t truncatedIdx = (size_t)m_phase;
+    size_t truncatedIdx = m_phase;
     size_t nextIdx = (truncatedIdx + 1) % WAVETABLE_SIZE;
     float nextIdxWeight = m_phase - (float)truncatedIdx;
     float truncatedIdxWeight = 1.0f - nextIdxWeight;

src/generators/oscillator.h

@@ -1,23 +1,24 @@
 #pragma once
 
-#include <cmath>
-
+#include "abstractions/generator.h"
+#include "abstractions/neuron.h"
+#include "abstractions/parameter.h"
 #include "audio/context.h"
-#include "audio/sample.h"
 #include "audio/waveform.h"
-#include "utilities/arithmetic.h"
-#include "utilities/generator.h"
-#include "utilities/parameter.h"
 
 namespace neuron {
 
     const size_t WAVETABLE_SIZE = 256;
 
+    enum class OscillatorParameter {
+        FREQUENCY,
+    };
+
     /**
      * The Oscillator class creates an audio signal
      * with a basic waveform.
      */
-    class Oscillator : public Generator<Oscillator> {
+    class Oscillator : public Generator<Oscillator>, public Neuron<Oscillator, OscillatorParameter> {
     public:
         /**
          * Creates an oscillator generator.
@@ -67,12 +68,15 @@ namespace neuron {
          */
         void DetachFollower();
 
-        Parameter<float> p_frequency;
-
     protected:
         friend class Generator<Oscillator>;
         Sample GenerateImpl();
 
+#ifdef NEO_USE_STD_ATOMIC
+        friend class Neuron<Oscillator, OscillatorParameter>;
+        void AttachParameterImpl(OscillatorParameter parameter, std::atomic<float>* source);
+#endif
+
     private:
         void PopulateWavetable();
         void IncrementPhase();
@@ -83,6 +87,8 @@ namespace neuron {
         Sample m_wavetable[WAVETABLE_SIZE];
         Waveform m_waveform;
 
+        Parameter<float> p_frequency;
+
         float m_phase = 0.0f;
         float m_phaseIncrement = 0.0f;
 

src/modulators/adsr.h

@@ -1,7 +1,7 @@
 #pragma once
 
+#include "abstractions/modulator.h"
 #include "audio/context.h"
-#include "utilities/modulator.h"
 
 namespace neuron {
 

src/neuron.h

@@ -8,6 +8,13 @@
 #ifndef NEURON_LIB_H
 #define NEURON_LIB_H
 
+// ABSTRACTIONS
+#include "abstractions/generator.h"
+#include "abstractions/modulator.h"
+#include "abstractions/neuron.h"
+#include "abstractions/parameter.h"
+#include "abstractions/processor.h"
+
 // AUDIO
 #include "audio/context.h"
 #include "audio/sample.h"
@@ -26,12 +33,8 @@
 
 // UTILITIES
 #include "utilities/arithmetic.h"
-#include "utilities/generator.h"
 #include "utilities/logger.h"
 #include "utilities/midi.h"
-#include "utilities/modulator.h"
-#include "utilities/parameter.h"
-#include "utilities/processor.h"
 #include "utilities/timer.h"
 
 #endif

src/processors/effects/saturator.cpp

@@ -1,4 +1,5 @@
 #include "processors/effects/saturator.h"
+#include "utilities/arithmetic.h"
 
 using namespace neuron;
 
@@ -18,6 +19,22 @@ Sample Saturator::ProcessImpl(Sample input)
     return clamp(output, -1.0f, 1.0f);
 }
 
+#ifdef NEO_USE_STD_ATOMIC
+void Saturator::AttachParameterImpl(SaturatorParameter parameter, std::atomic<float>* source)
+{
+    switch (parameter) {
+        case SaturatorParameter::SATURATION:
+            p_saturation.AttachSource(source);
+            break;
+        case SaturatorParameter::SYMMETRY:
+            p_symmetry.AttachSource(source);
+            break;
+        default:
+            break;
+    }
+}
+#endif
+
 void Saturator::SetSaturation(float saturation)
 {
     p_saturation = saturation < 1.0f ? 1.0f : saturation;

src/processors/effects/saturator.h

@@ -1,17 +1,22 @@
 #pragma once
 
+#include "abstractions/neuron.h"
+#include "abstractions/parameter.h"
+#include "abstractions/processor.h"
 #include "audio/sample.h"
-#include "utilities/arithmetic.h"
-#include "utilities/parameter.h"
-#include "utilities/processor.h"
 
 namespace neuron {
 
+    enum class SaturatorParameter {
+        SATURATION,
+        SYMMETRY,
+    };
+
     /**
      * The Saturator class applies a tape saturation
      * algorithm to audio signals.
      */
-    class Saturator : public Processor<Saturator> {
+    class Saturator : public Processor<Saturator>, public Neuron<Saturator, SaturatorParameter> {
     public:
         /**
          * Creates a default saturator processor.
@@ -51,6 +56,11 @@ namespace neuron {
     protected:
         friend class Processor<Saturator>;
         Sample ProcessImpl(Sample input);
+
+#ifdef NEO_USE_STD_ATOMIC
+        friend class Neuron<Saturator, SaturatorParameter>;
+        void AttachParameterImpl(SaturatorParameter parameter, std::atomic<float>* source);
     };
+#endif
 
 }

src/processors/effects/wavefolder.cpp

@@ -1,4 +1,5 @@
 #include "processors/effects/wavefolder.h"
+#include "utilities/arithmetic.h"
 
 using namespace neuron;
 
@@ -27,6 +28,25 @@ Sample Wavefolder::ProcessImpl(Sample input)
     return clamp(output, -1.0f, 1.0f);
 }
 
+#ifdef NEO_USE_STD_ATOMIC
+void Wavefolder::AttachParameterImpl(const WavefolderParameter parameter, std::atomic<float>* source)
+{
+    switch (parameter) {
+        case WavefolderParameter::INPUT_GAIN:
+            p_inputGain.AttachSource(source);
+            break;
+        case WavefolderParameter::THRESHOLD:
+            p_threshold.AttachSource(source);
+            break;
+        case WavefolderParameter::SYMMETRY:
+            p_symmetry.AttachSource(source);
+            break;
+        default:
+            break;
+    }
+}
+#endif
+
 void Wavefolder::SetInputGain(float gain)
 {
     p_inputGain = gain;

src/processors/effects/wavefolder.h

@@ -1,17 +1,22 @@
 #pragma once
 
-#include "audio/sample.h"
-#include "utilities/arithmetic.h"
-#include "utilities/parameter.h"
-#include "utilities/processor.h"
+#include "abstractions/neuron.h"
+#include "abstractions/parameter.h"
+#include "abstractions/processor.h"
 
 namespace neuron {
 
+    enum class WavefolderParameter {
+        INPUT_GAIN,
+        THRESHOLD,
+        SYMMETRY,
+    };
+
     /**
      * The Wavefolder class applies a wavefolding
      * algorithm to audio signals.
      */
-    class Wavefolder : public Processor<Wavefolder> {
+    class Wavefolder : public Processor<Wavefolder>, public Neuron<Wavefolder, WavefolderParameter> {
     public:
         /**
          * Creates a default wavefolder processor.
@@ -43,13 +48,19 @@ namespace neuron {
          */
         void SetSymmetry(float symmetry);
 
-        Parameter<float> p_inputGain;
-        Parameter<float> p_threshold;
-        Parameter<float> p_symmetry;
-
     protected:
         friend class Processor<Wavefolder>;
         Sample ProcessImpl(Sample input);
+
+#ifdef NEO_USE_STD_ATOMIC
+        friend class Neuron<Wavefolder, WavefolderParameter>;
+        void AttachParameterImpl(const WavefolderParameter parameter, std::atomic<float>* source);
+#endif
+
+    private:
+        Parameter<float> p_inputGain;
+        Parameter<float> p_threshold;
+        Parameter<float> p_symmetry;
     };
 
 }

src/processors/filters/filter.cpp

@@ -1,4 +1,5 @@
 #include "processors/filters/filter.h"
+#include "utilities/arithmetic.h"
 
 using namespace neuron;
 
@@ -17,6 +18,19 @@ Sample Filter::ProcessImpl(Sample input)
     return output;
 }
 
+#ifdef NEO_USE_STD_ATOMIC
+void Filter::AttachParameterImpl(FilterParameter parameter, std::atomic<float>* source)
+{
+    switch (parameter) {
+        case FilterParameter::CUTOFF_FREQUENCY:
+            p_cutoffFrequency.AttachSource(source);
+            break;
+        default:
+            break;
+    }
+}
+#endif
+
 void Filter::SetCutoffFrequency(float frequency)
 {
     p_cutoffFrequency = clamp(frequency, FILTER_CUTOFF_FREQ_MIN, FILTER_CUTOFF_FREQ_MAX);

src/processors/filters/filter.h

@@ -1,21 +1,25 @@
 #pragma once
 
+#include "abstractions/neuron.h"
+#include "abstractions/parameter.h"
+#include "abstractions/processor.h"
 #include "audio/context.h"
 #include "audio/sample.h"
-#include "utilities/arithmetic.h"
-#include "utilities/parameter.h"
-#include "utilities/processor.h"
 
 namespace neuron {
 
     const float FILTER_CUTOFF_FREQ_MIN = 20.0f;
     const float FILTER_CUTOFF_FREQ_MAX = 20000.0f;
 
+    enum class FilterParameter {
+        CUTOFF_FREQUENCY,
+    };
+
     /**
      * The Filter class applies a simple low-pass filter
      * to audio signals.
      */
-    class Filter : public Processor<Filter> {
+    class Filter : public Processor<Filter>, public Neuron<Filter, FilterParameter> {
     public:
         /**
          * Creates a filter processor.
@@ -40,6 +44,11 @@ namespace neuron {
         friend class Processor<Filter>;
         Sample ProcessImpl(Sample input);
 
+#ifdef NEO_USE_STD_ATOMIC
+        friend class Neuron<Filter, FilterParameter>;
+        void AttachParameterImpl(FilterParameter parameter, std::atomic<float>* source);
+#endif
+
     private:
         void CalculateAlpha();
 

src/utilities/midi.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cmath>
-
 #include "utilities/arithmetic.h"
 
 namespace neuron {

src/utilities/timer.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <chrono>
 
 #include "utilities/logger.h"