viseq/src/midi-node.h

#pragma once

#include "config-node.h"
#include "datatypes.h"
#include "edge.h"
#include "node.h"
#include "raymath.h"
#include <map>

#define RADIUS 14.0f

namespace VISEQ::GRAPH::NODES {

	class MidiNode : public Node{
		private:
		MIDI::MidiNote midiNote;
		MIDI::MidiCC midiCC;
		MIDI::MidiPitchBend midiPitchBend;
		MIDI::MidiAftertouch midiAftertouch;
		MIDI::MidiPolyPressure midiPolyPressure;
		MIDI::MidiPC midiPC;

		public:

		struct NodeMidiOut{
			int i;
			std::string name;
			bool enabled;
		};

		MidiNode() : Node() {std::cout << "MidiNode Constructor std" << std::endl;}
		MidiNode(Vec2Df position) : Node(position) {}

		NodeType nodeType = NodeType::MIDINODE;

		bool send_note = true;
		bool send_cc = false;
		bool send_pc = false;
		bool send_pitch_bend = false;

		int midi_out = -1;
		
		std::map<int, NodeMidiOut> midi_outs;

		bool gui_midi_channel_edit = false;
		bool gui_midi_note_edit = false;
		bool gui_midi_velocity_edit = false;
		bool gui_midi_gate_edit = false;
		
		bool triggered = false;

		int mode = 0;

		float start = 0;
		float fade = 0;
		float time = 0;
		float last = 0;

		std::shared_ptr<MidiNode> getPtr(){
			return std::static_pointer_cast<MidiNode>(shared_from_this());
		}

		virtual NodeType getNodeType() const override {return nodeType;}

		void setMidiPort(int midi_port, bool _state){
			midi_outs[midi_port].enabled = _state;
		}

		void trigger() override {
			triggered = true;
			start = GetTime();
			fade = midiNote.gate;
		}

		void SMode(int _mode) override{
			mode = _mode;
		}

		int GGate(){
			return midiNote.gate;
		}

		MIDI::MidiNote getNotes(){
			MIDI::MidiNote cNote;
			for(auto cn : getConnectedConfigNodes()){
				cNote += cn.lock()->getNotes();
			}
			return cNote;
		}
		
		MIDI::MidiCC getCC(){
			MIDI::MidiCC cCC;
			for(auto cn : getConnectedConfigNodes()){
				cCC += cn.lock()->getCC();
			}
			return cCC;
		}
		
		MIDI::MidiPC getPC(){
			MIDI::MidiPC cPC;
			for(auto cn : getConnectedConfigNodes()){
				cPC += cn.lock()->getPC();
			}
			return cPC;
		}
		
		MIDI::MidiPitchBend getPitchBend(){
			MIDI::MidiPitchBend cPitchBend;
			for(auto cn : getConnectedConfigNodes()){
				cPitchBend += cn.lock()->getPitchBend();
			}
			return cPitchBend;
		}
		
		MIDI::MidiAftertouch getAftertouch(){
			MIDI::MidiAftertouch cAftertouch;
			for(auto cn : getConnectedConfigNodes()){
				cAftertouch += cn.lock()->getAftertouch();
			}
			return cAftertouch;
		}
		
		MIDI::MidiPolyPressure getPolyPressure(){
			MIDI::MidiPolyPressure cPolyPressure;
			for(auto cn : getConnectedConfigNodes()){
				cPolyPressure += cn.lock()->getPolyPressure();
			}
			return cPolyPressure;
		}
		
		std::vector<std::weak_ptr<ConfigNode>> getConnectedConfigNodes(){
			auto config_conns = connections | RANGE_FILTER([](EDGES::SPTR_Edge c){ return c->start.lock()->getNodeType() == NodeType::CONFIGNODE || c->end.lock()->getNodeType() == NodeType::CONFIGNODE;}) | std::ranges::to<std::vector<std::shared_ptr<EDGES::Edge>>>();
			std::vector<std::weak_ptr<ConfigNode>> config_nodes;
			for(auto e : config_conns){
				if(e->start.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ConfigNode>(e->start.lock()));
				if(e->end.lock()->getNodeType() == NodeType::CONFIGNODE) config_nodes.push_back(std::dynamic_pointer_cast<ConfigNode>(e->end.lock()));
			}
			return config_nodes;
		}

		void update() override {
			Node::update();
			mode = state->node_mode;

		}
		
		int getMidiNote(){
			int mod_notes = 0;
			for(auto cn : getConnectedConfigNodes()){
				mod_notes += cn.lock()->midiNote.note;
			}
			return midiNote.note + mod_notes;
		}

		void modMidiNote(int incr){
			midiNote.note += incr;
			if(midiNote.note < 0 ) midiNote.note = VISEQ::MIDI::Notes.size()-1;
			if(midiNote.note >= (int)VISEQ::MIDI::Notes.size()) midiNote.note = 0;	
		}

		void modMidiCC(int incr){
			midiCC.control += incr;
			if(midiCC.control < 0 ) midiCC.control = 127;
			if(midiCC.control > 127 ) midiCC.control = 0;
		}
		
		void modMidiPitchBend(int incr){
			midiPitchBend.value += incr;
			if(midiPitchBend.value < 0 ) midiPitchBend.value = 0;
			if(midiPitchBend.value > 16383 ) midiPitchBend.value = 16383;
		}

		void interact(){
			float wheel = GetMouseWheelMove();

			if(KEYS_DOWN.ctrl && !KEYS_DOWN.alt){
				switch(state->node_mode){
					case 0:{
						modMidiNote(wheel);
					break;}
					case 1:{
						modMidiCC(wheel);
					break;}
					case 2:{
						modMidiPitchBend(wheel);
					break;}
				};
			} else if(KEYS_DOWN.shift && !KEYS_DOWN.alt) {
				midiNote.velocity += wheel;
				if(midiNote.velocity < 0 ) midiNote.velocity = 127;
				if(midiNote.velocity > 127 ) midiNote.velocity = 0; 
			} else if(KEYS_DOWN.alt) {
				switch(state->node_mode){
					case 0:{
						float incr = (float)wheel * (KEYS_DOWN.shift ? 100.0f : KEYS_DOWN.ctrl ? 1000.0f : 10.0f);
						midiNote.gate += incr;
						if(midiNote.gate < 0 ) midiNote.gate = 0;
					break;}
					case 1:{
						midiCC.value += wheel;
						if(midiCC.value < 0 ) midiCC.value = 0;
						if(midiCC.value > 127 ) midiCC.value = 127;
					break;}
					case 2:{
						float incr = (float)wheel * (KEYS_DOWN.shift ? 100.0f : KEYS_DOWN.ctrl ? 1000.0f : 10.0f);
						midiPitchBend.value += incr;
						if(midiPitchBend.value < 0 ) midiPitchBend.value = 0;
						if(midiPitchBend.value > 16383 ) midiPitchBend.value = 16383;
					break;}
				};
			}
		}

		void draw(Vec2Df mouse, Camera2D cam) override {
			Node::draw();
			if(hovering() || selected) interact();

			last = time;
			time = GetTime();
			if(time - start >= (float)midiNote.gate / 1000.0f){
				triggered = false;
				fade = 0;
			} else {
				fade -= (time - last)*1000.0f;
			}

			DrawRing(position, radius, radius+4, 0, 360, 24, (Color){60, 60, 60, 255});
			DrawRing(position, radius, radius+4, 0.0f - 90.0f, (360.0f/127.0f) * midiNote.velocity - 90.0f, 24, (Color){158, 134, 200, 255});
			DrawCircleLinesV(position, radius + 4, (Color){100, 100, 100, 255});

			float midi_gate_map = round((255.f / midiNote.gate) * fade);

			Color gate_color = VS_COLOR_GREEN;

			switch(mode){
				case 0:{
					gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){180, 210, 115, (unsigned char)Clamp(255 - midi_gate_map, 0, 255)}, WHITE);
					break;}
				case 1:{
					gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){229, 181, 103, (unsigned char)Clamp(255 - midi_gate_map, 0, 255)}, WHITE);
					break;}
				case 2:{
					gate_color = ColorAlphaBlend(VS_COLOR_RED, (Color){232, 125, 62, (unsigned char)Clamp(255 - midi_gate_map, 0, 255)}, WHITE);
					break;}
			}
			if(!picked_up && !selected && !in_selection_rect && !hovering()) DrawCircle(position.x, position.y, radius, gate_color);
			if(picked_up || in_selection_rect || hovering()) DrawCircle(position.x, position.y, radius, (Color){108, 153, 187, 255});
			if(selected) DrawCircle(position.x, position.y, radius, (Color){255, 153, 187, 255});

			if(distributionMode == Distribution::RANDOM) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_PINK);
			if(distributionMode == Distribution::ROUNDROBIN) DrawCircle(position.x, position.y, radius/2.0f, VS_COLOR_YELLOW);
			
			if(selected) DrawCircleLinesV(position, radius+8, (Color){158, 255, 210, 255});
				
			if(KEYS_DOWN.alt){
				float value = 0;
				int offset_gate = 0;
				switch(mode){
					case 0:
						value = (float)midiNote.gate/1000.0f;
						offset_gate = MeasureText(std::format("{:.2f}", value).c_str(), 12);
						DrawText(std::format("{:.2f}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, WHITE );
						break;
					case 1:
						value = (float)midiCC.value;
						offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
						DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, WHITE );
						break;
					case 2:
						value = (float)midiPitchBend.value;
						offset_gate = MeasureText(std::format("{}", value).c_str(), 12);
						DrawText(std::format("{}",value).c_str(), position.x-offset_gate/2.0f, position.y-5, 12, WHITE );
						break;
				}
			} else {
				switch(mode){
					case 0:{
						int offset = MeasureText(MIDI::Notes[(int)midiNote.note].c_str(), 12);
						DrawText(MIDI::Notes[midiNote.note].c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
						break;}
					case 1:{
						int offset = MeasureText(std::format("{}", midiCC.control).c_str(), 12);
						DrawText(std::format("{}", midiCC.control).c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
						break;}
					case 2:{
						int offset = MeasureText(std::format("{}", midiPitchBend.value).c_str(), 12);
						DrawText(std::format("{}", midiPitchBend.value).c_str(), position.x-offset/2.0f, position.y-5, 12, WHITE );
						break;}
				}
			}

			if(highlighted) DrawCircleLinesV(position, radius+2, (Color){255, 0, 0, 200});
			DrawText(std::format("{}", id).c_str(), position.x + 20.0f, position.y + 20.0f, 10, WHITE);
		}
	};
}