VCVRack
/
Rack
mirror of https://github.com/VCVRack/Rack.git
1
0
Fork 0
Code Issues 0 Releases 43 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1168 Commits
4 Branches
573MB
Tree: 0d3928872a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0d3928872a'
${ noResults }
Rack/plugins/community/repos/moDllz/src/MIDIdualCV.cpp

407 lines
14KB
Raw Blame History 

  1. 

  2. #include <list>

  3. #include <algorithm>

  4. #include "dsp/digital.hpp"

  5. #include "moDllz.hpp"

  6. #include "midi.hpp"

  7. #include "dsp/filter.hpp"

  8. 

  9. /*

  10.  * MIDIdualCV converts upper/lower midi note on/off events, velocity , channel aftertouch, pitch wheel,  mod wheel breath cc and expression to CV

  11.  */

  12. 

  13. namespace rack_plugin_moDllz {

  14. 

  15. struct MidiNoteData {

  16.     uint8_t velocity = 0;

  17.     uint8_t aftertouch = 0;

  18. };

  19. 

  20. struct MIDIdualCV :  Module {

  21. 	enum ParamIds {

  22. 		RESETMIDI_PARAM,

  23.         LWRRETRGGMODE_PARAM,

  24.         UPRRETRGGMODE_PARAM,

  25.         PBDUALPOLARITY_PARAM,

  26.         SUSTAINHOLD_PARAM,

  27.         NUM_PARAMS

  28. 	};

  29. 	enum InputIds {

  30. 		NUM_INPUTS

  31. 	};

  32. 	enum OutputIds {

  33. 		PITCH_OUTPUT_Lwr,

  34.         PITCH_OUTPUT_Upr,

  35. 		VELOCITY_OUTPUT_Lwr,

  36.         VELOCITY_OUTPUT_Upr,

  37.         RETRIGGATE_OUTPUT_Lwr,

  38.         RETRIGGATE_OUTPUT_Upr,

  39.         GATE_OUTPUT,

  40.         PBEND_OUTPUT,

  41.         MOD_OUTPUT,

  42.         EXPRESSION_OUTPUT,

  43.         BREATH_OUTPUT,

  44.         SUSTAIN_OUTPUT,

  45.         PRESSURE_OUTPUT,

  46. 		NUM_OUTPUTS

  47. 	};

  48. 	enum LightIds {

  49. 		RESETMIDI_LIGHT,

  50. 		NUM_LIGHTS

  51. 	};

  52.  

  53.     MidiInputQueue midiInput;

  54.     

  55.     uint8_t mod = 0;

  56.     ExponentialFilter modFilter;

  57.     uint8_t breath = 0;

  58.     ExponentialFilter breathFilter;

  59.     uint8_t expression = 0;

  60.     ExponentialFilter exprFilter;

  61.     uint16_t pitch = 8192;

  62.     ExponentialFilter pitchFilter;

  63.     uint8_t sustain = 0;

  64.     ExponentialFilter sustainFilter;

  65.     uint8_t pressure = 0;

  66.     ExponentialFilter pressureFilter;

  67. 

  68.     

  69.     MidiNoteData noteData[128];

  70.     

  71.     struct noteLive{

  72.         int note = 0;

  73.         uint8_t vel = 0;

  74.         bool trig = false;

  75.     };

  76.     noteLive lowerNote;

  77.     noteLive upperNote;

  78.     bool anynoteGate = false;

  79.     bool sustpedal = false;

  80.     

  81.     PulseGenerator gatePulse;

  82.     SchmittTrigger resetMidiTrigger;

  83.     

  84.     

  85.     MIDIdualCV() : Module(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS) {}

  86.    

  87.     bool noteupdated = false;

  88.     

  89.     

  90.     

  91.     ///////////////////         ////           ////          ////         /////////////////////

  92.     /////////////////   ///////////////  /////////  ////////////  //////  ////////////////////

  93.     /////////////////         ////////  /////////       ///////        //////////////////////

  94.     ///////////////////////   ///////  /////////  ////////////  ////////////////////////////

  95.     //////////////         /////////  /////////         /////  ////////////////////////////

  96.     

  97.     void step() override {

  98.         MidiMessage msg;

  99.         while (midiInput.shift(&msg)) {

  100.             processMessage(msg);

  101.         }

  102.         ///reset triggers...

  103.         lowerNote.trig = false;

  104.         upperNote.trig = false;

  105.         ///////////////////////

  106.         if (noteupdated){

  107.             anynoteGate = false;

  108.             noteupdated = false;

  109.             ///LOWER///

  110.             for (int i = 0; i < 128; i++){

  111.                 if (noteData[i].velocity > 0){

  112.                     anynoteGate = true;

  113.                     /////// trigger !!

  114.                     gatePulse.trigger(1e-3);

  115.                     /////////

  116.                     if (i < lowerNote.note) lowerNote.trig = true;

  117.                     lowerNote.note = i;

  118.                     lowerNote.vel = noteData[i].velocity;

  119.                     break;

  120.                 }

  121.             }

  122.             if (anynoteGate){

  123.                     ///UPPER///

  124.                     for (int i = 127; i > -1; i--){

  125.                         if (noteData[i].velocity > 0){

  126.                             if (i > upperNote.note) upperNote.trig = true;

  127.                             upperNote.note = i;

  128.                             upperNote.vel = noteData[i].velocity;

  129.                             break;

  130.                         }

  131.                     }

  132.             }else{

  133.                 lowerNote.note = 128;

  134.                 upperNote.note = -1;

  135.             }

  136.             if (lowerNote.note < 128)

  137.                 outputs[PITCH_OUTPUT_Lwr].value = static_cast<float>(lowerNote.note - 60) / 12.0f;

  138.             

  139.             if (upperNote.note > -1)

  140.                 outputs[PITCH_OUTPUT_Upr].value = static_cast<float>(upperNote.note - 60) / 12.0f;

  141.             

  142.             if (lowerNote.vel > 0)

  143.             outputs[VELOCITY_OUTPUT_Lwr].value = static_cast<float>(lowerNote.vel) / 127.0f * 10.0f;

  144. 

  145.             if (upperNote.vel > 0)

  146.             outputs[VELOCITY_OUTPUT_Upr].value = static_cast<float>(upperNote.vel) / 127.0 * 10.0;

  147.         }

  148.         

  149.         bool retriggLwr = lowerNote.trig || params[LWRRETRGGMODE_PARAM].value > 0.5;

  150.         bool retriggUpr = upperNote.trig || params[UPRRETRGGMODE_PARAM].value > 0.5;

  151.         bool pulse = gatePulse.process(1.0 / engineGetSampleRate());

  152.         bool gateout = anynoteGate || sustpedal;

  153.         

  154.         outputs[RETRIGGATE_OUTPUT_Lwr].value = gateout && !(retriggLwr && pulse)? 10.0f : 0.0f ;

  155.         outputs[RETRIGGATE_OUTPUT_Upr].value = gateout && !(retriggUpr && pulse)? 10.0f : 0.0f ;

  156.         outputs[GATE_OUTPUT].value = gateout ? 10.0f : 0.0f ;

  157.         

  158.         pitchFilter.lambda = 100.f * engineGetSampleTime();

  159.         if (params[PBDUALPOLARITY_PARAM].value < 0.5f)

  160.         outputs[PBEND_OUTPUT].value = pitchFilter.process(rescale(pitch, 0, 16384, -5.f, 5.f));

  161.         else

  162.         outputs[PBEND_OUTPUT].value = pitchFilter.process(rescale(pitch, 0, 16384, 0.f, 10.f));

  163.         

  164.         modFilter.lambda = 100.f * engineGetSampleTime();

  165.         outputs[MOD_OUTPUT].value = modFilter.process(rescale(mod, 0, 127, 0.f, 10.f));

  166.         

  167.         breathFilter.lambda = 100.f * engineGetSampleTime();

  168.         outputs[BREATH_OUTPUT].value = breathFilter.process(rescale(breath, 0, 127, 0.f, 10.f));

  169.         

  170.         exprFilter.lambda = 100.f * engineGetSampleTime();

  171.         outputs[EXPRESSION_OUTPUT].value = exprFilter.process(rescale(expression, 0, 127, 0.f, 10.f));

  172.         

  173.         sustainFilter.lambda = 100.f * engineGetSampleTime();

  174.         outputs[SUSTAIN_OUTPUT].value = sustainFilter.process(rescale(sustain, 0, 127, 0.f, 10.f));

  175.         

  176.         pressureFilter.lambda = 100.f * engineGetSampleTime();

  177.         outputs[PRESSURE_OUTPUT].value = pressureFilter.process(rescale(pressure, 0, 127, 0.f, 10.f));

  178.     

  179.         ///// RESET MIDI LIGHT

  180.         if (resetMidiTrigger.process(params[RESETMIDI_PARAM].value)) {

  181.             lights[RESETMIDI_LIGHT].value= 1.0f;

  182.             MidiPanic();

  183.             return;

  184.         }

  185.         if (lights[RESETMIDI_LIGHT].value > 0.0001f){

  186.             lights[RESETMIDI_LIGHT].value -= 0.0001f ; // fade out light

  187.         }

  188.     }

  189. /////////////////////// * * * ///////////////////////////////////////////////// * * *

  190. //                      * * *         E  N  D      O  F     S  T  E  P          * * *

  191. /////////////////////// * * * ///////////////////////////////////////////////// * * *

  192. 

  193. void processMessage(MidiMessage msg) {

  194.    // debug("MIDI: %01x %01x %02x %02x", msg.status(), msg.channel(), msg.data1, msg.data2);

  195.     if ((midiInput.channel < 0) || (midiInput.channel == msg.channel())){

  196.         switch (msg.status()) {

  197.             case 0x8: { // note off

  198.                     uint8_t note = msg.data1 & 0x7f;

  199.                     noteData[note].velocity = 0;

  200.                     noteData[note].aftertouch = 0;

  201.                     noteupdated = true;

  202.                 }

  203.                 break;

  204.             case 0x9: { // note on

  205.                     uint8_t note = msg.data1 & 0x7f;

  206.                     noteData[note].velocity = msg.data2;

  207.                     noteData[note].aftertouch = 0;

  208.                     noteupdated = true;

  209.                 }

  210.                 break;

  211.             case 0xb: // cc

  212.                 processCC(msg);

  213.                 break;

  214.             case 0xe: // pitch wheel

  215.                 pitch = msg.data2 * 128 + msg.data1;

  216.                 break;

  217.             case 0xd: // channel aftertouch

  218.                 pressure = msg.data1;

  219.                 break;

  220. //          case 0xf: ///realtime clock etc

  221. //              processSystem(msg);

  222. //              break;

  223.             default: break;

  224.         }

  225.     }

  226. }

  227. 

  228. void processCC(MidiMessage msg) {

  229.     switch (msg.data1) {

  230.         case 0x01: // mod

  231.             mod = msg.data2;

  232.             break;

  233.         case 0x02: // breath

  234.             breath = msg.data2;

  235.             break;

  236.         case 0x0B: // Expression

  237.             expression = msg.data2;

  238.             break;

  239.         case 0x40: { // sustain

  240.              sustain = msg.data2;

  241.              if ((params[SUSTAINHOLD_PARAM].value > 0.5) && anynoteGate) sustpedal = (msg.data2 >= 64);

  242.              else sustpedal = false;

  243.             }

  244.             break;

  245.         default: break;

  246.     }

  247. }

  248. 

  249. //void processSystem(MidiMessage msg) {

  250. //    switch (msg.channel()) {

  251. //        case 0x8: {

  252. //            debug("timing clock");

  253. //        } break;

  254. //        case 0xa: {

  255. //            debug("start");

  256. //        } break;

  257. //        case 0xb: {

  258. //            debug("continue");

  259. //        } break;

  260. //        case 0xc: {

  261. //            debug("stop");

  262. //        } break;

  263. //        default: break;

  264. //    }

  265. //}

  266.     void MidiPanic() {

  267.         pitch = 8192;

  268.         outputs[PBEND_OUTPUT].value = 0.0f;

  269.         mod = 0;

  270.         outputs[MOD_OUTPUT].value = 0.0f;

  271.         breath = 0;

  272.         outputs[BREATH_OUTPUT].value = 0.0f;

  273.         expression = 0;

  274.         outputs[EXPRESSION_OUTPUT].value = 0.0f;

  275.         pressure = 0;

  276.         outputs[PRESSURE_OUTPUT].value = 0.0f;

  277.         sustain = 0;

  278.         outputs[SUSTAIN_OUTPUT].value = 0.0f;

  279.         sustpedal = false;

  280.     }

  281.     

  282.     

  283.     

  284. json_t *toJson() override {

  285.     json_t *rootJ = json_object();

  286.     json_object_set_new(rootJ, "midi", midiInput.toJson());

  287.     return rootJ;

  288. }

  289. 

  290. void fromJson(json_t *rootJ) override {

  291.     json_t *midiJ = json_object_get(rootJ, "midi");

  292.     midiInput.fromJson(midiJ);

  293. }

  294. };

  295. 

  296. 

  297. struct overMidiDisplay : TransparentWidget {

  298.     

  299.     void draw(NVGcontext* vg)

  300.     {

  301.         NVGcolor backgroundColor = nvgRGBA(0x80, 0x80, 0x80, 0x24);

  302.         nvgBeginPath(vg);

  303.         nvgRoundedRect(vg, 0, 0, 113, 48, 5.0f);

  304.         nvgFillColor(vg, backgroundColor);

  305.         nvgFill(vg);

  306.         nvgBeginPath(vg);

  307.         NVGcolor linecolor = nvgRGB(0x50, 0x50, 0x50);

  308.         nvgRect(vg, 61, 0, 1, 16);

  309.         nvgFillColor(vg, linecolor);

  310.         nvgFill(vg);

  311.     }

  312. };

  313. 

  314. 

  315. struct MIDIdualCVWidget : ModuleWidget {

  316.     

  317.     MIDIdualCVWidget(MIDIdualCV *module): ModuleWidget(module){

  318.        setPanel(SVG::load(assetPlugin(plugin, "res/MIDIdualCV.svg")));

  319.         

  320.         //Screws

  321.         addChild(Widget::create<ScrewBlack>(Vec(0, 0)));

  322.         addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 15, 0)));

  323.         addChild(Widget::create<ScrewBlack>(Vec(0, 365)));

  324.         addChild(Widget::create<ScrewBlack>(Vec(box.size.x - 15, 365)));

  325.         

  326. ///MIDI

  327. 	float yPos = 21.0f;

  328.     float xPos = 11.0f;

  329.    

  330.         

  331.         MidiWidget *midiWidget = Widget::create<MidiWidget>(Vec(xPos,yPos));

  332.         midiWidget->box.size = Vec(113,48);

  333.         midiWidget->midiIO = &module->midiInput;

  334.         

  335.         midiWidget->driverChoice->box.size = Vec(56,16);

  336.         midiWidget->deviceChoice->box.size = Vec(113,16);

  337.         midiWidget->channelChoice->box.size = Vec(113,16);

  338.         

  339.         midiWidget->driverChoice->box.pos = Vec(0, 0);

  340.         midiWidget->deviceChoice->box.pos = Vec(0, 16);

  341.         midiWidget->channelChoice->box.pos = Vec(0, 32);

  342.         

  343.         midiWidget->driverSeparator->box.pos = Vec(0, 16);

  344.         midiWidget->deviceSeparator->box.pos = Vec(0, 32);

  345.         

  346.         midiWidget->driverChoice->font = Font::load(mFONT_FILE);

  347.         midiWidget->deviceChoice->font = Font::load(mFONT_FILE);

  348.         midiWidget->channelChoice->font = Font::load(mFONT_FILE);

  349.         

  350.         midiWidget->driverChoice->textOffset = Vec(4,12);

  351.         midiWidget->deviceChoice->textOffset = Vec(4,12);

  352.         midiWidget->channelChoice->textOffset = Vec(4,12);

  353.         

  354.         midiWidget->driverChoice->color = nvgRGB(0xdd, 0xdd, 0xdd);

  355.         midiWidget->deviceChoice->color = nvgRGB(0xdd, 0xdd, 0xdd);

  356.         midiWidget->channelChoice->color = nvgRGB(0xdd, 0xdd, 0xdd);

  357.         addChild(midiWidget);

  358.         

  359.         overMidiDisplay *overmididisplay = Widget::create<overMidiDisplay>(Vec(xPos,yPos));

  360.         addChild(overmididisplay);

  361.         

  362.         

  363. //    //reset button

  364.         xPos = 77;

  365.         yPos = 22;

  366.         addParam(ParamWidget::create<moDllzMidiPanic>(Vec(xPos, yPos), module, MIDIdualCV::RESETMIDI_PARAM, 0.0f, 1.0f, 0.0f));

  367.         addChild(ModuleLightWidget::create<SmallLight<RedLight>>(Vec(xPos+35.f, yPos+4.f), module, MIDIdualCV::RESETMIDI_LIGHT));

  368.     

  369.     yPos = 94.0f;

  370. 

  371.     //Lower-Upper Outputs

  372.     for (int i = 0; i < 3; i++)

  373.     {

  374.         addOutput(Port::create<moDllzPort>(Vec(20, yPos), Port::OUTPUT, module, i * 2));

  375.         addOutput(Port::create<moDllzPort>(Vec(93, yPos), Port::OUTPUT, module, i * 2 + 1));

  376.         yPos += 24;

  377.     }

  378.     //Retrig Switches

  379.     addParam(ParamWidget::create<moDllzSwitch>(Vec(21, 168), module, MIDIdualCV::LWRRETRGGMODE_PARAM, 0.0, 1.0, 0.0));

  380.     addParam(ParamWidget::create<moDllzSwitch>(Vec(105, 168), module, MIDIdualCV::UPRRETRGGMODE_PARAM, 0.0, 1.0, 0.0));

  381.     

  382.     yPos = 200;

  383.     xPos = 72;

  384.     //Common Outputs

  385.     for (int i = 6; i < MIDIdualCV::NUM_OUTPUTS; i++)

  386.     {

  387.         addOutput(Port::create<moDllzPort>(Vec(xPos, yPos), Port::OUTPUT, module, i));

  388.         yPos += 23;

  389.     }

  390.     ///PitchWheel +- or +

  391.     addParam(ParamWidget::create<moDllzSwitch>(Vec(105, 225), module, MIDIdualCV::PBDUALPOLARITY_PARAM, 0.0, 1.0, 0.0));

  392.     ///Sustain hold notes

  393.     addParam(ParamWidget::create<moDllzSwitchLed>(Vec(105, 318), module, MIDIdualCV::SUSTAINHOLD_PARAM, 0.0, 1.0, 1.0));

  394.  

  395.     }

  396. };

  397. 

  398. } // namespace rack_plugin_moDllz

  399. 

  400. using namespace rack_plugin_moDllz;

  401. 

  402. RACK_PLUGIN_MODEL_INIT(moDllz, MIDIdualCV) {

  403.    Model *modelMIDIdualCV = Model::create<MIDIdualCV, MIDIdualCVWidget>("moDllz", "MIDIdualCV", "MIDI to dual CV interface", MIDI_TAG, DUAL_TAG, EXTERNAL_TAG);

  404.    return modelMIDIdualCV;

  405. }