Rename to Filter

src/Sound/Chunk.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../Types.hpp"
-#include "./EffectNode.hpp"
+#include "./Filter.hpp"
 #include "./Sound.hpp"
 
 namespace Dynamo::Sound {
@@ -30,10 +30,10 @@ namespace Dynamo::Sound {
         std::reference_wrapper<Sound> sound;
 
         /**
-         * @brief Reference to the audio processing effect graph.
+         * @brief Reference to the audio processing filter graph.
          *
          */
-        std::reference_wrapper<EffectNode> effect;
+        std::reference_wrapper<Filter> filter;
 
         /**
          * @brief Frame offset of the chunk.

src/Sound/Filter.cpp

@@ -0,0 +1,61 @@
+#include "./Filter.hpp"
+
+namespace Dynamo::Sound {
+    b8 Filter::has_cycles() {
+        std::unordered_set<Filter *> visited;
+        std::vector<std::reference_wrapper<Filter>> stack;
+
+        stack.push_back(*this);
+        while (!stack.empty()) {
+            Filter &node = stack.back();
+            stack.pop_back();
+            if (visited.count(&node) > 0) {
+                return true;
+            }
+            for (Filter &child : node._dependencies) {
+                stack.push_back(child);
+            }
+            visited.insert(&node);
+        }
+        return false;
+    }
+
+    void Filter::connect(Filter &destination) {
+        _dependencies.push_back(destination);
+        if (has_cycles()) {
+            Log::error("Jukebox Filter graph disallows cycles.");
+        }
+    }
+
+    void Filter::disconnect(Filter &node) {
+        auto it = _dependencies.begin();
+        while (it != _dependencies.end()) {
+            Filter &curr = *it;
+            if (&curr == &node) {
+                it = _dependencies.erase(it);
+                return;
+            } else {
+                it++;
+            }
+        }
+        Log::error("Jukebox Filter graph attempted to disconnect a "
+                   "non-existent node.");
+    }
+
+    void Filter::disconnect() { _dependencies.clear(); }
+
+    const std::vector<std::reference_wrapper<Filter>> &
+    Filter::get_dependencies() const {
+        return _dependencies;
+    }
+
+    Sound &Filter::get_output() { return _output; }
+
+    Sound &run_filter(Filter &filter,
+                      Sound &src,
+                      u32 offset,
+                      u32 length,
+                      ListenerSet &listeners) {
+        return src;
+    }
+} // namespace Dynamo::Sound

src/Sound/Filter.hpp

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <functional>
+#include <unordered_set>
+#include <vector>
+
+#include "../Types.hpp"
+#include "./Listener.hpp"
+#include "./Sound.hpp"
+
+namespace Dynamo::Sound {
+    /**
+     * @brief Filter node in a signal processing graph.
+     *
+     */
+    class Filter {
+        Sound _output;
+        std::vector<std::reference_wrapper<Filter>> _dependencies;
+
+      private:
+        /**
+         * @brief Test if the graph has cycles.
+         *
+         * @return b8
+         */
+        b8 has_cycles();
+
+      public:
+        /**
+         * @brief Destroy the Filter object.
+         *
+         */
+        virtual ~Filter() = default;
+
+        /**
+         * @brief Connect a dependency.
+         *
+         * The resulting graph must not result in a cycle.
+         *
+         * @param node
+         */
+        void connect(Filter &node);
+
+        /**
+         * @brief Disconnect all dependencies.
+         *
+         */
+        void disconnect();
+
+        /**
+         * @brief Disconnect a dependency.
+         *
+         * @param node
+         */
+        void disconnect(Filter &node);
+
+        /**
+         * @brief Get the immutable list of dependencies.
+         *
+         * @return const std::vector<std::reference_wrapper<Filter>>&
+         */
+        const std::vector<std::reference_wrapper<Filter>> &
+        get_dependencies() const;
+
+        /**
+         * @brief Get the output sound buffer.
+         *
+         * @return Sound&
+         */
+        Sound &get_output();
+
+        /**
+         * @brief Transform a Sound.
+         *
+         * @param src
+         * @param length
+         * @param listeners
+         */
+        virtual void transform(Sound &src,
+                               u32 offset,
+                               u32 length,
+                               ListenerSet &listeners) = 0;
+    };
+
+    /**
+     * @brief Traverse the filter graph and process the sound.
+     *
+     * @param filter
+     * @param src
+     * @param offset
+     * @param length
+     * @param listeners
+     * @return Sound&
+     */
+    Sound &run_filter(Filter &root,
+                      Sound &src,
+                      u32 offset,
+                      u32 length,
+                      ListenerSet &listeners);
+} // namespace Dynamo::Sound

src/Sound/Filters/Attenuation.cpp

@@ -14,20 +14,20 @@ namespace Dynamo::Sound {
         return (_cutoff_radius - distance) / (_cutoff_radius - _inner_radius);
     }
 
-    Sound &Attenuation::transform(Sound &src,
-                                  u32 offset,
-                                  u32 length,
-                                  ListenerSet &listeners) {
+    void Attenuation::transform(Sound &src,
+                                u32 offset,
+                                u32 length,
+                                ListenerSet &listeners) {
         ListenerProperties &listener = listeners.find_closest(position);
         f32 distance = (position - listener.position).length();
         f32 gain = linear(distance);
 
-        _output.resize(length, src.channels());
-        for (u32 c = 0; c < _output.channels(); c++) {
-            for (u32 f = 0; f < _output.frames(); f++) {
-                _output[c][f] = src[c][f + offset] * gain;
+        Sound &output = get_output();
+        output.resize(length, src.channels());
+        for (u32 c = 0; c < output.channels(); c++) {
+            for (u32 f = 0; f < output.frames(); f++) {
+                output[c][f] = src[c][f + offset] * gain;
             }
         }
-        return _output;
     }
 } // namespace Dynamo::Sound

src/Sound/Filters/Attenuation.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "../../Types.hpp"
-#include "../EffectNode.hpp"
+#include "../Filter.hpp"
 #include "../Sound.hpp"
 
 namespace Dynamo::Sound {
@@ -10,8 +10,7 @@ namespace Dynamo::Sound {
      * as it moves further away from the listener.
      *
      */
-    class Attenuation : public EffectNode {
-        Sound _output;
+    class Attenuation : public Filter {
         f32 _inner_radius;
         f32 _cutoff_radius;
 
@@ -38,9 +37,9 @@ namespace Dynamo::Sound {
          */
         Attenuation(f32 inner_radius, f32 cutoff_radius);
 
-        Sound &transform(Sound &src,
-                         u32 offset,
-                         u32 length,
-                         ListenerSet &listeners) override;
+        void transform(Sound &src,
+                       u32 offset,
+                       u32 length,
+                       ListenerSet &listeners) override;
     };
 } // namespace Dynamo::Sound