move sequencer into own module

src/main_perkons.cc

@@ -6,6 +6,7 @@
 #include "track.hh"
 #include "utils.hh"
 #include "midiclock.hh"
+#include "sequencer.hh"
 #include "instr_abstract.hh"
 #include "instr_kick.hh"
 #include "instr_noise.hh"
@@ -15,7 +16,6 @@
 namespace ld = daisy;
 namespace dsp = daisysp;
 
-
 namespace Heck {
     // =============================================================================================
     // INIT
@@ -33,92 +33,6 @@ namespace Heck {
     Instrument::Grainlet instrument3{};
 
     std::array<Track, Constants::TRACK_COUNT> tracks;
-
-    struct Sequencer {
-
-        Sequencer()
-        {
-            clear_sequence();
-        }
-
-        // its a MIDI CC step sequencer
-        constexpr static int MIDI_MAX = 127;
-        constexpr static int STEP_COUNT = 16;
-        constexpr static int TRACK_COUNT = 16;
-
-        using Step = std::array<int, MIDI_MAX>;
-        using Track = std::array<Step, STEP_COUNT>;
-        using Sequence = std::array<Track, TRACK_COUNT>;
-
-
-        void reset()
-        {
-            step_current = 0;
-        }
-
-        void next_step()
-        {
-            step_current++;
-            if (step_current >= STEP_COUNT) {
-                step_current = 0;
-            }
-        }
-
-        void clear_track(int track_nr)
-        {
-            for (int step = 0; step < STEP_COUNT; step++) {
-                for (int cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
-                    sequence[track_nr][step][cc_nr] = -1;
-                }
-            }
-        }
-
-        void clear_track_cc(int track_nr, int cc_nr)
-        {
-            for (int step = 0; step < STEP_COUNT; step++) {
-                sequence[track_nr][step][cc_nr] = -1;
-            }
-        }
-
-        void clear_sequence()
-        {
-            for (int track = 0; track < TRACK_COUNT; track++) {
-                clear_track(track);
-            }
-        }
-
-        void midi_in(ld::MidiEvent& msg)
-        {
-            if (recording) {
-                ld::ControlChangeEvent cc = msg.AsControlChange();
-                sequence[cc.channel][step_current][cc.control_number] = cc.value;
-            }
-        }
-
-        std::vector<ld::MidiEvent> midi_out()
-        {
-            std::vector<ld::MidiEvent> ret{};
-            for (int track = 0; track < TRACK_COUNT; track++) {
-                for (int cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
-                    int cc_val = sequence[track][step_current][cc_nr];
-                    if (cc_val != -1) {
-                        ld::MidiEvent ev{};
-                        ev.channel = track;
-                        ev.type = ld::ControlChange;
-                        ev.data[0] = cc_nr;
-                        ev.data[1] = cc_val;
-                        ret.push_back(ev);
-                    }
-                }
-            }
-            return ret;
-        }
-
-        int step_current{ 0 };
-        bool recording{ false };
-        Sequence sequence{};
-    };
-
     MidiClock clock{};
     Sequencer sequencer{};
 

src/sequencer.cc

@@ -0,0 +1,72 @@
+#include "sequencer.hh"
+
+namespace Heck {
+    Sequencer::Sequencer()
+    {
+        clear_sequence();
+    }
+
+    void Sequencer::reset()
+    {
+        step_current = 0;
+    }
+
+    void Sequencer::next_step()
+    {
+        step_current++;
+        if (step_current >= STEP_COUNT) {
+            step_current = 0;
+        }
+    }
+
+    void Sequencer::clear_track(int track_nr)
+    {
+        for (int step = 0; step < STEP_COUNT; step++) {
+            for (int cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
+                sequence[track_nr][step][cc_nr] = -1;
+            }
+        }
+    }
+
+    void Sequencer::clear_track_cc(int track_nr, int cc_nr)
+    {
+        for (int step = 0; step < STEP_COUNT; step++) {
+            sequence[track_nr][step][cc_nr] = -1;
+        }
+    }
+
+    void Sequencer::clear_sequence()
+    {
+        for (int track = 0; track < TRACK_COUNT; track++) {
+            clear_track(track);
+        }
+    }
+
+    void Sequencer::midi_in(ld::MidiEvent& msg)
+    {
+        if (recording) {
+            ld::ControlChangeEvent cc = msg.AsControlChange();
+            sequence[cc.channel][step_current][cc.control_number] = cc.value;
+        }
+    }
+
+    std::vector<ld::MidiEvent> Sequencer::midi_out()
+    {
+        std::vector<ld::MidiEvent> ret{};
+        for (int track = 0; track < TRACK_COUNT; track++) {
+            for (int cc_nr = 0; cc_nr < MIDI_MAX; cc_nr++) {
+                int cc_val = sequence[track][step_current][cc_nr];
+                if (cc_val != -1) {
+                    ld::MidiEvent ev{};
+                    ev.channel = track;
+                    ev.type = ld::ControlChange;
+                    ev.data[0] = cc_nr;
+                    ev.data[1] = cc_val;
+                    ret.push_back(ev);
+                }
+            }
+        }
+        return ret;
+    }
+
+} // namespace Heck

src/sequencer.hh

@@ -0,0 +1,35 @@
+#ifndef HECK_PERKONS_SEQUENCER_HH
+#define HECK_PERKONS_SEQUENCER_HH
+
+#include <vector>
+#include "daisy_seed.h"
+
+namespace ld = daisy;
+
+namespace Heck {
+    struct Sequencer {
+        // its a MIDI CC step sequencer
+        constexpr static int MIDI_MAX = 127;
+        constexpr static int STEP_COUNT = 16;
+        constexpr static int TRACK_COUNT = 16;
+
+        using Step = std::array<int, MIDI_MAX>;
+        using Track = std::array<Step, STEP_COUNT>;
+        using Sequence = std::array<Track, TRACK_COUNT>;
+
+        Sequencer();
+        void reset();
+        void next_step();
+        void clear_track(int track_nr);
+        void clear_track_cc(int track_nr, int cc_nr);
+        void clear_sequence();
+        void midi_in(ld::MidiEvent& msg);
+        std::vector<ld::MidiEvent> midi_out();
+
+        int step_current{ 0 };
+        bool recording{ false };
+        Sequence sequence{};
+    };
+} // namespace Heck
+
+#endif