modified: .gitignore

	modified:   src/matrix-sequencer.cpp
	modified:   src/matrix-sequencer.hpp
	modified:   src/sequence_algorithms.cpp
	modified:   src/sequence_algorithms.hpp

Author: Retr0-code

.gitignore

@@ -5,3 +5,4 @@
 /*.dylib
 /*.dll
 .DS_Store
+/.vscode

src/matrix-sequencer.cpp

@@ -4,6 +4,7 @@
 Matrix_sequencer::Matrix_sequencer() : _current_step(0, 0, 0), _run(true), _reset(false)
 {
 	_sequence_algorithms = {
+		new StraightSequence(),
 		new LeftRight_UpDown(),
 		new SpiralSequence()
 	};
@@ -43,6 +44,7 @@ Matrix_sequencer::Matrix_sequencer() : _current_step(0, 0, 0), _run(true), _rese
 	}
 
 	paramQuantities[ALGORITHM_KNOB_PARAM]->snapEnabled = true;
+	_algorithm_type = params[ALGORITHM_KNOB_PARAM].getValue();
 }
 
 
@@ -68,15 +70,26 @@ void Matrix_sequencer::process(const ProcessArgs& args)
 		_current_step = {0, 0, 0};
 	}
 
+	_algorithm_type = params[ALGORITHM_KNOB_PARAM].getValue();
+	if (inputs[ALGORITHM_FM_INPUT].isConnected())
+	{
+		_algorithm_type = std::ceil(inputs[ALGORITHM_FM_INPUT].getVoltage());
+
+		if (_algorithm_type >= _sequence_algorithms.size())
+			_algorithm_type = _sequence_algorithms.size() - 1;
+
+		if (_algorithm_type < 0)
+			_algorithm_type = 0;
+	}
+
 	// Process trigger clock
 	if (clockTrigger.process(inputs[CLOCK_IN_INPUT].getVoltage()))
 	{
 		// Turn off current light
 		lights[translateCoords()].setBrightness(0);
 
 		//------------ Current Step = chosen callback algorithm ------------//
-		// _current_step = static_cast<sequence_t>(SequnceAlgorithm_base(_current_step));
-		_sequence_algorithms.at(params[ALGORITHM_KNOB_PARAM].getValue())->callback(_current_step);
+		_sequence_algorithms.at(_algorithm_type)->callback(_current_step);
 		float param_voltage = params[translateCoords()].getValue();
 
 		outputs[_current_step.y].setVoltage(param_voltage);

src/matrix-sequencer.hpp

@@ -79,6 +79,7 @@ struct Matrix_sequencer : Module {
 private:
 	bool _run;
     bool _reset;
+	uint16_t _algorithm_type;
     sequence_t _current_step;
     dsp::SchmittTrigger clockTrigger;
 	std::vector<SequenceAlgorithm_base*> _sequence_algorithms;

src/sequence_algorithms.cpp

@@ -5,6 +5,24 @@ void SequenceAlgorithm_base::callback(sequence_t &current_step)
     throw std::runtime_error("Call of pure virtual function\n");
 }
 
+
+void StraightSequence::callback(sequence_t &current_step)
+{
+    current_step.x++;
+    if (current_step.x > 3)
+    {
+        current_step.x = 0;
+        current_step.y++ ;
+    }
+        
+    if (current_step.y > 3)
+    {
+        current_step.y = 0;
+        current_step.round++ ;
+    }
+}
+
+
 void LeftRight_UpDown::callback(sequence_t &current_step)
 {
     uint8_t* direction = reinterpret_cast<uint8_t*>((&current_step.x) + (current_step.round & 1));
@@ -27,16 +45,46 @@ void LeftRight_UpDown::callback(sequence_t &current_step)
 
 void SpiralSequence::callback(sequence_t &current_step)
 {
-    current_step.x++;
-    if (current_step.x > 3)
+    // Change to inner spiral
+    if ((current_step.y == (nearest + 1)) && (current_step.x == nearest))
     {
-        current_step.x = 0;
-        current_step.y++ ;
+        furthest--;
+        nearest++;
     }
-        
-    if (current_step.y > 3)
+	
+    // Down
+    if ((current_step.x == furthest) && (current_step.y < furthest))
     {
-        current_step.y = 0;
-        current_step.round++ ;
+        current_step.y++;
+        return;
+    }
+
+    // Right
+	if ((current_step.x < furthest) && (current_step.y == nearest))
+    {
+        current_step.x++;
+        return;
+    }
+
+    // Left
+	if ((current_step.y == furthest) && (current_step.x > nearest))
+    {
+        current_step.x--;
+        return;
+    }
+
+    // Up
+	if ((current_step.x == nearest) && (current_step.y > nearest))
+    {
+        current_step.y--;
+        return;
+    }
+
+    // Reset
+    else 
+    {
+        current_step = {0, 0, 0};
+        furthest = 3;
+        nearest = 0;
     }
 }

src/sequence_algorithms.hpp

@@ -18,16 +18,17 @@ struct sequence_t
 
 struct SequenceAlgorithm_base
 {
-    // SequenceAlgorithm_base() = default;
-
-    // SequenceAlgorithm_base(const SequenceAlgorithm_base&) = default;
-
-    // SequenceAlgorithm_base(SequenceAlgorithm_base&&) = default;
-
     // Override this function to implement own algorithm
     virtual void callback(sequence_t &current_step);
 };
 
+struct StraightSequence : public SequenceAlgorithm_base
+{
+    StraightSequence() = default;
+
+    void callback(sequence_t &current_step) override;
+};
+
 struct LeftRight_UpDown : public SequenceAlgorithm_base
 {
     LeftRight_UpDown() = default;
@@ -40,6 +41,9 @@ struct SpiralSequence : public SequenceAlgorithm_base
     SpiralSequence() = default;
 
     void callback(sequence_t &current_step) override;
+
+private:
+    uint8_t furthest = 3, nearest = 0;
 };
 
 #endif