falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
962 Commits
17 Branches
249MB
Tree: cd5896e555
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cd5896e555'
${ noResults }
Carla/source/modules/carla_native/vex-synth.cpp

1312 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.         setDropShadowEnabled(false);

  80.         setOpaque(true);

  81.         //setResizable(false, false);

  82.         //setUsingNativeTitleBar(false);

  83.     }

  84. 

  85.     void show(Component* const comp)

  86.     {

  87.         fClosed = false;

  88. 

  89.         const int width  = comp->getWidth();

  90.         const int height = comp->getHeight()+getTitleBarHeight();

  91. 

  92.         centreWithSize(width, height);

  93.         setContentNonOwned(comp, false);

  94.         setSize(width, height);

  95. 

  96.         if (! isOnDesktop())

  97.             addToDesktop();

  98. 

  99.         setVisible(true);

  100.     }

  101. 

  102.     void hide()

  103.     {

  104.         setVisible(false);

  105. 

  106.         if (isOnDesktop())

  107.             removeFromDesktop();

  108. 

  109.         clearContentComponent();

  110.     }

  111. 

  112.     bool wasClosedByUser() const

  113.     {

  114.         return fClosed;

  115.     }

  116. 

  117. protected:

  118.     void closeButtonPressed() override

  119.     {

  120.         fClosed = true;

  121.     }

  122. 

  123. private:

  124.     bool fClosed;

  125. 

  126.     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(HelperWindow2)

  127. };

  128. 

  129. // -----------------------------------------------------------------------

  130. 

  131. class VexEditorComponent : public Component,

  132.                            public Timer,

  133.                            public ComboBox::Listener,

  134.                            public Slider::Listener,

  135.                            public Button::Listener,

  136.                            public PeggyViewComponent::Callback // ignored

  137. {

  138. public:

  139.     class Callback

  140.     {

  141.     public:

  142.         virtual ~Callback() {}

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

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

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

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

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

  148.     };

  149. 

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

  151.         : fCallback(callback),

  152.           fNeedsUpdate(false)

  153.     {

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

  155. 

  156.         // Comboboxes, wave selection

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

  158.         comboBox1->setEditableText(false);

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

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

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

  162.         comboBox1->addListener(this);

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

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

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

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

  167.         comboBox1->setWantsKeyboardFocus(false);

  168.         comboBox1->setLookAndFeel(&mlaf);

  169. 

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

  171.         comboBox2->setEditableText(false);

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

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

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

  175.         comboBox2->addListener(this);

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

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

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

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

  180.         comboBox2->setWantsKeyboardFocus(false);

  181.         comboBox2->setLookAndFeel(&mlaf);

  182. 

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

  184.         comboBox3->setEditableText(false);

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

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

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

  188.         comboBox3->addListener(this);

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

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

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

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

  193.         comboBox3->setWantsKeyboardFocus(false);

  194.         comboBox3->setLookAndFeel(&mlaf);

  195. 

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

  197.         {

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

  199. 

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

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

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

  203.         }

  204. 

  205.         //Make sliders

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

  207.         {

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

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

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

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

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

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

  214.         }

  215. 

  216.         //Adjust the center of some

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

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

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

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

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

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

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

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

  225. 

  226.         int tmp = 24;

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

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

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

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

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

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

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

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

  235. 

  236.         tmp = 48;

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

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

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

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

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

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

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

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

  245. 

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

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

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

  249. 

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

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

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

  253. 

  254.         //PART ON/OFF

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

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

  257.         TB1->addListener(this);

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

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

  260.         TB1->setClickingTogglesState(true);

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

  262. 

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

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

  265.         TB2->addListener(this);

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

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

  268.         TB2->setClickingTogglesState(true);

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

  270. 

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

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

  273.         TB3->addListener(this);

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

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

  276.         TB3->setClickingTogglesState(true);

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

  278. 

  279.         //Peggy ON/OFF

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

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

  282.         TB4->addListener(this);

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

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

  285.         TB4->setClickingTogglesState(true);

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

  287. 

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

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

  290.         TB5->addListener(this);

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

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

  293.         TB5->setClickingTogglesState(true);

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

  295. 

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

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

  298.         TB6->addListener(this);

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

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

  301.         TB6->setClickingTogglesState(true);

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

  303. 

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

  305.         p1->setLookAndFeel(&mlaf);

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

  307.         p2->setLookAndFeel(&mlaf);

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

  309.         p3->setLookAndFeel(&mlaf);

  310. 

  311.         setSize(800,500);

  312.         updateParametersFromFilter(true);

  313. 

  314.         startTimer(50);

  315.     }

  316. 

  317.     ~VexEditorComponent()

  318.     {

  319.         stopTimer();

  320.         removeAllChildren();

  321.     }

  322. 

  323.     void setNeedsUpdate()

  324.     {

  325.         fNeedsUpdate = true;

  326.     }

  327. 

  328. protected:

  329.     void paint(Graphics& g) override

  330.     {

  331.         g.drawImage(internalCachedImage1,

  332.                     0, 0, 800, 500,

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

  334.     }

  335. 

  336.     void resized() override

  337.     {

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

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

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

  341. 

  342.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  360. 

  361.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

  374. 

  375.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

  388. 

  389.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  405. 

  406.         // ...

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  422. 

  423.         // ...

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

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

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

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

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

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

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

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

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

  433. 

  434.         // ...

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

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

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

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

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

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

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

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

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

  444. 

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

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

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

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

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

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

  451. 

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

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

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

  455.     }

  456. 

  457.     void timerCallback() override

  458.     {

  459.         if (fNeedsUpdate)

  460.         {

  461.             updateParametersFromFilter(true);

  462.             fNeedsUpdate = false;

  463.         }

  464.         else

  465.         {

  466.             updateParametersFromFilter(false);

  467.         }

  468.     }

  469. 

  470.     void comboBoxChanged(ComboBox* comboBoxThatHasChanged) override

  471.     {

  472.         if (comboBoxThatHasChanged == comboBox1)

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

  474.         else if (comboBoxThatHasChanged == comboBox2)

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

  476.         else if (comboBoxThatHasChanged == comboBox3)

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

  478.     }

  479. 

  480.     void sliderValueChanged(Slider* sliderThatWasMoved) override

  481.     {

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

  483.         {

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

  485.             {

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

  487.                 return;

  488.             }

  489.         }

  490.     }

  491. 

  492.     void buttonClicked(Button* buttonThatWasClicked) override

  493.     {

  494.         if (buttonThatWasClicked == TB1)

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

  496.         else if (buttonThatWasClicked == TB2)

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

  498.         else if (buttonThatWasClicked == TB3)

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

  500.         else if (buttonThatWasClicked == TB4)

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

  502.         else if (buttonThatWasClicked == TB5)

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

  504.         else if (buttonThatWasClicked == TB6)

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

  506.     }

  507. 

  508.     void arpParameterChanged(const uint32_t) override

  509.     {

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

  511.     }

  512. 

  513.     void updateParametersFromFilter(const bool all)

  514.     {

  515.         if (all)

  516.         {

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

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

  519. 

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

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

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

  523. 

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

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

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

  527. 

  528.             p1->update();

  529.             p2->update();

  530.             p3->update();

  531.         }

  532.         else

  533.         {

  534.             bool params[92];

  535.             fCallback->getChangedParameters(params);

  536. 

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

  538.             {

  539.                 if (params[i])

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

  541.             }

  542. 

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

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

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

  546.         }

  547.     }

  548. 

  549. private:

  550.     static const int kSliderCount = 89;

  551. 

  552.     Callback* const fCallback;

  553.     volatile bool fNeedsUpdate;

  554. 

  555.     Image internalCachedImage1;

  556.     MyLookAndFeel mlaf;

  557. 

  558.     ScopedPointer<ComboBox> comboBox1;

  559.     ScopedPointer<ComboBox> comboBox2;

  560.     ScopedPointer<ComboBox> comboBox3;

  561. 

  562.     ScopedPointer<SnappingSlider> sliders[kSliderCount];

  563. 

  564.     ScopedPointer<TextButton> TB1;

  565.     ScopedPointer<TextButton> TB2;

  566.     ScopedPointer<TextButton> TB3;

  567.     ScopedPointer<TextButton> TB4;

  568.     ScopedPointer<TextButton> TB5;

  569.     ScopedPointer<TextButton> TB6;

  570. 

  571.     ScopedPointer<PeggyViewComponent> p1;

  572.     ScopedPointer<PeggyViewComponent> p2;

  573.     ScopedPointer<PeggyViewComponent> p3;

  574. 

  575.     VexArpSettings _d;

  576. };

  577. 

  578. // -----------------------------------------------------------------------

  579. 

  580. class VexSynthPlugin : public PluginClass,

  581.                        public VexEditorComponent::Callback

  582. {

  583. public:

  584.     static const unsigned int kParamCount = 92;

  585. 

  586.     VexSynthPlugin(const HostDescriptor* const host)

  587.         : PluginClass(host),

  588.           obf(nullptr),

  589.           abf(nullptr),

  590.           dbf1(nullptr),

  591.           dbf2(nullptr),

  592.           dbf3(nullptr),

  593.           fArp1(&fArpSet1),

  594.           fArp2(&fArpSet2),

  595.           fArp3(&fArpSet3),

  596.           fChorus(fParameters),

  597.           fDelay(fParameters),

  598.           fReverb(fParameters),

  599.           fSynth(fParameters)

  600.     {

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

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

  603. 

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

  605. 

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

  607.         {

  608.             const int offset = i * 24;

  609. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  634.         }

  635. 

  636.         // ^1 - 72

  637. 

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

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

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

  641. 

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

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

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

  645. 

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

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

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

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

  650. 

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

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

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

  654. 

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

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

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

  658. 

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

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

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

  662. 

  663.         bufferSizeChanged(getBufferSize());

  664.         sampleRateChanged(getSampleRate());

  665. 

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

  667.             fSynth.update(i);

  668. 

  669.         fMidiInBuffer.ensureSize(512*4);

  670.     }

  671. 

  672.     ~VexSynthPlugin() override

  673.     {

  674.         delete obf;

  675.         delete abf;

  676.         delete dbf1;

  677.         delete dbf2;

  678.         delete dbf3;

  679.     }

  680. 

  681. protected:

  682.     // -------------------------------------------------------------------

  683.     // Plugin parameter calls

  684. 

  685.     uint32_t getParameterCount() const override

  686.     {

  687.         return kParamCount;

  688.     }

  689. 

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

  691.     {

  692.         static Parameter paramInfo;

  693. 

  694.         int hints = PARAMETER_IS_ENABLED|PARAMETER_IS_AUTOMABLE;

  695. 

  696.         paramInfo.name = nullptr;

  697.         paramInfo.unit = nullptr;

  698.         paramInfo.ranges.def       = 0.0f;

  699.         paramInfo.ranges.min       = 0.0f;

  700.         paramInfo.ranges.max       = 1.0f;

  701.         paramInfo.ranges.step      = PARAMETER_RANGES_DEFAULT_STEP;

  702.         paramInfo.ranges.stepSmall = PARAMETER_RANGES_DEFAULT_STEP_SMALL;

  703.         paramInfo.ranges.stepLarge = PARAMETER_RANGES_DEFAULT_STEP_LARGE;

  704.         paramInfo.scalePointCount  = 0;

  705.         paramInfo.scalePoints      = nullptr;

  706. 

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

  708.         {

  709.             uint32_t ri = index % 24;

  710. 

  711.             switch (ri)

  712.             {

  713.             case 1:

  714.                 paramInfo.name = "oct";

  715.                 paramInfo.ranges.def = 0.5f;

  716.                 break;

  717.             case 2:

  718.                 paramInfo.name = "cent";

  719.                 paramInfo.ranges.def = 0.5f;

  720.                 break;

  721.             case 3:

  722.                 paramInfo.name = "phaseOffset";

  723.                 paramInfo.ranges.def = 0.5f;

  724.                 break;

  725.             case 4:

  726.                 paramInfo.name = "phaseIncOffset";

  727.                 paramInfo.ranges.def = 0.5f;

  728.                 break;

  729.             case 5:

  730.                 paramInfo.name = "filter";

  731.                 paramInfo.ranges.def = 0.9f;

  732.                 break;

  733.             case 6:

  734.                 paramInfo.name = "filter";

  735.                 paramInfo.ranges.def = 0.0f;

  736.                 break;

  737.             case 7:

  738.                 paramInfo.name = "filter";

  739.                 paramInfo.ranges.def = 1.0f;

  740.                 break;

  741.             case 8:

  742.                 paramInfo.name = "filter";

  743.                 paramInfo.ranges.def = 0.5f;

  744.                 break;

  745.             case 9:

  746.                 paramInfo.name = "F ADSR";

  747.                 paramInfo.ranges.def = 0.0f;

  748.                 break;

  749.             case 10:

  750.                 paramInfo.name = "F ADSR";

  751.                 paramInfo.ranges.def = 0.2f;

  752.                 break;

  753.             case 11:

  754.                 paramInfo.name = "F ADSR";

  755.                 paramInfo.ranges.def = 0.0f;

  756.                 break;

  757.             case 12:

  758.                 paramInfo.name = "F ADSR";

  759.                 paramInfo.ranges.def = 0.5f;

  760.                 break;

  761.             case 13:

  762.                 paramInfo.name = "F velocity";

  763.                 paramInfo.ranges.def = 0.5f;

  764.                 break;

  765.             case 14:

  766.                 paramInfo.name = "A ADSR";

  767.                 paramInfo.ranges.def = 0.0f;

  768.                 break;

  769.             case 15:

  770.                 paramInfo.name = "A ADSR";

  771.                 paramInfo.ranges.def = 0.3f;

  772.                 break;

  773.             case 16:

  774.                 paramInfo.name = "A ADSR";

  775.                 paramInfo.ranges.def = 0.7f;

  776.                 break;

  777.             case 17:

  778.                 paramInfo.name = "A ADSR";

  779.                 paramInfo.ranges.def = 0.1f;

  780.                 break;

  781.             case 18:

  782.                 paramInfo.name = "A velocity";

  783.                 paramInfo.ranges.def = 0.5f;

  784.                 break;

  785.             case 19:

  786.                 paramInfo.name = "lfoC";

  787.                 paramInfo.ranges.def = 0.5f;

  788.                 break;

  789.             case 20:

  790.                 paramInfo.name = "lfoA";

  791.                 paramInfo.ranges.def = 0.0f;

  792.                 break;

  793.             case 21:

  794.                 paramInfo.name = "lfoF";

  795.                 paramInfo.ranges.def = 0.0f;

  796.                 break;

  797.             case 22:

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

  799.                 paramInfo.ranges.def = 0.5f;

  800.                 break;

  801.             case 23:

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

  803.                 paramInfo.ranges.def = 0.5f;

  804.                 break;

  805.             case 24:

  806.             case 0:

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

  808.                 paramInfo.ranges.def = 0.5f;

  809.                 break;

  810.             default:

  811.                 paramInfo.name = "unknown2";

  812.                 break;

  813.             }

  814. 

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

  816.             return &paramInfo;

  817.         }

  818. 

  819.         switch (index)

  820.         {

  821.         case 0:

  822.             paramInfo.name = "Main volume";

  823.             paramInfo.ranges.def = 1.0f;

  824.             break;

  825.         case 73:

  826.             hints |= PARAMETER_IS_INTEGER;

  827.             paramInfo.name = "Delay Time";

  828.             paramInfo.unit = "steps";

  829.             paramInfo.ranges.def = 4.0f;

  830.             paramInfo.ranges.min = 0.0f;

  831.             paramInfo.ranges.max = 8.0f;

  832.             break;

  833.         case 74:

  834.             paramInfo.name = "Delay Feedback";

  835.             paramInfo.unit = "%";

  836.             paramInfo.ranges.def = 40.0f;

  837.             paramInfo.ranges.min = 0.0f;

  838.             paramInfo.ranges.max = 100.0f;

  839.             break;

  840.         case 75:

  841.             paramInfo.name = "Delay Volume";

  842.             paramInfo.ranges.def = 0.0f;

  843.             break;

  844.         case 76:

  845.             paramInfo.name = "Chorus Rate";

  846.             paramInfo.ranges.def = 0.3f;

  847.             break;

  848.         case 77:

  849.             paramInfo.name = "Chorus Depth";

  850.             paramInfo.ranges.def = 0.6f;

  851.             break;

  852.         case 78:

  853.             paramInfo.name = "Chorus Volume";

  854.             paramInfo.ranges.def = 0.5f;

  855.             break;

  856.         case 79:

  857.             paramInfo.name = "Reverb Size";

  858.             paramInfo.ranges.def = 0.6f;

  859.             break;

  860.         case 80:

  861.             paramInfo.name = "Reverb Width";

  862.             paramInfo.ranges.def = 0.7f;

  863.             break;

  864.         case 81:

  865.             paramInfo.name = "Reverb Damp";

  866.             paramInfo.ranges.def = 0.6f;

  867.             break;

  868.         case 82:

  869.             paramInfo.name = "Reverb Volume";

  870.             paramInfo.ranges.def = 0.0f;

  871.             break;

  872.         case 83:

  873.             paramInfo.name = "Wave1 Panning";

  874.             paramInfo.ranges.def = 0.5f;

  875.             break;

  876.         case 84:

  877.             paramInfo.name = "Wave2 Panning";

  878.             paramInfo.ranges.def = 0.5f;

  879.             break;

  880.         case 85:

  881.             paramInfo.name = "Wave3 Panning";

  882.             paramInfo.ranges.def = 0.5f;

  883.             break;

  884.         case 86:

  885.             paramInfo.name = "Wave1 Volume";

  886.             paramInfo.ranges.def = 0.5f;

  887.             break;

  888.         case 87:

  889.             paramInfo.name = "Wave2 Volume";

  890.             paramInfo.ranges.def = 0.5f;

  891.             break;

  892.         case 88:

  893.             paramInfo.name = "Wave3 Volume";

  894.             paramInfo.ranges.def = 0.5f;

  895.             break;

  896.         case 89:

  897.             hints |= PARAMETER_IS_BOOLEAN;

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

  899.             paramInfo.ranges.def = 0.1f;

  900.             break;

  901.         case 90:

  902.             hints |= PARAMETER_IS_BOOLEAN;

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

  904.             paramInfo.ranges.def = 0.0f;

  905.             break;

  906.         case 91:

  907.             hints |= PARAMETER_IS_BOOLEAN;

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

  909.             paramInfo.ranges.def = 0.0f;

  910.             break;

  911.         default:

  912.             paramInfo.name = "unknown";

  913.             break;

  914.         }

  915. 

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

  917.         return &paramInfo;

  918.     }

  919. 

  920.     float getParameterValue(const uint32_t index) const override

  921.     {

  922.         if (index >= kParamCount)

  923.             return 0.0f;

  924. 

  925.         switch (index)

  926.         {

  927.         case 73:

  928.             return fParameters[index] * 8.0f;

  929.         case 74:

  930.             return fParameters[index] * 100.0f;

  931.         default:

  932.             return fParameters[index];

  933.         }

  934.     }

  935. 

  936.     // -------------------------------------------------------------------

  937.     // Plugin state calls

  938. 

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

  940.     {

  941.         if (index >= kParamCount)

  942.             return;

  943. 

  944.         float realValue;

  945. 

  946.         switch (index)

  947.         {

  948.         case 73:

  949.             realValue = value/8.0f;

  950.             break;

  951.         case 74:

  952.             realValue = value/100.0f;

  953.             break;

  954.         default:

  955.             realValue = value;

  956.             break;

  957.         }

  958. 

  959.         fParameters[index] = realValue;

  960.         fParamsChanged[index] = true;

  961.         fSynth.update(index);

  962.     }

  963. 

  964.     // -------------------------------------------------------------------

  965.     // Plugin process calls

  966. 

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

  968.     {

  969.         // Get time info

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

  971. 

  972.         bool   timePlaying = false;

  973.         double ppqPos      = 0.0;

  974.         double barStartPos = 0.0;

  975.         double bpm         = 120.0;

  976. 

  977.         if (timeInfo != nullptr)

  978.         {

  979.             timePlaying = timeInfo->playing;

  980. 

  981.             if (timeInfo->bbt.valid)

  982.             {

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

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

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

  986. 

  987.                 ppqPos      = ppqBar + ppqBeat + ppqTick;

  988.                 barStartPos = ppqBar;

  989.                 bpm         = timeInfo->bbt.beatsPerMinute;

  990.             }

  991.         }

  992. 

  993.         // put carla events in juce midi buffer

  994.         fMidiInBuffer.clear();

  995. 

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

  997.         {

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

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

  1000.         }

  1001. 

  1002.         // process MIDI (arppeggiator)

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

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

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

  1006. 

  1007.         int snum;

  1008.         MidiMessage midiMessage(0xf4);

  1009.         MidiBuffer::Iterator Iterator1(part1Midi);

  1010. 

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

  1012.         {

  1013.             if (midiMessage.isNoteOn())

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

  1015.             else if (midiMessage.isNoteOff())

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

  1017.             else if (midiMessage.isAllSoundOff())

  1018.                 fSynth.kill();

  1019.             else if (midiMessage.isAllNotesOff())

  1020.                 fSynth.releaseAll(snum);

  1021.         }

  1022. 

  1023.         MidiBuffer::Iterator Iterator2(part2Midi);

  1024. 

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

  1026.         {

  1027.             if (midiMessage.isNoteOn())

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

  1029.             else if (midiMessage.isNoteOff())

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

  1031.         }

  1032. 

  1033.         MidiBuffer::Iterator Iterator3(part3Midi);

  1034. 

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

  1036.         {

  1037.             if (midiMessage.isNoteOn())

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

  1039.             else if (midiMessage.isNoteOff())

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

  1041.         }

  1042. 

  1043.         fMidiInBuffer.clear();

  1044. 

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

  1046.         {

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

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

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

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

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

  1052.         }

  1053. 

  1054.         obf ->clear();

  1055.         dbf1->clear();

  1056.         dbf2->clear();

  1057.         dbf3->clear();

  1058. 

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

  1060. 

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

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

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

  1064. 

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

  1066.         output.clear();

  1067. 

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

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

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

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

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

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

  1074. 

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

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

  1077.     }

  1078. 

  1079.     // -------------------------------------------------------------------

  1080.     // Plugin UI calls

  1081. 

  1082.     void uiShow(const bool show) override

  1083.     {

  1084.         if (show)

  1085.         {

  1086.             if (fWindow == nullptr)

  1087.             {

  1088.                 fWindow = new HelperWindow2();

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

  1090.             }

  1091. 

  1092.             if (fView == nullptr)

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

  1094. 

  1095.             fWindow->show(fView);

  1096.         }

  1097.         else if (fWindow != nullptr)

  1098.         {

  1099.             fWindow->hide();

  1100. 

  1101.             fView = nullptr;

  1102.             fWindow = nullptr;

  1103.         }

  1104.     }

  1105. 

  1106.     void uiIdle() override

  1107.     {

  1108.         if (fWindow == nullptr)

  1109.             return;

  1110. 

  1111.         if (fWindow->wasClosedByUser())

  1112.         {

  1113.             uiShow(false);

  1114.             uiClosed();

  1115.         }

  1116.     }

  1117. 

  1118.     // -------------------------------------------------------------------

  1119.     // Plugin state calls

  1120. 

  1121.     char* getState() const override

  1122.     {

  1123.         MemoryBlock destData;

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

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

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

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

  1128. 

  1129.         XmlElement xmlState("VEX");

  1130. 

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

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

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

  1134. 

  1135.         MemoryBlock tmp;

  1136.         copyXmlToBinary(xmlState, tmp);

  1137. 

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

  1139. 

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

  1141.     }

  1142. 

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

  1144.     {

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

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

  1147. 

  1148.         MemoryBlock destData;

  1149.         destData.fromBase64Encoding(data64);

  1150. 

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

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

  1153. 

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

  1155.         {

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

  1157.             {

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

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

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

  1161. 

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

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

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

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

  1166. 

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

  1168.                 //    fSynth.update(i);

  1169. 

  1170.                 if (fView != nullptr)

  1171.                     fView->setNeedsUpdate();

  1172.             }

  1173. 

  1174.             delete xmlState;

  1175.         }

  1176.     }

  1177. 

  1178.     // -------------------------------------------------------------------

  1179.     // Plugin dispatcher calls

  1180. 

  1181.     void bufferSizeChanged(const uint32_t bufferSize) override

  1182.     {

  1183.         delete obf;

  1184.         delete abf;

  1185.         delete dbf1;

  1186.         delete dbf2;

  1187.         delete dbf3;

  1188. 

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

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

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

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

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

  1194.     }

  1195. 

  1196.     void sampleRateChanged(const double sampleRate) override

  1197.     {

  1198.         fArp1.setSampleRate(sampleRate);

  1199.         fArp2.setSampleRate(sampleRate);

  1200.         fArp3.setSampleRate(sampleRate);

  1201.         fChorus.setSampleRate(sampleRate);

  1202.         fDelay.setSampleRate(sampleRate);

  1203.         fSynth.setSampleRate(sampleRate);

  1204.     }

  1205. 

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

  1207.     {

  1208.         if (fWindow == nullptr)

  1209.             return;

  1210. 

  1211.         fWindow->setName(uiName);

  1212.     }

  1213. 

  1214.     // -------------------------------------------------------------------

  1215.     // Vex editor calls

  1216. 

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

  1218.     {

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

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

  1221.     }

  1222. 

  1223.     float getFilterParameterValue(const uint32_t index) const override

  1224.     {

  1225.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount, 0.0f)

  1226. 

  1227.         return fParameters[index];

  1228.     }

  1229. 

  1230.     String getFilterWaveName(const int part) const override

  1231.     {

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

  1233. 

  1234.         return fSynth.getWaveName(part);

  1235.     }

  1236. 

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

  1238.     {

  1239.         CARLA_SAFE_ASSERT_RETURN(index < kParamCount,)

  1240. 

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

  1242.             return;

  1243. 

  1244.         fParameters[index] = value;

  1245.         fSynth.update(index);

  1246. 

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

  1248.     }

  1249. 

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

  1251.     {

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

  1253. 

  1254.         fSynth.setWaveLater(part, wave);

  1255.     }

  1256. 

  1257. private:

  1258.     float fParameters[kParamCount];

  1259.     bool  fParamsChanged[92];

  1260. 

  1261.     AudioSampleBuffer* obf;

  1262.     AudioSampleBuffer* abf;

  1263.     AudioSampleBuffer* dbf1; // delay

  1264.     AudioSampleBuffer* dbf2; // chorus

  1265.     AudioSampleBuffer* dbf3; // reverb

  1266. 

  1267.     VexArpSettings fArpSet1, fArpSet2, fArpSet3;

  1268.     VexArp fArp1, fArp2, fArp3;

  1269. 

  1270.     VexChorus fChorus;

  1271.     VexDelay fDelay;

  1272.     VexReverb fReverb;

  1273.     VexSyntModule fSynth;

  1274. 

  1275.     ScopedPointer<VexEditorComponent> fView;

  1276.     ScopedPointer<HelperWindow2> fWindow;

  1277. 

  1278.     MidiBuffer fMidiInBuffer;

  1279. 

  1280.     PluginClassEND(VexSynthPlugin)

  1281.     CARLA_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR(VexSynthPlugin)

  1282. };

  1283. 

  1284. // -----------------------------------------------------------------------

  1285. 

  1286. static const PluginDescriptor vexSynthDesc = {

  1287.     /* category  */ PLUGIN_CATEGORY_SYNTH,

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

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

  1290.     /* audioIns  */ 0,

  1291.     /* audioOuts */ 2,

  1292.     /* midiIns   */ 1,

  1293.     /* midiOuts  */ 0,

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

  1295.     /* paramOuts */ 0,

  1296.     /* name      */ "VexSynth",

  1297.     /* label     */ "vexSynth",

  1298.     /* maker     */ "falkTX",

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

  1300.     PluginDescriptorFILL(VexSynthPlugin)

  1301. };

  1302. 

  1303. // -----------------------------------------------------------------------

  1304. 

  1305. CARLA_EXPORT

  1306. void carla_register_native_plugin_vex_synth()

  1307. {

  1308.     carla_register_native_plugin(&vexSynthDesc);

  1309. }

  1310. 

  1311. // -----------------------------------------------------------------------