viseq/src/signal-manager.h

#pragma once

#include "connection-manager.h"
#include "datatypes.h"
#include "node-manager.h"
#include "signal.h"
#include "node.h"
#include "midi.h"

#include <chrono>
#include <thread>

class SignalManager{

	public:
		SignalManager() {}
		SignalManager(NodeManager *nm, ConnectionManager *cm, std::mutex *mutex) : mutex(mutex), cm(cm), nm(nm) {}
		
		Midi midi;
		
		std::mutex *mutex;
		ConnectionManager *cm;
		NodeManager *nm;

		std::vector<Signal> signals;

		bool loop = true;
		bool play = false;
	
		void pause(){
			play = false;
		}

		void stop(){
			play = false;
			reset();
		}

		void start(){
			play = true;
		}
		
		void reset(){
			for(auto &s : signals){
				s.position = nm->nodes[s.start].position + Vec2D<float>{0.1, 0.1};
				s.next = s.start;
				s.last = s.start;
			}
			cm->reset();
		}

		void startSignalThread(){
			std::thread t1(&SignalManager::updateSignals, this);
			t1.detach();
		}

		void stopSignalThread(){
			loop = false;
		}
	
		void addSignalAtNode(int node_id){
			Color c = {(unsigned char)(20 + (rand() % 200)), 100, (unsigned char)(20 + (int)(rand() % 200)), 200};
			signals.emplace(signals.end(), Signal(nm->nodes[node_id].position.x+1, nm->nodes[node_id].position.y+1, 8.0f, 0, c)); // position + 1 or else it does not render. why? no idea!
			signals.back().next = node_id;
			signals.back().last = node_id;
			signals.back().start = node_id;
		}

		void removeSignal(int n){
			signals.erase(signals.begin() + n);
		}

		void updateSignals(){
			auto last = std::chrono::high_resolution_clock::now();
			while(loop){
				std::chrono::duration<double, std::micro> diff = std::chrono::high_resolution_clock::now() - last;
				if((int)diff.count() >= 250){
					mutex->lock();
					if(play){
						for(auto& s : signals){
							s.direction = (nm->nodes[s.next].position - s.position).norm();
							s.update(diff.count());
							if(s.position.dist(&nm->nodes[s.next].position) < 0.6f) {
								int n = cm->next(s.next, s.last);
								nm->nodes[s.next].trigger();

								if(n != s.next && n != -1) {
									for(auto &m : nm->nodes[s.next].midi_outs){
										if(m.second.enabled) {
											if(nm->nodes[s.next].send_note) midi.note(m.second.i, nm->nodes[s.next].midi_note_channel, nm->nodes[s.next].midi_note, nm->nodes[s.next].midi_velocity, nm->nodes[s.next].midi_gate);	
											if(nm->nodes[s.next].send_cc) midi.cc(m.second.i, nm->nodes[s.next].midi_cc_channel, nm->nodes[s.next].midi_cc, nm->nodes[s.next].midi_cc_value);	
											if(nm->nodes[s.next].send_pitch_bend) midi.pitch_bend(m.second.i, nm->nodes[s.next].midi_pitch_bend_channel, nm->nodes[s.next].midi_pitch_bend);	
										}
									}
									s.last = s.next;
									s.next = n;
								}
							}
						}
					}
					midi.update();
					mutex->unlock();
					last = std::chrono::high_resolution_clock::now();
				}
			}
		}

		void drawSignals(Vec2D<float> *mouse_pos, Camera2D *camera){
			for(auto& s : signals){
				mutex->lock();
				s.draw(mouse_pos, camera);
				mutex->unlock();
			}
		}

};