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.
210 Commits
7 Branches
40MB
Tree: d1916efe99
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd1916efe99'
${ noResults }
Cardinal/plugins/plugins.cpp

1153 lines
33KB
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. // Cardinal (built-in)

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

  24. 

  25. #ifndef NOPLUGINS

  26. // AmalgamatedHarmonics

  27. #include "AmalgamatedHarmonics/src/AH.hpp"

  28. 

  29. // AnimatedCircuits

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

  31. 

  32. // AS

  33. #define modelADSR modelASADSR

  34. #define modelVCA modelASVCA

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

  36. #undef modelADSR

  37. #undef modelVCA

  38. 

  39. // AudibleInstruments

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

  41. 

  42. // Befaco

  43. #define modelADSR modelBefacoADSR

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

  45. #undef modelADSR

  46. 

  47. // Bidoo

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

  49. 

  50. // BogaudioModules - force dark skin as default

  51. #include <mutex>

  52. #include <string>

  53. #include <unordered_map>

  54. #include <unordered_set>

  55. #include <vector>

  56. #define private public

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

  58. #undef private

  59. 

  60. // BogaudioModules

  61. #define modelADSR modelBogaudioADSR

  62. #define modelLFO modelBogaudioLFO

  63. #define modelNoise modelBogaudioNoise

  64. #define modelVCA modelBogaudioVCA

  65. #define modelVCF modelBogaudioVCF

  66. #define modelVCO modelBogaudioVCO

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  175. #undef modelADSR

  176. #undef modelLFO

  177. #undef modelNoise

  178. #undef modelVCA

  179. #undef modelVCF

  180. #undef modelVCO

  181. 

  182. // cf

  183. #include "cf/src/plugin.hpp"

  184. 

  185. // DrumKit

  186. #include "DrumKit/src/DrumKit.hpp"

  187. void setupSamples();

  188. 

  189. // ESeries

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

  191. 

  192. // Fundamental

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

  194. 

  195. // GrandeModular

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

  197. 

  198. // ImpromptuModular

  199. /* NOTE too much noise in original include, do this a different way

  200. // #include "ImpromptuModular/src/ImpromptuModular.hpp"

  201. */

  202. extern Model *modelBigButtonSeq;

  203. extern Model *modelBigButtonSeq2;

  204. extern Model *modelChordKey;

  205. extern Model *modelChordKeyExpander;

  206. extern Model *modelClocked;

  207. extern Model *modelClockedExpander;

  208. extern Model *modelClkd;

  209. extern Model *modelCvPad;

  210. extern Model *modelFoundry;

  211. extern Model *modelFoundryExpander;

  212. extern Model *modelFourView;

  213. extern Model *modelGateSeq64;

  214. extern Model *modelGateSeq64Expander;

  215. extern Model *modelHotkey;

  216. extern Model *modelPart;

  217. extern Model *modelPhraseSeq16;

  218. extern Model *modelPhraseSeq32;

  219. extern Model *modelPhraseSeqExpander;

  220. extern Model *modelProbKey;

  221. // extern Model *modelProbKeyExpander;

  222. extern Model *modelSemiModularSynth;

  223. extern Model *modelTact;

  224. extern Model *modelTact1;

  225. extern Model *modelTactG;

  226. extern Model *modelTwelveKey;

  227. extern Model *modelWriteSeq32;

  228. extern Model *modelWriteSeq64;

  229. extern Model *modelBlankPanel;

  230. 

  231. // JW-Modules

  232. #define modelQuantizer modelJWQuantizer

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

  234. #undef modelQuantizer

  235. 

  236. // MindMeldModular

  237. /* NOTE too much noise in original include, do this a different way

  238. // #include "MindMeldModular/src/MindMeldModular.hpp"

  239. */

  240. extern Model *modelMixMasterJr;

  241. extern Model *modelAuxExpanderJr;

  242. extern Model *modelMixMaster;

  243. extern Model *modelAuxExpander;

  244. extern Model *modelMeld;

  245. extern Model *modelUnmeld;

  246. extern Model *modelEqMaster;

  247. extern Model *modelEqExpander;

  248. extern Model *modelBassMaster;

  249. extern Model *modelBassMasterJr;

  250. extern Model *modelShapeMaster;

  251. 

  252. // rackwindows

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

  254. 

  255. // ValleyAudio

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

  257. 

  258. // ZetaCarinaeModules

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

  260. 

  261. #endif // NOPLUGINS

  262. 

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

  264. int loadConsoleType() { return 0; }

  265. int loadDirectOutMode() { return 0; }

  266. bool loadDarkAsDefault() { return true; }

  267. bool loadQuality() { return false; }

  268. void saveConsoleType(int) {}

  269. void saveDarkAsDefault(bool) {}

  270. void saveDirectOutMode(bool) {}

  271. void saveHighQualityAsDefault(bool) {}

  272. 

  273. // plugin instances

  274. Plugin* pluginInstance__Cardinal;

  275. #ifndef NOPLUGINS

  276. Plugin* pluginInstance__AmalgamatedHarmonics;

  277. Plugin* pluginInstance__AnimatedCircuits;

  278. Plugin* pluginInstance__AS;

  279. Plugin* pluginInstance__AudibleInstruments;

  280. Plugin* pluginInstance__Befaco;

  281. Plugin* pluginInstance__Bidoo;

  282. Plugin* pluginInstance__BogaudioModules;

  283. Plugin* pluginInstance__cf;

  284. extern Plugin* pluginInstance__DrumKit;

  285. Plugin* pluginInstance__ESeries;

  286. Plugin* pluginInstance__Fundamental;

  287. Plugin* pluginInstance__GrandeModular;

  288. extern Plugin* pluginInstance__ImpromptuModular;

  289. Plugin* pluginInstance__JW;

  290. extern Plugin* pluginInstance__MindMeld;

  291. Plugin* pluginInstance__rackwindows;

  292. Plugin* pluginInstance__ValleyAudio;

  293. Plugin* pluginInstance__ZetaCarinaeModules;

  294. #endif // NOPLUGINS

  295. 

  296. namespace rack {

  297. 

  298. namespace asset {

  299. std::string pluginManifest(const std::string& dirname);

  300. std::string pluginPath(const std::string& dirname);

  301. }

  302. 

  303. // core plugins

  304. namespace core {

  305. extern Model* modelAudioInterface;

  306. extern Model* modelAudioInterface2;

  307. extern Model* modelAudioInterface16;

  308. extern Model* modelMIDI_CV;

  309. extern Model* modelMIDI_CC;

  310. extern Model* modelMIDI_Gate;

  311. extern Model* modelMIDI_Map;

  312. extern Model* modelCV_MIDI;

  313. extern Model* modelCV_CC;

  314. extern Model* modelCV_Gate;

  315. extern Model* modelBlank;

  316. extern Model* modelNotes;

  317. }

  318. 

  319. // regular plugins

  320. namespace plugin {

  321. 

  322. struct StaticPluginLoader {

  323.     Plugin* const plugin;

  324.     FILE* file;

  325.     json_t* rootJ;

  326. 

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

  328.         : plugin(p),

  329.           file(nullptr),

  330.           rootJ(nullptr)

  331.     {

  332. #ifdef DEBUG

  333.         DEBUG("Loading plugin module %s", name);

  334. #endif

  335. 

  336.         p->path = asset::pluginPath(name);

  337. 

  338.         const std::string manifestFilename = asset::pluginManifest(name);

  339. 

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

  341.         {

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

  343.             return;

  344.         }

  345. 

  346.         json_error_t error;

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

  348.         {

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

  350.             return;

  351.         }

  352. 

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

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

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

  356.         json_decref(version);

  357.     }

  358. 

  359.     ~StaticPluginLoader()

  360.     {

  361.         if (rootJ != nullptr)

  362.         {

  363.             plugin->fromJson(rootJ);

  364.             json_decref(rootJ);

  365.             plugins.push_back(plugin);

  366.         }

  367. 

  368.         if (file != nullptr)

  369.             std::fclose(file);

  370.     }

  371. 

  372.     bool ok() const noexcept

  373.     {

  374.         return rootJ != nullptr;

  375.     }

  376. };

  377. 

  378. static void initStatic__Core()

  379. {

  380.     Plugin* const p = new Plugin;

  381. 

  382.     const StaticPluginLoader spl(p, "Core");

  383.     if (spl.ok())

  384.     {

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

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

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

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

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

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

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

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

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

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

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

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

  397.     }

  398. }

  399. 

  400. static void initStatic__Cardinal()

  401. {

  402.     Plugin* const p = new Plugin;

  403.     pluginInstance__Cardinal = p;

  404. 

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

  406.     if (spl.ok())

  407.     {

  408.         p->addModel(modelGlBars);

  409.         p->addModel(modelIldaeil);

  410.         p->addModel(modelHostParameters);

  411.         p->addModel(modelHostTime);

  412.     }

  413. }

  414. 

  415. #ifndef NOPLUGINS

  416. static void initStatic__AmalgamatedHarmonics()

  417. {

  418.     Plugin* const p = new Plugin;

  419.     pluginInstance__AmalgamatedHarmonics = p;

  420. 

  421.     const StaticPluginLoader spl(p, "AmalgamatedHarmonics");

  422.     if (spl.ok())

  423.     {

  424.         p->addModel(modelArp31);

  425.         p->addModel(modelArp32);

  426.         p->addModel(modelBombe);

  427.         p->addModel(modelChord);

  428.         p->addModel(modelCircle);

  429.         p->addModel(modelGalaxy);

  430.         p->addModel(modelGenerative);

  431.         p->addModel(modelImp);

  432.         p->addModel(modelImperfect2);

  433.         p->addModel(modelProgress2);

  434.         p->addModel(modelRuckus);

  435.         p->addModel(modelScaleQuantizer2);

  436.         p->addModel(modelSLN);

  437.         p->addModel(modelMuxDeMux);

  438.         p->addModel(modelPolyProbe);

  439.         p->addModel(modelPolyScope);

  440.         p->addModel(modelPolyUtils);

  441.         p->addModel(modelPolyVolt);

  442.         p->addModel(modelScaleQuantizer);

  443.         p->addModel(modelArpeggiator2);

  444.         p->addModel(modelProgress);

  445.     }

  446. }

  447. 

  448. static void initStatic__AnimatedCircuits()

  449. {

  450.     Plugin* const p = new Plugin;

  451.     pluginInstance__AnimatedCircuits = p;

  452. 

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

  454.     if (spl.ok())

  455.     {

  456.         p->addModel(model_AC_Folding);

  457.     }

  458. }

  459. 

  460. static void initStatic__AS()

  461. {

  462.     Plugin* const p = new Plugin;

  463.     pluginInstance__AS = p;

  464. 

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

  466.     if (spl.ok())

  467.     {

  468. #define modelADSR modelASADSR

  469. #define modelVCA modelASVCA

  470.         //OSCILLATORS

  471.         p->addModel(modelSineOsc);

  472.         p->addModel(modelSawOsc);

  473. 

  474.         //TOOLS

  475.         p->addModel(modelADSR);

  476.         p->addModel(modelVCA);

  477.         p->addModel(modelQuadVCA);

  478.         p->addModel(modelTriLFO);

  479.         p->addModel(modelAtNuVrTr);

  480.         p->addModel(modelBPMClock);

  481.         p->addModel(modelSEQ16);

  482.         p->addModel(modelMixer2ch);

  483.         p->addModel(modelMixer4ch);

  484.         p->addModel(modelMixer8ch);

  485.         p->addModel(modelMonoVUmeter);

  486.         p->addModel(modelStereoVUmeter);

  487.         p->addModel(modelMultiple2_5);

  488.         p->addModel(modelMerge2_5);

  489.         p->addModel(modelSteps);

  490.         p->addModel(modelLaunchGate);

  491.         p->addModel(modelKillGate);

  492.         p->addModel(modelFlow);

  493.         p->addModel(modelSignalDelay);

  494.         p->addModel(modelTriggersMKI);

  495.         p->addModel(modelTriggersMKII);

  496.         p->addModel(modelTriggersMKIII);

  497.         p->addModel(modelBPMCalc);

  498.         p->addModel(modelBPMCalc2);

  499.         p->addModel(modelCv2T);

  500.         p->addModel(modelZeroCV2T);

  501.         p->addModel(modelReScale);

  502. 

  503.         //EFFECTS

  504.         p->addModel(modelDelayPlusFx);

  505.         p->addModel(modelDelayPlusStereoFx);

  506.         p->addModel(modelPhaserFx);

  507.         p->addModel(modelReverbFx);

  508.         p->addModel(modelReverbStereoFx);

  509.         p->addModel(modelSuperDriveFx);

  510.         p->addModel(modelSuperDriveStereoFx);

  511.         p->addModel(modelTremoloFx);

  512.         p->addModel(modelTremoloStereoFx);

  513.         p->addModel(modelWaveShaper);

  514.         p->addModel(modelWaveShaperStereo);

  515. 

  516.         //BLANK PANELS

  517.         p->addModel(modelBlankPanel4);

  518.         p->addModel(modelBlankPanel6);

  519.         p->addModel(modelBlankPanel8);

  520.         p->addModel(modelBlankPanelSpecial);

  521. #undef modelADSR

  522. #undef modelVCA

  523.     }

  524. }

  525. 

  526. static void initStatic__AudibleInstruments()

  527. {

  528.     Plugin* const p = new Plugin;

  529.     pluginInstance__AudibleInstruments = p;

  530. 

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

  532.     if (spl.ok())

  533.     {

  534.         p->addModel(modelBraids);

  535.         p->addModel(modelPlaits);

  536.         p->addModel(modelElements);

  537.         p->addModel(modelTides);

  538.         p->addModel(modelTides2);

  539.         p->addModel(modelClouds);

  540.         p->addModel(modelWarps);

  541.         p->addModel(modelRings);

  542.         p->addModel(modelLinks);

  543.         p->addModel(modelKinks);

  544.         p->addModel(modelShades);

  545.         p->addModel(modelBranches);

  546.         p->addModel(modelBlinds);

  547.         p->addModel(modelVeils);

  548.         p->addModel(modelFrames);

  549.         p->addModel(modelMarbles);

  550.         p->addModel(modelStages);

  551.         p->addModel(modelRipples);

  552.         p->addModel(modelShelves);

  553.         p->addModel(modelStreams);

  554.     }

  555. }

  556. 

  557. static void initStatic__Befaco()

  558. {

  559.     Plugin* const p = new Plugin;

  560.     pluginInstance__Befaco = p;

  561. 

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

  563.     if (spl.ok())

  564.     {

  565. #define modelADSR modelBefacoADSR

  566.         p->addModel(modelEvenVCO);

  567.         p->addModel(modelRampage);

  568.         p->addModel(modelABC);

  569.         p->addModel(modelSpringReverb);

  570.         p->addModel(modelMixer);

  571.         p->addModel(modelSlewLimiter);

  572.         p->addModel(modelDualAtenuverter);

  573.         p->addModel(modelPercall);

  574.         p->addModel(modelHexmixVCA);

  575.         p->addModel(modelChoppingKinky);

  576.         p->addModel(modelKickall);

  577.         p->addModel(modelSamplingModulator);

  578.         p->addModel(modelMorphader);

  579.         p->addModel(modelADSR);

  580.         p->addModel(modelSTMix);

  581.         p->addModel(modelMuxlicer);

  582.         p->addModel(modelMex);

  583. #undef modelADSR

  584.     }

  585. }

  586. 

  587. static void initStatic__Bidoo()

  588. {

  589.     Plugin* const p = new Plugin;

  590.     pluginInstance__Bidoo = p;

  591. 

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

  593.     if (spl.ok())

  594.     {

  595.         p->addModel(modelTOCANTE);

  596.         p->addModel(modelLATE);

  597.         p->addModel(modelDIKTAT);

  598.         p->addModel(modelDTROY);

  599.         p->addModel(modelBORDL);

  600.         p->addModel(modelZOUMAI);

  601.         p->addModel(modelMU);

  602.         p->addModel(modelCHUTE);

  603.         p->addModel(modelLOURDE);

  604.         p->addModel(modelACNE);

  605.         p->addModel(modelMS);

  606.         p->addModel(modelDUKE);

  607.         p->addModel(modelMOIRE);

  608.         p->addModel(modelPILOT);

  609.         p->addModel(modelHUITRE);

  610.         p->addModel(modelOUAIVE);

  611.         p->addModel(modelPOUPRE);

  612.         p->addModel(modelMAGMA);

  613.         p->addModel(modelOAI);

  614.         p->addModel(modelCANARD);

  615.         p->addModel(modelEMILE);

  616.         p->addModel(modelFORK);

  617.         p->addModel(modelTIARE);

  618.         p->addModel(modelLIMONADE);

  619.         p->addModel(modelLIMBO);

  620.         p->addModel(modelPERCO);

  621.         p->addModel(modelBAFIS);

  622.         p->addModel(modelBAR);

  623.         p->addModel(modelMINIBAR);

  624.         p->addModel(modelZINC);

  625.         p->addModel(modelFREIN);

  626.         p->addModel(modelHCTIP);

  627.         p->addModel(modelDFUZE);

  628.         p->addModel(modelREI);

  629.         p->addModel(modelRABBIT);

  630.         p->addModel(modelBISTROT);

  631.         p->addModel(modelSIGMA);

  632.         p->addModel(modelFLAME);

  633.         p->addModel(modelVOID);

  634. 

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

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

  637. 

  638.         // intentionally remove known bad plugin

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

  640.         {

  641.             size_t i;

  642.             json_t* v;

  643.             json_array_foreach(modules, i, v)

  644.             {

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

  646.                 {

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

  648.                     {

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

  650.                         {

  651.                             json_array_remove(modules, i);

  652.                             break;

  653.                         }

  654.                     }

  655.                 }

  656.             }

  657.         }

  658.     }

  659. }

  660. 

  661. static void initStatic__BogaudioModules()

  662. {

  663.     Plugin* const p = new Plugin;

  664.     pluginInstance__BogaudioModules = p;

  665. 

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

  667.     if (spl.ok())

  668.     {

  669.         // Make sure to use dark theme as default

  670.         Skins& skins(Skins::skins());

  671.         skins._default = "dark";

  672. #define modelADSR modelBogaudioADSR

  673. #define modelLFO modelBogaudioLFO

  674. #define modelNoise modelBogaudioNoise

  675. #define modelVCA modelBogaudioVCA

  676. #define modelVCF modelBogaudioVCF

  677. #define modelVCO modelBogaudioVCO

  678.         p->addModel(modelVCO);

  679.         p->addModel(modelLVCO);

  680.         p->addModel(modelSine);

  681.         p->addModel(modelPulse);

  682.         p->addModel(modelXCO);

  683.         p->addModel(modelAdditator);

  684.         p->addModel(modelFMOp);

  685.         p->addModel(modelChirp);

  686.         p->addModel(modelLFO);

  687.         p->addModel(modelLLFO);

  688.         p->addModel(modelFourFO);

  689.         p->addModel(modelEightFO);

  690.         p->addModel(modelVCF);

  691.         p->addModel(modelLVCF);

  692.         p->addModel(modelFFB);

  693.         p->addModel(modelEQ);

  694.         p->addModel(modelEQS);

  695.         p->addModel(modelLPG);

  696.         p->addModel(modelLLPG);

  697.         p->addModel(modelMegaGate);

  698.         p->addModel(modelPEQ);

  699.         p->addModel(modelPEQ6);

  700.         p->addModel(modelPEQ6XF);

  701.         p->addModel(modelPEQ14);

  702.         p->addModel(modelPEQ14XF);

  703.         p->addModel(modelDADSRH);

  704.         p->addModel(modelDADSRHPlus);

  705.         p->addModel(modelShaper);

  706.         p->addModel(modelShaperPlus);

  707.         p->addModel(modelAD);

  708.         p->addModel(modelASR);

  709.         p->addModel(modelADSR);

  710.         p->addModel(modelVish);

  711.         p->addModel(modelFollow);

  712.         p->addModel(modelDGate);

  713.         p->addModel(modelRGate);

  714.         p->addModel(modelEdge);

  715.         p->addModel(modelNoise);

  716.         p->addModel(modelSampleHold);

  717.         p->addModel(modelWalk2);

  718.         p->addModel(modelWalk);

  719.         p->addModel(modelMix8);

  720.         p->addModel(modelMix8x);

  721.         p->addModel(modelMix4);

  722.         p->addModel(modelMix4x);

  723.         p->addModel(modelMix2);

  724.         p->addModel(modelMix1);

  725.         p->addModel(modelVCM);

  726.         p->addModel(modelMute8);

  727.         p->addModel(modelPan);

  728.         p->addModel(modelXFade);

  729.         p->addModel(modelVCA);

  730.         p->addModel(modelVCAmp);

  731.         p->addModel(modelVelo);

  732.         p->addModel(modelUMix);

  733.         p->addModel(modelMumix);

  734.         p->addModel(modelMatrix81);

  735.         p->addModel(modelMatrix18);

  736.         p->addModel(modelMatrix44);

  737.         p->addModel(modelMatrix44Cvm);

  738.         p->addModel(modelMatrix88);

  739.         p->addModel(modelMatrix88Cv);

  740.         p->addModel(modelMatrix88M);

  741.         p->addModel(modelSwitch81);

  742.         p->addModel(modelSwitch18);

  743.         p->addModel(modelSwitch44);

  744.         p->addModel(modelSwitch88);

  745.         p->addModel(modelSwitch1616);

  746.         p->addModel(modelAMRM);

  747.         p->addModel(modelPressor);

  748.         p->addModel(modelClpr);

  749.         p->addModel(modelLmtr);

  750.         p->addModel(modelNsgt);

  751.         p->addModel(modelCmpDist);

  752.         p->addModel(modelOneEight);

  753.         p->addModel(modelEightOne);

  754.         p->addModel(modelAddrSeq);

  755.         p->addModel(modelAddrSeqX);

  756.         p->addModel(modelPgmr);

  757.         p->addModel(modelPgmrX);

  758.         p->addModel(modelVU);

  759.         p->addModel(modelAnalyzer);

  760.         p->addModel(modelAnalyzerXL);

  761.         p->addModel(modelRanalyzer);

  762.         p->addModel(modelDetune);

  763.         p->addModel(modelStack);

  764.         p->addModel(modelReftone);

  765.         p->addModel(modelMono);

  766.         p->addModel(modelArp);

  767.         p->addModel(modelAssign);

  768.         p->addModel(modelUnison);

  769.         p->addModel(modelPolyCon8);

  770.         p->addModel(modelPolyCon16);

  771.         p->addModel(modelPolyOff8);

  772.         p->addModel(modelPolyOff16);

  773.         p->addModel(modelPolyMult);

  774.         p->addModel(modelBool);

  775.         p->addModel(modelCmp);

  776.         p->addModel(modelCVD);

  777.         p->addModel(modelFlipFlop);

  778.         p->addModel(modelInv);

  779.         p->addModel(modelManual);

  780.         p->addModel(modelFourMan);

  781.         p->addModel(modelMult);

  782.         p->addModel(modelOffset);

  783.         p->addModel(modelSlew);

  784.         p->addModel(modelSums);

  785.         p->addModel(modelSwitch);

  786.         p->addModel(modelLgsw);

  787.         p->addModel(modelBlank3);

  788.         p->addModel(modelBlank6);

  789. #ifdef EXPERIMENTAL

  790.         p->addModel(modelLag);

  791.         p->addModel(modelPEQ14XR);

  792.         p->addModel(modelPEQ14XV);

  793. #endif

  794. #ifdef TEST

  795.         p->addModel(modelTest);

  796.         p->addModel(modelTest2);

  797.         p->addModel(modelTestExpanderBase);

  798.         p->addModel(modelTestExpanderExtension);

  799.         p->addModel(modelTestGl);

  800.         p->addModel(modelTestVCF);

  801. #endif

  802. #undef modelADSR

  803. #undef modelLFO

  804. #undef modelNoise

  805. #undef modelVCA

  806. #undef modelVCF

  807. #undef modelVCO

  808.     }

  809. }

  810. 

  811. static void initStatic__cf()

  812. {

  813.     Plugin* const p = new Plugin;

  814.     pluginInstance__cf = p;

  815. 

  816.     const StaticPluginLoader spl(p, "cf");

  817.     if (spl.ok())

  818.     {

  819.         p->addModel(modelMETRO);

  820.         p->addModel(modelEACH);

  821.         p->addModel(modeltrSEQ);

  822.         p->addModel(modelLEDSEQ);

  823.         p->addModel(modelL3DS3Q);

  824.         p->addModel(modelSLIDERSEQ);

  825.         p->addModel(modelPLAYER);

  826.         p->addModel(modelPLAY);

  827.         p->addModel(modelMONO);

  828.         p->addModel(modelSTEREO);

  829.         p->addModel(modelSUB);

  830.         p->addModel(modelMASTER);

  831.         p->addModel(modelVARIABLE);

  832.         p->addModel(modelALGEBRA);

  833.         p->addModel(modelFUNKTION);

  834.         p->addModel(modelCHOKE);

  835.         p->addModel(modelFOUR);

  836.         p->addModel(modelSTEPS);

  837.         p->addModel(modelPEAK);

  838.         p->addModel(modelCUTS);

  839.         p->addModel(modelBUFFER);

  840.         p->addModel(modelDISTO);

  841.         p->addModel(modelCUBE);

  842.         p->addModel(modelPATCH);

  843.         p->addModel(modelLABEL);

  844.         p->addModel(modelDAVE);

  845.     }

  846. }

  847. 

  848. static void initStatic__DrumKit()

  849. {

  850.     Plugin* const p = new Plugin;

  851.     pluginInstance__DrumKit = p;

  852. 

  853.     const StaticPluginLoader spl(p, "DrumKit");

  854.     if (spl.ok())

  855.     {

  856.         setupSamples();

  857.         p->addModel(modelBD9);

  858.         p->addModel(modelSnare);

  859.         p->addModel(modelClosedHH);

  860.         p->addModel(modelOpenHH);

  861.         p->addModel(modelDMX);

  862.         p->addModel(modelCR78);

  863.         p->addModel(modelSBD);

  864.         p->addModel(modelGnome);

  865.         p->addModel(modelSequencer);

  866.         p->addModel(modelTomi);

  867.         p->addModel(modelBaronial);

  868.         p->addModel(modelMarionette);

  869.     }

  870. }

  871. 

  872. static void initStatic__ESeries()

  873. {

  874.     Plugin* const p = new Plugin;

  875.     pluginInstance__ESeries = p;

  876. 

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

  878.     if (spl.ok())

  879.     {

  880.         p->addModel(modelE340);

  881.     }

  882. }

  883. 

  884. static void initStatic__Fundamental()

  885. {

  886.     Plugin* const p = new Plugin;

  887.     pluginInstance__Fundamental = p;

  888. 

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

  890.     if (spl.ok())

  891.     {

  892.         p->addModel(modelVCO);

  893.         p->addModel(modelVCO2);

  894.         p->addModel(modelVCF);

  895.         p->addModel(modelVCA_1);

  896.         p->addModel(modelVCA);

  897.         p->addModel(modelLFO);

  898.         p->addModel(modelLFO2);

  899.         p->addModel(modelDelay);

  900.         p->addModel(modelADSR);

  901.         p->addModel(modelVCMixer);

  902.         p->addModel(model_8vert);

  903.         p->addModel(modelUnity);

  904.         p->addModel(modelMutes);

  905.         p->addModel(modelPulses);

  906.         p->addModel(modelScope);

  907.         p->addModel(modelSEQ3);

  908.         p->addModel(modelSequentialSwitch1);

  909.         p->addModel(modelSequentialSwitch2);

  910.         p->addModel(modelOctave);

  911.         p->addModel(modelQuantizer);

  912.         p->addModel(modelSplit);

  913.         p->addModel(modelMerge);

  914.         p->addModel(modelSum);

  915.         p->addModel(modelViz);

  916.         p->addModel(modelMidSide);

  917.         p->addModel(modelNoise);

  918.         p->addModel(modelRandom);

  919.     }

  920. }

  921. 

  922. static void initStatic__GrandeModular()

  923. {

  924.     Plugin* const p = new Plugin;

  925.     pluginInstance__GrandeModular = p;

  926. 

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

  928.     if (spl.ok())

  929.     {

  930.         p->addModel(modelClip);

  931.         p->addModel(modelMergeSplit4);

  932.         p->addModel(modelMicrotonalChords);

  933.         p->addModel(modelMicrotonalNotes);

  934.         p->addModel(modelNoteMT);

  935.         p->addModel(modelPolyMergeResplit);

  936.         p->addModel(modelQuant);

  937.         p->addModel(modelQuantIntervals);

  938.         p->addModel(modelQuantMT);

  939.         p->addModel(modelSampleDelays);

  940.         p->addModel(modelScale);

  941.         p->addModel(modelTails);

  942.         p->addModel(modelVarSampleDelays);

  943.     }

  944. }

  945. 

  946. static void initStatic__ImpromptuModular()

  947. {

  948.     Plugin* const p = new Plugin;

  949.     pluginInstance__ImpromptuModular = p;

  950. 

  951.     const StaticPluginLoader spl(p, "ImpromptuModular");

  952.     if (spl.ok())

  953.     {

  954.         p->addModel(modelBigButtonSeq);

  955.         p->addModel(modelBigButtonSeq2);

  956.         p->addModel(modelChordKey);

  957.         p->addModel(modelChordKeyExpander);

  958.         p->addModel(modelClocked);

  959.         p->addModel(modelClockedExpander);

  960.         p->addModel(modelClkd);

  961.         p->addModel(modelCvPad);

  962.         p->addModel(modelFoundry);

  963.         p->addModel(modelFoundryExpander);

  964.         p->addModel(modelFourView);

  965.         p->addModel(modelGateSeq64);

  966.         p->addModel(modelGateSeq64Expander);

  967.         p->addModel(modelHotkey);

  968.         p->addModel(modelPart);

  969.         p->addModel(modelPhraseSeq16);

  970.         p->addModel(modelPhraseSeq32);

  971.         p->addModel(modelPhraseSeqExpander);

  972.         p->addModel(modelProbKey);

  973.         // p->addModel(modelProbKeyExpander);

  974.         p->addModel(modelSemiModularSynth);

  975.         p->addModel(modelTact);

  976.         p->addModel(modelTact1);

  977.         p->addModel(modelTactG);

  978.         p->addModel(modelTwelveKey);

  979.         p->addModel(modelWriteSeq32);

  980.         p->addModel(modelWriteSeq64);

  981.         p->addModel(modelBlankPanel);

  982.     }

  983. }

  984. 

  985. static void initStatic__JW()

  986. {

  987.     Plugin* const p = new Plugin;

  988.     pluginInstance__JW = p;

  989. 

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

  991.     if (spl.ok())

  992.     {

  993. #define modelQuantizer modelJWQuantizer

  994.         p->addModel(modelAdd5);

  995.         p->addModel(modelBouncyBalls);

  996.         p->addModel(modelCat);

  997.         p->addModel(modelTree);

  998.         p->addModel(modelFullScope);

  999.         p->addModel(modelGridSeq);

  1000.         p->addModel(modelEightSeq);

  1001.         p->addModel(modelDivSeq);

  1002.         p->addModel(modelMinMax);

  1003.         p->addModel(modelNoteSeq);

  1004.         p->addModel(modelNoteSeqFu);

  1005.         p->addModel(modelNoteSeq16);

  1006.         p->addModel(modelTrigs);

  1007.         p->addModel(modelOnePattern);

  1008.         p->addModel(modelPatterns);

  1009.         p->addModel(modelQuantizer);

  1010.         p->addModel(modelSimpleClock);

  1011.         p->addModel(modelStr1ker);

  1012.         p->addModel(modelD1v1de);

  1013.         p->addModel(modelPres1t);

  1014.         p->addModel(modelThingThing);

  1015.         p->addModel(modelWavHead);

  1016.         p->addModel(modelXYPad);

  1017.         p->addModel(modelBlankPanel1hp);

  1018.         p->addModel(modelBlankPanelSmall);

  1019.         p->addModel(modelBlankPanelMedium);

  1020.         p->addModel(modelBlankPanelLarge);

  1021.         p->addModel(modelCoolBreeze);

  1022.         p->addModel(modelPete);

  1023. #undef modelQuantizer

  1024.     }

  1025. }

  1026. 

  1027. static void initStatic__MindMeld()

  1028. {

  1029.     Plugin* const p = new Plugin;

  1030.     pluginInstance__MindMeld = p;

  1031. 

  1032.     const StaticPluginLoader spl(p, "MindMeldModular");

  1033.     if (spl.ok())

  1034.     {

  1035.         p->addModel(modelMixMasterJr);

  1036.         p->addModel(modelAuxExpanderJr);

  1037.         p->addModel(modelMixMaster);

  1038.         p->addModel(modelAuxExpander);

  1039.         p->addModel(modelMeld);

  1040.         p->addModel(modelUnmeld);

  1041.         p->addModel(modelEqMaster);

  1042.         p->addModel(modelEqExpander);

  1043.         p->addModel(modelBassMaster);

  1044.         p->addModel(modelBassMasterJr);

  1045.         p->addModel(modelShapeMaster);

  1046.     }

  1047. }

  1048. 

  1049. static void initStatic__rackwindows()

  1050. {

  1051.     Plugin* const p = new Plugin;

  1052.     pluginInstance__rackwindows = p;

  1053. 

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

  1055.     if (spl.ok())

  1056.     {

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

  1058.         p->addModel(modelBitshiftgain);

  1059.         p->addModel(modelCapacitor);

  1060.         p->addModel(modelCapacitor_stereo);

  1061.         p->addModel(modelChorus);

  1062.         p->addModel(modelConsole);

  1063.         p->addModel(modelConsole_mm);

  1064.         p->addModel(modelDistance);

  1065.         p->addModel(modelGolem);

  1066.         p->addModel(modelHolt);

  1067.         p->addModel(modelHombre);

  1068.         p->addModel(modelInterstage);

  1069.         p->addModel(modelMonitoring);

  1070.         p->addModel(modelMv);

  1071.         p->addModel(modelRasp);

  1072.         p->addModel(modelReseq);

  1073.         p->addModel(modelTape);

  1074.         p->addModel(modelTremolo);

  1075.         p->addModel(modelVibrato);

  1076.     }

  1077. }

  1078. 

  1079. static void initStatic__ValleyAudio()

  1080. {

  1081.     Plugin* const p = new Plugin;

  1082.     pluginInstance__ValleyAudio = p;

  1083. 

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

  1085.     if (spl.ok())

  1086.     {

  1087.         p->addModel(modelTopograph);

  1088.         p->addModel(modelUGraph);

  1089.         p->addModel(modelDexter);

  1090.         p->addModel(modelPlateau);

  1091.         p->addModel(modelInterzone);

  1092.         p->addModel(modelAmalgam);

  1093.         p->addModel(modelFeline);

  1094.         p->addModel(modelTerrorform);

  1095.     }

  1096. }

  1097. 

  1098. static void initStatic__ZetaCarinaeModules()

  1099. {

  1100.     Plugin* p = new Plugin;

  1101.     pluginInstance__ZetaCarinaeModules = p;

  1102. 

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

  1104.     if (spl.ok())

  1105.     {

  1106.         p->addModel(modelBrownianBridge);

  1107.         p->addModel(modelOrnsteinUhlenbeck);

  1108.         p->addModel(modelIOU);

  1109.         p->addModel(modelWarbler);

  1110.         p->addModel(modelRosenchance);

  1111.         p->addModel(modelGuildensTurn);

  1112.         p->addModel(modelRosslerRustler);

  1113.         p->addModel(modelFirefly);

  1114.     }

  1115. }

  1116. #endif // NOPLUGINS

  1117. 

  1118. void initStaticPlugins()

  1119. {

  1120.     initStatic__Core();

  1121.     initStatic__Cardinal();

  1122. #ifndef NOPLUGINS

  1123.     initStatic__AmalgamatedHarmonics();

  1124.     initStatic__AnimatedCircuits();

  1125.     initStatic__AS();

  1126.     initStatic__AudibleInstruments();

  1127.     initStatic__Befaco();

  1128.     initStatic__Bidoo();

  1129.     initStatic__BogaudioModules();

  1130.     initStatic__cf();

  1131.     initStatic__DrumKit();

  1132.     initStatic__ESeries();

  1133.     initStatic__Fundamental();

  1134.     initStatic__GrandeModular();

  1135.     initStatic__ImpromptuModular();

  1136.     initStatic__JW();

  1137.     initStatic__MindMeld();

  1138.     initStatic__rackwindows();

  1139.     initStatic__ValleyAudio();

  1140.     initStatic__ZetaCarinaeModules();

  1141. #endif // NOPLUGINS

  1142. }

  1143. 

  1144. void destroyStaticPlugins()

  1145. {

  1146.     for (Plugin* p : plugins)

  1147.         delete p;

  1148.     plugins.clear();

  1149. }

  1150. 

  1151. }

  1152. }