Added abstract class for callback algorithms;

(Will be changed to function pointers)

Author: Retr0-code

src/matrix-sequencer.cpp

@@ -1,7 +1,7 @@
 #include "matrix-sequencer.hpp"
 
 
-Matrix_sequencer::Matrix_sequencer()
+Matrix_sequencer::Matrix_sequencer() : _current_step(0, 0, 0)
 {
 	{
 		config(PARAMS_LEN, INPUTS_LEN, OUTPUTS_LEN, LIGHTS_LEN);
@@ -35,35 +35,41 @@ Matrix_sequencer::Matrix_sequencer()
 		configOutput(TOTAL_PITCH_OUT_OUTPUT, "Sequence output");
 	}
 
-	_run = false;
 	_reset = false;
-	_current_step = X4_Y4_LIGHT_LIGHT;
 }
 
-void Matrix_sequencer::process(const ProcessArgs& args)
+
+inline uint8_t Matrix_sequencer::translateCoords()
 {
-	if (inputs[RUN_IN_INPUT].getVoltage())
-		_run = !_run;
+	return _current_step.x + (_current_step.y << 2);
+}
+
 
+void Matrix_sequencer::process(const ProcessArgs& args)
+{
 	// Reset sequencer
 	if (inputs[RESET_IN_INPUT].getVoltage())
 	{
-		lights[_current_step].setBrightness(0);
-		_current_step = X4_Y4_LIGHT_LIGHT;
+		lights[translateCoords()].setBrightness(0);
+		_current_step = {0, 0, 0};
 	}
 
 	// Process trigger clock
 	if (clockTrigger.process(inputs[CLOCK_IN_INPUT].getVoltage()))
 	{
 		// Turn off current light
-		lights[_current_step].setBrightness(0);
+		lights[translateCoords()].setBrightness(0);
+
+		//------------ Current Step = chosen callback algorithm ------------//
+		_current_step = static_cast<sequence_t>(SequnceAlgorithm_base(_current_step));
+		float param_voltage = params[translateCoords()].getValue();
 
-		// Switch light
-		_current_step++ ;
-		_current_step %= LIGHTS_LEN;
+		outputs[_current_step.y].setVoltage(param_voltage);
+		outputs[_current_step.x + 3].setVoltage(param_voltage);
+		outputs[TOTAL_PITCH_OUT_OUTPUT].setVoltage(param_voltage);
 
 		// Turn on new light
-		lights[_current_step].setBrightness(1);
+		lights[translateCoords()].setBrightness(1);
 	}
 }
 

src/matrix-sequencer.hpp

@@ -2,6 +2,7 @@
 #define MATRIX_SEQUNCER
 
 #include "plugin.hpp"
+#include "sequence_algorithm.hpp"
 
 struct Matrix_sequencer : Module {
 	enum ParamId {
@@ -68,12 +69,11 @@ struct Matrix_sequencer : Module {
 
     void process(const ProcessArgs& args) override;
 
-    void updateSequence();
+    inline uint8_t translateCoords();
 
 private:
-    bool _run;
     bool _reset;
-    uint8_t _current_step;
+    sequence_t _current_step;
     dsp::SchmittTrigger clockTrigger;
 };
 

src/sequence_algorithm.hpp

@@ -0,0 +1,51 @@
+#ifndef SEQUENCE_ALGORITHM
+#define SEQUENCE_ALGORITHM
+
+#include <iostream>
+
+struct sequence_t
+{
+    uint8_t x;
+    uint8_t y;
+    uint8_t round;
+    sequence_t(uint8_t _x, uint8_t _y, uint8_t _round) : x(_x), y(_y), round(_round) {}
+};
+
+
+struct SequnceAlgorithm_base : public sequence_t
+{
+    SequnceAlgorithm_base(sequence_t current_step) : sequence_t(current_step)
+    {
+        callback();
+    }
+
+    SequnceAlgorithm_base() = delete;
+
+    SequnceAlgorithm_base(const SequnceAlgorithm_base&) = delete;
+
+    SequnceAlgorithm_base(SequnceAlgorithm_base&&) = delete;
+
+
+private:
+    virtual void callback()
+    {
+        uint8_t* direction = reinterpret_cast<uint8_t*>((&this->x) + (round & 1));
+        uint8_t* shift = reinterpret_cast<uint8_t*>((&this->y) - (round & 1));
+
+        (*direction)++;
+
+        if ((*direction) > 3)
+        {
+            (*direction) = 0;
+            (*shift)++ ;
+        }
+            
+        if ((*shift) > 3)
+        {
+            (*shift) = 0;
+            this->round++ ;
+        }
+    };
+};
+
+#endif