DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 19 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.
78 Commits
7 Branches
91MB
Tree: 8eb1366e97
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8eb1366e97'
${ noResults }
Cardinal/plugins/plugins.cpp

916 lines
27KB
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. // AS

  26. #define modelADSR modelASADSR

  27. #define modelVCA modelASVCA

  28. #include "AS/src/AS.hpp"

  29. #undef modelADSR

  30. #undef modelVCA

  31. 

  32. // AudibleInstruments

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

  34. 

  35. // Befaco

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

  37. 

  38. // Bidoo

  39. #include "Bidoo/src/plugin.hpp"

  40. 

  41. // BogaudioModules

  42. #define modelADSR modelBogaudioADSR

  43. #define modelLFO modelBogaudioLFO

  44. #define modelNoise modelBogaudioNoise

  45. #define modelVCA modelBogaudioVCA

  46. #define modelVCF modelBogaudioVCF

  47. #define modelVCO modelBogaudioVCO

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  156. #undef modelADSR

  157. #undef modelLFO

  158. #undef modelNoise

  159. #undef modelVCA

  160. #undef modelVCF

  161. #undef modelVCO

  162. 

  163. // Cardinal (built-in)

  164. #include "Cardinal/src/plugin.hpp"

  165. 

  166. // ESeries

  167. #include "ESeries/src/plugin.hpp"

  168. 

  169. // Fundamental

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

  171. 

  172. // GrandeModular

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

  174. 

  175. // JW-Modules

  176. #include "JW-Modules/src/JWModules.hpp"

  177. 

  178. // rackwindows

  179. #include "rackwindows/src/plugin.hpp"

  180. // stuff that reads config files, we dont want that

  181. int loadConsoleType() { return 0; }

  182. int loadDirectOutMode() { return 0; }

  183. bool loadDarkAsDefault() { return true; }

  184. bool loadQuality() { return false; }

  185. void saveConsoleType(int) {}

  186. void saveDarkAsDefault(bool) {}

  187. void saveDirectOutMode(bool) {}

  188. void saveHighQualityAsDefault(bool) {}

  189. 

  190. // ValleyAudio

  191. /* does not build against v2

  192. #include "ValleyAudio/src/Valley.hpp"

  193. */

  194. 

  195. // ZetaCarinaeModules

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

  197. 

  198. Plugin* pluginInstance__AnimatedCircuits;

  199. Plugin* pluginInstance__AS;

  200. Plugin* pluginInstance__AudibleInstruments;

  201. Plugin* pluginInstance__Befaco;

  202. Plugin* pluginInstance__Bidoo;

  203. Plugin* pluginInstance__BogaudioModules;

  204. Plugin* pluginInstance__Cardinal;

  205. Plugin* pluginInstance__ESeries;

  206. Plugin* pluginInstance__Fundamental;

  207. Plugin* pluginInstance__GrandeModular;

  208. Plugin* pluginInstance__JW;

  209. Plugin* pluginInstance__rackwindows;

  210. Plugin* pluginInstance__ValleyAudio;

  211. Plugin* pluginInstance__ZetaCarinaeModules;

  212. 

  213. namespace rack {

  214. 

  215. // core plugins

  216. namespace core {

  217. extern Model* modelAudioInterface;

  218. extern Model* modelAudioInterface2;

  219. extern Model* modelAudioInterface16;

  220. extern Model* modelMIDI_CV;

  221. extern Model* modelMIDI_CC;

  222. extern Model* modelMIDI_Gate;

  223. extern Model* modelMIDI_Map;

  224. extern Model* modelCV_MIDI;

  225. extern Model* modelCV_CC;

  226. extern Model* modelCV_Gate;

  227. extern Model* modelBlank;

  228. extern Model* modelNotes;

  229. }

  230. 

  231. // regular plugins

  232. namespace plugin {

  233. 

  234. struct StaticPluginLoader {

  235.     Plugin* const plugin;

  236.     FILE* file;

  237.     json_t* rootJ;

  238. 

  239.     // core

  240.     StaticPluginLoader(Plugin* const p)

  241.         : plugin(p),

  242.           file(nullptr),

  243.           rootJ(nullptr)

  244.     {

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

  246. 

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

  248.         {

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

  250.             return;

  251.         }

  252. 

  253.         json_error_t error;

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

  255.         {

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

  257.             return;

  258.         }

  259. 

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

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

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

  263.         json_decref(version);

  264.     }

  265. 

  266.     // regular plugins

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

  268.         : plugin(p),

  269.           file(nullptr),

  270.           rootJ(nullptr)

  271.     {

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

  273. 

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

  275. 

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

  277.         {

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

  279.             return;

  280.         }

  281. 

  282.         json_error_t error;

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

  284.         {

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

  286.             return;

  287.         }

  288. 

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

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

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

  292.         json_decref(version);

  293.     }

  294. 

  295.     ~StaticPluginLoader()

  296.     {

  297.         if (rootJ != nullptr)

  298.         {

  299.             plugin->fromJson(rootJ);

  300.             json_decref(rootJ);

  301.             plugins.push_back(plugin);

  302.         }

  303. 

  304.         if (file != nullptr)

  305.             std::fclose(file);

  306.     }

  307. 

  308.     bool ok() const noexcept

  309.     {

  310.         return rootJ != nullptr;

  311.     }

  312. };

  313. 

  314. static void initStatic__Core()

  315. {

  316.     Plugin* const p = new Plugin;

  317. 

  318.     const StaticPluginLoader spl(p);

  319.     if (spl.ok())

  320.     {

  321.         p->addModel(rack::core::modelAudioInterface);

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

  323.         p->addModel(rack::core::modelAudioInterface16);

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

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

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

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

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

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

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

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

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

  333.     }

  334. }

  335. 

  336. static void initStatic__AnimatedCircuits()

  337. {

  338.     Plugin* const p = new Plugin;

  339.     pluginInstance__AnimatedCircuits = p;

  340. 

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

  342.     if (spl.ok())

  343.     {

  344.         p->addModel(model_AC_Folding);

  345.     }

  346. }

  347. 

  348. static void initStatic__AS()

  349. {

  350.     Plugin* const p = new Plugin;

  351.     pluginInstance__AS = p;

  352. 

  353.     const StaticPluginLoader spl(p, "AS");

  354.     if (spl.ok())

  355.     {

  356. #define modelADSR modelASADSR

  357. #define modelVCA modelASVCA

  358.         //OSCILLATORS

  359.         p->addModel(modelSineOsc);

  360.         p->addModel(modelSawOsc);

  361. 

  362.         //TOOLS

  363.         p->addModel(modelADSR);

  364.         p->addModel(modelVCA);

  365.         p->addModel(modelQuadVCA);

  366.         p->addModel(modelTriLFO);

  367.         p->addModel(modelAtNuVrTr);

  368.         p->addModel(modelBPMClock);

  369.         p->addModel(modelSEQ16);

  370.         p->addModel(modelMixer2ch);

  371.         p->addModel(modelMixer4ch);

  372.         p->addModel(modelMixer8ch);

  373.         p->addModel(modelMonoVUmeter);

  374.         p->addModel(modelStereoVUmeter);

  375.         p->addModel(modelMultiple2_5);

  376.         p->addModel(modelMerge2_5);

  377.         p->addModel(modelSteps);

  378.         p->addModel(modelLaunchGate);

  379.         p->addModel(modelKillGate);

  380.         p->addModel(modelFlow);

  381.         p->addModel(modelSignalDelay);

  382.         p->addModel(modelTriggersMKI);

  383.         p->addModel(modelTriggersMKII);

  384.         p->addModel(modelTriggersMKIII);

  385.         p->addModel(modelBPMCalc);

  386.         p->addModel(modelBPMCalc2);

  387.         p->addModel(modelCv2T);

  388.         p->addModel(modelZeroCV2T);

  389.         p->addModel(modelReScale);

  390. 

  391.         //EFFECTS

  392.         p->addModel(modelDelayPlusFx);

  393.         p->addModel(modelDelayPlusStereoFx);

  394.         p->addModel(modelPhaserFx);

  395.         p->addModel(modelReverbFx);

  396.         p->addModel(modelReverbStereoFx);

  397.         p->addModel(modelSuperDriveFx);

  398.         p->addModel(modelSuperDriveStereoFx);

  399.         p->addModel(modelTremoloFx);

  400.         p->addModel(modelTremoloStereoFx);

  401.         p->addModel(modelWaveShaper);

  402.         p->addModel(modelWaveShaperStereo);

  403. 

  404.         //BLANK PANELS

  405.         p->addModel(modelBlankPanel4);

  406.         p->addModel(modelBlankPanel6);

  407.         p->addModel(modelBlankPanel8);

  408.         p->addModel(modelBlankPanelSpecial);

  409. #undef modelADSR

  410. #undef modelVCA

  411.     }

  412. }

  413. 

  414. static void initStatic__AudibleInstruments()

  415. {

  416.     Plugin* const p = new Plugin;

  417.     pluginInstance__AudibleInstruments = p;

  418. 

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

  420.     if (spl.ok())

  421.     {

  422.         p->addModel(modelBraids);

  423.         p->addModel(modelPlaits);

  424.         p->addModel(modelElements);

  425.         p->addModel(modelTides);

  426.         p->addModel(modelTides2);

  427.         p->addModel(modelClouds);

  428.         p->addModel(modelWarps);

  429.         p->addModel(modelRings);

  430.         p->addModel(modelLinks);

  431.         p->addModel(modelKinks);

  432.         p->addModel(modelShades);

  433.         p->addModel(modelBranches);

  434.         p->addModel(modelBlinds);

  435.         p->addModel(modelVeils);

  436.         p->addModel(modelFrames);

  437.         p->addModel(modelMarbles);

  438.         p->addModel(modelStages);

  439.         p->addModel(modelRipples);

  440.         p->addModel(modelShelves);

  441.         p->addModel(modelStreams);

  442.     }

  443. }

  444. 

  445. static void initStatic__Befaco()

  446. {

  447.     Plugin* const p = new Plugin;

  448.     pluginInstance__Befaco = p;

  449. 

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

  451.     if (spl.ok())

  452.     {

  453.         p->addModel(modelEvenVCO);

  454.         p->addModel(modelRampage);

  455.         p->addModel(modelABC);

  456.         p->addModel(modelSpringReverb);

  457.         p->addModel(modelMixer);

  458.         p->addModel(modelSlewLimiter);

  459.         p->addModel(modelDualAtenuverter);

  460.     }

  461. }

  462. 

  463. static void initStatic__Bidoo()

  464. {

  465.     Plugin* const p = new Plugin;

  466.     pluginInstance__Bidoo = p;

  467. 

  468.     const StaticPluginLoader spl(p, "Bidoo");

  469.     if (spl.ok())

  470.     {

  471.         p->addModel(modelTOCANTE);

  472.         p->addModel(modelLATE);

  473.         p->addModel(modelDIKTAT);

  474.         p->addModel(modelDTROY);

  475.         p->addModel(modelBORDL);

  476.         p->addModel(modelZOUMAI);

  477.         p->addModel(modelMU);

  478.         p->addModel(modelCHUTE);

  479.         p->addModel(modelLOURDE);

  480.         p->addModel(modelACNE);

  481.         p->addModel(modelMS);

  482.         p->addModel(modelDUKE);

  483.         p->addModel(modelMOIRE);

  484.         p->addModel(modelPILOT);

  485.         p->addModel(modelHUITRE);

  486.         p->addModel(modelOUAIVE);

  487.         p->addModel(modelPOUPRE);

  488.         p->addModel(modelMAGMA);

  489.         p->addModel(modelOAI);

  490.         p->addModel(modelCANARD);

  491.         p->addModel(modelEMILE);

  492.         p->addModel(modelFORK);

  493.         p->addModel(modelTIARE);

  494.         //p->addModel(modelCLACOS);

  495.         //p->addModel(modelPENEQUE);

  496.         p->addModel(modelLIMONADE);

  497.         p->addModel(modelLIMBO);

  498.         p->addModel(modelPERCO);

  499.         p->addModel(modelBAFIS);

  500.         p->addModel(modelFFILTR);

  501.         p->addModel(modelBAR);

  502.         p->addModel(modelMINIBAR);

  503.         p->addModel(modelZINC);

  504.         p->addModel(modelFREIN);

  505.         p->addModel(modelHCTIP);

  506.         //p->addModel(modelCURT);

  507.         p->addModel(modelDFUZE);

  508.         p->addModel(modelREI);

  509.         p->addModel(modelRABBIT);

  510.         p->addModel(modelBISTROT);

  511.         p->addModel(modelSIGMA);

  512.         p->addModel(modelGARCON);

  513.         p->addModel(modelVOID);

  514. 

  515.         // NOTE disabled in Cardinal due to curl usage

  516.         // p->addModel(modelANTN);

  517. 

  518.         // intentionally remove known bad plugin

  519.         if (json_t* const modules = json_object_get(spl.rootJ, "modules"))

  520.         {

  521.             size_t i;

  522.             json_t* v;

  523.             json_array_foreach(modules, i, v)

  524.             {

  525.                 if (json_t* const slug = json_object_get(v, "slug"))

  526.                 {

  527.                     if (const char* const value = json_string_value(slug))

  528.                     {

  529.                         if (std::strcmp(value, "antN") == 0)

  530.                         {

  531.                             json_array_remove(modules, i);

  532.                             break;

  533.                         }

  534.                     }

  535.                 }

  536.             }

  537.         }

  538.     }

  539. }

  540. 

  541. static void initStatic__BogaudioModules()

  542. {

  543.     Plugin* const p = new Plugin;

  544.     pluginInstance__BogaudioModules = p;

  545. 

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

  547.     if (spl.ok())

  548.     {

  549. #define modelADSR modelBogaudioADSR

  550. #define modelLFO modelBogaudioLFO

  551. #define modelNoise modelBogaudioNoise

  552. #define modelVCA modelBogaudioVCA

  553. #define modelVCF modelBogaudioVCF

  554. #define modelVCO modelBogaudioVCO

  555.         p->addModel(modelVCO);

  556.         p->addModel(modelLVCO);

  557.         p->addModel(modelSine);

  558.         p->addModel(modelPulse);

  559.         p->addModel(modelXCO);

  560.         p->addModel(modelAdditator);

  561.         p->addModel(modelFMOp);

  562.         p->addModel(modelChirp);

  563.         p->addModel(modelLFO);

  564.         p->addModel(modelLLFO);

  565.         p->addModel(modelFourFO);

  566.         p->addModel(modelEightFO);

  567.         p->addModel(modelVCF);

  568.         p->addModel(modelLVCF);

  569.         p->addModel(modelFFB);

  570.         p->addModel(modelEQ);

  571.         p->addModel(modelEQS);

  572.         p->addModel(modelLPG);

  573.         p->addModel(modelLLPG);

  574.         p->addModel(modelMegaGate);

  575.         p->addModel(modelPEQ);

  576.         p->addModel(modelPEQ6);

  577.         p->addModel(modelPEQ6XF);

  578.         p->addModel(modelPEQ14);

  579.         p->addModel(modelPEQ14XF);

  580.         p->addModel(modelDADSRH);

  581.         p->addModel(modelDADSRHPlus);

  582.         p->addModel(modelShaper);

  583.         p->addModel(modelShaperPlus);

  584.         p->addModel(modelAD);

  585.         p->addModel(modelASR);

  586.         p->addModel(modelADSR);

  587.         p->addModel(modelVish);

  588.         p->addModel(modelFollow);

  589.         p->addModel(modelDGate);

  590.         p->addModel(modelRGate);

  591.         p->addModel(modelEdge);

  592.         p->addModel(modelNoise);

  593.         p->addModel(modelSampleHold);

  594.         p->addModel(modelWalk2);

  595.         p->addModel(modelWalk);

  596.         p->addModel(modelMix8);

  597.         p->addModel(modelMix8x);

  598.         p->addModel(modelMix4);

  599.         p->addModel(modelMix4x);

  600.         p->addModel(modelMix2);

  601.         p->addModel(modelMix1);

  602.         p->addModel(modelVCM);

  603.         p->addModel(modelMute8);

  604.         p->addModel(modelPan);

  605.         p->addModel(modelXFade);

  606.         p->addModel(modelVCA);

  607.         p->addModel(modelVCAmp);

  608.         p->addModel(modelVelo);

  609.         p->addModel(modelUMix);

  610.         p->addModel(modelMumix);

  611.         p->addModel(modelMatrix81);

  612.         p->addModel(modelMatrix18);

  613.         p->addModel(modelMatrix44);

  614.         p->addModel(modelMatrix44Cvm);

  615.         p->addModel(modelMatrix88);

  616.         p->addModel(modelMatrix88Cv);

  617.         p->addModel(modelMatrix88M);

  618.         p->addModel(modelSwitch81);

  619.         p->addModel(modelSwitch18);

  620.         p->addModel(modelSwitch44);

  621.         p->addModel(modelSwitch88);

  622.         p->addModel(modelSwitch1616);

  623.         p->addModel(modelAMRM);

  624.         p->addModel(modelPressor);

  625.         p->addModel(modelClpr);

  626.         p->addModel(modelLmtr);

  627.         p->addModel(modelNsgt);

  628.         p->addModel(modelCmpDist);

  629.         p->addModel(modelOneEight);

  630.         p->addModel(modelEightOne);

  631.         p->addModel(modelAddrSeq);

  632.         p->addModel(modelAddrSeqX);

  633.         p->addModel(modelPgmr);

  634.         p->addModel(modelPgmrX);

  635.         p->addModel(modelVU);

  636.         p->addModel(modelAnalyzer);

  637.         p->addModel(modelAnalyzerXL);

  638.         p->addModel(modelRanalyzer);

  639.         p->addModel(modelDetune);

  640.         p->addModel(modelStack);

  641.         p->addModel(modelReftone);

  642.         p->addModel(modelMono);

  643.         p->addModel(modelArp);

  644.         p->addModel(modelAssign);

  645.         p->addModel(modelUnison);

  646.         p->addModel(modelPolyCon8);

  647.         p->addModel(modelPolyCon16);

  648.         p->addModel(modelPolyOff8);

  649.         p->addModel(modelPolyOff16);

  650.         p->addModel(modelPolyMult);

  651.         p->addModel(modelBool);

  652.         p->addModel(modelCmp);

  653.         p->addModel(modelCVD);

  654.         p->addModel(modelFlipFlop);

  655.         p->addModel(modelInv);

  656.         p->addModel(modelManual);

  657.         p->addModel(modelFourMan);

  658.         p->addModel(modelMult);

  659.         p->addModel(modelOffset);

  660.         p->addModel(modelSlew);

  661.         p->addModel(modelSums);

  662.         p->addModel(modelSwitch);

  663.         p->addModel(modelLgsw);

  664.         p->addModel(modelBlank3);

  665.         p->addModel(modelBlank6);

  666. #ifdef EXPERIMENTAL

  667.         p->addModel(modelLag);

  668.         p->addModel(modelPEQ14XR);

  669.         p->addModel(modelPEQ14XV);

  670. #endif

  671. #ifdef TEST

  672.         p->addModel(modelTest);

  673.         p->addModel(modelTest2);

  674.         p->addModel(modelTestExpanderBase);

  675.         p->addModel(modelTestExpanderExtension);

  676.         p->addModel(modelTestGl);

  677.         p->addModel(modelTestVCF);

  678. #endif

  679. #undef modelADSR

  680. #undef modelLFO

  681. #undef modelNoise

  682. #undef modelVCA

  683. #undef modelVCF

  684. #undef modelVCO

  685.     }

  686. }

  687. 

  688. static void initStatic__Cardinal()

  689. {

  690.     Plugin* const p = new Plugin;

  691.     pluginInstance__Cardinal = p;

  692. 

  693.     const StaticPluginLoader spl(p, "Cardinal");

  694.     if (spl.ok())

  695.     {

  696.         // TODO implement these

  697.         // p->addModel(modelHostParameters);

  698.         // p->addModel(modelHostTime);

  699.     }

  700. }

  701. 

  702. static void initStatic__ESeries()

  703. {

  704.     Plugin* const p = new Plugin;

  705.     pluginInstance__ESeries = p;

  706. 

  707.     const StaticPluginLoader spl(p, "ESeries");

  708.     if (spl.ok())

  709.     {

  710.         p->addModel(modelE340);

  711.     }

  712. }

  713. 

  714. static void initStatic__Fundamental()

  715. {

  716.     Plugin* const p = new Plugin;

  717.     pluginInstance__Fundamental = p;

  718. 

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

  720.     if (spl.ok())

  721.     {

  722.         p->addModel(modelVCO);

  723.         p->addModel(modelVCO2);

  724.         p->addModel(modelVCF);

  725.         p->addModel(modelVCA_1);

  726.         p->addModel(modelVCA);

  727.         p->addModel(modelLFO);

  728.         p->addModel(modelLFO2);

  729.         p->addModel(modelDelay);

  730.         p->addModel(modelADSR);

  731.         p->addModel(modelVCMixer);

  732.         p->addModel(model_8vert);

  733.         p->addModel(modelUnity);

  734.         p->addModel(modelMutes);

  735.         p->addModel(modelPulses);

  736.         p->addModel(modelScope);

  737.         p->addModel(modelSEQ3);

  738.         p->addModel(modelSequentialSwitch1);

  739.         p->addModel(modelSequentialSwitch2);

  740.         p->addModel(modelOctave);

  741.         p->addModel(modelQuantizer);

  742.         p->addModel(modelSplit);

  743.         p->addModel(modelMerge);

  744.         p->addModel(modelSum);

  745.         p->addModel(modelViz);

  746.         p->addModel(modelMidSide);

  747.         p->addModel(modelNoise);

  748.         p->addModel(modelRandom);

  749.     }

  750. }

  751. 

  752. static void initStatic__GrandeModular()

  753. {

  754.     Plugin* const p = new Plugin;

  755.     pluginInstance__GrandeModular = p;

  756. 

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

  758.     if (spl.ok())

  759.     {

  760.         p->addModel(modelClip);

  761.         p->addModel(modelMergeSplit4);

  762.         p->addModel(modelMicrotonalChords);

  763.         p->addModel(modelMicrotonalNotes);

  764.         p->addModel(modelNoteMT);

  765.         p->addModel(modelPolyMergeResplit);

  766.         p->addModel(modelQuant);

  767.         p->addModel(modelQuantIntervals);

  768.         p->addModel(modelQuantMT);

  769.         p->addModel(modelSampleDelays);

  770.         p->addModel(modelScale);

  771.         p->addModel(modelTails);

  772.         p->addModel(modelVarSampleDelays);

  773.     }

  774. }

  775. 

  776. static void initStatic__JW()

  777. {

  778.     Plugin* const p = new Plugin;

  779.     pluginInstance__JW = p;

  780. 

  781.     const StaticPluginLoader spl(p, "JW-Modules");

  782.     if (spl.ok())

  783.     {

  784.         p->addModel(modelAdd5);

  785.         p->addModel(modelBouncyBalls);

  786.         p->addModel(modelCat);

  787.         p->addModel(modelTree);

  788.         p->addModel(modelFullScope);

  789.         p->addModel(modelGridSeq);

  790.         p->addModel(modelEightSeq);

  791.         p->addModel(modelDivSeq);

  792.         p->addModel(modelMinMax);

  793.         p->addModel(modelNoteSeq);

  794.         p->addModel(modelNoteSeqFu);

  795.         p->addModel(modelNoteSeq16);

  796.         p->addModel(modelTrigs);

  797.         p->addModel(modelOnePattern);

  798.         p->addModel(modelPatterns);

  799.         p->addModel(modelQuantizer);

  800.         p->addModel(modelSimpleClock);

  801.         p->addModel(modelStr1ker);

  802.         p->addModel(modelD1v1de);

  803.         p->addModel(modelPres1t);

  804.         p->addModel(modelThingThing);

  805.         p->addModel(modelWavHead);

  806.         p->addModel(modelXYPad);

  807.         p->addModel(modelBlankPanel1hp);

  808.         p->addModel(modelBlankPanelSmall);

  809.         p->addModel(modelBlankPanelMedium);

  810.         p->addModel(modelBlankPanelLarge);

  811.         p->addModel(modelCoolBreeze);

  812.         p->addModel(modelPete);

  813.     }

  814. }

  815. 

  816. static void initStatic__rackwindows()

  817. {

  818.     Plugin* const p = new Plugin;

  819.     pluginInstance__rackwindows = p;

  820. 

  821.     const StaticPluginLoader spl(p, "rackwindows");

  822.     if (spl.ok())

  823.     {

  824.         // p->addModel(modelAcceleration);

  825.         p->addModel(modelBitshiftgain);

  826.         p->addModel(modelCapacitor);

  827.         p->addModel(modelCapacitor_stereo);

  828.         p->addModel(modelChorus);

  829.         p->addModel(modelConsole);

  830.         p->addModel(modelConsole_mm);

  831.         p->addModel(modelDistance);

  832.         p->addModel(modelGolem);

  833.         p->addModel(modelHolt);

  834.         p->addModel(modelHombre);

  835.         p->addModel(modelInterstage);

  836.         p->addModel(modelMonitoring);

  837.         p->addModel(modelMv);

  838.         p->addModel(modelRasp);

  839.         p->addModel(modelReseq);

  840.         p->addModel(modelTape);

  841.         p->addModel(modelTremolo);

  842.         p->addModel(modelVibrato);

  843.     }

  844. }

  845. 

  846. /* does not build against v2

  847. static void initStatic__ValleyAudio()

  848. {

  849.     Plugin* const p = new Plugin;

  850.     pluginInstance__ValleyAudio = p;

  851. 

  852.     const StaticPluginLoader spl(p, "ValleyAudio");

  853.     if (spl.ok())

  854.     {

  855.         p->addModel(modelTopograph);

  856.         p->addModel(modelUGraph);

  857.         p->addModel(modelDexter);

  858.         p->addModel(modelPlateau);

  859.         p->addModel(modelInterzone);

  860.         p->addModel(modelAmalgam);

  861.         p->addModel(modelFeline);

  862.         p->addModel(modelTerrorform);

  863.     }

  864. }

  865. */

  866. 

  867. static void initStatic__ZetaCarinaeModules()

  868. {

  869.     Plugin* p = new Plugin;

  870.     pluginInstance__ZetaCarinaeModules = p;

  871. 

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

  873.     if (spl.ok())

  874.     {

  875.         p->addModel(modelBrownianBridge);

  876.         p->addModel(modelOrnsteinUhlenbeck);

  877.         p->addModel(modelIOU);

  878.         p->addModel(modelWarbler);

  879.         p->addModel(modelRosenchance);

  880.         p->addModel(modelGuildensTurn);

  881.         p->addModel(modelRosslerRustler);

  882.         p->addModel(modelFirefly);

  883.     }

  884. }

  885. 

  886. void initStaticPlugins()

  887. {

  888.     initStatic__Core();

  889.     initStatic__AnimatedCircuits();

  890.     initStatic__AS();

  891.     initStatic__AudibleInstruments();

  892.     initStatic__Befaco();

  893.     initStatic__Bidoo();

  894.     initStatic__BogaudioModules();

  895.     initStatic__Cardinal();

  896.     initStatic__ESeries();

  897.     initStatic__Fundamental();

  898.     initStatic__GrandeModular();

  899.     initStatic__JW();

  900.     initStatic__rackwindows();

  901.     /* does not build against v2

  902.     initStatic__ValleyAudio();

  903.     */

  904.     initStatic__ZetaCarinaeModules();

  905. }

  906. 

  907. void destroyStaticPlugins()

  908. {

  909.     for (Plugin* p : plugins)

  910.         delete p;

  911.     plugins.clear();

  912. }

  913. 

  914. }

  915. }