falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 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.
995 Commits
16 Branches
14GB
Tree: 6194dd6a11
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '6194dd6a11'
${ noResults }
Carla/source/modules/carla_native/vex-synth.cpp

1241 lines
43KB
Raw Blame History 

  1. /*

  2.  * Carla Native Plugins

  3.  * Copyright (C) 2013 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()

  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 < 89; ++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 PluginClass,

  519.                        public VexEditorComponent::Callback

  520. {

  521. public:

  522.     static const unsigned int kParamCount = 92;

  523. 

  524.     VexSynthPlugin(const HostDescriptor* const host)

  525.         : PluginClass(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 Parameter* getParameterInfo(const uint32_t index) const override

  619.     {

  620.         static CarlaString tmpName;

  621.         static Parameter 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.             tmpName[4] = '0' + ((index-1+24) / 24);

  745. 

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

  747.             paramInfo.hints = static_cast<ParameterHints>(hints);

  748.             return &paramInfo;

  749.         }

  750. 

  751.         switch (index)

  752.         {

  753.         case 0:

  754.             paramInfo.name = "Master";

  755.             paramInfo.ranges.def = 1.0f;

  756.             break;

  757.         case 73:

  758.             hints |= PARAMETER_IS_INTEGER;

  759.             paramInfo.name = "Delay Time";

  760.             paramInfo.unit = "steps";

  761.             paramInfo.ranges.def = 4.0f;

  762.             paramInfo.ranges.min = 0.0f;

  763.             paramInfo.ranges.max = 8.0f;

  764.             break;

  765.         case 74:

  766.             paramInfo.name = "Delay Feedback";

  767.             paramInfo.unit = "%";

  768.             paramInfo.ranges.def = 40.0f;

  769.             paramInfo.ranges.min = 0.0f;

  770.             paramInfo.ranges.max = 100.0f;

  771.             break;

  772.         case 75:

  773.             paramInfo.name = "Delay Level";

  774.             paramInfo.ranges.def = 0.0f;

  775.             break;

  776.         case 76:

  777.             paramInfo.name = "Chorus Rate";

  778.             paramInfo.ranges.def = 0.3f;

  779.             break;

  780.         case 77:

  781.             paramInfo.name = "Chorus Depth";

  782.             paramInfo.ranges.def = 0.6f;

  783.             break;

  784.         case 78:

  785.             paramInfo.name = "Chorus Level";

  786.             paramInfo.ranges.def = 0.5f;

  787.             break;

  788.         case 79:

  789.             paramInfo.name = "Reverb Size";

  790.             paramInfo.ranges.def = 0.6f;

  791.             break;

  792.         case 80:

  793.             paramInfo.name = "Reverb Width";

  794.             paramInfo.ranges.def = 0.7f;

  795.             break;

  796.         case 81:

  797.             paramInfo.name = "Reverb Damp";

  798.             paramInfo.ranges.def = 0.6f;

  799.             break;

  800.         case 82:

  801.             paramInfo.name = "Reverb Level";

  802.             paramInfo.ranges.def = 0.0f;

  803.             break;

  804.         case 83:

  805.             paramInfo.name = "Part1 Panning";

  806.             paramInfo.ranges.def = 0.5f;

  807.             break;

  808.         case 84:

  809.             paramInfo.name = "Part2 Panning";

  810.             paramInfo.ranges.def = 0.5f;

  811.             break;

  812.         case 85:

  813.             paramInfo.name = "Part3 Panning";

  814.             paramInfo.ranges.def = 0.5f;

  815.             break;

  816.         case 86:

  817.             paramInfo.name = "Part1 Volume";

  818.             paramInfo.ranges.def = 0.5f;

  819.             break;

  820.         case 87:

  821.             paramInfo.name = "Part2 Volume";

  822.             paramInfo.ranges.def = 0.5f;

  823.             break;

  824.         case 88:

  825.             paramInfo.name = "Part3 Volume";

  826.             paramInfo.ranges.def = 0.5f;

  827.             break;

  828.         case 89:

  829.             hints |= PARAMETER_IS_BOOLEAN;

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

  831.             paramInfo.ranges.def = 1.0f;

  832.             break;

  833.         case 90:

  834.             hints |= PARAMETER_IS_BOOLEAN;

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

  836.             paramInfo.ranges.def = 0.0f;

  837.             break;

  838.         case 91:

  839.             hints |= PARAMETER_IS_BOOLEAN;

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

  841.             paramInfo.ranges.def = 0.0f;

  842.             break;

  843.         default:

  844.             paramInfo.name = "unknown";

  845.             break;

  846.         }

  847. 

  848.         paramInfo.hints = static_cast<ParameterHints>(hints);

  849.         return &paramInfo;

  850.     }

  851. 

  852.     float getParameterValue(const uint32_t index) const override

  853.     {

  854.         if (index >= kParamCount)

  855.             return 0.0f;

  856. 

  857.         switch (index)

  858.         {

  859.         case 73:

  860.             return fParameters[index] * 8.0f;

  861.         case 74:

  862.             return fParameters[index] * 100.0f;

  863.         default:

  864.             return fParameters[index];

  865.         }

  866.     }

  867. 

  868.     // -------------------------------------------------------------------

  869.     // Plugin state calls

  870. 

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

  872.     {

  873.         if (index >= kParamCount)

  874.             return;

  875. 

  876.         float realValue;

  877. 

  878.         switch (index)

  879.         {

  880.         case 73:

  881.             realValue = value/8.0f;

  882.             break;

  883.         case 74:

  884.             realValue = value/100.0f;

  885.             break;

  886.         default:

  887.             realValue = value;

  888.             break;

  889.         }

  890. 

  891.         fParameters[index] = realValue;

  892.         fParamsChanged[index] = true;

  893.         fSynth.update(index);

  894.     }

  895. 

  896.     // -------------------------------------------------------------------

  897.     // Plugin process calls

  898. 

  899.     void process(float**, float** outBuffer, const uint32_t frames, const MidiEvent* const midiEvents, const uint32_t midiEventCount) override

  900.     {

  901.         // Get time info

  902.         const TimeInfo* const timeInfo(getTimeInfo());

  903. 

  904.         bool   timePlaying = false;

  905.         double ppqPos      = 0.0;

  906.         double barStartPos = 0.0;

  907.         double bpm         = 120.0;

  908. 

  909.         if (timeInfo != nullptr)

  910.         {

  911.             timePlaying = timeInfo->playing;

  912. 

  913.             if (timeInfo->bbt.valid)

  914.             {

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

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

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

  918. 

  919.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  920.                 barStartPos = ppqBar;

  921.                 bpm         = timeInfo->bbt.beatsPerMinute;

  922.             }

  923.         }

  924. 

  925.         // put carla events in juce midi buffer

  926.         fMidiInBuffer.clear();

  927. 

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

  929.         {

  930.             const MidiEvent* const midiEvent(&midiEvents[i]);

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

  932.         }

  933. 

  934.         // process MIDI (arppeggiator)

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

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

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

  938. 

  939.         int snum;

  940.         MidiMessage midiMessage(0xf4);

  941.         MidiBuffer::Iterator Iterator1(part1Midi);

  942. 

  943.         while (Iterator1.getNextEvent(midiMessage, snum))

  944.         {

  945.             if (midiMessage.isNoteOn())

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

  947.             else if (midiMessage.isNoteOff())

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

  949.             else if (midiMessage.isAllSoundOff())

  950.                 fSynth.kill();

  951.             else if (midiMessage.isAllNotesOff())

  952.                 fSynth.releaseAll(snum);

  953.         }

  954. 

  955.         MidiBuffer::Iterator Iterator2(part2Midi);

  956. 

  957.         while (Iterator2.getNextEvent(midiMessage, snum))

  958.         {

  959.             if (midiMessage.isNoteOn())

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

  961.             else if (midiMessage.isNoteOff())

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

  963.         }

  964. 

  965.         MidiBuffer::Iterator Iterator3(part3Midi);

  966. 

  967.         while (Iterator3.getNextEvent(midiMessage, snum))

  968.         {

  969.             if (midiMessage.isNoteOn())

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

  971.             else if (midiMessage.isNoteOff())

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

  973.         }

  974. 

  975.         fMidiInBuffer.clear();

  976. 

  977.         if (obf->getNumSamples() < (int)frames)

  978.         {

  979.             obf->setSize(2,  frames, 0, 0, 1);

  980.             abf->setSize(2,  frames, 0, 0, 1);

  981.             dbf1->setSize(2, frames, 0, 0, 1);

  982.             dbf2->setSize(2, frames, 0, 0, 1);

  983.             dbf3->setSize(2, frames, 0, 0, 1);

  984.         }

  985. 

  986.         obf ->clear();

  987.         dbf1->clear();

  988.         dbf2->clear();

  989.         dbf3->clear();

  990. 

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

  992. 

  993.         if (fParameters[75] > 0.001f) fDelay.processBlock(dbf1, bpm);

  994.         if (fParameters[78] > 0.001f) fChorus.processBlock(dbf2);

  995.         if (fParameters[82] > 0.001f) fReverb.processBlock(dbf3);

  996. 

  997.         AudioSampleBuffer output(outBuffer, 2, 0, frames);

  998.         output.clear();

  999. 

  1000.         obf->addFrom(0, 0, *dbf1, 0, 0, frames, fParameters[75]);

  1001.         obf->addFrom(1, 0, *dbf1, 1, 0, frames, fParameters[75]);

  1002.         obf->addFrom(0, 0, *dbf2, 0, 0, frames, fParameters[78]);

  1003.         obf->addFrom(1, 0, *dbf2, 1, 0, frames, fParameters[78]);

  1004.         obf->addFrom(0, 0, *dbf3, 0, 0, frames, fParameters[82]);

  1005.         obf->addFrom(1, 0, *dbf3, 1, 0, frames, fParameters[82]);

  1006. 

  1007.         output.addFrom(0, 0, *obf, 0, 0, frames, fParameters[0]);

  1008.         output.addFrom(1, 0, *obf, 1, 0, frames, fParameters[0]);

  1009.     }

  1010. 

  1011.     // -------------------------------------------------------------------

  1012.     // Plugin UI calls

  1013. 

  1014.     void uiShow(const bool show) override

  1015.     {

  1016.         MessageManagerLock mmLock;

  1017. 

  1018.         if (show)

  1019.         {

  1020.             if (fWindow == nullptr)

  1021.             {

  1022.                 fWindow = new JucePluginWindow();

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

  1024.             }

  1025. 

  1026.             if (fView == nullptr)

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

  1028. 

  1029.             fWindow->show(fView);

  1030.         }

  1031.         else if (fWindow != nullptr)

  1032.         {

  1033.             fWindow->hide();

  1034. 

  1035.             fView = nullptr;

  1036.             fWindow = nullptr;

  1037.         }

  1038.     }

  1039. 

  1040.     void uiIdle() override

  1041.     {

  1042.         if (fWindow == nullptr)

  1043.             return;

  1044. 

  1045.         if (fWindow->wasClosedByUser())

  1046.         {

  1047.             uiShow(false);

  1048.             uiClosed();

  1049.         }

  1050.     }

  1051. 

  1052.     // -------------------------------------------------------------------

  1053.     // Plugin state calls

  1054. 

  1055.     char* getState() const override

  1056.     {

  1057.         MemoryBlock destData;

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

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

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

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

  1062. 

  1063.         XmlElement xmlState("VEX");

  1064. 

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

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

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

  1068. 

  1069.         MemoryBlock tmp;

  1070.         copyXmlToBinary(xmlState, tmp);

  1071. 

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

  1073. 

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

  1075.     }

  1076. 

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

  1078.     {

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

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

  1081. 

  1082.         MemoryBlock destData;

  1083.         destData.fromBase64Encoding(data64);

  1084. 

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

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

  1087. 

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

  1089.         {

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

  1091.             {

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

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

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

  1095. 

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

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

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

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

  1100. 

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

  1102.                 //    fSynth.update(i);

  1103. 

  1104.                 if (fView != nullptr)

  1105.                     fView->setNeedsUpdate();

  1106.             }

  1107. 

  1108.             delete xmlState;

  1109.         }

  1110.     }

  1111. 

  1112.     // -------------------------------------------------------------------

  1113.     // Plugin dispatcher calls

  1114. 

  1115.     void bufferSizeChanged(const uint32_t bufferSize) override

  1116.     {

  1117.         obf  = new AudioSampleBuffer(2, bufferSize);

  1118.         abf  = new AudioSampleBuffer(2, bufferSize);

  1119.         dbf1 = new AudioSampleBuffer(2, bufferSize);

  1120.         dbf2 = new AudioSampleBuffer(2, bufferSize);

  1121.         dbf3 = new AudioSampleBuffer(2, bufferSize);

  1122.     }

  1123. 

  1124.     void sampleRateChanged(const double sampleRate) override

  1125.     {

  1126.         fArp1.setSampleRate(sampleRate);

  1127.         fArp2.setSampleRate(sampleRate);

  1128.         fArp3.setSampleRate(sampleRate);

  1129.         fChorus.setSampleRate(sampleRate);

  1130.         fDelay.setSampleRate(sampleRate);

  1131.         fSynth.setSampleRate(sampleRate);

  1132.     }

  1133. 

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

  1135.     {

  1136.         if (fWindow == nullptr)

  1137.             return;

  1138. 

  1139.         MessageManagerLock mmLock;

  1140.         fWindow->setName(uiName);

  1141.     }

  1142. 

  1143.     // -------------------------------------------------------------------

  1144.     // Vex editor calls

  1145. 

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

  1147.     {

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

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

  1150.     }

  1151. 

  1152.     float getFilterParameterValue(const uint32_t index) const override

  1153.     {

  1154.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount, 0.0f)

  1155. 

  1156.         return fParameters[index];

  1157.     }

  1158. 

  1159.     String getFilterWaveName(const int part) const override

  1160.     {

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

  1162. 

  1163.         return fSynth.getWaveName(part);

  1164.     }

  1165. 

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

  1167.     {

  1168.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount,)

  1169. 

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

  1171.             return;

  1172. 

  1173.         fParameters[index] = value;

  1174.         fSynth.update(index);

  1175. 

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

  1177.     }

  1178. 

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

  1180.     {

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

  1182. 

  1183.         fSynth.setWaveLater(part, wave);

  1184.     }

  1185. 

  1186. private:

  1187.     float fParameters[kParamCount];

  1188.     bool  fParamsChanged[92];

  1189. 

  1190.     ScopedPointer<AudioSampleBuffer> obf;

  1191.     ScopedPointer<AudioSampleBuffer> abf;

  1192.     ScopedPointer<AudioSampleBuffer> dbf1; // delay

  1193.     ScopedPointer<AudioSampleBuffer> dbf2; // chorus

  1194.     ScopedPointer<AudioSampleBuffer> dbf3; // reverb

  1195. 

  1196.     VexArpSettings fArpSet1, fArpSet2, fArpSet3;

  1197.     VexArp fArp1, fArp2, fArp3;

  1198. 

  1199.     VexChorus fChorus;

  1200.     VexDelay fDelay;

  1201.     VexReverb fReverb;

  1202.     VexSyntModule fSynth;

  1203. 

  1204.     ScopedPointer<VexEditorComponent> fView;

  1205.     ScopedPointer<JucePluginWindow> fWindow;

  1206. 

  1207.     MidiBuffer fMidiInBuffer;

  1208. 

  1209.     PluginClassEND(VexSynthPlugin)

  1210.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  1211. };

  1212. 

  1213. // -----------------------------------------------------------------------

  1214. 

  1215. static const PluginDescriptor vexSynthDesc = {

  1216.     /* category  */ PLUGIN_CATEGORY_SYNTH,

  1217.     /* hints     */ static_cast<PluginHints>(PLUGIN_HAS_GUI|PLUGIN_NEEDS_UI_JUCE|PLUGIN_USES_STATE|PLUGIN_USES_TIME),

  1218.     /* supports  */ static_cast<PluginSupports>(0x0),

  1219.     /* audioIns  */ 0,

  1220.     /* audioOuts */ 2,

  1221.     /* midiIns   */ 1,

  1222.     /* midiOuts  */ 0,

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

  1224.     /* paramOuts */ 0,

  1225.     /* name      */ "VexSynth",

  1226.     /* label     */ "vexSynth",

  1227.     /* maker     */ "falkTX",

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

  1229.     PluginDescriptorFILL(VexSynthPlugin)

  1230. };

  1231. 

  1232. // -----------------------------------------------------------------------

  1233. 

  1234. CARLA_EXPORT

  1235. void carla_register_native_plugin_vex_synth()

  1236. {

  1237.     carla_register_native_plugin(&vexSynthDesc);

  1238. }

  1239. 

  1240. // -----------------------------------------------------------------------