falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
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.
1953 Commits
17 Branches
463MB
Tree: a23a55eeec
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a23a55eeec'
${ noResults }
Carla/source/modules/native-plugins/vex-synth.cpp

1250 lines
43KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2012-2014 Filipe Coelho <falktx@falktx.com>

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 2 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the doc/GPL.txt file.

  16.  */

  17. 

  18. #include "CarlaNative.hpp"

  19. #include "CarlaString.hpp"

  20. 

  21. #include "JucePluginWindow.hpp"

  22. 

  23. using namespace juce;

  24. 

  25. #include "vex/VexArp.h"

  26. #include "vex/VexChorus.h"

  27. #include "vex/VexDelay.h"

  28. #include "vex/VexReverb.h"

  29. #include "vex/VexSyntModule.h"

  30. 

  31. #include "vex/PeggyViewComponent.h"

  32. #include "vex/gui/SnappingSlider.h"

  33. #include "vex/lookandfeel/MyLookAndFeel.h"

  34. #include "vex/resources/Resources.h"

  35. 

  36. // -----------------------------------------------------------------------

  37. // Copied from juce_AudioProcessor.cpp

  38. 

  39. // magic number to identify memory blocks that we've stored as XML

  40. const uint32 magicXmlNumber = 0x21324356;

  41. 

  42. void copyXmlToBinary(const XmlElement& xml, juce::MemoryBlock& destData)

  43. {

  44.     const String xmlString(xml.createDocument(String::empty, true, false));

  45.     const size_t stringLength = xmlString.getNumBytesAsUTF8();

  46. 

  47.     destData.setSize(stringLength + 9);

  48. 

  49.     uint32* const d = static_cast<uint32*>(destData.getData());

  50.     d[0] = ByteOrder::swapIfBigEndian((const uint32) magicXmlNumber);

  51.     d[1] = ByteOrder::swapIfBigEndian((const uint32) stringLength);

  52. 

  53.     xmlString.copyToUTF8((CharPointer_UTF8::CharType*) (d + 2), stringLength + 1);

  54. }

  55. 

  56. XmlElement* getXmlFromBinary(const void* data, const int sizeInBytes)

  57. {

  58.     if (sizeInBytes > 8 && ByteOrder::littleEndianInt(data) == magicXmlNumber)

  59.     {

  60.         const int stringLength = (int) ByteOrder::littleEndianInt (addBytesToPointer (data, 4));

  61. 

  62.         if (stringLength > 0)

  63.             return XmlDocument::parse (String::fromUTF8 (static_cast<const char*> (data) + 8, jmin ((sizeInBytes - 8), stringLength)));

  64.     }

  65. 

  66.     return nullptr;

  67. }

  68. 

  69. // -----------------------------------------------------------------------

  70. 

  71. class VexEditorComponent : public Component,

  72.                            public Timer,

  73.                            public ComboBox::Listener,

  74.                            public Slider::Listener,

  75.                            public Button::Listener,

  76.                            public PeggyViewComponent::Callback // ignored

  77. {

  78. public:

  79.     class Callback

  80.     {

  81.     public:

  82.         virtual ~Callback() {}

  83.         virtual void getChangedParameters(bool params[92]) = 0;

  84.         virtual float getFilterParameterValue(const uint32_t index) const = 0;

  85.         virtual String getFilterWaveName(const int part) const = 0;

  86.         virtual void editorParameterChanged(const uint32_t index, const float value) = 0;

  87.         virtual void editorWaveChanged(const int part, const String& wave) = 0;

  88.     };

  89. 

  90.     VexEditorComponent(Callback* const callback, VexArpSettings& arpSet1, VexArpSettings& arpSet2, VexArpSettings& arpSet3)

  91.         : fCallback(callback),

  92.           fNeedsUpdate(false)

  93.     {

  94.         internalCachedImage1 = ImageCache::getFromMemory(Resources::vex3_png, Resources::vex3_pngSize);

  95. 

  96.         // Comboboxes, wave selection

  97.         addAndMakeVisible(comboBox1 = new ComboBox("comboBox1"));

  98.         comboBox1->setEditableText(false);

  99.         comboBox1->setJustificationType(Justification::centredLeft);

  100.         comboBox1->setTextWhenNothingSelected(String("silent"));

  101.         comboBox1->setTextWhenNoChoicesAvailable(String("silent"));

  102.         comboBox1->addListener(this);

  103.         comboBox1->setColour(ComboBox::backgroundColourId, Colours::black);

  104.         comboBox1->setColour(ComboBox::textColourId, Colours::lightgrey);

  105.         comboBox1->setColour(ComboBox::outlineColourId, Colours::grey);

  106.         comboBox1->setColour(ComboBox::buttonColourId, Colours::grey);

  107.         comboBox1->setWantsKeyboardFocus(false);

  108.         comboBox1->setLookAndFeel(&mlaf);

  109. 

  110.         addAndMakeVisible(comboBox2 = new ComboBox("comboBox2"));

  111.         comboBox2->setEditableText(false);

  112.         comboBox2->setJustificationType(Justification::centredLeft);

  113.         comboBox2->setTextWhenNothingSelected(String("silent"));

  114.         comboBox2->setTextWhenNoChoicesAvailable(String("silent"));

  115.         comboBox2->addListener(this);

  116.         comboBox2->setColour(ComboBox::backgroundColourId, Colours::black);

  117.         comboBox2->setColour(ComboBox::textColourId, Colours::lightgrey);

  118.         comboBox2->setColour(ComboBox::outlineColourId, Colours::grey);

  119.         comboBox2->setColour(ComboBox::buttonColourId, Colours::grey);

  120.         comboBox2->setWantsKeyboardFocus(false);

  121.         comboBox2->setLookAndFeel(&mlaf);

  122. 

  123.         addAndMakeVisible(comboBox3 = new ComboBox("comboBox3"));

  124.         comboBox3->setEditableText(false);

  125.         comboBox3->setJustificationType(Justification::centredLeft);

  126.         comboBox3->setTextWhenNothingSelected(String("silent"));

  127.         comboBox3->setTextWhenNoChoicesAvailable(String("silent"));

  128.         comboBox3->addListener(this);

  129.         comboBox3->setColour(ComboBox::backgroundColourId, Colours::black);

  130.         comboBox3->setColour(ComboBox::textColourId, Colours::lightgrey);

  131.         comboBox3->setColour(ComboBox::outlineColourId, Colours::grey);

  132.         comboBox3->setColour(ComboBox::buttonColourId, Colours::grey);

  133.         comboBox3->setWantsKeyboardFocus(false);

  134.         comboBox3->setLookAndFeel(&mlaf);

  135. 

  136.         for (int i = 0, tableSize = WaveRenderer::getWaveTableSize(); i < tableSize; ++i)

  137.         {

  138.             String tableName(WaveRenderer::getWaveTableName(i));

  139. 

  140.             comboBox1->addItem(tableName, i + 1);

  141.             comboBox2->addItem(tableName, i + 1);

  142.             comboBox3->addItem(tableName, i + 1);

  143.         }

  144. 

  145.         //Make sliders

  146.         for (int i = 0; i < kSliderCount; ++i)

  147.         {

  148.             addAndMakeVisible(sliders[i] = new SnappingSlider("s"));

  149.             sliders[i]->setSliderStyle(Slider::RotaryVerticalDrag);

  150.             sliders[i]->setRange(0, 1, 0);

  151.             sliders[i]->setSnap(0.0f, 0.0f);

  152.             sliders[i]->setLookAndFeel(&mlaf);

  153.             sliders[i]->addListener(this);

  154.         }

  155. 

  156.         //Adjust the center of some

  157.         sliders[1]->setRange(0, 1, 0.25f);

  158.         sliders[1]->setSnap(0.5f, 0.05f);

  159.         sliders[2]->setSnap(0.5f, 0.05f);

  160.         sliders[3]->setSnap(0.5f, 0.05f);

  161.         sliders[4]->setSnap(0.5f, 0.05f);

  162.         sliders[8]->setSnap(0.5f, 0.05f);

  163.         sliders[13]->setSnap(0.5f, 0.05f);

  164.         sliders[18]->setSnap(0.5f, 0.05f);

  165. 

  166.         int tmp = 24;

  167.         sliders[1 + tmp]->setRange(0, 1, 0.25f);

  168.         sliders[1 + tmp]->setSnap(0.5f, 0.05f);

  169.         sliders[2 + tmp]->setSnap(0.5f, 0.05f);

  170.         sliders[3 + tmp]->setSnap(0.5f, 0.05f);

  171.         sliders[4 + tmp]->setSnap(0.5f, 0.05f);

  172.         sliders[8 + tmp]->setSnap(0.5f, 0.05f);

  173.         sliders[13 + tmp]->setSnap(0.5f, 0.05f);

  174.         sliders[18 + tmp]->setSnap(0.5f, 0.05f);

  175. 

  176.         tmp = 48;

  177.         sliders[1 + tmp]->setRange(0, 1, 0.25f);

  178.         sliders[1 + tmp]->setSnap(0.5f, 0.05f);

  179.         sliders[2 + tmp]->setSnap(0.5f, 0.05f);

  180.         sliders[3 + tmp]->setSnap(0.5f, 0.05f);

  181.         sliders[4 + tmp]->setSnap(0.5f, 0.05f);

  182.         sliders[8 + tmp]->setSnap(0.5f, 0.05f);

  183.         sliders[13 + tmp]->setSnap(0.5f, 0.05f);

  184.         sliders[18 + tmp]->setSnap(0.5f, 0.05f);

  185. 

  186.         sliders[83]->setSnap(0.5f, 0.05f);

  187.         sliders[84]->setSnap(0.5f, 0.05f);

  188.         sliders[85]->setSnap(0.5f, 0.05f);

  189. 

  190.         sliders[75]->setSnap(0.0f, 0.05f);

  191.         sliders[78]->setSnap(0.0f, 0.05f);

  192.         sliders[82]->setSnap(0.0f, 0.05f);

  193. 

  194.         //PART ON/OFF

  195.         addAndMakeVisible(TB1 = new TextButton("TB1"));

  196.         TB1->setButtonText(String::empty);

  197.         TB1->addListener(this);

  198.         TB1->setColour(TextButton::buttonColourId, Colours::darkred.withAlpha(0.5f));

  199.         TB1->setColour(TextButton::buttonOnColourId, Colours::red);

  200.         TB1->setClickingTogglesState(true);

  201.         TB1->setToggleState(false, dontSendNotification);

  202. 

  203.         addAndMakeVisible(TB2 = new TextButton("TB2"));

  204.         TB2->setButtonText(String::empty);

  205.         TB2->addListener(this);

  206.         TB2->setColour(TextButton::buttonColourId, Colours::darkred.withAlpha(0.5f));

  207.         TB2->setColour(TextButton::buttonOnColourId, Colours::red);

  208.         TB2->setClickingTogglesState(true);

  209.         TB2->setToggleState(false, dontSendNotification);

  210. 

  211.         addAndMakeVisible(TB3 = new TextButton("TB3"));

  212.         TB3->setButtonText(String::empty);

  213.         TB3->addListener(this);

  214.         TB3->setColour(TextButton::buttonColourId, Colours::darkred.withAlpha(0.5f));

  215.         TB3->setColour(TextButton::buttonOnColourId, Colours::red);

  216.         TB3->setClickingTogglesState(true);

  217.         TB3->setToggleState(false, dontSendNotification);

  218. 

  219.         //Peggy ON/OFF

  220.         addAndMakeVisible(TB4 = new TextButton("TB4"));

  221.         TB4->setButtonText(String::empty);

  222.         TB4->addListener(this);

  223.         TB4->setColour(TextButton::buttonColourId, Colours::darkblue.withAlpha(0.5f));

  224.         TB4->setColour(TextButton::buttonOnColourId, Colours::blue);

  225.         TB4->setClickingTogglesState(true);

  226.         TB4->setToggleState(false, dontSendNotification);

  227. 

  228.         addAndMakeVisible(TB5 = new TextButton("TB5"));

  229.         TB5->setButtonText(String::empty);

  230.         TB5->addListener(this);

  231.         TB5->setColour(TextButton::buttonColourId, Colours::darkblue.withAlpha(0.5f));

  232.         TB5->setColour(TextButton::buttonOnColourId, Colours::blue);

  233.         TB5->setClickingTogglesState(true);

  234.         TB5->setToggleState(false, dontSendNotification);

  235. 

  236.         addAndMakeVisible(TB6 = new TextButton("TB6"));

  237.         TB6->setButtonText(String::empty);

  238.         TB6->addListener(this);

  239.         TB6->setColour(TextButton::buttonColourId, Colours::darkblue.withAlpha(0.5f));

  240.         TB6->setColour(TextButton::buttonOnColourId, Colours::blue);

  241.         TB6->setClickingTogglesState(true);

  242.         TB6->setToggleState(false, dontSendNotification);

  243. 

  244.         addChildComponent(p1 = new PeggyViewComponent(arpSet1, this));

  245.         p1->setLookAndFeel(&mlaf);

  246.         addChildComponent(p2 = new PeggyViewComponent(arpSet2, this));

  247.         p2->setLookAndFeel(&mlaf);

  248.         addChildComponent(p3 = new PeggyViewComponent(arpSet3, this));

  249.         p3->setLookAndFeel(&mlaf);

  250. 

  251.         setSize(800,500);

  252.         updateParametersFromFilter(true);

  253. 

  254.         startTimer(50);

  255.     }

  256. 

  257.     ~VexEditorComponent() override

  258.     {

  259.         stopTimer();

  260.         removeAllChildren();

  261.     }

  262. 

  263.     void setNeedsUpdate()

  264.     {

  265.         fNeedsUpdate = true;

  266.     }

  267. 

  268. protected:

  269.     void paint(Graphics& g) override

  270.     {

  271.         g.drawImage(internalCachedImage1,

  272.                     0, 0, 800, 500,

  273.                     0, 0, internalCachedImage1.getWidth(), internalCachedImage1.getHeight());

  274.     }

  275. 

  276.     void resized() override

  277.     {

  278.         comboBox1->setBounds(13, 38, 173, 23);

  279.         comboBox2->setBounds(213, 38, 173, 23);

  280.         comboBox3->setBounds(413, 38, 173, 23);

  281. 

  282.         // ...

  283.         sliders[73]->setBounds(623, 23, 28, 28);

  284.         sliders[74]->setBounds(686, 23, 28, 28);

  285.         sliders[75]->setBounds(748, 23, 28, 28);

  286.         sliders[76]->setBounds(623, 98, 28, 28);

  287.         sliders[77]->setBounds(686, 98, 28, 28);

  288.         sliders[78]->setBounds(748, 98, 28, 28);

  289.         sliders[79]->setBounds(611, 173, 28, 28);

  290.         sliders[80]->setBounds(661, 173, 28, 28);

  291.         sliders[81]->setBounds(711, 173, 28, 28);

  292.         sliders[82]->setBounds(761, 173, 28, 28);

  293.         sliders[85]->setBounds(711, 373, 28, 28);

  294.         sliders[84]->setBounds(661, 373, 28, 28);

  295.         sliders[83]->setBounds(611, 373, 28, 28);

  296.         sliders[86]->setBounds(611, 449, 28, 28);

  297.         sliders[87]->setBounds(661, 449, 28, 28);

  298.         sliders[88]->setBounds(711, 449, 28, 28);

  299.         sliders[0]->setBounds(761, 449, 28, 28);

  300. 

  301.         // ...

  302.         sliders[1]->setBounds(11, 73, 28, 28);

  303.         sliders[2]->setBounds(61, 73, 28, 28);

  304.         sliders[3]->setBounds(111, 73, 28, 28);

  305.         sliders[4]->setBounds(161, 73, 28, 28);

  306.         sliders[24 + 1]->setBounds(211, 73, 28, 28);

  307.         sliders[24 + 2]->setBounds(261, 73, 28, 28);

  308.         sliders[24 + 3]->setBounds(311, 73, 28, 28);

  309.         sliders[24 + 4]->setBounds(361, 73, 28, 28);

  310.         sliders[48 + 1]->setBounds(411, 73, 28, 28);

  311.         sliders[48 + 2]->setBounds(461, 73, 28, 28);

  312.         sliders[48 + 3]->setBounds(511, 73, 28, 28);

  313.         sliders[48 + 4]->setBounds(561, 73, 28, 28);

  314. 

  315.         // ...

  316.         sliders[5]->setBounds(11, 149, 28, 28);

  317.         sliders[6]->setBounds(61, 149, 28, 28);

  318.         sliders[7]->setBounds(111, 149, 28, 28);

  319.         sliders[8]->setBounds(161, 149, 28, 28);

  320.         sliders[24 + 5]->setBounds(211, 149, 28, 28);

  321.         sliders[24 + 6]->setBounds(261, 149, 28, 28);

  322.         sliders[24 + 7]->setBounds(311, 149, 28, 28);

  323.         sliders[24 + 8]->setBounds(361, 149, 28, 28);

  324.         sliders[48 + 5]->setBounds(411, 149, 28, 28);

  325.         sliders[48 + 6]->setBounds(461, 149, 28, 28);

  326.         sliders[48 + 7]->setBounds(511, 149, 28, 28);

  327.         sliders[48 + 8]->setBounds(561, 149, 28, 28);

  328. 

  329.         // ...

  330.         sliders[9]->setBounds(11, 223, 28, 28);

  331.         sliders[10]->setBounds(48, 223, 28, 28);

  332.         sliders[11]->setBounds(86, 223, 28, 28);

  333.         sliders[12]->setBounds(123, 223, 28, 28);

  334.         sliders[13]->setBounds(161, 223, 28, 28);

  335.         sliders[24 + 9]->setBounds(211, 223, 28, 28);

  336.         sliders[24 + 10]->setBounds(248, 223, 28, 28);

  337.         sliders[24 + 11]->setBounds(286, 223, 28, 28);

  338.         sliders[24 + 12]->setBounds(323, 223, 28, 28);

  339.         sliders[24 + 13]->setBounds(361, 223, 28, 28);

  340.         sliders[48 + 9]->setBounds(411, 223, 28, 28);

  341.         sliders[48 + 10]->setBounds(448, 223, 28, 28);

  342.         sliders[48 + 11]->setBounds(486, 223, 28, 28);

  343.         sliders[48 + 12]->setBounds(523, 223, 28, 28);

  344.         sliders[48 + 13]->setBounds(561, 223, 28, 28);

  345. 

  346.         // ...

  347.         sliders[14]->setBounds(11, 298, 28, 28);

  348.         sliders[15]->setBounds(48, 298, 28, 28);

  349.         sliders[16]->setBounds(86, 298, 28, 28);

  350.         sliders[17]->setBounds(123, 298, 28, 28);

  351.         sliders[18]->setBounds(161, 298, 28, 28);

  352.         sliders[24 + 14]->setBounds(211, 298, 28, 28);

  353.         sliders[24 + 15]->setBounds(248, 298, 28, 28);

  354.         sliders[24 + 16]->setBounds(286, 298, 28, 28);

  355.         sliders[24 + 17]->setBounds(323, 298, 28, 28);

  356.         sliders[24 + 18]->setBounds(361, 298, 28, 28);

  357.         sliders[48 + 14]->setBounds(411, 298, 28, 28);

  358.         sliders[48 + 15]->setBounds(448, 298, 28, 28);

  359.         sliders[48 + 16]->setBounds(486, 298, 28, 28);

  360.         sliders[48 + 17]->setBounds(523, 298, 28, 28);

  361.         sliders[48 + 18]->setBounds(561, 298, 28, 28);

  362. 

  363.         // ...

  364.         sliders[19]->setBounds(11, 374, 28, 28);

  365.         sliders[20]->setBounds(86, 374, 28, 28);

  366.         sliders[21]->setBounds(161, 374, 28, 28);

  367.         sliders[24 + 19]->setBounds(211, 374, 28, 28);

  368.         sliders[24 + 20]->setBounds(286, 374, 28, 28);

  369.         sliders[24 + 21]->setBounds(361, 374, 28, 28);

  370.         sliders[48 + 19]->setBounds(411, 374, 28, 28);

  371.         sliders[48 + 20]->setBounds(486, 374, 28, 28);

  372.         sliders[48 + 21]->setBounds(561, 374, 28, 28);

  373. 

  374.         // ...

  375.         sliders[22]->setBounds(11, 448, 28, 28);

  376.         sliders[23]->setBounds(86, 448, 28, 28);

  377.         sliders[24]->setBounds(161, 448, 28, 28);

  378.         sliders[24 + 22]->setBounds(211, 448, 28, 28);

  379.         sliders[24 + 23]->setBounds(286, 448, 28, 28);

  380.         sliders[48]->setBounds(361, 448, 28, 28);

  381.         sliders[48 + 22]->setBounds(411, 448, 28, 28);

  382.         sliders[48 + 23]->setBounds(486, 448, 28, 28);

  383.         sliders[48 + 24]->setBounds(561, 448, 28, 28);

  384. 

  385.         TB1->setBounds(174, 4, 13, 13);

  386.         TB2->setBounds(374, 4, 13, 13);

  387.         TB3->setBounds(574, 4, 13, 13);

  388.         TB4->setBounds(154, 4, 13, 13);

  389.         TB5->setBounds(354, 4, 13, 13);

  390.         TB6->setBounds(554, 4, 13, 13);

  391. 

  392.         p1->setBounds(10, 20, 207, 280);

  393.         p2->setBounds(210, 20, 207, 280);

  394.         p3->setBounds(410, 20, 207, 280);

  395.     }

  396. 

  397.     void timerCallback() override

  398.     {

  399.         if (fNeedsUpdate)

  400.         {

  401.             updateParametersFromFilter(true);

  402.             fNeedsUpdate = false;

  403.         }

  404.         else

  405.         {

  406.             updateParametersFromFilter(false);

  407.         }

  408.     }

  409. 

  410.     void comboBoxChanged(ComboBox* comboBoxThatHasChanged) override

  411.     {

  412.         if (comboBoxThatHasChanged == comboBox1)

  413.             fCallback->editorWaveChanged(1, comboBox1->getText());

  414.         else if (comboBoxThatHasChanged == comboBox2)

  415.             fCallback->editorWaveChanged(2, comboBox2->getText());

  416.         else if (comboBoxThatHasChanged == comboBox3)

  417.             fCallback->editorWaveChanged(3, comboBox3->getText());

  418.     }

  419. 

  420.     void sliderValueChanged(Slider* sliderThatWasMoved) override

  421.     {

  422.         for (int i = 0; i < kSliderCount; ++i)

  423.         {

  424.             if (sliders[i] == sliderThatWasMoved)

  425.             {

  426.                 fCallback->editorParameterChanged(i, (float)sliderThatWasMoved->getValue());

  427.                 return;

  428.             }

  429.         }

  430.     }

  431. 

  432.     void buttonClicked(Button* buttonThatWasClicked) override

  433.     {

  434.         if (buttonThatWasClicked == TB1)

  435.             fCallback->editorParameterChanged(89, TB1->getToggleState() ? 1.0f : 0.0f);

  436.         else if (buttonThatWasClicked == TB2)

  437.             fCallback->editorParameterChanged(90, TB2->getToggleState() ? 1.0f : 0.0f);

  438.         else if (buttonThatWasClicked == TB3)

  439.             fCallback->editorParameterChanged(91, TB3->getToggleState() ? 1.0f : 0.0f);

  440.         else if (buttonThatWasClicked == TB4)

  441.             p1->setVisible(!p1->isVisible());

  442.         else if (buttonThatWasClicked == TB5)

  443.             p2->setVisible(!p2->isVisible());

  444.         else if (buttonThatWasClicked == TB6)

  445.             p3->setVisible(!p3->isVisible());

  446.     }

  447. 

  448.     void arpParameterChanged(const uint32_t) override

  449.     {

  450.         // unused, we don't need to register arp settings changes in synth

  451.     }

  452. 

  453.     void updateParametersFromFilter(const bool all)

  454.     {

  455.         if (all)

  456.         {

  457.             for (int i = 0; i < kSliderCount; ++i)

  458.                 sliders[i]->setValue(fCallback->getFilterParameterValue(i), dontSendNotification);

  459. 

  460.             TB1->setToggleState(fCallback->getFilterParameterValue(89) > 0.5f ? true : false, dontSendNotification);

  461.             TB2->setToggleState(fCallback->getFilterParameterValue(90) > 0.5f ? true : false, dontSendNotification);

  462.             TB3->setToggleState(fCallback->getFilterParameterValue(91) > 0.5f ? true : false, dontSendNotification);

  463. 

  464.             comboBox1->setText(fCallback->getFilterWaveName(1), dontSendNotification);

  465.             comboBox2->setText(fCallback->getFilterWaveName(2), dontSendNotification);

  466.             comboBox3->setText(fCallback->getFilterWaveName(3), dontSendNotification);

  467. 

  468.             p1->update();

  469.             p2->update();

  470.             p3->update();

  471.         }

  472.         else

  473.         {

  474.             bool params[92];

  475.             fCallback->getChangedParameters(params);

  476. 

  477.             for (int i=0; i < kSliderCount; ++i)

  478.             {

  479.                 if (params[i])

  480.                     sliders[i]->setValue(fCallback->getFilterParameterValue(i), dontSendNotification);

  481.             }

  482. 

  483.             if (params[89]) TB1->setToggleState(fCallback->getFilterParameterValue(89) > 0.5f ? true : false, dontSendNotification);

  484.             if (params[90]) TB2->setToggleState(fCallback->getFilterParameterValue(90) > 0.5f ? true : false, dontSendNotification);

  485.             if (params[91]) TB3->setToggleState(fCallback->getFilterParameterValue(91) > 0.5f ? true : false, dontSendNotification);

  486.         }

  487.     }

  488. 

  489. private:

  490.     static const int kSliderCount = 89;

  491. 

  492.     Callback* const fCallback;

  493.     volatile bool fNeedsUpdate;

  494. 

  495.     Image internalCachedImage1;

  496.     MyLookAndFeel mlaf;

  497. 

  498.     ScopedPointer<ComboBox> comboBox1;

  499.     ScopedPointer<ComboBox> comboBox2;

  500.     ScopedPointer<ComboBox> comboBox3;

  501. 

  502.     ScopedPointer<SnappingSlider> sliders[kSliderCount];

  503. 

  504.     ScopedPointer<TextButton> TB1;

  505.     ScopedPointer<TextButton> TB2;

  506.     ScopedPointer<TextButton> TB3;

  507.     ScopedPointer<TextButton> TB4;

  508.     ScopedPointer<TextButton> TB5;

  509.     ScopedPointer<TextButton> TB6;

  510. 

  511.     ScopedPointer<PeggyViewComponent> p1;

  512.     ScopedPointer<PeggyViewComponent> p2;

  513.     ScopedPointer<PeggyViewComponent> p3;

  514. };

  515. 

  516. // -----------------------------------------------------------------------

  517. 

  518. class VexSynthPlugin : public NativePluginClass,

  519.                        public VexEditorComponent::Callback

  520. {

  521. public:

  522.     static const unsigned int kParamCount = 92;

  523. 

  524.     VexSynthPlugin(const NativeHostDescriptor* const host)

  525.         : NativePluginClass(host),

  526.           fArp1(&fArpSet1),

  527.           fArp2(&fArpSet2),

  528.           fArp3(&fArpSet3),

  529.           fChorus(fParameters),

  530.           fDelay(fParameters),

  531.           fReverb(fParameters),

  532.           fSynth(fParameters)

  533.     {

  534.         std::memset(fParameters, 0, sizeof(float)*kParamCount);

  535.         std::memset(fParamsChanged, 0, sizeof(bool)*92);

  536. 

  537.         fParameters[0] = 1.0f; // main volume

  538. 

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

  540.         {

  541.             const int offset = i * 24;

  542. 

  543.             fParameters[offset +  1] = 0.5f;

  544.             fParameters[offset +  2] = 0.5f;

  545.             fParameters[offset +  3] = 0.5f;

  546.             fParameters[offset +  4] = 0.5f;

  547.             fParameters[offset +  5] = 0.9f;

  548.             fParameters[offset +  6] = 0.0f;

  549.             fParameters[offset +  7] = 1.0f;

  550.             fParameters[offset +  8] = 0.5f;

  551.             fParameters[offset +  9] = 0.0f;

  552.             fParameters[offset + 10] = 0.2f;

  553.             fParameters[offset + 11] = 0.0f;

  554.             fParameters[offset + 12] = 0.5f;

  555.             fParameters[offset + 13] = 0.5f;

  556.             fParameters[offset + 14] = 0.0f;

  557.             fParameters[offset + 15] = 0.3f;

  558.             fParameters[offset + 16] = 0.7f;

  559.             fParameters[offset + 17] = 0.1f;

  560.             fParameters[offset + 18] = 0.5f;

  561.             fParameters[offset + 19] = 0.5f;

  562.             fParameters[offset + 20] = 0.0f;

  563.             fParameters[offset + 21] = 0.0f;

  564.             fParameters[offset + 22] = 0.5f;

  565.             fParameters[offset + 23] = 0.5f;

  566.             fParameters[offset + 24] = 0.5f;

  567.         }

  568. 

  569.         // ^1 - 72

  570. 

  571.         fParameters[73] = 0.5f; // Delay Time

  572.         fParameters[74] = 0.4f; // Delay Feedback

  573.         fParameters[75] = 0.0f; // Delay Volume

  574. 

  575.         fParameters[76] = 0.3f; // Chorus Rate

  576.         fParameters[77] = 0.6f; // Chorus Depth

  577.         fParameters[78] = 0.5f; // Chorus Volume

  578. 

  579.         fParameters[79] = 0.6f; // Reverb Size

  580.         fParameters[80] = 0.7f; // Reverb Width

  581.         fParameters[81] = 0.6f; // Reverb Damp

  582.         fParameters[82] = 0.0f; // Reverb Volume

  583. 

  584.         fParameters[83] = 0.5f; // wave1 panning

  585.         fParameters[84] = 0.5f; // wave2 panning

  586.         fParameters[85] = 0.5f; // wave3 panning

  587. 

  588.         fParameters[86] = 0.5f; // wave1 volume

  589.         fParameters[87] = 0.5f; // wave2 volume

  590.         fParameters[88] = 0.5f; // wave3 volume

  591. 

  592.         fParameters[89] = 1.0f; // wave1 on/off

  593.         fParameters[90] = 0.0f; // wave2 on/off

  594.         fParameters[91] = 0.0f; // wave3 on/off

  595. 

  596.         bufferSizeChanged(getBufferSize());

  597.         sampleRateChanged(getSampleRate());

  598. 

  599.         for (unsigned int i = 0; i < kParamCount; ++i)

  600.             fSynth.update(i);

  601. 

  602.         fMidiInBuffer.ensureSize(512*4);

  603.     }

  604. 

  605.     ~VexSynthPlugin() override

  606.     {

  607.     }

  608. 

  609. protected:

  610.     // -------------------------------------------------------------------

  611.     // Plugin parameter calls

  612. 

  613.     uint32_t getParameterCount() const override

  614.     {

  615.         return kParamCount;

  616.     }

  617. 

  618.     const NativeParameter* getParameterInfo(const uint32_t index) const override

  619.     {

  620.         static CarlaString tmpName;

  621.         static NativeParameter paramInfo;

  622. 

  623.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  624. 

  625.         paramInfo.name = nullptr;

  626.         paramInfo.unit = nullptr;

  627.         paramInfo.ranges.def       = 0.0f;

  628.         paramInfo.ranges.min       = 0.0f;

  629.         paramInfo.ranges.max       = 1.0f;

  630.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  631.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  632.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  633.         paramInfo.scalePointCount  = 0;

  634.         paramInfo.scalePoints      = nullptr;

  635. 

  636.         if (index >= 1 && index <= 72)

  637.         {

  638.             uint32_t ri = index % 24;

  639. 

  640.             switch (ri)

  641.             {

  642.             case 1:

  643.                 tmpName = "Part0 Oct";

  644.                 paramInfo.ranges.def = 0.5f;

  645.                 break;

  646.             case 2:

  647.                 tmpName = "Part0 Cent";

  648.                 paramInfo.ranges.def = 0.5f;

  649.                 break;

  650.             case 3:

  651.                 tmpName = "Part0 Phase";

  652.                 paramInfo.ranges.def = 0.5f;

  653.                 break;

  654.             case 4:

  655.                 tmpName = "Part0 Tune";

  656.                 paramInfo.ranges.def = 0.5f;

  657.                 break;

  658.             case 5:

  659.                 tmpName = "Part0 Filter Cut";

  660.                 paramInfo.ranges.def = 0.9f;

  661.                 break;

  662.             case 6:

  663.                 tmpName = "Part0 Filter Res";

  664.                 paramInfo.ranges.def = 0.0f;

  665.                 break;

  666.             case 7:

  667.                 tmpName = "Part0 Filter HP/LP";

  668.                 paramInfo.ranges.def = 1.0f;

  669.                 break;

  670.             case 8:

  671.                 tmpName = "Part0 Filter Env";

  672.                 paramInfo.ranges.def = 0.5f;

  673.                 break;

  674.             case 9:

  675.                 tmpName = "Part0 Filter Env Atk";

  676.                 paramInfo.ranges.def = 0.0f;

  677.                 break;

  678.             case 10:

  679.                 tmpName = "Part0 Filter Env Dec";

  680.                 paramInfo.ranges.def = 0.2f;

  681.                 break;

  682.             case 11:

  683.                 tmpName = "Part0 Filter Env Sus";

  684.                 paramInfo.ranges.def = 0.0f;

  685.                 break;

  686.             case 12:

  687.                 tmpName = "Part0 Filter Env Rel";

  688.                 paramInfo.ranges.def = 0.5f;

  689.                 break;

  690.             case 13:

  691.                 tmpName = "Part0 Filter Env Vel";

  692.                 paramInfo.ranges.def = 0.5f;

  693.                 break;

  694.             case 14:

  695.                 tmpName = "Part0 Amp Env Atk";

  696.                 paramInfo.ranges.def = 0.0f;

  697.                 break;

  698.             case 15:

  699.                 tmpName = "Part0 Amp Env Dec";

  700.                 paramInfo.ranges.def = 0.3f;

  701.                 break;

  702.             case 16:

  703.                 tmpName = "Part0 Amp Env Sus";

  704.                 paramInfo.ranges.def = 0.7f;

  705.                 break;

  706.             case 17:

  707.                 tmpName = "Part0 Amp Env Rel";

  708.                 paramInfo.ranges.def = 0.1f;

  709.                 break;

  710.             case 18:

  711.                 tmpName = "Part0 Amp Env Vel";

  712.                 paramInfo.ranges.def = 0.5f;

  713.                 break;

  714.             case 19:

  715.                 tmpName = "Part0 LFO Rate";

  716.                 paramInfo.ranges.def = 0.5f;

  717.                 break;

  718.             case 20:

  719.                 tmpName = "Part0 LFO Amp";

  720.                 paramInfo.ranges.def = 0.0f;

  721.                 break;

  722.             case 21:

  723.                 tmpName = "Part0 LFO Flt";

  724.                 paramInfo.ranges.def = 0.0f;

  725.                 break;

  726.             case 22:

  727.                 tmpName = "Part0 Delay";

  728.                 paramInfo.ranges.def = 0.5f;

  729.                 break;

  730.             case 23:

  731.                 tmpName = "Part0 Chorus";

  732.                 paramInfo.ranges.def = 0.5f;

  733.                 break;

  734.             case 24:

  735.             case 0:

  736.                 tmpName = "Part0 Reverb";

  737.                 paramInfo.ranges.def = 0.5f;

  738.                 break;

  739.             default:

  740.                 tmpName = "Part0 Unknown";

  741.                 break;

  742.             }

  743. 

  744. #ifdef CARLA_OS_LINUX

  745.             // there seems to be a problem with this...

  746.             tmpName[4] = '0' + ((index-1+24) / 24);

  747. #else

  748.             char* tmpBuf(const_cast<char*>(tmpName.buffer()));

  749.             tmpBuf[4] = '0' + ((index-1+24) / 24);

  750. #endif

  751. 

  752.             paramInfo.name  = (const char*)tmpName;

  753.             paramInfo.hints = static_cast<NativeParameterHints>(hints);

  754.             return &paramInfo;

  755.         }

  756. 

  757.         switch (index)

  758.         {

  759.         case 0:

  760.             paramInfo.name = "Master";

  761.             paramInfo.ranges.def = 1.0f;

  762.             break;

  763.         case 73:

  764.             hints |= PARAMETER_IS_INTEGER;

  765.             paramInfo.name = "Delay Time";

  766.             paramInfo.unit = "steps";

  767.             paramInfo.ranges.def = 4.0f;

  768.             paramInfo.ranges.min = 0.0f;

  769.             paramInfo.ranges.max = 8.0f;

  770.             break;

  771.         case 74:

  772.             paramInfo.name = "Delay Feedback";

  773.             paramInfo.unit = "%";

  774.             paramInfo.ranges.def = 40.0f;

  775.             paramInfo.ranges.min = 0.0f;

  776.             paramInfo.ranges.max = 100.0f;

  777.             break;

  778.         case 75:

  779.             paramInfo.name = "Delay Level";

  780.             paramInfo.ranges.def = 0.0f;

  781.             break;

  782.         case 76:

  783.             paramInfo.name = "Chorus Rate";

  784.             paramInfo.ranges.def = 0.3f;

  785.             break;

  786.         case 77:

  787.             paramInfo.name = "Chorus Depth";

  788.             paramInfo.ranges.def = 0.6f;

  789.             break;

  790.         case 78:

  791.             paramInfo.name = "Chorus Level";

  792.             paramInfo.ranges.def = 0.5f;

  793.             break;

  794.         case 79:

  795.             paramInfo.name = "Reverb Size";

  796.             paramInfo.ranges.def = 0.6f;

  797.             break;

  798.         case 80:

  799.             paramInfo.name = "Reverb Width";

  800.             paramInfo.ranges.def = 0.7f;

  801.             break;

  802.         case 81:

  803.             paramInfo.name = "Reverb Damp";

  804.             paramInfo.ranges.def = 0.6f;

  805.             break;

  806.         case 82:

  807.             paramInfo.name = "Reverb Level";

  808.             paramInfo.ranges.def = 0.0f;

  809.             break;

  810.         case 83:

  811.             paramInfo.name = "Part1 Panning";

  812.             paramInfo.ranges.def = 0.5f;

  813.             break;

  814.         case 84:

  815.             paramInfo.name = "Part2 Panning";

  816.             paramInfo.ranges.def = 0.5f;

  817.             break;

  818.         case 85:

  819.             paramInfo.name = "Part3 Panning";

  820.             paramInfo.ranges.def = 0.5f;

  821.             break;

  822.         case 86:

  823.             paramInfo.name = "Part1 Volume";

  824.             paramInfo.ranges.def = 0.5f;

  825.             break;

  826.         case 87:

  827.             paramInfo.name = "Part2 Volume";

  828.             paramInfo.ranges.def = 0.5f;

  829.             break;

  830.         case 88:

  831.             paramInfo.name = "Part3 Volume";

  832.             paramInfo.ranges.def = 0.5f;

  833.             break;

  834.         case 89:

  835.             hints |= PARAMETER_IS_BOOLEAN;

  836.             paramInfo.name = "Part1 on/off";

  837.             paramInfo.ranges.def = 1.0f;

  838.             break;

  839.         case 90:

  840.             hints |= PARAMETER_IS_BOOLEAN;

  841.             paramInfo.name = "Part2 on/off";

  842.             paramInfo.ranges.def = 0.0f;

  843.             break;

  844.         case 91:

  845.             hints |= PARAMETER_IS_BOOLEAN;

  846.             paramInfo.name = "Part3 on/off";

  847.             paramInfo.ranges.def = 0.0f;

  848.             break;

  849.         default:

  850.             paramInfo.name = "unknown";

  851.             break;

  852.         }

  853. 

  854.         paramInfo.hints = static_cast<NativeParameterHints>(hints);

  855.         return &paramInfo;

  856.     }

  857. 

  858.     float getParameterValue(const uint32_t index) const override

  859.     {

  860.         if (index >= kParamCount)

  861.             return 0.0f;

  862. 

  863.         switch (index)

  864.         {

  865.         case 73:

  866.             return fParameters[index] * 8.0f;

  867.         case 74:

  868.             return fParameters[index] * 100.0f;

  869.         default:

  870.             return fParameters[index];

  871.         }

  872.     }

  873. 

  874.     // -------------------------------------------------------------------

  875.     // Plugin state calls

  876. 

  877.     void setParameterValue(const uint32_t index, const float value) override

  878.     {

  879.         if (index >= kParamCount)

  880.             return;

  881. 

  882.         float realValue;

  883. 

  884.         switch (index)

  885.         {

  886.         case 73:

  887.             realValue = value/8.0f;

  888.             break;

  889.         case 74:

  890.             realValue = value/100.0f;

  891.             break;

  892.         default:

  893.             realValue = value;

  894.             break;

  895.         }

  896. 

  897.         fParameters[index] = realValue;

  898.         fParamsChanged[index] = true;

  899.         fSynth.update(index);

  900.     }

  901. 

  902.     // -------------------------------------------------------------------

  903.     // Plugin process calls

  904. 

  905.     void process(float**, float** outBuffer, const uint32_t frames, const NativeMidiEvent* const midiEvents, const uint32_t midiEventCount) override

  906.     {

  907.         // Get time info

  908.         const NativeTimeInfo* const timeInfo(getTimeInfo());

  909. 

  910.         bool   timePlaying = false;

  911.         double ppqPos      = 0.0;

  912.         double barStartPos = 0.0;

  913.         double bpm         = 120.0;

  914. 

  915.         if (timeInfo != nullptr)

  916.         {

  917.             timePlaying = timeInfo->playing;

  918. 

  919.             if (timeInfo->bbt.valid)

  920.             {

  921.                 double ppqBar  = double(timeInfo->bbt.bar - 1) * timeInfo->bbt.beatsPerBar;

  922.                 double ppqBeat = double(timeInfo->bbt.beat - 1);

  923.                 double ppqTick = double(timeInfo->bbt.tick) / timeInfo->bbt.ticksPerBeat;

  924. 

  925.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  926.                 barStartPos = ppqBar;

  927.                 bpm         = timeInfo->bbt.beatsPerMinute;

  928.             }

  929.         }

  930. 

  931.         // put carla events in juce midi buffer

  932.         fMidiInBuffer.clear();

  933. 

  934.         for (uint32_t i=0; i < midiEventCount; ++i)

  935.         {

  936.             const NativeMidiEvent* const midiEvent(&midiEvents[i]);

  937.             fMidiInBuffer.addEvent(MidiMessage(midiEvent->data, midiEvent->size), midiEvent->time);

  938.         }

  939. 

  940.         // process MIDI (arppeggiator)

  941.         const MidiBuffer& part1Midi(fArpSet1.on ? fArp1.processMidi(fMidiInBuffer, timePlaying, ppqPos, barStartPos, bpm, frames) : fMidiInBuffer);

  942.         const MidiBuffer& part2Midi(fArpSet2.on ? fArp2.processMidi(fMidiInBuffer, timePlaying, ppqPos, barStartPos, bpm, frames) : fMidiInBuffer);

  943.         const MidiBuffer& part3Midi(fArpSet3.on ? fArp3.processMidi(fMidiInBuffer, timePlaying, ppqPos, barStartPos, bpm, frames) : fMidiInBuffer);

  944. 

  945.         int snum;

  946.         MidiMessage midiMessage(0xf4);

  947. 

  948.         for (MidiBuffer::Iterator Iterator1(part1Midi); Iterator1.getNextEvent(midiMessage, snum);)

  949.         {

  950.             if (midiMessage.isNoteOn())

  951.                 fSynth.playNote(midiMessage.getNoteNumber(), midiMessage.getVelocity(), snum, 1);

  952.             else if (midiMessage.isNoteOff())

  953.                 fSynth.releaseNote(midiMessage.getNoteNumber(), snum, 1);

  954.             else if (midiMessage.isAllSoundOff())

  955.                 fSynth.kill();

  956.             else if (midiMessage.isAllNotesOff())

  957.                 fSynth.releaseAll(snum);

  958.         }

  959. 

  960.         for (MidiBuffer::Iterator Iterator2(part2Midi); Iterator2.getNextEvent(midiMessage, snum);)

  961.         {

  962.             if (midiMessage.isNoteOn())

  963.                 fSynth.playNote(midiMessage.getNoteNumber(), midiMessage.getVelocity(), snum, 2);

  964.             else if (midiMessage.isNoteOff())

  965.                 fSynth.releaseNote(midiMessage.getNoteNumber(), snum, 2);

  966.         }

  967. 

  968.         for (MidiBuffer::Iterator Iterator3(part3Midi); Iterator3.getNextEvent(midiMessage, snum);)

  969.         {

  970.             if (midiMessage.isNoteOn())

  971.                 fSynth.playNote(midiMessage.getNoteNumber(), midiMessage.getVelocity(), snum, 3);

  972.             else if (midiMessage.isNoteOff())

  973.                 fSynth.releaseNote(midiMessage.getNoteNumber(), snum, 3);

  974.         }

  975. 

  976.         fMidiInBuffer.clear();

  977. 

  978.         if (obf.getNumSamples() < (int)frames)

  979.         {

  980.             obf.setSize(2,  frames, false, false, true);

  981.             dbf1.setSize(2, frames, false, false, true);

  982.             dbf2.setSize(2, frames, false, false, true);

  983.             dbf3.setSize(2, frames, false, false, true);

  984.         }

  985. 

  986.         obf .clear();

  987.         dbf1.clear();

  988.         dbf2.clear();

  989.         dbf3.clear();

  990. 

  991.         fSynth.doProcess(obf, dbf1, dbf2, dbf3);

  992. 

  993.         if (fParameters[75] > 0.001f)

  994.         {

  995.             fDelay.processBlock(dbf1, bpm);

  996.             obf.addFrom(0, 0, dbf1, 0, 0, frames, fParameters[75]);

  997.             obf.addFrom(1, 0, dbf1, 1, 0, frames, fParameters[75]);

  998.         }

  999. 

  1000.         if (fParameters[78] > 0.001f)

  1001.         {

  1002.             fChorus.processBlock(dbf2);

  1003.             obf.addFrom(0, 0, dbf2, 0, 0, frames, fParameters[78]);

  1004.             obf.addFrom(1, 0, dbf2, 1, 0, frames, fParameters[78]);

  1005.         }

  1006. 

  1007.         if (fParameters[82] > 0.001f)

  1008.         {

  1009.             fReverb.processBlock(dbf3);

  1010.             obf.addFrom(0, 0, dbf3, 0, 0, frames, fParameters[82]);

  1011.             obf.addFrom(1, 0, dbf3, 1, 0, frames, fParameters[82]);

  1012.         }

  1013. 

  1014.         FloatVectorOperations::copyWithMultiply(outBuffer[0], obf.getReadPointer(0), fParameters[0], frames);

  1015.         FloatVectorOperations::copyWithMultiply(outBuffer[1], obf.getReadPointer(1), fParameters[0], frames);

  1016.     }

  1017. 

  1018.     // -------------------------------------------------------------------

  1019.     // Plugin UI calls

  1020. 

  1021.     void uiShow(const bool show) override

  1022.     {

  1023.         const MessageManagerLock mmLock;

  1024. 

  1025.         if (show)

  1026.         {

  1027.             if (fWindow == nullptr)

  1028.             {

  1029.                 fWindow = new JucePluginWindow();

  1030.                 fWindow->setName(getUiName());

  1031.             }

  1032. 

  1033.             if (fView == nullptr)

  1034.                 fView = new VexEditorComponent(this, fArpSet1, fArpSet2, fArpSet3);

  1035. 

  1036.             fWindow->show(fView);

  1037. 

  1038.             if (const uintptr_t winId = getUiParentId())

  1039.                 fWindow->setTransientWinId(winId);

  1040.         }

  1041.         else if (fWindow != nullptr)

  1042.         {

  1043.             fWindow->hide();

  1044. 

  1045.             fView = nullptr;

  1046.             fWindow = nullptr;

  1047.         }

  1048.     }

  1049. 

  1050.     void uiIdle() override

  1051.     {

  1052.         if (fWindow == nullptr)

  1053.             return;

  1054. 

  1055.         if (fWindow->wasClosedByUser())

  1056.         {

  1057.             uiShow(false);

  1058.             uiClosed();

  1059.         }

  1060.     }

  1061. 

  1062.     // -------------------------------------------------------------------

  1063.     // Plugin state calls

  1064. 

  1065.     char* getState() const override

  1066.     {

  1067.         MemoryBlock destData;

  1068.         //destData.append(fParameters, sizeof(float) * kParamCount);

  1069.         destData.append(&fArpSet1, sizeof(VexArpSettings));

  1070.         destData.append(&fArpSet2, sizeof(VexArpSettings));

  1071.         destData.append(&fArpSet3, sizeof(VexArpSettings));

  1072. 

  1073.         XmlElement xmlState("VEX");

  1074. 

  1075.         xmlState.setAttribute("Wave1", fSynth.getWaveName(1));

  1076.         xmlState.setAttribute("Wave2", fSynth.getWaveName(2));

  1077.         xmlState.setAttribute("Wave3", fSynth.getWaveName(3));

  1078. 

  1079.         MemoryBlock tmp;

  1080.         copyXmlToBinary(xmlState, tmp);

  1081. 

  1082.         destData.append(tmp.getData(), tmp.getSize());

  1083. 

  1084.         return strdup(destData.toBase64Encoding().toRawUTF8());

  1085.     }

  1086. 

  1087.     void setState(const char* const data64) override

  1088.     {

  1089.         static const int kParamDataSize = 0; //sizeof(float)*kParamCount

  1090.         static const int xmlOffset      = kParamDataSize + sizeof(VexArpSettings) * 3;

  1091. 

  1092.         MemoryBlock destData;

  1093.         destData.fromBase64Encoding(data64);

  1094. 

  1095.         const char* const data(&destData[0]);

  1096.         const size_t  dataSize(destData.getSize());

  1097. 

  1098.         if (XmlElement* const xmlState = getXmlFromBinary(data + xmlOffset, dataSize - xmlOffset))

  1099.         {

  1100.             if (xmlState->hasTagName("VEX"))

  1101.             {

  1102.                 fSynth.setWaveLater(1, xmlState->getStringAttribute("Wave1"));

  1103.                 fSynth.setWaveLater(2, xmlState->getStringAttribute("Wave2"));

  1104.                 fSynth.setWaveLater(3, xmlState->getStringAttribute("Wave3"));

  1105. 

  1106.                 //std::memcpy(fParameters, data,                                               sizeof(float) * kParamCount);

  1107.                 std::memcpy(&fArpSet1,   data + (kParamDataSize + sizeof(VexArpSettings)*0), sizeof(VexArpSettings));

  1108.                 std::memcpy(&fArpSet2,   data + (kParamDataSize + sizeof(VexArpSettings)*1), sizeof(VexArpSettings));

  1109.                 std::memcpy(&fArpSet3,   data + (kParamDataSize + sizeof(VexArpSettings)*2), sizeof(VexArpSettings));

  1110. 

  1111.                 //for (unsigned int i = 0; i < kParamCount; ++i)

  1112.                 //    fSynth.update(i);

  1113. 

  1114.                 if (fView != nullptr)

  1115.                     fView->setNeedsUpdate();

  1116.             }

  1117. 

  1118.             delete xmlState;

  1119.         }

  1120.     }

  1121. 

  1122.     // -------------------------------------------------------------------

  1123.     // Plugin dispatcher calls

  1124. 

  1125.     void bufferSizeChanged(const uint32_t bufferSize) override

  1126.     {

  1127.         obf.setSize(2, bufferSize);

  1128.         dbf1.setSize(2, bufferSize);

  1129.         dbf2.setSize(2, bufferSize);

  1130.         dbf3.setSize(2, bufferSize);

  1131.         fSynth.setBufferSize(bufferSize);

  1132.     }

  1133. 

  1134.     void sampleRateChanged(const double sampleRate) override

  1135.     {

  1136.         fArp1.setSampleRate(sampleRate);

  1137.         fArp2.setSampleRate(sampleRate);

  1138.         fArp3.setSampleRate(sampleRate);

  1139.         fChorus.setSampleRate(sampleRate);

  1140.         fDelay.setSampleRate(sampleRate);

  1141.         fSynth.setSampleRate(sampleRate);

  1142.     }

  1143. 

  1144.     void uiNameChanged(const char* const uiName) override

  1145.     {

  1146.         if (fWindow == nullptr)

  1147.             return;

  1148. 

  1149.         const MessageManagerLock mmLock;

  1150.         fWindow->setName(uiName);

  1151.     }

  1152. 

  1153.     // -------------------------------------------------------------------

  1154.     // Vex editor calls

  1155. 

  1156.     void getChangedParameters(bool params[92]) override

  1157.     {

  1158.         std::memcpy(params, fParamsChanged, sizeof(bool)*92);

  1159.         std::memset(fParamsChanged, 0, sizeof(bool)*92);

  1160.     }

  1161. 

  1162.     float getFilterParameterValue(const uint32_t index) const override

  1163.     {

  1164.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount, 0.0f)

  1165. 

  1166.         return fParameters[index];

  1167.     }

  1168. 

  1169.     String getFilterWaveName(const int part) const override

  1170.     {

  1171.         CARLA_SAFE_ASSERT_RETURN(part >= 1 && part <= 3, "")

  1172. 

  1173.         return fSynth.getWaveName(part);

  1174.     }

  1175. 

  1176.     void editorParameterChanged(const uint32_t index, const float value) override

  1177.     {

  1178.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount,)

  1179. 

  1180.         if (fParameters[index] == value)

  1181.             return;

  1182. 

  1183.         fParameters[index] = value;

  1184.         fSynth.update(index);

  1185. 

  1186.         uiParameterChanged(index, getParameterValue(index)); // some params have specific bounds

  1187.     }

  1188. 

  1189.     void editorWaveChanged(const int part, const String& wave) override

  1190.     {

  1191.         CARLA_SAFE_ASSERT_RETURN(part >= 1 && part <= 3,)

  1192. 

  1193.         fSynth.setWaveLater(part, wave);

  1194.     }

  1195. 

  1196. private:

  1197.     float fParameters[kParamCount];

  1198.     bool  fParamsChanged[92];

  1199. 

  1200.     AudioSampleBuffer obf;

  1201.     AudioSampleBuffer dbf1; // delay

  1202.     AudioSampleBuffer dbf2; // chorus

  1203.     AudioSampleBuffer dbf3; // reverb

  1204. 

  1205.     VexArpSettings fArpSet1, fArpSet2, fArpSet3;

  1206.     VexArp fArp1, fArp2, fArp3;

  1207. 

  1208.     VexChorus fChorus;

  1209.     VexDelay fDelay;

  1210.     VexReverb fReverb;

  1211.     VexSyntModule fSynth;

  1212. 

  1213.     ScopedPointer<VexEditorComponent> fView;

  1214.     ScopedPointer<JucePluginWindow> fWindow;

  1215. 

  1216.     MidiBuffer fMidiInBuffer;

  1217. 

  1218.     PluginClassEND(VexSynthPlugin)

  1219.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  1220. };

  1221. 

  1222. // -----------------------------------------------------------------------

  1223. 

  1224. static const NativePluginDescriptor vexsynthDesc = {

  1225.     /* category  */ PLUGIN_CATEGORY_SYNTH,

  1226.     /* hints     */ static_cast<NativePluginHints>(PLUGIN_IS_SYNTH|PLUGIN_HAS_UI|PLUGIN_NEEDS_FIXED_BUFFERS|PLUGIN_NEEDS_UI_JUCE|PLUGIN_USES_STATE|PLUGIN_USES_TIME|PLUGIN_USES_PARENT_ID),

  1227.     /* supports  */ static_cast<NativePluginSupports>(PLUGIN_SUPPORTS_ALL_SOUND_OFF),

  1228.     /* audioIns  */ 0,

  1229.     /* audioOuts */ 2,

  1230.     /* midiIns   */ 1,

  1231.     /* midiOuts  */ 0,

  1232.     /* paramIns  */ VexSynthPlugin::kParamCount,

  1233.     /* paramOuts */ 0,

  1234.     /* name      */ "VexSynth",

  1235.     /* label     */ "vexsynth",

  1236.     /* maker     */ "falkTX, Lucio Asnaghi, rockhardbuns",

  1237.     /* copyright */ "GNU GPL v2+",

  1238.     PluginDescriptorFILL(VexSynthPlugin)

  1239. };

  1240. 

  1241. // -----------------------------------------------------------------------

  1242. 

  1243. CARLA_EXPORT

  1244. void carla_register_native_plugin_vex_synth()

  1245. {

  1246.     carla_register_native_plugin(&vexsynthDesc);

  1247. }

  1248. 

  1249. // -----------------------------------------------------------------------