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.
977 Commits
16 Branches
153MB
Tree: e2aa9e3b42
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e2aa9e3b42'
${ noResults }
Carla/source/modules/carla_native/vex-synth.cpp

1310 lines
44KB
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. 

  20. #include "juce_gui_basics.h"

  21. 

  22. using namespace juce;

  23. 

  24. #include "vex/VexArp.h"

  25. #include "vex/VexChorus.h"

  26. #include "vex/VexDelay.h"

  27. #include "vex/VexReverb.h"

  28. #include "vex/VexSyntModule.h"

  29. 

  30. #include "vex/PeggyViewComponent.h"

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

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

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

  34. 

  35. // -----------------------------------------------------------------------

  36. // Copied from juce_AudioProcessor.cpp

  37. 

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

  39. const uint32 magicXmlNumber = 0x21324356;

  40. 

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

  42. {

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

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

  45. 

  46.     destData.setSize(stringLength + 9);

  47. 

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

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

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

  51. 

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

  53. }

  54. 

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

  56. {

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

  58.     {

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

  60. 

  61.         if (stringLength > 0)

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

  63.     }

  64. 

  65.     return nullptr;

  66. }

  67. 

  68. // -----------------------------------------------------------------------

  69. 

  70. class HelperWindow2 : public DocumentWindow

  71. {

  72. public:

  73.     HelperWindow2()

  74.         : DocumentWindow("PlugWindow", Colour(50, 50, 200), DocumentWindow::closeButton, false),

  75.           fClosed(false)

  76.     {

  77.         setVisible(false);

  78.         //setAlwaysOnTop(true);

  79.         setOpaque(true);

  80.         setResizable(false, false);

  81.         setUsingNativeTitleBar(true);

  82.     }

  83. 

  84.     void show(Component* const comp)

  85.     {

  86.         fClosed = false;

  87. 

  88.         centreWithSize(comp->getWidth(), comp->getHeight());

  89.         setContentNonOwned(comp, true);

  90. 

  91.         if (! isOnDesktop())

  92.             addToDesktop();

  93. 

  94.         setVisible(true);

  95.     }

  96. 

  97.     void hide()

  98.     {

  99.         setVisible(false);

  100. 

  101.         if (isOnDesktop())

  102.             removeFromDesktop();

  103. 

  104.         clearContentComponent();

  105.     }

  106. 

  107.     bool wasClosedByUser() const

  108.     {

  109.         return fClosed;

  110.     }

  111. 

  112. protected:

  113.     void closeButtonPressed() override

  114.     {

  115.         fClosed = true;

  116.     }

  117. 

  118. private:

  119.     volatile bool fClosed;

  120. 

  121.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(HelperWindow2)

  122. };

  123. 

  124. // -----------------------------------------------------------------------

  125. 

  126. class VexEditorComponent : public Component,

  127.                            public Timer,

  128.                            public ComboBox::Listener,

  129.                            public Slider::Listener,

  130.                            public Button::Listener,

  131.                            public PeggyViewComponent::Callback // ignored

  132. {

  133. public:

  134.     class Callback

  135.     {

  136.     public:

  137.         virtual ~Callback() {}

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

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

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

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

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

  143.     };

  144. 

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

  146.         : fCallback(callback),

  147.           fNeedsUpdate(false)

  148.     {

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

  150. 

  151.         // Comboboxes, wave selection

  152.         addAndMakeVisible(comboBox1 = new ComboBox (String::empty));

  153.         comboBox1->setEditableText(false);

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

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

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

  157.         comboBox1->addListener(this);

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

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

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

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

  162.         comboBox1->setWantsKeyboardFocus(false);

  163.         comboBox1->setLookAndFeel(&mlaf);

  164. 

  165.         addAndMakeVisible(comboBox2 = new ComboBox (String::empty));

  166.         comboBox2->setEditableText(false);

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

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

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

  170.         comboBox2->addListener(this);

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

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

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

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

  175.         comboBox2->setWantsKeyboardFocus(false);

  176.         comboBox2->setLookAndFeel(&mlaf);

  177. 

  178.         addAndMakeVisible(comboBox3 = new ComboBox(String::empty));

  179.         comboBox3->setEditableText(false);

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

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

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

  183.         comboBox3->addListener(this);

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

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

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

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

  188.         comboBox3->setWantsKeyboardFocus(false);

  189.         comboBox3->setLookAndFeel(&mlaf);

  190. 

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

  192.         {

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

  194. 

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

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

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

  198.         }

  199. 

  200.         //Make sliders

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

  202.         {

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

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

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

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

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

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

  209.         }

  210. 

  211.         //Adjust the center of some

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

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

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

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

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

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

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

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

  220. 

  221.         int tmp = 24;

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

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

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

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

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

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

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

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

  230. 

  231.         tmp = 48;

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

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

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

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

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

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

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

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

  240. 

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

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

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

  244. 

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

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

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

  248. 

  249.         //PART ON/OFF

  250.         addAndMakeVisible(TB1 = new TextButton ("new button"));

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

  252.         TB1->addListener(this);

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

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

  255.         TB1->setClickingTogglesState(true);

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

  257. 

  258.         addAndMakeVisible(TB2 = new TextButton ("new button"));

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

  260.         TB2->addListener(this);

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

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

  263.         TB2->setClickingTogglesState(true);

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

  265. 

  266.         addAndMakeVisible(TB3 = new TextButton ("new button"));

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

  268.         TB3->addListener(this);

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

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

  271.         TB3->setClickingTogglesState(true);

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

  273. 

  274.         //Peggy ON/OFF

  275.         addAndMakeVisible(TB4 = new TextButton ("new button"));

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

  277.         TB4->addListener(this);

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

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

  280.         TB4->setClickingTogglesState(true);

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

  282. 

  283.         addAndMakeVisible(TB5 = new TextButton ("new button"));

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

  285.         TB5->addListener(this);

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

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

  288.         TB5->setClickingTogglesState(true);

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

  290. 

  291.         addAndMakeVisible(TB6 = new TextButton ("new button"));

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

  293.         TB6->addListener(this);

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

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

  296.         TB6->setClickingTogglesState(true);

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

  298. 

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

  300.         p1->setLookAndFeel(&mlaf);

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

  302.         p2->setLookAndFeel(&mlaf);

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

  304.         p3->setLookAndFeel(&mlaf);

  305. 

  306.         setSize(800,500);

  307.         updateParametersFromFilter(true);

  308. 

  309.         startTimer(50);

  310.     }

  311. 

  312.     ~VexEditorComponent()

  313.     {

  314.         stopTimer();

  315.         removeAllChildren();

  316.     }

  317. 

  318.     void setNeedsUpdate()

  319.     {

  320.         fNeedsUpdate = true;

  321.     }

  322. 

  323. protected:

  324.     void paint(Graphics& g) override

  325.     {

  326.         g.drawImage(internalCachedImage1,

  327.                     0, 0, 800, 500,

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

  329.     }

  330. 

  331.     void resized() override

  332.     {

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

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

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

  336. 

  337.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  355. 

  356.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

  369. 

  370.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

  383. 

  384.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  400. 

  401.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  417. 

  418.         // ...

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

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

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

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

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

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

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

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

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

  428. 

  429.         // ...

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

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

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

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

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

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

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

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

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

  439. 

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

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

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

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

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

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

  446. 

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

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

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

  450.     }

  451. 

  452.     void timerCallback() override

  453.     {

  454.         if (fNeedsUpdate)

  455.         {

  456.             updateParametersFromFilter(true);

  457.             fNeedsUpdate = false;

  458.         }

  459.         else

  460.         {

  461.             updateParametersFromFilter(false);

  462.         }

  463.     }

  464. 

  465.     void comboBoxChanged(ComboBox* comboBoxThatHasChanged) override

  466.     {

  467.         if (comboBoxThatHasChanged == comboBox1)

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

  469.         else if (comboBoxThatHasChanged == comboBox2)

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

  471.         else if (comboBoxThatHasChanged == comboBox3)

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

  473.     }

  474. 

  475.     void sliderValueChanged(Slider* sliderThatWasMoved) override

  476.     {

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

  478.         {

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

  480.             {

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

  482.                 return;

  483.             }

  484.         }

  485.     }

  486. 

  487.     void buttonClicked(Button* buttonThatWasClicked) override

  488.     {

  489.         if (buttonThatWasClicked == TB1)

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

  491.         else if (buttonThatWasClicked == TB2)

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

  493.         else if (buttonThatWasClicked == TB3)

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

  495.         else if (buttonThatWasClicked == TB4)

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

  497.         else if (buttonThatWasClicked == TB5)

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

  499.         else if (buttonThatWasClicked == TB6)

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

  501.     }

  502. 

  503.     void arpParameterChanged(const uint32_t) override

  504.     {

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

  506.     }

  507. 

  508.     void updateParametersFromFilter(const bool all)

  509.     {

  510.         if (all)

  511.         {

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

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

  514. 

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

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

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

  518. 

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

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

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

  522. 

  523.             p1->update();

  524.             p2->update();

  525.             p3->update();

  526.         }

  527.         else

  528.         {

  529.             bool params[92];

  530.             fCallback->getChangedParameters(params);

  531. 

  532.             for (int i=0; i < 89; ++i)

  533.             {

  534.                 if (params[i])

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

  536.             }

  537. 

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

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

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

  541.         }

  542.     }

  543. 

  544. private:

  545.     static const int kSliderCount = 89;

  546. 

  547.     Callback* const fCallback;

  548.     volatile bool fNeedsUpdate;

  549. 

  550.     Image internalCachedImage1;

  551.     MyLookAndFeel mlaf;

  552. 

  553.     ScopedPointer<ComboBox> comboBox1;

  554.     ScopedPointer<ComboBox> comboBox2;

  555.     ScopedPointer<ComboBox> comboBox3;

  556. 

  557.     ScopedPointer<SnappingSlider> sliders[kSliderCount];

  558. 

  559.     ScopedPointer<TextButton> TB1;

  560.     ScopedPointer<TextButton> TB2;

  561.     ScopedPointer<TextButton> TB3;

  562.     ScopedPointer<TextButton> TB4;

  563.     ScopedPointer<TextButton> TB5;

  564.     ScopedPointer<TextButton> TB6;

  565. 

  566.     ScopedPointer<PeggyViewComponent> p1;

  567.     ScopedPointer<PeggyViewComponent> p2;

  568.     ScopedPointer<PeggyViewComponent> p3;

  569. 

  570.     VexArpSettings _d;

  571. };

  572. 

  573. // -----------------------------------------------------------------------

  574. 

  575. class VexSynthPlugin : public PluginClass,

  576.                        public VexEditorComponent::Callback

  577. {

  578. public:

  579.     static const unsigned int kParamCount = 92;

  580. 

  581.     VexSynthPlugin(const HostDescriptor* const host)

  582.         : PluginClass(host),

  583.           obf(nullptr),

  584.           abf(nullptr),

  585.           dbf1(nullptr),

  586.           dbf2(nullptr),

  587.           dbf3(nullptr),

  588.           fArp1(&fArpSet1),

  589.           fArp2(&fArpSet2),

  590.           fArp3(&fArpSet3),

  591.           fChorus(fParameters),

  592.           fDelay(fParameters),

  593.           fReverb(fParameters),

  594.           fSynth(fParameters)

  595.     {

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

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

  598. 

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

  600. 

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

  602.         {

  603.             const int offset = i * 24;

  604. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  629.         }

  630. 

  631.         // ^1 - 72

  632. 

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

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

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

  636. 

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

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

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

  640. 

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

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

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

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

  645. 

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

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

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

  649. 

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

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

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

  653. 

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

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

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

  657. 

  658.         bufferSizeChanged(getBufferSize());

  659.         sampleRateChanged(getSampleRate());

  660. 

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

  662.             fSynth.update(i);

  663. 

  664.         fMidiInBuffer.ensureSize(512*4);

  665.     }

  666. 

  667.     ~VexSynthPlugin() override

  668.     {

  669.         delete obf;

  670.         delete abf;

  671.         delete dbf1;

  672.         delete dbf2;

  673.         delete dbf3;

  674.     }

  675. 

  676. protected:

  677.     // -------------------------------------------------------------------

  678.     // Plugin parameter calls

  679. 

  680.     uint32_t getParameterCount() const override

  681.     {

  682.         return kParamCount;

  683.     }

  684. 

  685.     const Parameter* getParameterInfo(const uint32_t index) const override

  686.     {

  687.         static Parameter paramInfo;

  688. 

  689.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  690. 

  691.         paramInfo.name = nullptr;

  692.         paramInfo.unit = nullptr;

  693.         paramInfo.ranges.def       = 0.0f;

  694.         paramInfo.ranges.min       = 0.0f;

  695.         paramInfo.ranges.max       = 1.0f;

  696.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  697.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  698.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  699.         paramInfo.scalePointCount  = 0;

  700.         paramInfo.scalePoints      = nullptr;

  701. 

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

  703.         {

  704.             uint32_t ri = index % 24;

  705. 

  706.             switch (ri)

  707.             {

  708.             case 1:

  709.                 paramInfo.name = "oct";

  710.                 paramInfo.ranges.def = 0.5f;

  711.                 break;

  712.             case 2:

  713.                 paramInfo.name = "cent";

  714.                 paramInfo.ranges.def = 0.5f;

  715.                 break;

  716.             case 3:

  717.                 paramInfo.name = "phaseOffset";

  718.                 paramInfo.ranges.def = 0.5f;

  719.                 break;

  720.             case 4:

  721.                 paramInfo.name = "phaseIncOffset";

  722.                 paramInfo.ranges.def = 0.5f;

  723.                 break;

  724.             case 5:

  725.                 paramInfo.name = "filter";

  726.                 paramInfo.ranges.def = 0.9f;

  727.                 break;

  728.             case 6:

  729.                 paramInfo.name = "filter";

  730.                 paramInfo.ranges.def = 0.0f;

  731.                 break;

  732.             case 7:

  733.                 paramInfo.name = "filter";

  734.                 paramInfo.ranges.def = 1.0f;

  735.                 break;

  736.             case 8:

  737.                 paramInfo.name = "filter";

  738.                 paramInfo.ranges.def = 0.5f;

  739.                 break;

  740.             case 9:

  741.                 paramInfo.name = "F ADSR";

  742.                 paramInfo.ranges.def = 0.0f;

  743.                 break;

  744.             case 10:

  745.                 paramInfo.name = "F ADSR";

  746.                 paramInfo.ranges.def = 0.2f;

  747.                 break;

  748.             case 11:

  749.                 paramInfo.name = "F ADSR";

  750.                 paramInfo.ranges.def = 0.0f;

  751.                 break;

  752.             case 12:

  753.                 paramInfo.name = "F ADSR";

  754.                 paramInfo.ranges.def = 0.5f;

  755.                 break;

  756.             case 13:

  757.                 paramInfo.name = "F velocity";

  758.                 paramInfo.ranges.def = 0.5f;

  759.                 break;

  760.             case 14:

  761.                 paramInfo.name = "A ADSR";

  762.                 paramInfo.ranges.def = 0.0f;

  763.                 break;

  764.             case 15:

  765.                 paramInfo.name = "A ADSR";

  766.                 paramInfo.ranges.def = 0.3f;

  767.                 break;

  768.             case 16:

  769.                 paramInfo.name = "A ADSR";

  770.                 paramInfo.ranges.def = 0.7f;

  771.                 break;

  772.             case 17:

  773.                 paramInfo.name = "A ADSR";

  774.                 paramInfo.ranges.def = 0.1f;

  775.                 break;

  776.             case 18:

  777.                 paramInfo.name = "A velocity";

  778.                 paramInfo.ranges.def = 0.5f;

  779.                 break;

  780.             case 19:

  781.                 paramInfo.name = "lfoC";

  782.                 paramInfo.ranges.def = 0.5f;

  783.                 break;

  784.             case 20:

  785.                 paramInfo.name = "lfoA";

  786.                 paramInfo.ranges.def = 0.0f;

  787.                 break;

  788.             case 21:

  789.                 paramInfo.name = "lfoF";

  790.                 paramInfo.ranges.def = 0.0f;

  791.                 break;

  792.             case 22:

  793.                 paramInfo.name = "fx vol D";

  794.                 paramInfo.ranges.def = 0.5f;

  795.                 break;

  796.             case 23:

  797.                 paramInfo.name = "fx vol C";

  798.                 paramInfo.ranges.def = 0.5f;

  799.                 break;

  800.             case 24:

  801.             case 0:

  802.                 paramInfo.name = "fx vol R";

  803.                 paramInfo.ranges.def = 0.5f;

  804.                 break;

  805.             default:

  806.                 paramInfo.name = "unknown2";

  807.                 break;

  808.             }

  809. 

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

  811.             return &paramInfo;

  812.         }

  813. 

  814.         switch (index)

  815.         {

  816.         case 0:

  817.             paramInfo.name = "Main volume";

  818.             paramInfo.ranges.def = 1.0f;

  819.             break;

  820.         case 73:

  821.             hints |= PARAMETER_IS_INTEGER;

  822.             paramInfo.name = "Delay Time";

  823.             paramInfo.unit = "steps";

  824.             paramInfo.ranges.def = 4.0f;

  825.             paramInfo.ranges.min = 0.0f;

  826.             paramInfo.ranges.max = 8.0f;

  827.             break;

  828.         case 74:

  829.             paramInfo.name = "Delay Feedback";

  830.             paramInfo.unit = "%";

  831.             paramInfo.ranges.def = 40.0f;

  832.             paramInfo.ranges.min = 0.0f;

  833.             paramInfo.ranges.max = 100.0f;

  834.             break;

  835.         case 75:

  836.             paramInfo.name = "Delay Volume";

  837.             paramInfo.ranges.def = 0.0f;

  838.             break;

  839.         case 76:

  840.             paramInfo.name = "Chorus Rate";

  841.             paramInfo.ranges.def = 0.3f;

  842.             break;

  843.         case 77:

  844.             paramInfo.name = "Chorus Depth";

  845.             paramInfo.ranges.def = 0.6f;

  846.             break;

  847.         case 78:

  848.             paramInfo.name = "Chorus Volume";

  849.             paramInfo.ranges.def = 0.5f;

  850.             break;

  851.         case 79:

  852.             paramInfo.name = "Reverb Size";

  853.             paramInfo.ranges.def = 0.6f;

  854.             break;

  855.         case 80:

  856.             paramInfo.name = "Reverb Width";

  857.             paramInfo.ranges.def = 0.7f;

  858.             break;

  859.         case 81:

  860.             paramInfo.name = "Reverb Damp";

  861.             paramInfo.ranges.def = 0.6f;

  862.             break;

  863.         case 82:

  864.             paramInfo.name = "Reverb Volume";

  865.             paramInfo.ranges.def = 0.0f;

  866.             break;

  867.         case 83:

  868.             paramInfo.name = "Wave1 Panning";

  869.             paramInfo.ranges.def = 0.5f;

  870.             break;

  871.         case 84:

  872.             paramInfo.name = "Wave2 Panning";

  873.             paramInfo.ranges.def = 0.5f;

  874.             break;

  875.         case 85:

  876.             paramInfo.name = "Wave3 Panning";

  877.             paramInfo.ranges.def = 0.5f;

  878.             break;

  879.         case 86:

  880.             paramInfo.name = "Wave1 Volume";

  881.             paramInfo.ranges.def = 0.5f;

  882.             break;

  883.         case 87:

  884.             paramInfo.name = "Wave2 Volume";

  885.             paramInfo.ranges.def = 0.5f;

  886.             break;

  887.         case 88:

  888.             paramInfo.name = "Wave3 Volume";

  889.             paramInfo.ranges.def = 0.5f;

  890.             break;

  891.         case 89:

  892.             hints |= PARAMETER_IS_BOOLEAN;

  893.             paramInfo.name = "Wave1 on/off";

  894.             paramInfo.ranges.def = 1.0f;

  895.             break;

  896.         case 90:

  897.             hints |= PARAMETER_IS_BOOLEAN;

  898.             paramInfo.name = "Wave2 on/off";

  899.             paramInfo.ranges.def = 0.0f;

  900.             break;

  901.         case 91:

  902.             hints |= PARAMETER_IS_BOOLEAN;

  903.             paramInfo.name = "Wave3 on/off";

  904.             paramInfo.ranges.def = 0.0f;

  905.             break;

  906.         default:

  907.             paramInfo.name = "unknown";

  908.             break;

  909.         }

  910. 

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

  912.         return &paramInfo;

  913.     }

  914. 

  915.     float getParameterValue(const uint32_t index) const override

  916.     {

  917.         if (index >= kParamCount)

  918.             return 0.0f;

  919. 

  920.         switch (index)

  921.         {

  922.         case 73:

  923.             return fParameters[index] * 8.0f;

  924.         case 74:

  925.             return fParameters[index] * 100.0f;

  926.         default:

  927.             return fParameters[index];

  928.         }

  929.     }

  930. 

  931.     // -------------------------------------------------------------------

  932.     // Plugin state calls

  933. 

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

  935.     {

  936.         if (index >= kParamCount)

  937.             return;

  938. 

  939.         float realValue;

  940. 

  941.         switch (index)

  942.         {

  943.         case 73:

  944.             realValue = value/8.0f;

  945.             break;

  946.         case 74:

  947.             realValue = value/100.0f;

  948.             break;

  949.         default:

  950.             realValue = value;

  951.             break;

  952.         }

  953. 

  954.         fParameters[index] = realValue;

  955.         fParamsChanged[index] = true;

  956.         fSynth.update(index);

  957.     }

  958. 

  959.     // -------------------------------------------------------------------

  960.     // Plugin process calls

  961. 

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

  963.     {

  964.         // Get time info

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

  966. 

  967.         bool   timePlaying = false;

  968.         double ppqPos      = 0.0;

  969.         double barStartPos = 0.0;

  970.         double bpm         = 120.0;

  971. 

  972.         if (timeInfo != nullptr)

  973.         {

  974.             timePlaying = timeInfo->playing;

  975. 

  976.             if (timeInfo->bbt.valid)

  977.             {

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

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

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

  981. 

  982.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  983.                 barStartPos = ppqBar;

  984.                 bpm         = timeInfo->bbt.beatsPerMinute;

  985.             }

  986.         }

  987. 

  988.         // put carla events in juce midi buffer

  989.         fMidiInBuffer.clear();

  990. 

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

  992.         {

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

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

  995.         }

  996. 

  997.         // process MIDI (arppeggiator)

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

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

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

  1001. 

  1002.         int snum;

  1003.         MidiMessage midiMessage(0xf4);

  1004.         MidiBuffer::Iterator Iterator1(part1Midi);

  1005. 

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

  1007.         {

  1008.             if (midiMessage.isNoteOn())

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

  1010.             else if (midiMessage.isNoteOff())

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

  1012.             else if (midiMessage.isAllSoundOff())

  1013.                 fSynth.kill();

  1014.             else if (midiMessage.isAllNotesOff())

  1015.                 fSynth.releaseAll(snum);

  1016.         }

  1017. 

  1018.         MidiBuffer::Iterator Iterator2(part2Midi);

  1019. 

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

  1021.         {

  1022.             if (midiMessage.isNoteOn())

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

  1024.             else if (midiMessage.isNoteOff())

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

  1026.         }

  1027. 

  1028.         MidiBuffer::Iterator Iterator3(part3Midi);

  1029. 

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

  1031.         {

  1032.             if (midiMessage.isNoteOn())

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

  1034.             else if (midiMessage.isNoteOff())

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

  1036.         }

  1037. 

  1038.         fMidiInBuffer.clear();

  1039. 

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

  1041.         {

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

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

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

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

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

  1047.         }

  1048. 

  1049.         obf ->clear();

  1050.         dbf1->clear();

  1051.         dbf2->clear();

  1052.         dbf3->clear();

  1053. 

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

  1055. 

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

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

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

  1059. 

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

  1061.         output.clear();

  1062. 

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

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

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

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

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

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

  1069. 

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

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

  1072.     }

  1073. 

  1074.     // -------------------------------------------------------------------

  1075.     // Plugin UI calls

  1076. 

  1077.     void uiShow(const bool show) override

  1078.     {

  1079.         MessageManagerLock mmLock;

  1080. 

  1081.         if (show)

  1082.         {

  1083.             if (fWindow == nullptr)

  1084.             {

  1085.                 fWindow = new HelperWindow2();

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

  1087.             }

  1088. 

  1089.             if (fView == nullptr)

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

  1091. 

  1092.             fWindow->show(fView);

  1093.         }

  1094.         else if (fWindow != nullptr)

  1095.         {

  1096.             fWindow->hide();

  1097. 

  1098.             fView = nullptr;

  1099.             fWindow = nullptr;

  1100.         }

  1101.     }

  1102. 

  1103.     void uiIdle() override

  1104.     {

  1105.         if (fWindow == nullptr)

  1106.             return;

  1107. 

  1108.         if (fWindow->wasClosedByUser())

  1109.         {

  1110.             uiShow(false);

  1111.             uiClosed();

  1112.         }

  1113.     }

  1114. 

  1115.     // -------------------------------------------------------------------

  1116.     // Plugin state calls

  1117. 

  1118.     char* getState() const override

  1119.     {

  1120.         MemoryBlock destData;

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

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

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

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

  1125. 

  1126.         XmlElement xmlState("VEX");

  1127. 

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

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

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

  1131. 

  1132.         MemoryBlock tmp;

  1133.         copyXmlToBinary(xmlState, tmp);

  1134. 

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

  1136. 

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

  1138.     }

  1139. 

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

  1141.     {

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

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

  1144. 

  1145.         MemoryBlock destData;

  1146.         destData.fromBase64Encoding(data64);

  1147. 

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

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

  1150. 

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

  1152.         {

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

  1154.             {

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

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

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

  1158. 

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

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

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

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

  1163. 

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

  1165.                 //    fSynth.update(i);

  1166. 

  1167.                 if (fView != nullptr)

  1168.                     fView->setNeedsUpdate();

  1169.             }

  1170. 

  1171.             delete xmlState;

  1172.         }

  1173.     }

  1174. 

  1175.     // -------------------------------------------------------------------

  1176.     // Plugin dispatcher calls

  1177. 

  1178.     void bufferSizeChanged(const uint32_t bufferSize) override

  1179.     {

  1180.         delete obf;

  1181.         delete abf;

  1182.         delete dbf1;

  1183.         delete dbf2;

  1184.         delete dbf3;

  1185. 

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

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

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

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

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

  1191.     }

  1192. 

  1193.     void sampleRateChanged(const double sampleRate) override

  1194.     {

  1195.         fArp1.setSampleRate(sampleRate);

  1196.         fArp2.setSampleRate(sampleRate);

  1197.         fArp3.setSampleRate(sampleRate);

  1198.         fChorus.setSampleRate(sampleRate);

  1199.         fDelay.setSampleRate(sampleRate);

  1200.         fSynth.setSampleRate(sampleRate);

  1201.     }

  1202. 

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

  1204.     {

  1205.         if (fWindow == nullptr)

  1206.             return;

  1207. 

  1208.         MessageManagerLock mmLock;

  1209.         fWindow->setName(uiName);

  1210.     }

  1211. 

  1212.     // -------------------------------------------------------------------

  1213.     // Vex editor calls

  1214. 

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

  1216.     {

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

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

  1219.     }

  1220. 

  1221.     float getFilterParameterValue(const uint32_t index) const override

  1222.     {

  1223.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount, 0.0f)

  1224. 

  1225.         return fParameters[index];

  1226.     }

  1227. 

  1228.     String getFilterWaveName(const int part) const override

  1229.     {

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

  1231. 

  1232.         return fSynth.getWaveName(part);

  1233.     }

  1234. 

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

  1236.     {

  1237.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount,)

  1238. 

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

  1240.             return;

  1241. 

  1242.         fParameters[index] = value;

  1243.         fSynth.update(index);

  1244. 

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

  1246.     }

  1247. 

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

  1249.     {

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

  1251. 

  1252.         fSynth.setWaveLater(part, wave);

  1253.     }

  1254. 

  1255. private:

  1256.     float fParameters[kParamCount];

  1257.     bool  fParamsChanged[92];

  1258. 

  1259.     AudioSampleBuffer* obf;

  1260.     AudioSampleBuffer* abf;

  1261.     AudioSampleBuffer* dbf1; // delay

  1262.     AudioSampleBuffer* dbf2; // chorus

  1263.     AudioSampleBuffer* dbf3; // reverb

  1264. 

  1265.     VexArpSettings fArpSet1, fArpSet2, fArpSet3;

  1266.     VexArp fArp1, fArp2, fArp3;

  1267. 

  1268.     VexChorus fChorus;

  1269.     VexDelay fDelay;

  1270.     VexReverb fReverb;

  1271.     VexSyntModule fSynth;

  1272. 

  1273.     ScopedPointer<VexEditorComponent> fView;

  1274.     ScopedPointer<HelperWindow2> fWindow;

  1275. 

  1276.     MidiBuffer fMidiInBuffer;

  1277. 

  1278.     PluginClassEND(VexSynthPlugin)

  1279.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  1280. };

  1281. 

  1282. // -----------------------------------------------------------------------

  1283. 

  1284. static const PluginDescriptor vexSynthDesc = {

  1285.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  1288.     /* audioIns  */ 0,

  1289.     /* audioOuts */ 2,

  1290.     /* midiIns   */ 1,

  1291.     /* midiOuts  */ 0,

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

  1293.     /* paramOuts */ 0,

  1294.     /* name      */ "VexSynth",

  1295.     /* label     */ "vexSynth",

  1296.     /* maker     */ "falkTX",

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

  1298.     PluginDescriptorFILL(VexSynthPlugin)

  1299. };

  1300. 

  1301. // -----------------------------------------------------------------------

  1302. 

  1303. CARLA_EXPORT

  1304. void carla_register_native_plugin_vex_synth()

  1305. {

  1306.     carla_register_native_plugin(&vexSynthDesc);

  1307. }

  1308. 

  1309. // -----------------------------------------------------------------------