viseq/src/midi-node.cpp

#include "midi-node.h"

#include "config-node.h"
#include "datatypes.h"
#include "edge.h"
#include "midi.h"
#include "node.h"
#include "raylib.h"
#include "state.h"
#include <iostream>
#include <map>
#include <memory>

namespace VISEQ::GRAPH::NODES {

    void MidiNode::init(){
        midiNote.note = 64;
        midiNote.channel = 1;
        midiNote.gate = 250;
        midiNote.velocity = 64;
    }

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

    NodeType MidiNode::getNodeType() const {
        return nodeType;
    }

    void MidiNode::setMidiPort(int midi_port, bool _state){
        selected_midi_outs[midi_port].enabled = _state;
        std::cout << midi_port << " " << _state << std::endl;
    }

    void MidiNode::trigger() {
        triggered = true;
        start = GetTime();
        fade = getNotes().gate;
    }

    void MidiNode::setMode(int _mode) {
        mode = _mode;
    }

    MIDI::MidiNote MidiNode::getNotes() const {
        MIDI::MidiNote cNote;
        for(auto cn : getConnectedConfigNodes()){
            cNote += cn.lock()->getNotes();
        }
        return midiNote + cNote;
    }
    
    MIDI::MidiCC MidiNode::getCC() const {
        MIDI::MidiCC cCC;
        for(auto cn : getConnectedConfigNodes()){
            cCC += cn.lock()->getCC();
        }
        return midiCC + cCC;
    }
    
    MIDI::MidiPC MidiNode::getPC() const {
        MIDI::MidiPC cPC;
        for(auto cn : getConnectedConfigNodes()){
            cPC += cn.lock()->getPC();
        }
        return midiPC + cPC;
    }
    
    MIDI::MidiPitchBend MidiNode::getPitchBend() const {
        MIDI::MidiPitchBend cPitchBend;
        for(auto cn : getConnectedConfigNodes()){
            cPitchBend += cn.lock()->getPitchBend();
        }
        return midiPitchBend + cPitchBend;
    }
    
    MIDI::MidiAftertouch MidiNode::getAftertouch() const {
        MIDI::MidiAftertouch cAftertouch;
        for(auto cn : getConnectedConfigNodes()){
            cAftertouch += cn.lock()->getAftertouch();
        }
        return midiAftertouch + cAftertouch;
    }
    
    MIDI::MidiPolyPressure MidiNode::getPolyPressure() const {
        MIDI::MidiPolyPressure cPolyPressure;
        for(auto cn : getConnectedConfigNodes()){
            cPolyPressure += cn.lock()->getPolyPressure();
        }
        return midiPolyPressure + cPolyPressure;
    }
    
    std::vector<std::weak_ptr<ConfigNode>> MidiNode::getConnectedConfigNodes() const {
        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()));
        }
        /*std::cout << "id: " << id << " n cn: " << config_nodes.size() << std::endl;*/
        return config_nodes;
    }

    void MidiNode::update() {
        Node::update();
    }
   
    void MidiNode::modMidiChannel(int incr){

    }

    void MidiNode::modMidiNoteValue(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 MidiNode::modMidiNoteVelocity(int incr){
        midiNote.velocity += incr;
        if(midiNote.velocity < 0 ) midiNote.velocity = 127;
        if(midiNote.velocity > 127 ) midiNote.velocity = 0; 
    }
    
    void MidiNode::modMidiNoteGate(int incr){
        midiNote.gate += incr;
        if(midiNote.gate < 0 ) midiNote.gate = 0;
        if(midiNote.gate > 20000) midiNote.gate = 20000;
    }

    void MidiNode::modMidiCCValue(int incr){
        midiCC.value += incr;
        if(midiCC.value < 0 ) midiCC.value = 127;
        if(midiCC.value > 127 ) midiCC.value = 0;
    }
    
    void MidiNode::modMidiCCControl(int incr){
        midiCC.control += incr;
        if(midiCC.control < 0 ) midiCC.control = 127;
        if(midiCC.control > 127 ) midiCC.control = 0;
    }
    
    void MidiNode::modMidiPCValue(int incr){
        midiPC.value += incr;
        if(midiPC.value < 0 ) midiPC.value = 127;
        if(midiPC.value > 127 ) midiPC.value = 0;
    }
    
    void MidiNode::modMidiPCProgram(int incr){
        midiPC.program += incr;
        if(midiPC.program < 0 ) midiPC.program = 127;
        if(midiPC.program > 127 ) midiPC.program = 0;
    }
    
    void MidiNode::modMidiPitchBend(int incr){
        midiPitchBend.value += incr;
        if(midiPitchBend.value < 0 ) midiPitchBend.value = 0;
        if(midiPitchBend.value > 16383 ) midiPitchBend.value = 16383;
    }
    
    void MidiNode::modMidiAftertouch(int incr){
        midiAftertouch.value += incr;
        if(midiAftertouch.value < 0 ) midiAftertouch.value = 0;
        if(midiAftertouch.value > 127 ) midiAftertouch.value = 127;
    }
    
    void MidiNode::modMidiPolyPressureValue(int incr){
        midiPolyPressure.value += incr;
        if(midiPolyPressure.value < 0 ) midiPolyPressure.value = 0;
        if(midiPolyPressure.value > 16383 ) midiPolyPressure.value = 16383;
    }
    
    void MidiNode::modMidiPolyPressureNote(int incr){
        midiPolyPressure.note += incr;
        if(midiPolyPressure.note < 0 ) midiPolyPressure.note = VISEQ::MIDI::Notes.size()-1;
        if(midiPolyPressure.note >= (int)VISEQ::MIDI::Notes.size()) midiPolyPressure.note = 0;	
    }

    void MidiNode::interact(){
        float wheel = GetMouseWheelMove();
            
        switch(mode){
            case NOTE:{
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiNoteValue(wheel);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiNoteVelocity(wheel);
                
                if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiNoteGate(wheel*100);
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiNoteGate(wheel*1000);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiNoteGate(wheel*10);
                if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiNoteGate(wheel);
            break;}
            case CC:{
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiCCValue(wheel);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiCCControl(wheel);
            break;}
            case PC:{
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiPCValue(wheel);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiPCProgram(wheel);
            break;}
            case PB:{
                if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPitchBend(wheel*64);
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPitchBend(wheel*2048);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPitchBend(wheel*256);
                if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPitchBend(wheel);
            break;}
            case AT:{
                if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiAftertouch(wheel*10);
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiAftertouch(wheel*100);
                if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiAftertouch(wheel);
            break;}
            case PP:{
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiPolyPressureNote(wheel);
                if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) modMidiPolyPressureNote(wheel*10);
                
                if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPolyPressureValue(wheel*64);
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPolyPressureValue(wheel*2048);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPolyPressureValue(wheel*256);
                if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) modMidiPolyPressureValue(wheel);
            break;}
        };
    }

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

        last = time;
        time = GetTime();
        if(time - start >= (float)getNotes().gate / 1000.0f){
            triggered = false;
            fade = 0;
        } else {
            fade -= (time - last)*1000.0f;
        }
        
        switch((Handles)mode){
            case NOTE:{
                radius = (float)midiNote.velocity * 0.2f + 5.0f;
                break;}
            case CC:{
                radius = (float)midiCC.value * 0.2f + 5.0f;
                break;}
            case PC:{
                radius = (float)midiPC.value * 0.2f + 5.0f;
                break;}
            case PB:{
                radius = (float)midiPitchBend.value * 0.002f + 5.0f;
                break;}
            case AT:{
                radius = (float)midiAftertouch.value * 0.002f + 5.0f;
                break;}
            case PP:{
                radius = (float)midiPolyPressure.value * 0.002f + 5.0f;
                break;}
        }

        DrawRing(position, radius, radius + 4, 0, 360, 24, VS_COLOR_DARKGREY);
        //DrawRing(position, radius, radius + 4, 0.0f - 90.0f, (360.0f/127.0f) * getNotes().velocity - 90.0f, 24, (Color){158, 134, 200, 255});
        if(!selected) DrawCircleLinesV(position, radius + 4, VS_COLOR_GREY);

        float trigger_alpha = (1.f / getNotes().gate) * fade;
        
        DrawCircle(position.x, position.y, radius, ColorLerp(state->settings.mode_colors[mode], VS_COLOR_RED, trigger_alpha));
        if(hovering()) DrawCircleLinesV(position, radius + 4, VS_COLOR_PINK);
        if(picked_up || (in_selection_rect && MOUSE_LEFT.down) || selected) DrawCircleLinesV(position, radius + 4, VS_COLOR_LIGHTBLUE);
        //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});
       
        VMATH::Vec2D<float> desc_position = position + VMATH::Vec2D<float>(radius + 7.0f, radius + 7.0f);
        switch(mode){
            case NOTE:{
                if(!KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawCenteredText(MIDI::Notes[getNotes().note], position, 14, VS_COLOR_BLACK);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawCenteredText(std::format("{}", getNotes().velocity), position, 12, VS_COLOR_BLACK);
                
                if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawCenteredText(std::format("{:.1f}s", (float)getNotes().gate / 1000.f), position, 12, VS_COLOR_BLACK);
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawCenteredText(std::format("{:.2f}s", (float)getNotes().gate / 1000.f), position, 12, VS_COLOR_BLACK);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawCenteredText(std::format("{:.2f}s", (float)getNotes().gate / 1000.f), position, 12, VS_COLOR_BLACK);
                if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawCenteredText(std::format("{:.3f}s", (float)getNotes().gate / 1000.f), position, 12, VS_COLOR_BLACK);
               
                if(selected){
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("NOTE", desc_position, 8, VS_COLOR_BLACK);
                    if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("VALUE", desc_position, 8, VS_COLOR_BLACK);
                    if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("VELOCITY", desc_position, 8, VS_COLOR_BLACK);
                
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("GATE 0.1s", desc_position, 8, VS_COLOR_BLACK);                    
                    if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("GATE 1.0s", desc_position, 8, VS_COLOR_BLACK);                    
                    if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("GATE 0.01s", desc_position, 8, VS_COLOR_BLACK);
                    if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("GATE 0.001s", desc_position, 8, VS_COLOR_BLACK);
                }
            break;}
            case CC:{
                if(!KEYS_DOWN.shift) DrawCenteredText(std::format("{}", getCC().value), position, 12, WHITE);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawCenteredText(std::format("{}", getCC().control), position, 12, BLACK);
                if(selected){
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("CC", desc_position, 8, WHITE);
                    if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("VALUE", desc_position, 8, WHITE);
                    if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("CONTROL", desc_position, 8, WHITE);
                }
            break;}
            case PC:{
                if(!KEYS_DOWN.shift) DrawCenteredText(std::format("{}", getPC().value), position, 12, WHITE);
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawCenteredText(std::format("{}", getPC().program), position, 12, BLACK);
                if(selected){
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("PROGRAM CHANGE", desc_position, 8, WHITE);
                    if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("VALUE", desc_position, 8, WHITE);
                    if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("PROGRAM", desc_position, 8, WHITE);
                }
            break;}
            case PB:{
                DrawCenteredText(std::format("{}", getPitchBend().value), position, 10, WHITE);
                if(selected){
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("PITCHBEND", desc_position, 8, WHITE);
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("64", desc_position, 8, WHITE); 
                    if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("2048", desc_position, 8, WHITE); 
                    if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("256", desc_position, 8, WHITE);
                    if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("1", desc_position, 8, WHITE);
                }
            break;}
            case AT:{
                DrawCenteredText(std::format("{}", getAftertouch().value), position, 12, WHITE);
                if(selected){
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("AFTERTOUCH", desc_position, 8, WHITE);                    
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("10", desc_position, 8, WHITE);                    
                    if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("100", desc_position, 8, WHITE);                    
                    if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("1", desc_position, 8, WHITE); 
                }
            break;}
            case PP:{
                if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawCenteredText(MIDI::Notes[getPolyPressure().note], position, 12, WHITE);
                
                if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawCenteredText(std::format("{}", getPolyPressure().value), position, 12, WHITE);
                if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawCenteredText(std::format("{}", getPolyPressure().value), position, 12, WHITE);
                if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawCenteredText(std::format("{}", getPolyPressure().value), position, 12, WHITE);
                if(selected){
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && !KEYS_DOWN.alt) DrawText("POLYPRESSURE", desc_position, 8, WHITE);                    
                    if(!KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("64", desc_position, 8, WHITE);                    
                    if(KEYS_DOWN.ctrl && !KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("2048", desc_position, 8, WHITE);                    
                    if(!KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("256", desc_position, 8, WHITE);                    
                    if(KEYS_DOWN.ctrl && KEYS_DOWN.shift && KEYS_DOWN.alt) DrawText("1", desc_position, 8, WHITE); 
                }
            break;}
        };

        if(highlighted) DrawCircleLinesV(position, radius+2, (Color){255, 0, 0, 200});
    }

    void to_json(json& j, const MidiNode& N){
        std::vector<int> conns;		
        std::ranges::transform(N.connections.begin(), N.connections.end(), std::back_inserter(conns), [](VISEQ::GRAPH::EDGES::SPTR_Edge e){ return e->id;});
        
        j = json{
            {"id", N.id},
            {"position", N.position},
            {"distributionMode", N.distributionMode},
            {"nodeType", N.nodeType},
            {"midiNote", N.midiNote},
            {"midiCC", N.midiCC},
            {"midiPC", N.midiPC},
            {"midiPitchBend", N.midiPitchBend},
            {"midiAftertouch", N.midiAftertouch},
            {"midiPolyPressure", N.midiPolyPressure},
            {"connections",conns}};

    }

    void from_json(const json& j, MidiNode& N){
        std::cout << "MidiNode" << std::endl;

        j.at("id").get_to(N.id);
        j.at("position").get_to<Vec2Df>(N.position);
        j.at("distributionMode").get_to(N.distributionMode);
        j.at("nodeType").get_to(N.nodeType);
        j.at("midiNote").get_to(N.midiNote);
        j.at("midiCC").get_to(N.midiCC);
        j.at("midiPC").get_to(N.midiPC);
        j.at("midiPitchBend").get_to(N.midiPitchBend);
        j.at("midiAftertouch").get_to(N.midiAftertouch);
        j.at("midiPolyPressure").get_to(N.midiPolyPressure);
    }
    
    void to_json(json& j, const std::shared_ptr<MidiNode>& N){
        j = *N;
    }
    
    void from_json(const json& j, std::shared_ptr<MidiNode>& N){
        N.reset(new MidiNode(j.get<MidiNode>()));	
    }

}