DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 18 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
53 Commits
7 Branches
40MB
Tree: d11db41c43
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd11db41c43'
${ noResults }
Cardinal/plugins/plugins.cpp

599 lines
18KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021 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 3 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 LICENSE file.

  16.  */

  17. 

  18. #include <plugin.hpp>

  19. 

  20. #include "DistrhoUtils.hpp"

  21. 

  22. // AnimatedCircuits

  23. #include "AnimatedCircuits/src/plugin.hpp"

  24. 

  25. // AudibleInstruments

  26. #include "AudibleInstruments/src/plugin.hpp"

  27. 

  28. // Befaco

  29. #include "Befaco/src/plugin.hpp"

  30. 

  31. // BogaudioModules

  32. #define modelADSR modelBogaudioADSR

  33. #define modelLFO modelBogaudioLFO

  34. #define modelNoise modelBogaudioNoise

  35. #define modelVCA modelBogaudioVCA

  36. #define modelVCF modelBogaudioVCF

  37. #define modelVCO modelBogaudioVCO

  38. #include "BogaudioModules/src/AD.hpp"

  39. #include "BogaudioModules/src/Additator.hpp"

  40. #include "BogaudioModules/src/AddrSeqX.hpp"

  41. #include "BogaudioModules/src/ADSR.hpp"

  42. #include "BogaudioModules/src/AMRM.hpp"

  43. #include "BogaudioModules/src/Analyzer.hpp"

  44. #include "BogaudioModules/src/AnalyzerXL.hpp"

  45. #include "BogaudioModules/src/Assign.hpp"

  46. #include "BogaudioModules/src/ASR.hpp"

  47. #include "BogaudioModules/src/Arp.hpp"

  48. #include "BogaudioModules/src/Blank3.hpp"

  49. #include "BogaudioModules/src/Blank6.hpp"

  50. #include "BogaudioModules/src/Bool.hpp"

  51. #include "BogaudioModules/src/Chirp.hpp"

  52. #include "BogaudioModules/src/Clpr.hpp"

  53. #include "BogaudioModules/src/Cmp.hpp"

  54. #include "BogaudioModules/src/CmpDist.hpp"

  55. #include "BogaudioModules/src/CVD.hpp"

  56. #include "BogaudioModules/src/DADSRH.hpp"

  57. #include "BogaudioModules/src/DADSRHPlus.hpp"

  58. #include "BogaudioModules/src/Detune.hpp"

  59. #include "BogaudioModules/src/DGate.hpp"

  60. #include "BogaudioModules/src/Edge.hpp"

  61. #include "BogaudioModules/src/EightFO.hpp"

  62. #include "BogaudioModules/src/EightOne.hpp"

  63. #include "BogaudioModules/src/EQ.hpp"

  64. #include "BogaudioModules/src/EQS.hpp"

  65. #include "BogaudioModules/src/FFB.hpp"

  66. #include "BogaudioModules/src/FlipFlop.hpp"

  67. #include "BogaudioModules/src/FMOp.hpp"

  68. #include "BogaudioModules/src/Follow.hpp"

  69. #include "BogaudioModules/src/FourFO.hpp"

  70. #include "BogaudioModules/src/FourMan.hpp"

  71. #include "BogaudioModules/src/Inv.hpp"

  72. #include "BogaudioModules/src/LFO.hpp"

  73. #include "BogaudioModules/src/Lgsw.hpp"

  74. #include "BogaudioModules/src/LLFO.hpp"

  75. #include "BogaudioModules/src/LLPG.hpp"

  76. #include "BogaudioModules/src/Lmtr.hpp"

  77. #include "BogaudioModules/src/LPG.hpp"

  78. #include "BogaudioModules/src/LVCF.hpp"

  79. #include "BogaudioModules/src/LVCO.hpp"

  80. #include "BogaudioModules/src/Manual.hpp"

  81. #include "BogaudioModules/src/Matrix18.hpp"

  82. #include "BogaudioModules/src/Matrix44.hpp"

  83. #include "BogaudioModules/src/Matrix81.hpp"

  84. #include "BogaudioModules/src/Matrix88.hpp"

  85. #include "BogaudioModules/src/Matrix88Cv.hpp"

  86. #include "BogaudioModules/src/Matrix88M.hpp"

  87. #include "BogaudioModules/src/MegaGate.hpp"

  88. #include "BogaudioModules/src/Mix1.hpp"

  89. #include "BogaudioModules/src/Mix2.hpp"

  90. #include "BogaudioModules/src/Mix4.hpp"

  91. #include "BogaudioModules/src/Mix4x.hpp"

  92. #include "BogaudioModules/src/Mix8x.hpp"

  93. #include "BogaudioModules/src/Mono.hpp"

  94. #include "BogaudioModules/src/Mult.hpp"

  95. #include "BogaudioModules/src/Mumix.hpp"

  96. #include "BogaudioModules/src/Mute8.hpp"

  97. #include "BogaudioModules/src/Noise.hpp"

  98. #include "BogaudioModules/src/Nsgt.hpp"

  99. #include "BogaudioModules/src/Offset.hpp"

  100. #include "BogaudioModules/src/OneEight.hpp"

  101. #include "BogaudioModules/src/Pan.hpp"

  102. #include "BogaudioModules/src/PEQ.hpp"

  103. #include "BogaudioModules/src/PEQ6.hpp"

  104. #include "BogaudioModules/src/PEQ6XF.hpp"

  105. #include "BogaudioModules/src/PEQ14.hpp"

  106. #include "BogaudioModules/src/PEQ14XF.hpp"

  107. #include "BogaudioModules/src/Pgmr.hpp"

  108. #include "BogaudioModules/src/PgmrX.hpp"

  109. #include "BogaudioModules/src/PolyCon16.hpp"

  110. #include "BogaudioModules/src/PolyCon8.hpp"

  111. #include "BogaudioModules/src/PolyMult.hpp"

  112. #include "BogaudioModules/src/PolyOff16.hpp"

  113. #include "BogaudioModules/src/PolyOff8.hpp"

  114. #include "BogaudioModules/src/Pressor.hpp"

  115. #include "BogaudioModules/src/Pulse.hpp"

  116. #include "BogaudioModules/src/Ranalyzer.hpp"

  117. #include "BogaudioModules/src/Reftone.hpp"

  118. #include "BogaudioModules/src/RGate.hpp"

  119. #include "BogaudioModules/src/SampleHold.hpp"

  120. #include "BogaudioModules/src/Shaper.hpp"

  121. #include "BogaudioModules/src/ShaperPlus.hpp"

  122. #include "BogaudioModules/src/Sine.hpp"

  123. #include "BogaudioModules/src/Slew.hpp"

  124. #include "BogaudioModules/src/Stack.hpp"

  125. #include "BogaudioModules/src/Sums.hpp"

  126. #include "BogaudioModules/src/Switch.hpp"

  127. #include "BogaudioModules/src/Switch1616.hpp"

  128. #include "BogaudioModules/src/Switch18.hpp"

  129. #include "BogaudioModules/src/Switch44.hpp"

  130. #include "BogaudioModules/src/Switch81.hpp"

  131. #include "BogaudioModules/src/Switch88.hpp"

  132. #include "BogaudioModules/src/UMix.hpp"

  133. #include "BogaudioModules/src/Unison.hpp"

  134. #include "BogaudioModules/src/VCA.hpp"

  135. #include "BogaudioModules/src/VCAmp.hpp"

  136. #include "BogaudioModules/src/VCF.hpp"

  137. #include "BogaudioModules/src/VCM.hpp"

  138. #include "BogaudioModules/src/VCO.hpp"

  139. #include "BogaudioModules/src/Velo.hpp"

  140. #include "BogaudioModules/src/Vish.hpp"

  141. #include "BogaudioModules/src/VU.hpp"

  142. #include "BogaudioModules/src/Walk.hpp"

  143. #include "BogaudioModules/src/Walk2.hpp"

  144. #include "BogaudioModules/src/XCO.hpp"

  145. #include "BogaudioModules/src/XFade.hpp"

  146. #undef modelADSR

  147. #undef modelLFO

  148. #undef modelNoise

  149. #undef modelVCA

  150. #undef modelVCF

  151. #undef modelVCO

  152. 

  153. // Fundamental

  154. #include "Fundamental/src/plugin.hpp"

  155. 

  156. // GrandeModular

  157. #include "GrandeModular/src/plugin.hpp"

  158. 

  159. // ZetaCarinaeModules

  160. #include "ZetaCarinaeModules/src/plugin.hpp"

  161. 

  162. Plugin* pluginInstance__AnimatedCircuits;

  163. Plugin* pluginInstance__AudibleInstruments;

  164. Plugin* pluginInstance__Befaco;

  165. Plugin* pluginInstance__BogaudioModules;

  166. Plugin* pluginInstance__Fundamental;

  167. Plugin* pluginInstance__GrandeModular;

  168. Plugin* pluginInstance__ZetaCarinaeModules;

  169. 

  170. namespace rack {

  171. 

  172. // core plugins

  173. namespace core {

  174. extern Model* modelAudioInterface2;

  175. extern Model* modelMIDI_CV;

  176. extern Model* modelMIDI_CC;

  177. extern Model* modelMIDI_Gate;

  178. extern Model* modelMIDI_Map;

  179. extern Model* modelCV_MIDI;

  180. extern Model* modelCV_CC;

  181. extern Model* modelCV_Gate;

  182. extern Model* modelBlank;

  183. extern Model* modelNotes;

  184. }

  185. 

  186. // regular plugins

  187. namespace plugin {

  188. 

  189. struct StaticPluginLoader {

  190.     Plugin* const plugin;

  191.     FILE* file;

  192.     json_t* rootJ;

  193. 

  194.     // core

  195.     StaticPluginLoader(Plugin* const p)

  196.         : plugin(p),

  197.           file(nullptr),

  198.           rootJ(nullptr)

  199.     {

  200.         p->path = system::join(CARDINAL_PLUGINS_DIR, "Core.json");

  201. 

  202.         if ((file = std::fopen(p->path.c_str(), "r")) == nullptr)

  203.         {

  204.             d_stderr2("Manifest file %s does not exist", p->path.c_str());

  205.             return;

  206.         }

  207. 

  208.         json_error_t error;

  209.         if ((rootJ = json_loadf(file, 0, &error)) == nullptr)

  210.         {

  211.             d_stderr2("JSON parsing error at %s %d:%d %s", p->path.c_str(), error.line, error.column, error.text);

  212.             return;

  213.         }

  214. 

  215.         // force ABI, we use static plugins so this doesnt matter as long as it builds

  216.         json_t* const version = json_string((APP_VERSION_MAJOR + ".0").c_str());

  217.         json_object_set(rootJ, "version", version);

  218.         json_decref(version);

  219.     }

  220. 

  221.     // regular plugins

  222.     StaticPluginLoader(Plugin* const p, const char* const name)

  223.         : plugin(p),

  224.           file(nullptr),

  225.           rootJ(nullptr)

  226.     {

  227.         p->path = system::join(CARDINAL_PLUGINS_DIR, name);

  228. 

  229.         const std::string manifestFilename = system::join(p->path, "plugin.json");

  230. 

  231.         if ((file = std::fopen(manifestFilename.c_str(), "r")) == nullptr)

  232.         {

  233.             d_stderr2("Manifest file %s does not exist", manifestFilename.c_str());

  234.             return;

  235.         }

  236. 

  237.         json_error_t error;

  238.         if ((rootJ = json_loadf(file, 0, &error)) == nullptr)

  239.         {

  240.             d_stderr2("JSON parsing error at %s %d:%d %s", manifestFilename.c_str(), error.line, error.column, error.text);

  241.             return;

  242.         }

  243. 

  244.         // force ABI, we use static plugins so this doesnt matter as long as it builds

  245.         json_t* const version = json_string((APP_VERSION_MAJOR + ".0").c_str());

  246.         json_object_set(rootJ, "version", version);

  247.         json_decref(version);

  248.     }

  249. 

  250.     ~StaticPluginLoader()

  251.     {

  252.         if (rootJ != nullptr)

  253.         {

  254.             plugin->fromJson(rootJ);

  255.             json_decref(rootJ);

  256.             plugins.push_back(plugin);

  257.         }

  258. 

  259.         if (file != nullptr)

  260.             std::fclose(file);

  261.     }

  262. 

  263.     bool ok() const noexcept

  264.     {

  265.         return rootJ != nullptr;

  266.     }

  267. };

  268. 

  269. static void initStatic__Core()

  270. {

  271.     Plugin* const p = new Plugin;

  272. 

  273.     const StaticPluginLoader spl(p);

  274.     if (spl.ok())

  275.     {

  276.         p->addModel(rack::core::modelAudioInterface2);

  277.         p->addModel(rack::core::modelMIDI_CV);

  278.         p->addModel(rack::core::modelMIDI_CC);

  279.         p->addModel(rack::core::modelMIDI_Gate);

  280.         p->addModel(rack::core::modelMIDI_Map);

  281.         p->addModel(rack::core::modelCV_MIDI);

  282.         p->addModel(rack::core::modelCV_CC);

  283.         p->addModel(rack::core::modelCV_Gate);

  284.         p->addModel(rack::core::modelBlank);

  285.         p->addModel(rack::core::modelNotes);

  286.     }

  287. }

  288. 

  289. static void initStatic__AnimatedCircuits()

  290. {

  291.     Plugin* const p = new Plugin;

  292.     pluginInstance__AnimatedCircuits = p;

  293. 

  294.     const StaticPluginLoader spl(p, "AnimatedCircuits");

  295.     if (spl.ok())

  296.     {

  297.         p->addModel(model_AC_Folding);

  298.     }

  299. }

  300. 

  301. static void initStatic__AudibleInstruments()

  302. {

  303.     Plugin* const p = new Plugin;

  304.     pluginInstance__AudibleInstruments = p;

  305. 

  306.     const StaticPluginLoader spl(p, "AudibleInstruments");

  307.     if (spl.ok())

  308.     {

  309.         p->addModel(modelBraids);

  310.         p->addModel(modelPlaits);

  311.         p->addModel(modelElements);

  312.         p->addModel(modelTides);

  313.         p->addModel(modelTides2);

  314.         p->addModel(modelClouds);

  315.         p->addModel(modelWarps);

  316.         p->addModel(modelRings);

  317.         p->addModel(modelLinks);

  318.         p->addModel(modelKinks);

  319.         p->addModel(modelShades);

  320.         p->addModel(modelBranches);

  321.         p->addModel(modelBlinds);

  322.         p->addModel(modelVeils);

  323.         p->addModel(modelFrames);

  324.         p->addModel(modelMarbles);

  325.         p->addModel(modelStages);

  326.         p->addModel(modelRipples);

  327.         p->addModel(modelShelves);

  328.         p->addModel(modelStreams);

  329.     }

  330. }

  331. 

  332. static void initStatic__Befaco()

  333. {

  334.     Plugin* const p = new Plugin;

  335.     pluginInstance__Befaco = p;

  336. 

  337.     const StaticPluginLoader spl(p, "Befaco");

  338.     if (spl.ok())

  339.     {

  340.         p->addModel(modelEvenVCO);

  341.         p->addModel(modelRampage);

  342.         p->addModel(modelABC);

  343.         p->addModel(modelSpringReverb);

  344.         p->addModel(modelMixer);

  345.         p->addModel(modelSlewLimiter);

  346.         p->addModel(modelDualAtenuverter);

  347.     }

  348. }

  349. 

  350. static void initStatic__BogaudioModules()

  351. {

  352.     Plugin* const p = new Plugin;

  353.     pluginInstance__BogaudioModules = p;

  354. 

  355.     const StaticPluginLoader spl(p, "BogaudioModules");

  356.     if (spl.ok())

  357.     {

  358. #define modelADSR modelBogaudioADSR

  359. #define modelLFO modelBogaudioLFO

  360. #define modelNoise modelBogaudioNoise

  361. #define modelVCA modelBogaudioVCA

  362. #define modelVCF modelBogaudioVCF

  363. #define modelVCO modelBogaudioVCO

  364.         p->addModel(modelVCO);

  365.         p->addModel(modelLVCO);

  366.         p->addModel(modelSine);

  367.         p->addModel(modelPulse);

  368.         p->addModel(modelXCO);

  369.         p->addModel(modelAdditator);

  370.         p->addModel(modelFMOp);

  371.         p->addModel(modelChirp);

  372.         p->addModel(modelLFO);

  373.         p->addModel(modelLLFO);

  374.         p->addModel(modelFourFO);

  375.         p->addModel(modelEightFO);

  376.         p->addModel(modelVCF);

  377.         p->addModel(modelLVCF);

  378.         p->addModel(modelFFB);

  379.         p->addModel(modelEQ);

  380.         p->addModel(modelEQS);

  381.         p->addModel(modelLPG);

  382.         p->addModel(modelLLPG);

  383.         p->addModel(modelMegaGate);

  384.         p->addModel(modelPEQ);

  385.         p->addModel(modelPEQ6);

  386.         p->addModel(modelPEQ6XF);

  387.         p->addModel(modelPEQ14);

  388.         p->addModel(modelPEQ14XF);

  389.         p->addModel(modelDADSRH);

  390.         p->addModel(modelDADSRHPlus);

  391.         p->addModel(modelShaper);

  392.         p->addModel(modelShaperPlus);

  393.         p->addModel(modelAD);

  394.         p->addModel(modelASR);

  395.         p->addModel(modelADSR);

  396.         p->addModel(modelVish);

  397.         p->addModel(modelFollow);

  398.         p->addModel(modelDGate);

  399.         p->addModel(modelRGate);

  400.         p->addModel(modelEdge);

  401.         p->addModel(modelNoise);

  402.         p->addModel(modelSampleHold);

  403.         p->addModel(modelWalk2);

  404.         p->addModel(modelWalk);

  405.         p->addModel(modelMix8);

  406.         p->addModel(modelMix8x);

  407.         p->addModel(modelMix4);

  408.         p->addModel(modelMix4x);

  409.         p->addModel(modelMix2);

  410.         p->addModel(modelMix1);

  411.         p->addModel(modelVCM);

  412.         p->addModel(modelMute8);

  413.         p->addModel(modelPan);

  414.         p->addModel(modelXFade);

  415.         p->addModel(modelVCA);

  416.         p->addModel(modelVCAmp);

  417.         p->addModel(modelVelo);

  418.         p->addModel(modelUMix);

  419.         p->addModel(modelMumix);

  420.         p->addModel(modelMatrix81);

  421.         p->addModel(modelMatrix18);

  422.         p->addModel(modelMatrix44);

  423.         p->addModel(modelMatrix44Cvm);

  424.         p->addModel(modelMatrix88);

  425.         p->addModel(modelMatrix88Cv);

  426.         p->addModel(modelMatrix88M);

  427.         p->addModel(modelSwitch81);

  428.         p->addModel(modelSwitch18);

  429.         p->addModel(modelSwitch44);

  430.         p->addModel(modelSwitch88);

  431.         p->addModel(modelSwitch1616);

  432.         p->addModel(modelAMRM);

  433.         p->addModel(modelPressor);

  434.         p->addModel(modelClpr);

  435.         p->addModel(modelLmtr);

  436.         p->addModel(modelNsgt);

  437.         p->addModel(modelCmpDist);

  438.         p->addModel(modelOneEight);

  439.         p->addModel(modelEightOne);

  440.         p->addModel(modelAddrSeq);

  441.         p->addModel(modelAddrSeqX);

  442.         p->addModel(modelPgmr);

  443.         p->addModel(modelPgmrX);

  444.         p->addModel(modelVU);

  445.         p->addModel(modelAnalyzer);

  446.         p->addModel(modelAnalyzerXL);

  447.         p->addModel(modelRanalyzer);

  448.         p->addModel(modelDetune);

  449.         p->addModel(modelStack);

  450.         p->addModel(modelReftone);

  451.         p->addModel(modelMono);

  452.         p->addModel(modelArp);

  453.         p->addModel(modelAssign);

  454.         p->addModel(modelUnison);

  455.         p->addModel(modelPolyCon8);

  456.         p->addModel(modelPolyCon16);

  457.         p->addModel(modelPolyOff8);

  458.         p->addModel(modelPolyOff16);

  459.         p->addModel(modelPolyMult);

  460.         p->addModel(modelBool);

  461.         p->addModel(modelCmp);

  462.         p->addModel(modelCVD);

  463.         p->addModel(modelFlipFlop);

  464.         p->addModel(modelInv);

  465.         p->addModel(modelManual);

  466.         p->addModel(modelFourMan);

  467.         p->addModel(modelMult);

  468.         p->addModel(modelOffset);

  469.         p->addModel(modelSlew);

  470.         p->addModel(modelSums);

  471.         p->addModel(modelSwitch);

  472.         p->addModel(modelLgsw);

  473.         p->addModel(modelBlank3);

  474.         p->addModel(modelBlank6);

  475. #ifdef EXPERIMENTAL

  476.         p->addModel(modelLag);

  477.         p->addModel(modelPEQ14XR);

  478.         p->addModel(modelPEQ14XV);

  479. #endif

  480. #ifdef TEST

  481.         p->addModel(modelTest);

  482.         p->addModel(modelTest2);

  483.         p->addModel(modelTestExpanderBase);

  484.         p->addModel(modelTestExpanderExtension);

  485.         p->addModel(modelTestGl);

  486.         p->addModel(modelTestVCF);

  487. #endif

  488. #undef modelADSR

  489. #undef modelLFO

  490. #undef modelNoise

  491. #undef modelVCA

  492. #undef modelVCF

  493. #undef modelVCO

  494.     }

  495. }

  496. 

  497. static void initStatic__Fundamental()

  498. {

  499.     Plugin* const p = new Plugin;

  500.     pluginInstance__Fundamental = p;

  501. 

  502.     const StaticPluginLoader spl(p, "Fundamental");

  503.     if (spl.ok())

  504.     {

  505.         p->addModel(modelVCO);

  506.         p->addModel(modelVCO2);

  507.         p->addModel(modelVCF);

  508.         p->addModel(modelVCA_1);

  509.         p->addModel(modelVCA);

  510.         p->addModel(modelLFO);

  511.         p->addModel(modelLFO2);

  512.         p->addModel(modelDelay);

  513.         p->addModel(modelADSR);

  514.         p->addModel(modelVCMixer);

  515.         p->addModel(model_8vert);

  516.         p->addModel(modelUnity);

  517.         p->addModel(modelMutes);

  518.         p->addModel(modelPulses);

  519.         p->addModel(modelScope);

  520.         p->addModel(modelSEQ3);

  521.         p->addModel(modelSequentialSwitch1);

  522.         p->addModel(modelSequentialSwitch2);

  523.         p->addModel(modelOctave);

  524.         p->addModel(modelQuantizer);

  525.         p->addModel(modelSplit);

  526.         p->addModel(modelMerge);

  527.         p->addModel(modelSum);

  528.         p->addModel(modelViz);

  529.         p->addModel(modelMidSide);

  530.         p->addModel(modelNoise);

  531.         p->addModel(modelRandom);

  532.     }

  533. }

  534. 

  535. static void initStatic__GrandeModular()

  536. {

  537.     Plugin* const p = new Plugin;

  538.     pluginInstance__GrandeModular = p;

  539. 

  540.     const StaticPluginLoader spl(p, "GrandeModular");

  541.     if (spl.ok())

  542.     {

  543.         p->addModel(modelClip);

  544.         p->addModel(modelMergeSplit4);

  545.         p->addModel(modelMicrotonalChords);

  546.         p->addModel(modelMicrotonalNotes);

  547.         p->addModel(modelNoteMT);

  548.         p->addModel(modelPolyMergeResplit);

  549.         p->addModel(modelQuant);

  550.         p->addModel(modelQuantIntervals);

  551.         p->addModel(modelQuantMT);

  552.         p->addModel(modelSampleDelays);

  553.         p->addModel(modelScale);

  554.         p->addModel(modelTails);

  555.         p->addModel(modelVarSampleDelays);

  556.     }

  557. }

  558. 

  559. static void initStatic__ZetaCarinaeModules()

  560. {

  561.     Plugin* p = new Plugin;

  562.     pluginInstance__ZetaCarinaeModules = p;

  563. 

  564.     const StaticPluginLoader spl(p, "ZetaCarinaeModules");

  565.     if (spl.ok())

  566.     {

  567.         p->addModel(modelBrownianBridge);

  568.         p->addModel(modelOrnsteinUhlenbeck);

  569.         p->addModel(modelIOU);

  570.         p->addModel(modelWarbler);

  571.         p->addModel(modelRosenchance);

  572.         p->addModel(modelGuildensTurn);

  573.         p->addModel(modelRosslerRustler);

  574.         p->addModel(modelFirefly);

  575.     }

  576. }

  577. 

  578. void initStaticPlugins()

  579. {

  580.     initStatic__Core();

  581.     initStatic__AnimatedCircuits();

  582.     initStatic__AudibleInstruments();

  583.     initStatic__Befaco();

  584.     initStatic__BogaudioModules();

  585.     initStatic__Fundamental();

  586.     initStatic__GrandeModular();

  587.     initStatic__ZetaCarinaeModules();

  588. }

  589. 

  590. void destroyStaticPlugins()

  591. {

  592.     for (Plugin* p : plugins)

  593.         delete p;

  594.     plugins.clear();

  595. }

  596. 

  597. }

  598. }