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

1716 lines
47KB
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 "rack.hpp"

  19. #include "plugin.hpp"

  20. 

  21. #include "DistrhoUtils.hpp"

  22. 

  23. // Cardinal (built-in)

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

  25. 

  26. #ifndef NOPLUGINS

  27. // AmalgamatedHarmonics

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

  29. 

  30. // AnimatedCircuits

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

  32. 

  33. // Aria

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

  35. // #include "AriaModules/src/plugin.hpp"

  36. */

  37. #define modelBlank modelAriaBlank

  38. extern Model *modelSplort;

  39. extern Model *modelSmerge;

  40. extern Model *modelSpleet;

  41. extern Model *modelSwerge;

  42. extern Model *modelSplirge;

  43. // extern Model *modelSrot;

  44. extern Model *modelQqqq;

  45. extern Model *modelQuack;

  46. extern Model *modelQ;

  47. extern Model *modelQuale;

  48. extern Model *modelDarius;

  49. extern Model *modelSolomon4;

  50. extern Model *modelSolomon8;

  51. extern Model *modelSolomon16;

  52. extern Model *modelPsychopump;

  53. extern Model *modelPokies4;

  54. extern Model *modelGrabby;

  55. extern Model *modelRotatoes4;

  56. extern Model *modelUndular;

  57. extern Model *modelBlank;

  58. #undef modelBlank

  59. 

  60. // AS

  61. #define modelADSR modelASADSR

  62. #define modelVCA modelASVCA

  63. #define YellowRedLight ASYellowRedLight

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

  65. #undef modelADSR

  66. #undef modelVCA

  67. #undef YellowRedLight

  68. 

  69. // Atelier

  70. #include "Atelier/src/plugin.hpp"

  71. 

  72. // AudibleInstruments

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

  74. 

  75. // BaconPlugs

  76. #define INCLUDE_COMPONENTS_HPP

  77. #include "BaconPlugs/src/BaconPlugs.hpp"

  78. #undef INCLUDE_COMPONENTS_HPP

  79. #undef SCREW_WIDTH

  80. #undef RACK_HEIGHT

  81. 

  82. // Befaco

  83. #define modelADSR modelBefacoADSR

  84. #define modelMixer modelBefacoMixer

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

  86. #undef modelADSR

  87. #undef modelMixer

  88. 

  89. // Bidoo

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

  91. 

  92. // BogaudioModules - force dark skin as default

  93. #include <mutex>

  94. #include <string>

  95. #include <unordered_map>

  96. #include <unordered_set>

  97. #include <vector>

  98. #define private public

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

  100. #undef private

  101. 

  102. // BogaudioModules

  103. #define modelADSR modelBogaudioADSR

  104. #define modelLFO modelBogaudioLFO

  105. #define modelNoise modelBogaudioNoise

  106. #define modelVCA modelBogaudioVCA

  107. #define modelVCF modelBogaudioVCF

  108. #define modelVCO modelBogaudioVCO

  109. extern Model *modelVCO;

  110. extern Model *modelLVCO;

  111. extern Model *modelSine;

  112. extern Model *modelPulse;

  113. extern Model *modelXCO;

  114. extern Model *modelAdditator;

  115. extern Model *modelFMOp;

  116. extern Model *modelChirp;

  117. extern Model *modelLFO;

  118. extern Model *modelLLFO;

  119. extern Model *modelFourFO;

  120. extern Model *modelEightFO;

  121. extern Model *modelVCF;

  122. extern Model *modelLVCF;

  123. extern Model *modelFFB;

  124. extern Model *modelEQ;

  125. extern Model *modelEQS;

  126. extern Model *modelLPG;

  127. extern Model *modelLLPG;

  128. extern Model *modelMegaGate;

  129. extern Model *modelPEQ;

  130. extern Model *modelPEQ6;

  131. extern Model *modelPEQ6XF;

  132. extern Model *modelPEQ14;

  133. extern Model *modelPEQ14XF;

  134. extern Model *modelDADSRH;

  135. extern Model *modelDADSRHPlus;

  136. extern Model *modelShaper;

  137. extern Model *modelShaperPlus;

  138. extern Model *modelAD;

  139. extern Model *modelASR;

  140. extern Model *modelADSR;

  141. extern Model *modelVish;

  142. extern Model *modelFollow;

  143. extern Model *modelDGate;

  144. extern Model *modelRGate;

  145. extern Model *modelEdge;

  146. extern Model *modelNoise;

  147. extern Model *modelSampleHold;

  148. extern Model *modelWalk2;

  149. extern Model *modelWalk;

  150. extern Model *modelMix8;

  151. extern Model *modelMix8x;

  152. extern Model *modelMix4;

  153. extern Model *modelMix4x;

  154. extern Model *modelMix2;

  155. extern Model *modelMix1;

  156. extern Model *modelVCM;

  157. extern Model *modelMute8;

  158. extern Model *modelPan;

  159. extern Model *modelXFade;

  160. extern Model *modelVCA;

  161. extern Model *modelVCAmp;

  162. extern Model *modelVelo;

  163. extern Model *modelUMix;

  164. extern Model *modelMumix;

  165. extern Model *modelMatrix81;

  166. extern Model *modelMatrix18;

  167. extern Model *modelMatrix44;

  168. extern Model *modelMatrix44Cvm;

  169. extern Model *modelMatrix88;

  170. extern Model *modelMatrix88Cv;

  171. extern Model *modelMatrix88M;

  172. extern Model *modelSwitch81;

  173. extern Model *modelSwitch18;

  174. extern Model *modelSwitch44;

  175. extern Model *modelSwitch88;

  176. extern Model *modelSwitch1616;

  177. extern Model *modelAMRM;

  178. extern Model *modelPressor;

  179. extern Model *modelClpr;

  180. extern Model *modelLmtr;

  181. extern Model *modelNsgt;

  182. extern Model *modelCmpDist;

  183. extern Model *modelOneEight;

  184. extern Model *modelEightOne;

  185. extern Model *modelAddrSeq;

  186. extern Model *modelAddrSeqX;

  187. extern Model *modelPgmr;

  188. extern Model *modelPgmrX;

  189. extern Model *modelVU;

  190. extern Model *modelAnalyzer;

  191. extern Model *modelAnalyzerXL;

  192. extern Model *modelRanalyzer;

  193. extern Model *modelDetune;

  194. extern Model *modelStack;

  195. extern Model *modelReftone;

  196. extern Model *modelMono;

  197. extern Model *modelArp;

  198. extern Model *modelAssign;

  199. extern Model *modelUnison;

  200. extern Model *modelPolyCon8;

  201. extern Model *modelPolyCon16;

  202. extern Model *modelPolyOff8;

  203. extern Model *modelPolyOff16;

  204. extern Model *modelPolyMult;

  205. extern Model *modelBool;

  206. extern Model *modelCmp;

  207. extern Model *modelCVD;

  208. extern Model *modelFlipFlop;

  209. extern Model *modelInv;

  210. extern Model *modelManual;

  211. extern Model *modelFourMan;

  212. extern Model *modelMult;

  213. extern Model *modelOffset;

  214. extern Model *modelSlew;

  215. extern Model *modelSums;

  216. extern Model *modelSwitch;

  217. extern Model *modelLgsw;

  218. extern Model *modelBlank3;

  219. extern Model *modelBlank6;

  220. #ifdef EXPERIMENTAL

  221. extern Model *modelLag;

  222. extern Model *modelPEQ14XR;

  223. extern Model *modelPEQ14XV;

  224. #endif

  225. #ifdef TEST

  226. extern Model *modelTest;

  227. extern Model *modelTest2;

  228. extern Model *modelTestExpanderBase;

  229. extern Model *modelTestExpanderExtension;

  230. extern Model *modelTestGl;

  231. extern Model *modelTestVCF;

  232. #endif

  233. #undef modelADSR

  234. #undef modelLFO

  235. #undef modelNoise

  236. #undef modelVCA

  237. #undef modelVCF

  238. #undef modelVCO

  239. 

  240. // cf

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

  242. 

  243. // ChowDSP

  244. #include "ChowDSP/src/plugin.hpp"

  245. #define init initChowDSP

  246. #include "ChowDSP/src/plugin.cpp"

  247. #undef init

  248. 

  249. // DrumKit

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

  251. void setupSamples();

  252. 

  253. // ESeries

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

  255. 

  256. // FehlerFabrik

  257. #include "FehlerFabrik/src/plugin.hpp"

  258. 

  259. // Fundamental

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

  261. 

  262. // GlueTheGiant

  263. #include "GlueTheGiant/src/plugin.hpp"

  264. bool audition_mixer = false;

  265. bool audition_depot = false;

  266. int gtg_default_theme = 1;

  267. int loadGtgPluginDefault(const char*, int) { return 1; }

  268. void saveGtgPluginDefault(const char*, int) {}

  269. 

  270. // GrandeModular

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

  272. 

  273. // ImpromptuModular

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

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

  276. */

  277. extern Model *modelAdaptiveQuantizer;

  278. extern Model *modelBigButtonSeq;

  279. extern Model *modelBigButtonSeq2;

  280. extern Model *modelChordKey;

  281. extern Model *modelChordKeyExpander;

  282. extern Model *modelClocked;

  283. extern Model *modelClockedExpander;

  284. extern Model *modelClkd;

  285. extern Model *modelCvPad;

  286. extern Model *modelFoundry;

  287. extern Model *modelFoundryExpander;

  288. extern Model *modelFourView;

  289. extern Model *modelGateSeq64;

  290. extern Model *modelGateSeq64Expander;

  291. extern Model *modelHotkey;

  292. extern Model *modelPart;

  293. extern Model *modelPhraseSeq16;

  294. extern Model *modelPhraseSeq32;

  295. extern Model *modelPhraseSeqExpander;

  296. extern Model *modelProbKey;

  297. // extern Model *modelProbKeyExpander;

  298. extern Model *modelSemiModularSynth;

  299. extern Model *modelTact;

  300. extern Model *modelTact1;

  301. extern Model *modelTactG;

  302. extern Model *modelTwelveKey;

  303. extern Model *modelWriteSeq32;

  304. extern Model *modelWriteSeq64;

  305. extern Model *modelBlankPanel;

  306. 

  307. // HetrickCV

  308. #define modelASR modelHetrickCVASR

  309. #define modelBlankPanel modelHetrickCVBlankPanel

  310. #define modelFlipFlop modelHetrickCVFlipFlop

  311. #define modelMidSide modelHetrickCVMidSide

  312. #define modelMinMax modelHetrickCVMinMax

  313. extern Model *modelTwoToFour;

  314. extern Model *modelAnalogToDigital;

  315. extern Model *modelASR;

  316. extern Model *modelBinaryGate;

  317. extern Model *modelBinaryNoise;

  318. extern Model *modelBitshift;

  319. extern Model *modelBlankPanel;

  320. extern Model *modelBoolean3;

  321. extern Model *modelChaos1Op;

  322. extern Model *modelChaos2Op;

  323. extern Model *modelChaos3Op;

  324. extern Model *modelChaoticAttractors;

  325. extern Model *modelClockedNoise;

  326. extern Model *modelComparator;

  327. extern Model *modelContrast;

  328. extern Model *modelCrackle;

  329. extern Model *modelDataCompander;

  330. extern Model *modelDelta;

  331. extern Model *modelDigitalToAnalog;

  332. extern Model *modelDust;

  333. extern Model *modelExponent;

  334. extern Model *modelFBSineChaos;

  335. extern Model *modelFlipFlop;

  336. extern Model *modelFlipPan;

  337. extern Model *modelGateJunction;

  338. extern Model *modelGingerbread;

  339. extern Model *modelLogicCombine;

  340. extern Model *modelMidSide;

  341. extern Model *modelMinMax;

  342. extern Model *modelRandomGates;

  343. extern Model *modelRotator;

  344. extern Model *modelRungler;

  345. extern Model *modelScanner;

  346. extern Model *modelWaveshape;

  347. extern Model *modelXYToPolar;

  348. #undef modelASR

  349. #undef modelBlankPanel

  350. #undef modelFlipFlop

  351. #undef modelMidSide

  352. #undef modelMinMax

  353. 

  354. // JW-Modules

  355. #define modelQuantizer modelJWQuantizer

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

  357. #undef modelQuantizer

  358. 

  359. // MindMeldModular

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

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

  362. */

  363. extern Model *modelMixMasterJr;

  364. extern Model *modelAuxExpanderJr;

  365. extern Model *modelMixMaster;

  366. extern Model *modelAuxExpander;

  367. extern Model *modelMeld;

  368. extern Model *modelUnmeld;

  369. extern Model *modelEqMaster;

  370. extern Model *modelEqExpander;

  371. extern Model *modelBassMaster;

  372. extern Model *modelBassMasterJr;

  373. extern Model *modelShapeMaster;

  374. 

  375. // Mog

  376. #include "Mog/src/plugin.hpp"

  377. 

  378. // mscHack

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

  380. // #include "mscHack/src/mscHack.hpp"

  381. */

  382. extern Model *modelCompressor;

  383. extern Model *modelSynthDrums;

  384. extern Model *modelSEQ_6x32x16;

  385. extern Model *modelMasterClockx8;

  386. extern Model *modelMasterClockx4;

  387. extern Model *modelSEQ_Envelope_8;

  388. extern Model *modelSeq_Triad2;

  389. extern Model *modelARP700;

  390. extern Model *modelMix_24_4_4;

  391. extern Model *modelMix_16_4_4;

  392. extern Model *modelMix_9_3_4;

  393. extern Model *modelMix_4_0_4;

  394. extern Model *modelASAF8;

  395. extern Model *modelPingPong;

  396. extern Model *modelStepDelay;

  397. extern Model *modelOsc_3Ch;

  398. extern Model *modelDronez;

  399. extern Model *modelMorze;

  400. extern Model *modelWindz;

  401. extern Model *modelLorenz;

  402. extern Model *modelAlienz;

  403. extern Model *modelOSC_WaveMorph_3;

  404. extern Model *modelMaude_221;

  405. 

  406. // rackwindows

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

  408. 

  409. // repelzen

  410. #define modelBlank modelrepelzenBlank

  411. #define modelMixer modelrepelzenMixer

  412. #define modelWerner modelrepelzenWerner

  413. #define tanh_pade repelzentanh_pade

  414. #include "repelzen/src/repelzen.hpp"

  415. #undef modelBlank

  416. #undef modelMixer

  417. #undef modelWerner

  418. #undef tanh_pade

  419. 

  420. // sonusmodular

  421. #include "sonusmodular/src/sonusmodular.hpp"

  422. 

  423. // ValleyAudio

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

  425. 

  426. // ZetaCarinaeModules

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

  428. 

  429. // ZZC

  430. #define DISPLAYS_H

  431. #define ZZC_SHARED_H

  432. #define ZZC_WIDGETS_H

  433. #define modelClock modelZZCClock

  434. #include "ZZC/src/ZZC.hpp"

  435. #undef modelClock

  436. 

  437. #endif // NOPLUGINS

  438. 

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

  440. int loadConsoleType() { return 0; }

  441. int loadDirectOutMode() { return 0; }

  442. void saveConsoleType(int) {}

  443. void saveDarkAsDefault(bool) {}

  444. void saveDirectOutMode(bool) {}

  445. void saveHighQualityAsDefault(bool) {}

  446. 

  447. // plugin instances

  448. Plugin* pluginInstance__Cardinal;

  449. #ifndef NOPLUGINS

  450. Plugin* pluginInstance__AmalgamatedHarmonics;

  451. Plugin* pluginInstance__AnimatedCircuits;

  452. Plugin* pluginInstance__Aria;

  453. Plugin* pluginInstance__AS;

  454. Plugin* pluginInstance__Atelier;

  455. Plugin* pluginInstance__AudibleInstruments;

  456. Plugin* pluginInstance__Bacon;

  457. Plugin* pluginInstance__Befaco;

  458. Plugin* pluginInstance__Bidoo;

  459. Plugin* pluginInstance__BogaudioModules;

  460. Plugin* pluginInstance__cf;

  461. Plugin* pluginInstance__ChowDSP;

  462. extern Plugin* pluginInstance__DrumKit;

  463. Plugin* pluginInstance__ESeries;

  464. Plugin* pluginInstance__FehlerFabrik;

  465. Plugin* pluginInstance__Fundamental;

  466. Plugin* pluginInstance__GrandeModular;

  467. Plugin* pluginInstance__GlueTheGiant;

  468. Plugin* pluginInstance__HetrickCV;

  469. extern Plugin* pluginInstance__ImpromptuModular;

  470. Plugin* pluginInstance__JW;

  471. extern Plugin* pluginInstance__MindMeld;

  472. Plugin* pluginInstance__Mog;

  473. extern Plugin* pluginInstance__mscHack;

  474. Plugin* pluginInstance__rackwindows;

  475. Plugin* pluginInstance__repelzen;

  476. Plugin* pluginInstance__sonusmodular;

  477. Plugin* pluginInstance__ValleyAudio;

  478. Plugin* pluginInstance__ZetaCarinaeModules;

  479. Plugin* pluginInstance__ZZC;

  480. #endif // NOPLUGINS

  481. 

  482. namespace rack {

  483. 

  484. namespace asset {

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

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

  487. }

  488. 

  489. // core plugins

  490. namespace core {

  491. extern Model* modelAudio2;

  492. extern Model* modelAudio8;

  493. extern Model* modelAudio16;

  494. extern Model* modelMIDI_CV;

  495. extern Model* modelMIDICC_CV;

  496. extern Model* modelMIDI_Gate;

  497. extern Model* modelMIDIMap;

  498. extern Model* modelCV_MIDI;

  499. extern Model* modelCV_MIDICC;

  500. extern Model* modelGate_MIDI;

  501. extern Model* modelBlank;

  502. extern Model* modelNotes;

  503. }

  504. 

  505. // regular plugins

  506. namespace plugin {

  507. 

  508. struct StaticPluginLoader {

  509.     Plugin* const plugin;

  510.     FILE* file;

  511.     json_t* rootJ;

  512. 

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

  514.         : plugin(p),

  515.           file(nullptr),

  516.           rootJ(nullptr)

  517.     {

  518. #ifdef DEBUG

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

  520. #endif

  521. 

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

  523. 

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

  525. 

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

  527.         {

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

  529.             return;

  530.         }

  531. 

  532.         json_error_t error;

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

  534.         {

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

  536.             return;

  537.         }

  538. 

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

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

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

  542.         json_decref(version);

  543.     }

  544. 

  545.     ~StaticPluginLoader()

  546.     {

  547.         if (rootJ != nullptr)

  548.         {

  549.             plugin->fromJson(rootJ);

  550.             json_decref(rootJ);

  551.             plugins.push_back(plugin);

  552.         }

  553. 

  554.         if (file != nullptr)

  555.             std::fclose(file);

  556.     }

  557. 

  558.     bool ok() const noexcept

  559.     {

  560.         return rootJ != nullptr;

  561.     }

  562. 

  563.     void removeModule(const char* const slugToRemove) const noexcept

  564.     {

  565.         json_t* const modules = json_object_get(rootJ, "modules");

  566.         DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);

  567. 

  568.         size_t i;

  569.         json_t* v;

  570.         json_array_foreach(modules, i, v)

  571.         {

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

  573.             {

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

  575.                 {

  576.                     if (std::strcmp(value, slugToRemove) == 0)

  577.                     {

  578.                         json_array_remove(modules, i);

  579.                         break;

  580.                     }

  581.                 }

  582.             }

  583.         }

  584.     }

  585. };

  586. 

  587. static void initStatic__Core()

  588. {

  589.     Plugin* const p = new Plugin;

  590. 

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

  592.     if (spl.ok())

  593.     {

  594.         p->addModel(rack::core::modelAudio2);

  595.         p->addModel(rack::core::modelAudio8);

  596.         p->addModel(rack::core::modelAudio16);

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

  598.         p->addModel(rack::core::modelMIDICC_CV);

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

  600.         p->addModel(rack::core::modelMIDIMap);

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

  602.         p->addModel(rack::core::modelCV_MIDICC);

  603.         p->addModel(rack::core::modelGate_MIDI);

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

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

  606.     }

  607. }

  608. 

  609. static void initStatic__Cardinal()

  610. {

  611.     Plugin* const p = new Plugin;

  612.     pluginInstance__Cardinal = p;

  613. 

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

  615.     if (spl.ok())

  616.     {

  617.         p->addModel(modelCarla);

  618.         p->addModel(modelCardinalBlank);

  619.         p->addModel(modelGlBars);

  620.         p->addModel(modelHostCV);

  621.         p->addModel(modelHostParameters);

  622.         p->addModel(modelHostTime);

  623.         p->addModel(modelIldaeil);

  624.     }

  625. }

  626. 

  627. #ifndef NOPLUGINS

  628. static void initStatic__AmalgamatedHarmonics()

  629. {

  630.     Plugin* const p = new Plugin;

  631.     pluginInstance__AmalgamatedHarmonics = p;

  632. 

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

  634.     if (spl.ok())

  635.     {

  636.         p->addModel(modelArp31);

  637.         p->addModel(modelArp32);

  638.         p->addModel(modelBombe);

  639.         p->addModel(modelChord);

  640.         p->addModel(modelCircle);

  641.         p->addModel(modelGalaxy);

  642.         p->addModel(modelGenerative);

  643.         p->addModel(modelImp);

  644.         p->addModel(modelImperfect2);

  645.         p->addModel(modelProgress2);

  646.         p->addModel(modelRuckus);

  647.         p->addModel(modelScaleQuantizer2);

  648.         p->addModel(modelSLN);

  649.         p->addModel(modelMuxDeMux);

  650.         p->addModel(modelPolyProbe);

  651.         p->addModel(modelPolyScope);

  652.         p->addModel(modelPolyUtils);

  653.         p->addModel(modelPolyVolt);

  654.         p->addModel(modelScaleQuantizer);

  655.         p->addModel(modelArpeggiator2);

  656.         p->addModel(modelProgress);

  657.     }

  658. }

  659. 

  660. static void initStatic__AnimatedCircuits()

  661. {

  662.     Plugin* const p = new Plugin;

  663.     pluginInstance__AnimatedCircuits = p;

  664. 

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

  666.     if (spl.ok())

  667.     {

  668.         p->addModel(model_AC_Folding);

  669.     }

  670. }

  671. 

  672. static void initStatic__Aria()

  673. {

  674.     Plugin* const p = new Plugin;

  675.     pluginInstance__Aria = p;

  676. 

  677.     const StaticPluginLoader spl(p, "AriaModules");

  678.     if (spl.ok())

  679.     {

  680. #define modelBlank modelAriaBlank

  681.         p->addModel(modelSplort);

  682.         p->addModel(modelSmerge);

  683.         p->addModel(modelSpleet);

  684.         p->addModel(modelSwerge);

  685.         p->addModel(modelSplirge);

  686.         // p->addModel(modelSrot);

  687.         p->addModel(modelQqqq);

  688.         p->addModel(modelQuack);

  689.         p->addModel(modelQ);

  690.         p->addModel(modelQuale);

  691.         p->addModel(modelDarius);

  692.         p->addModel(modelSolomon4);

  693.         p->addModel(modelSolomon8);

  694.         p->addModel(modelSolomon16);

  695.         p->addModel(modelPsychopump);

  696.         p->addModel(modelPokies4);

  697.         p->addModel(modelGrabby);

  698.         p->addModel(modelRotatoes4);

  699.         p->addModel(modelUndular);

  700.         p->addModel(modelBlank);

  701. #undef modelBlank

  702.         // NOTE disabled in Cardinal due to online requirement

  703.         spl.removeModule("Arcane");

  704.         spl.removeModule("Atout");

  705.         spl.removeModule("Aleister");

  706.     }

  707. }

  708. 

  709. static void initStatic__AS()

  710. {

  711.     Plugin* const p = new Plugin;

  712.     pluginInstance__AS = p;

  713. 

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

  715.     if (spl.ok())

  716.     {

  717. #define modelADSR modelASADSR

  718. #define modelVCA modelASVCA

  719.         //OSCILLATORS

  720.         p->addModel(modelSineOsc);

  721.         p->addModel(modelSawOsc);

  722. 

  723.         //TOOLS

  724.         p->addModel(modelADSR);

  725.         p->addModel(modelVCA);

  726.         p->addModel(modelQuadVCA);

  727.         p->addModel(modelTriLFO);

  728.         p->addModel(modelAtNuVrTr);

  729.         p->addModel(modelBPMClock);

  730.         p->addModel(modelSEQ16);

  731.         p->addModel(modelMixer2ch);

  732.         p->addModel(modelMixer4ch);

  733.         p->addModel(modelMixer8ch);

  734.         p->addModel(modelMonoVUmeter);

  735.         p->addModel(modelStereoVUmeter);

  736.         p->addModel(modelMultiple2_5);

  737.         p->addModel(modelMerge2_5);

  738.         p->addModel(modelSteps);

  739.         p->addModel(modelLaunchGate);

  740.         p->addModel(modelKillGate);

  741.         p->addModel(modelFlow);

  742.         p->addModel(modelSignalDelay);

  743.         p->addModel(modelTriggersMKI);

  744.         p->addModel(modelTriggersMKII);

  745.         p->addModel(modelTriggersMKIII);

  746.         p->addModel(modelBPMCalc);

  747.         p->addModel(modelBPMCalc2);

  748.         p->addModel(modelCv2T);

  749.         p->addModel(modelZeroCV2T);

  750.         p->addModel(modelReScale);

  751. 

  752.         //EFFECTS

  753.         p->addModel(modelDelayPlusFx);

  754.         p->addModel(modelDelayPlusStereoFx);

  755.         p->addModel(modelPhaserFx);

  756.         p->addModel(modelReverbFx);

  757.         p->addModel(modelReverbStereoFx);

  758.         p->addModel(modelSuperDriveFx);

  759.         p->addModel(modelSuperDriveStereoFx);

  760.         p->addModel(modelTremoloFx);

  761.         p->addModel(modelTremoloStereoFx);

  762.         p->addModel(modelWaveShaper);

  763.         p->addModel(modelWaveShaperStereo);

  764. 

  765.         //BLANK PANELS

  766.         p->addModel(modelBlankPanel4);

  767.         p->addModel(modelBlankPanel6);

  768.         p->addModel(modelBlankPanel8);

  769.         p->addModel(modelBlankPanelSpecial);

  770. #undef modelADSR

  771. #undef modelVCA

  772.     }

  773. }

  774. 

  775. static void initStatic__Atelier()

  776. {

  777.     Plugin* const p = new Plugin;

  778.     pluginInstance__Atelier = p;

  779. 

  780.     const StaticPluginLoader spl(p, "Atelier");

  781.     if (spl.ok())

  782.     {

  783.         p->addModel(modelPalette);

  784.     }

  785. }

  786. 

  787. static void initStatic__AudibleInstruments()

  788. {

  789.     Plugin* const p = new Plugin;

  790.     pluginInstance__AudibleInstruments = p;

  791. 

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

  793.     if (spl.ok())

  794.     {

  795.         p->addModel(modelBraids);

  796.         p->addModel(modelPlaits);

  797.         p->addModel(modelElements);

  798.         p->addModel(modelTides);

  799.         p->addModel(modelTides2);

  800.         p->addModel(modelClouds);

  801.         p->addModel(modelWarps);

  802.         p->addModel(modelRings);

  803.         p->addModel(modelLinks);

  804.         p->addModel(modelKinks);

  805.         p->addModel(modelShades);

  806.         p->addModel(modelBranches);

  807.         p->addModel(modelBlinds);

  808.         p->addModel(modelVeils);

  809.         p->addModel(modelFrames);

  810.         p->addModel(modelMarbles);

  811.         p->addModel(modelStages);

  812.         p->addModel(modelRipples);

  813.         p->addModel(modelShelves);

  814.         p->addModel(modelStreams);

  815.     }

  816. }

  817. 

  818. static void initStatic__Bacon()

  819. {

  820.     Plugin* const p = new Plugin;

  821.     pluginInstance__Bacon = p;

  822. 

  823.     const StaticPluginLoader spl(p, "BaconPlugs");

  824.     if (spl.ok())

  825.     {

  826.         p->addModel(modelHarMoNee);

  827.         p->addModel(modelGlissinator);

  828.         p->addModel(modelPolyGnome);

  829.         p->addModel(modelQuantEyes);

  830.         p->addModel(modelSampleDelay);

  831. #ifdef BUILD_SORTACHORUS

  832.         p->addModel(modelSortaChorus);

  833. #endif

  834.         p->addModel(modelChipNoise);

  835.         p->addModel(modelChipWaves);

  836.         p->addModel(modelChipYourWave);

  837.         p->addModel(modelOpen303);

  838. #ifdef BUILD_GENERICLSFR

  839.         p->addModel(modelGenericLFSR);

  840. #endif

  841.         p->addModel(modelKarplusStrongPoly);

  842.         p->addModel(modelALingADing);

  843.         p->addModel(modelBitulator);

  844. #ifdef BUILD_PHASER

  845.         p->addModel(modelPhaser);

  846. #endif

  847.         p->addModel(modelPolyGenerator);

  848.     }

  849. }

  850. 

  851. static void initStatic__Befaco()

  852. {

  853.     Plugin* const p = new Plugin;

  854.     pluginInstance__Befaco = p;

  855. 

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

  857.     if (spl.ok())

  858.     {

  859. #define modelADSR modelBefacoADSR

  860. #define modelMixer modelBefacoMixer

  861.         p->addModel(modelEvenVCO);

  862.         p->addModel(modelRampage);

  863.         p->addModel(modelABC);

  864.         p->addModel(modelSpringReverb);

  865.         p->addModel(modelMixer);

  866.         p->addModel(modelSlewLimiter);

  867.         p->addModel(modelDualAtenuverter);

  868.         p->addModel(modelPercall);

  869.         p->addModel(modelHexmixVCA);

  870.         p->addModel(modelChoppingKinky);

  871.         p->addModel(modelKickall);

  872.         p->addModel(modelSamplingModulator);

  873.         p->addModel(modelMorphader);

  874.         p->addModel(modelADSR);

  875.         p->addModel(modelSTMix);

  876.         p->addModel(modelMuxlicer);

  877.         p->addModel(modelMex);

  878. #undef modelADSR

  879. #undef modelMixer

  880.     }

  881. }

  882. 

  883. static void initStatic__Bidoo()

  884. {

  885.     Plugin* const p = new Plugin;

  886.     pluginInstance__Bidoo = p;

  887. 

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

  889.     if (spl.ok())

  890.     {

  891.         p->addModel(modelTOCANTE);

  892.         p->addModel(modelLATE);

  893.         p->addModel(modelDIKTAT);

  894.         p->addModel(modelDTROY);

  895.         p->addModel(modelBORDL);

  896.         p->addModel(modelZOUMAI);

  897.         p->addModel(modelMU);

  898.         p->addModel(modelCHUTE);

  899.         p->addModel(modelLOURDE);

  900.         p->addModel(modelDILEMO);

  901.         p->addModel(modelLAMBDA);

  902.         p->addModel(modelBANCAU);

  903.         p->addModel(modelACNE);

  904.         p->addModel(modelMS);

  905.         p->addModel(modelDUKE);

  906.         p->addModel(modelMOIRE);

  907.         p->addModel(modelPILOT);

  908.         p->addModel(modelHUITRE);

  909.         p->addModel(modelOUAIVE);

  910.         p->addModel(modelEDSAROS);

  911.         p->addModel(modelPOUPRE);

  912.         p->addModel(modelMAGMA);

  913.         p->addModel(modelOAI);

  914.         p->addModel(modelCANARD);

  915.         p->addModel(modelEMILE);

  916.         p->addModel(modelFORK);

  917.         p->addModel(modelTIARE);

  918.         p->addModel(modelLIMONADE);

  919.         p->addModel(modelLIMBO);

  920.         p->addModel(modelPERCO);

  921.         p->addModel(modelBAFIS);

  922.         p->addModel(modelBAR);

  923.         p->addModel(modelMINIBAR);

  924.         p->addModel(modelZINC);

  925.         p->addModel(modelFREIN);

  926.         p->addModel(modelHCTIP);

  927.         p->addModel(modelSPORE);

  928.         p->addModel(modelDFUZE);

  929.         p->addModel(modelREI);

  930.         p->addModel(modelRABBIT);

  931.         p->addModel(modelBISTROT);

  932.         p->addModel(modelSIGMA);

  933.         p->addModel(modelFLAME);

  934.         p->addModel(modelVOID);

  935. 

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

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

  938.         spl.removeModule("antN");

  939.     }

  940. }

  941. 

  942. static void initStatic__BogaudioModules()

  943. {

  944.     Plugin* const p = new Plugin;

  945.     pluginInstance__BogaudioModules = p;

  946. 

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

  948.     if (spl.ok())

  949.     {

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

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

  952.         skins._default = "dark";

  953. #define modelADSR modelBogaudioADSR

  954. #define modelLFO modelBogaudioLFO

  955. #define modelNoise modelBogaudioNoise

  956. #define modelVCA modelBogaudioVCA

  957. #define modelVCF modelBogaudioVCF

  958. #define modelVCO modelBogaudioVCO

  959.         p->addModel(modelVCO);

  960.         p->addModel(modelLVCO);

  961.         p->addModel(modelSine);

  962.         p->addModel(modelPulse);

  963.         p->addModel(modelXCO);

  964.         p->addModel(modelAdditator);

  965.         p->addModel(modelFMOp);

  966.         p->addModel(modelChirp);

  967.         p->addModel(modelLFO);

  968.         p->addModel(modelLLFO);

  969.         p->addModel(modelFourFO);

  970.         p->addModel(modelEightFO);

  971.         p->addModel(modelVCF);

  972.         p->addModel(modelLVCF);

  973.         p->addModel(modelFFB);

  974.         p->addModel(modelEQ);

  975.         p->addModel(modelEQS);

  976.         p->addModel(modelLPG);

  977.         p->addModel(modelLLPG);

  978.         p->addModel(modelMegaGate);

  979.         p->addModel(modelPEQ);

  980.         p->addModel(modelPEQ6);

  981.         p->addModel(modelPEQ6XF);

  982.         p->addModel(modelPEQ14);

  983.         p->addModel(modelPEQ14XF);

  984.         p->addModel(modelDADSRH);

  985.         p->addModel(modelDADSRHPlus);

  986.         p->addModel(modelShaper);

  987.         p->addModel(modelShaperPlus);

  988.         p->addModel(modelAD);

  989.         p->addModel(modelASR);

  990.         p->addModel(modelADSR);

  991.         p->addModel(modelVish);

  992.         p->addModel(modelFollow);

  993.         p->addModel(modelDGate);

  994.         p->addModel(modelRGate);

  995.         p->addModel(modelEdge);

  996.         p->addModel(modelNoise);

  997.         p->addModel(modelSampleHold);

  998.         p->addModel(modelWalk2);

  999.         p->addModel(modelWalk);

  1000.         p->addModel(modelMix8);

  1001.         p->addModel(modelMix8x);

  1002.         p->addModel(modelMix4);

  1003.         p->addModel(modelMix4x);

  1004.         p->addModel(modelMix2);

  1005.         p->addModel(modelMix1);

  1006.         p->addModel(modelVCM);

  1007.         p->addModel(modelMute8);

  1008.         p->addModel(modelPan);

  1009.         p->addModel(modelXFade);

  1010.         p->addModel(modelVCA);

  1011.         p->addModel(modelVCAmp);

  1012.         p->addModel(modelVelo);

  1013.         p->addModel(modelUMix);

  1014.         p->addModel(modelMumix);

  1015.         p->addModel(modelMatrix81);

  1016.         p->addModel(modelMatrix18);

  1017.         p->addModel(modelMatrix44);

  1018.         p->addModel(modelMatrix44Cvm);

  1019.         p->addModel(modelMatrix88);

  1020.         p->addModel(modelMatrix88Cv);

  1021.         p->addModel(modelMatrix88M);

  1022.         p->addModel(modelSwitch81);

  1023.         p->addModel(modelSwitch18);

  1024.         p->addModel(modelSwitch44);

  1025.         p->addModel(modelSwitch88);

  1026.         p->addModel(modelSwitch1616);

  1027.         p->addModel(modelAMRM);

  1028.         p->addModel(modelPressor);

  1029.         p->addModel(modelClpr);

  1030.         p->addModel(modelLmtr);

  1031.         p->addModel(modelNsgt);

  1032.         p->addModel(modelCmpDist);

  1033.         p->addModel(modelOneEight);

  1034.         p->addModel(modelEightOne);

  1035.         p->addModel(modelAddrSeq);

  1036.         p->addModel(modelAddrSeqX);

  1037.         p->addModel(modelPgmr);

  1038.         p->addModel(modelPgmrX);

  1039.         p->addModel(modelVU);

  1040.         p->addModel(modelAnalyzer);

  1041.         p->addModel(modelAnalyzerXL);

  1042.         p->addModel(modelRanalyzer);

  1043.         p->addModel(modelDetune);

  1044.         p->addModel(modelStack);

  1045.         p->addModel(modelReftone);

  1046.         p->addModel(modelMono);

  1047.         p->addModel(modelArp);

  1048.         p->addModel(modelAssign);

  1049.         p->addModel(modelUnison);

  1050.         p->addModel(modelPolyCon8);

  1051.         p->addModel(modelPolyCon16);

  1052.         p->addModel(modelPolyOff8);

  1053.         p->addModel(modelPolyOff16);

  1054.         p->addModel(modelPolyMult);

  1055.         p->addModel(modelBool);

  1056.         p->addModel(modelCmp);

  1057.         p->addModel(modelCVD);

  1058.         p->addModel(modelFlipFlop);

  1059.         p->addModel(modelInv);

  1060.         p->addModel(modelManual);

  1061.         p->addModel(modelFourMan);

  1062.         p->addModel(modelMult);

  1063.         p->addModel(modelOffset);

  1064.         p->addModel(modelSlew);

  1065.         p->addModel(modelSums);

  1066.         p->addModel(modelSwitch);

  1067.         p->addModel(modelLgsw);

  1068.         p->addModel(modelBlank3);

  1069.         p->addModel(modelBlank6);

  1070. #ifdef EXPERIMENTAL

  1071.         p->addModel(modelLag);

  1072.         p->addModel(modelPEQ14XR);

  1073.         p->addModel(modelPEQ14XV);

  1074. #endif

  1075. #ifdef TEST

  1076.         p->addModel(modelTest);

  1077.         p->addModel(modelTest2);

  1078.         p->addModel(modelTestExpanderBase);

  1079.         p->addModel(modelTestExpanderExtension);

  1080.         p->addModel(modelTestGl);

  1081.         p->addModel(modelTestVCF);

  1082. #endif

  1083. #undef modelADSR

  1084. #undef modelLFO

  1085. #undef modelNoise

  1086. #undef modelVCA

  1087. #undef modelVCF

  1088. #undef modelVCO

  1089.     }

  1090. }

  1091. 

  1092. static void initStatic__cf()

  1093. {

  1094.     Plugin* const p = new Plugin;

  1095.     pluginInstance__cf = p;

  1096. 

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

  1098.     if (spl.ok())

  1099.     {

  1100.         p->addModel(modelMETRO);

  1101.         p->addModel(modelEACH);

  1102.         p->addModel(modeltrSEQ);

  1103.         p->addModel(modelLEDSEQ);

  1104.         p->addModel(modelL3DS3Q);

  1105.         p->addModel(modelSLIDERSEQ);

  1106.         p->addModel(modelPLAYER);

  1107.         p->addModel(modelPLAY);

  1108.         p->addModel(modelMONO);

  1109.         p->addModel(modelSTEREO);

  1110.         p->addModel(modelSUB);

  1111.         p->addModel(modelMASTER);

  1112.         p->addModel(modelVARIABLE);

  1113.         p->addModel(modelALGEBRA);

  1114.         p->addModel(modelFUNKTION);

  1115.         p->addModel(modelCHOKE);

  1116.         p->addModel(modelFOUR);

  1117.         p->addModel(modelSTEPS);

  1118.         p->addModel(modelPEAK);

  1119.         p->addModel(modelCUTS);

  1120.         p->addModel(modelBUFFER);

  1121.         p->addModel(modelDISTO);

  1122.         p->addModel(modelCUBE);

  1123.         p->addModel(modelPATCH);

  1124.         p->addModel(modelLABEL);

  1125.         p->addModel(modelDAVE);

  1126.     }

  1127. }

  1128. 

  1129. static void initStatic__ChowDSP()

  1130. {

  1131.     Plugin* const p = new Plugin;

  1132.     pluginInstance__ChowDSP = p;

  1133. 

  1134.     const StaticPluginLoader spl(p, "ChowDSP");

  1135.     if (spl.ok())

  1136.     {

  1137.         p->addModel(modelChowTape);

  1138.         p->addModel(modelChowPhaserFeedback);

  1139.         p->addModel(modelChowPhaserMod);

  1140.         p->addModel(modelChowFDN);

  1141.         p->addModel(modelChowRNN);

  1142.         p->addModel(modelChowModal);

  1143.         p->addModel(modelChowDer);

  1144.         p->addModel(modelWarp);

  1145.         p->addModel(modelWerner);

  1146.         p->addModel(modelCredit);

  1147.         p->addModel(modelChowPulse);

  1148.         p->addModel(modelChowTapeCompression);

  1149.         p->addModel(modelChowTapeChew);

  1150.         p->addModel(modelChowTapeDegrade);

  1151.         p->addModel(modelChowTapeLoss);

  1152.         p->addModel(modelChowChorus);

  1153.     }

  1154. }

  1155. 

  1156. static void initStatic__DrumKit()

  1157. {

  1158.     Plugin* const p = new Plugin;

  1159.     pluginInstance__DrumKit = p;

  1160. 

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

  1162.     if (spl.ok())

  1163.     {

  1164.         setupSamples();

  1165.         p->addModel(modelBD9);

  1166.         p->addModel(modelSnare);

  1167.         p->addModel(modelClosedHH);

  1168.         p->addModel(modelOpenHH);

  1169.         p->addModel(modelDMX);

  1170.         p->addModel(modelCR78);

  1171.         p->addModel(modelSBD);

  1172.         p->addModel(modelGnome);

  1173.         p->addModel(modelSequencer);

  1174.         p->addModel(modelTomi);

  1175.         p->addModel(modelBaronial);

  1176.         p->addModel(modelMarionette);

  1177.     }

  1178. }

  1179. 

  1180. static void initStatic__ESeries()

  1181. {

  1182.     Plugin* const p = new Plugin;

  1183.     pluginInstance__ESeries = p;

  1184. 

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

  1186.     if (spl.ok())

  1187.     {

  1188.         p->addModel(modelE340);

  1189.     }

  1190. }

  1191. 

  1192. static void initStatic__FehlerFabrik()

  1193. {

  1194.     Plugin* const p = new Plugin;

  1195.     pluginInstance__FehlerFabrik = p;

  1196. 

  1197.     const StaticPluginLoader spl(p, "FehlerFabrik");

  1198.     if (spl.ok())

  1199.     {

  1200.         p->addModel(modelPSIOP);

  1201.         p->addModel(modelPlanck);

  1202.         p->addModel(modelLuigi);

  1203.         p->addModel(modelAspect);

  1204.         p->addModel(modelMonte);

  1205.         p->addModel(modelArpanet);

  1206.         p->addModel(modelSigma);

  1207.         p->addModel(modelFax);

  1208.         p->addModel(modelRasoir);

  1209.         p->addModel(modelChi);

  1210.         p->addModel(modelNova);

  1211.         p->addModel(modelLilt);

  1212.         p->addModel(modelBotzinger);

  1213.     }

  1214. }

  1215. 

  1216. static void initStatic__Fundamental()

  1217. {

  1218.     Plugin* const p = new Plugin;

  1219.     pluginInstance__Fundamental = p;

  1220. 

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

  1222.     if (spl.ok())

  1223.     {

  1224.         p->addModel(modelVCO);

  1225.         p->addModel(modelVCO2);

  1226.         p->addModel(modelVCF);

  1227.         p->addModel(modelVCA_1);

  1228.         p->addModel(modelVCA);

  1229.         p->addModel(modelLFO);

  1230.         p->addModel(modelLFO2);

  1231.         p->addModel(modelDelay);

  1232.         p->addModel(modelADSR);

  1233.         p->addModel(modelMixer);

  1234.         p->addModel(modelVCMixer);

  1235.         p->addModel(model_8vert);

  1236.         p->addModel(modelUnity);

  1237.         p->addModel(modelMutes);

  1238.         p->addModel(modelPulses);

  1239.         p->addModel(modelScope);

  1240.         p->addModel(modelSEQ3);

  1241.         p->addModel(modelSequentialSwitch1);

  1242.         p->addModel(modelSequentialSwitch2);

  1243.         p->addModel(modelOctave);

  1244.         p->addModel(modelQuantizer);

  1245.         p->addModel(modelSplit);

  1246.         p->addModel(modelMerge);

  1247.         p->addModel(modelSum);

  1248.         p->addModel(modelViz);

  1249.         p->addModel(modelMidSide);

  1250.         p->addModel(modelNoise);

  1251.         p->addModel(modelRandom);

  1252. 

  1253.         // show all plugins, helping those familiar with v1 Rack modules

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

  1255.         {

  1256.             size_t i;

  1257.             json_t* v;

  1258.             json_array_foreach(modules, i, v)

  1259.             {

  1260.                 json_object_set(v, "hidden", json_false());

  1261.             }

  1262.         }

  1263.     }

  1264. }

  1265. 

  1266. static void initStatic__GlueTheGiant()

  1267. {

  1268.     Plugin* const p = new Plugin;

  1269.     pluginInstance__GlueTheGiant = p;

  1270. 

  1271.     const StaticPluginLoader spl(p, "GlueTheGiant");

  1272.     if (spl.ok())

  1273.     {

  1274.         p->addModel(modelGigBus);

  1275.         p->addModel(modelMiniBus);

  1276.         p->addModel(modelSchoolBus);

  1277.         p->addModel(modelMetroCityBus);

  1278.         p->addModel(modelBusDepot);

  1279.         p->addModel(modelBusRoute);

  1280.         p->addModel(modelRoad);

  1281.         p->addModel(modelEnterBus);

  1282.         p->addModel(modelExitBus);

  1283.     }

  1284. }

  1285. 

  1286. static void initStatic__GrandeModular()

  1287. {

  1288.     Plugin* const p = new Plugin;

  1289.     pluginInstance__GrandeModular = p;

  1290. 

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

  1292.     if (spl.ok())

  1293.     {

  1294.         p->addModel(modelClip);

  1295.         p->addModel(modelMergeSplit4);

  1296.         p->addModel(modelMicrotonalChords);

  1297.         p->addModel(modelMicrotonalNotes);

  1298.         p->addModel(modelNoteMT);

  1299.         p->addModel(modelPolyMergeResplit);

  1300.         p->addModel(modelQuant);

  1301.         p->addModel(modelQuantIntervals);

  1302.         p->addModel(modelQuantMT);

  1303.         p->addModel(modelSampleDelays);

  1304.         p->addModel(modelScale);

  1305.         p->addModel(modelTails);

  1306.         p->addModel(modelVarSampleDelays);

  1307.     }

  1308. }

  1309. 

  1310. static void initStatic__HetrickCV()

  1311. {

  1312.     Plugin* const p = new Plugin;

  1313.     pluginInstance__HetrickCV = p;

  1314. 

  1315.     const StaticPluginLoader spl(p, "HetrickCV");

  1316.     if (spl.ok())

  1317.     {

  1318. #define modelASR modelHetrickCVASR

  1319. #define modelBlankPanel modelHetrickCVBlankPanel

  1320. #define modelFlipFlop modelHetrickCVFlipFlop

  1321. #define modelMidSide modelHetrickCVMidSide

  1322. #define modelMinMax modelHetrickCVMinMax

  1323.         p->addModel(modelTwoToFour);

  1324.         p->addModel(modelAnalogToDigital);

  1325.         p->addModel(modelASR);

  1326.         p->addModel(modelBinaryGate);

  1327.         p->addModel(modelBinaryNoise);

  1328.         p->addModel(modelBitshift);

  1329.         p->addModel(modelBlankPanel);

  1330.         p->addModel(modelBoolean3);

  1331.         p->addModel(modelChaos1Op);

  1332.         p->addModel(modelChaos2Op);

  1333.         p->addModel(modelChaos3Op);

  1334.         p->addModel(modelChaoticAttractors);

  1335.         p->addModel(modelClockedNoise);

  1336.         p->addModel(modelComparator);

  1337.         p->addModel(modelContrast);

  1338.         p->addModel(modelCrackle);

  1339.         p->addModel(modelDataCompander);

  1340.         p->addModel(modelDelta);

  1341.         p->addModel(modelDigitalToAnalog);

  1342.         p->addModel(modelDust);

  1343.         p->addModel(modelExponent);

  1344.         p->addModel(modelFBSineChaos);

  1345.         p->addModel(modelFlipFlop);

  1346.         p->addModel(modelFlipPan);

  1347.         p->addModel(modelGateJunction);

  1348.         p->addModel(modelGingerbread);

  1349.         p->addModel(modelLogicCombine);

  1350.         p->addModel(modelMidSide);

  1351.         p->addModel(modelMinMax);

  1352.         p->addModel(modelRandomGates);

  1353.         p->addModel(modelRotator);

  1354.         p->addModel(modelRungler);

  1355.         p->addModel(modelScanner);

  1356.         p->addModel(modelWaveshape);

  1357.         p->addModel(modelXYToPolar);

  1358. #undef modelASR

  1359. #undef modelBlankPanel

  1360. #undef modelFlipFlop

  1361. #undef modelMidSide

  1362. #undef modelMinMax

  1363.     }

  1364. }

  1365. 

  1366. static void initStatic__ImpromptuModular()

  1367. {

  1368.     Plugin* const p = new Plugin;

  1369.     pluginInstance__ImpromptuModular = p;

  1370. 

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

  1372.     if (spl.ok())

  1373.     {

  1374.         p->addModel(modelAdaptiveQuantizer);

  1375.         p->addModel(modelBigButtonSeq);

  1376.         p->addModel(modelBigButtonSeq2);

  1377.         p->addModel(modelChordKey);

  1378.         p->addModel(modelChordKeyExpander);

  1379.         p->addModel(modelClocked);

  1380.         p->addModel(modelClockedExpander);

  1381.         p->addModel(modelClkd);

  1382.         p->addModel(modelCvPad);

  1383.         p->addModel(modelFoundry);

  1384.         p->addModel(modelFoundryExpander);

  1385.         p->addModel(modelFourView);

  1386.         p->addModel(modelGateSeq64);

  1387.         p->addModel(modelGateSeq64Expander);

  1388.         p->addModel(modelHotkey);

  1389.         p->addModel(modelPart);

  1390.         p->addModel(modelPhraseSeq16);

  1391.         p->addModel(modelPhraseSeq32);

  1392.         p->addModel(modelPhraseSeqExpander);

  1393.         p->addModel(modelProbKey);

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

  1395.         p->addModel(modelSemiModularSynth);

  1396.         p->addModel(modelTact);

  1397.         p->addModel(modelTact1);

  1398.         p->addModel(modelTactG);

  1399.         p->addModel(modelTwelveKey);

  1400.         p->addModel(modelWriteSeq32);

  1401.         p->addModel(modelWriteSeq64);

  1402.         p->addModel(modelBlankPanel);

  1403.     }

  1404. }

  1405. 

  1406. static void initStatic__JW()

  1407. {

  1408.     Plugin* const p = new Plugin;

  1409.     pluginInstance__JW = p;

  1410. 

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

  1412.     if (spl.ok())

  1413.     {

  1414. #define modelQuantizer modelJWQuantizer

  1415.         p->addModel(modelAdd5);

  1416.         p->addModel(modelBouncyBalls);

  1417.         p->addModel(modelCat);

  1418.         p->addModel(modelTree);

  1419.         p->addModel(modelFullScope);

  1420.         p->addModel(modelGridSeq);

  1421.         p->addModel(modelEightSeq);

  1422.         p->addModel(modelDivSeq);

  1423.         p->addModel(modelMinMax);

  1424.         p->addModel(modelNoteSeq);

  1425.         p->addModel(modelNoteSeqFu);

  1426.         p->addModel(modelNoteSeq16);

  1427.         p->addModel(modelTrigs);

  1428.         p->addModel(modelOnePattern);

  1429.         p->addModel(modelPatterns);

  1430.         p->addModel(modelQuantizer);

  1431.         p->addModel(modelSimpleClock);

  1432.         p->addModel(modelStr1ker);

  1433.         p->addModel(modelD1v1de);

  1434.         p->addModel(modelPres1t);

  1435.         p->addModel(modelThingThing);

  1436.         p->addModel(modelWavHead);

  1437.         p->addModel(modelXYPad);

  1438.         p->addModel(modelBlankPanel1hp);

  1439.         p->addModel(modelBlankPanelSmall);

  1440.         p->addModel(modelBlankPanelMedium);

  1441.         p->addModel(modelBlankPanelLarge);

  1442.         p->addModel(modelCoolBreeze);

  1443.         p->addModel(modelPete);

  1444. #undef modelQuantizer

  1445.     }

  1446. }

  1447. 

  1448. static void initStatic__MindMeld()

  1449. {

  1450.     Plugin* const p = new Plugin;

  1451.     pluginInstance__MindMeld = p;

  1452. 

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

  1454.     if (spl.ok())

  1455.     {

  1456.         p->addModel(modelMixMasterJr);

  1457.         p->addModel(modelAuxExpanderJr);

  1458.         p->addModel(modelMixMaster);

  1459.         p->addModel(modelAuxExpander);

  1460.         p->addModel(modelMeld);

  1461.         p->addModel(modelUnmeld);

  1462.         p->addModel(modelEqMaster);

  1463.         p->addModel(modelEqExpander);

  1464.         p->addModel(modelBassMaster);

  1465.         p->addModel(modelBassMasterJr);

  1466.         p->addModel(modelShapeMaster);

  1467.     }

  1468. }

  1469. 

  1470. static void initStatic__Mog()

  1471. {

  1472.     Plugin* const p = new Plugin;

  1473.     pluginInstance__Mog = p;

  1474. 

  1475.     const StaticPluginLoader spl(p, "Mog");

  1476.     if (spl.ok())

  1477.     {

  1478.         p->addModel(modelNetwork);

  1479.         p->addModel(modelNexus);

  1480.     }

  1481. }

  1482. 

  1483. static void initStatic__mscHack()

  1484. {

  1485.     Plugin* const p = new Plugin;

  1486.     pluginInstance__mscHack = p;

  1487. 

  1488.     const StaticPluginLoader spl(p, "mscHack");

  1489.     if (spl.ok())

  1490.     {

  1491.         p->addModel(modelCompressor);

  1492.         p->addModel(modelSynthDrums);

  1493.         p->addModel(modelSEQ_6x32x16);

  1494.         p->addModel(modelMasterClockx4);

  1495.         //p->addModel(modelMasterClockx8);

  1496.         p->addModel(modelSEQ_Envelope_8);

  1497.         p->addModel(modelSeq_Triad2);

  1498.         p->addModel(modelARP700);

  1499.         p->addModel(modelMix_4_0_4);

  1500.         p->addModel(modelMix_9_3_4);

  1501.         p->addModel(modelMix_16_4_4);

  1502.         p->addModel(modelMix_24_4_4);

  1503.         p->addModel(modelASAF8);

  1504.         p->addModel(modelPingPong);

  1505.         p->addModel(modelStepDelay);

  1506.         p->addModel(modelOsc_3Ch);

  1507.         p->addModel(modelDronez);

  1508.         p->addModel(modelMorze);

  1509.         p->addModel(modelWindz);

  1510.         p->addModel(modelLorenz);

  1511.         p->addModel(modelAlienz);

  1512.         p->addModel(modelOSC_WaveMorph_3);

  1513.         p->addModel(modelMaude_221);

  1514.     }

  1515. }

  1516. 

  1517. static void initStatic__rackwindows()

  1518. {

  1519.     Plugin* const p = new Plugin;

  1520.     pluginInstance__rackwindows = p;

  1521. 

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

  1523.     if (spl.ok())

  1524.     {

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

  1526.         p->addModel(modelBitshiftgain);

  1527.         p->addModel(modelCapacitor);

  1528.         p->addModel(modelCapacitor_stereo);

  1529.         p->addModel(modelChorus);

  1530.         p->addModel(modelConsole);

  1531.         p->addModel(modelConsole_mm);

  1532.         p->addModel(modelDistance);

  1533.         p->addModel(modelGolem);

  1534.         p->addModel(modelHolt);

  1535.         p->addModel(modelHombre);

  1536.         p->addModel(modelInterstage);

  1537.         p->addModel(modelMonitoring);

  1538.         p->addModel(modelMv);

  1539.         p->addModel(modelRasp);

  1540.         p->addModel(modelReseq);

  1541.         p->addModel(modelTape);

  1542.         p->addModel(modelTremolo);

  1543.         p->addModel(modelVibrato);

  1544.     }

  1545. }

  1546. 

  1547. static void initStatic__repelzen()

  1548. {

  1549.     Plugin* const p = new Plugin;

  1550.     pluginInstance__repelzen = p;

  1551. 

  1552.     const StaticPluginLoader spl(p, "repelzen");

  1553.     if (spl.ok())

  1554.     {

  1555. #define modelBlank modelrepelzenBlank

  1556. #define modelMixer modelrepelzenMixer

  1557. #define modelWerner modelrepelzenWerner

  1558.         p->addModel(modelBlank);

  1559.         p->addModel(modelBurst);

  1560.         p->addModel(modelFolder);

  1561.         p->addModel(modelErwin);

  1562.         p->addModel(modelWerner);

  1563.         p->addModel(modelMixer);

  1564. #undef modelBlank

  1565. #undef modelMixer

  1566. #undef modelWerner

  1567.     }

  1568. }

  1569. 

  1570. static void initStatic__sonusmodular()

  1571. {

  1572.     Plugin* const p = new Plugin;

  1573.     pluginInstance__sonusmodular = p;

  1574. 

  1575.     const StaticPluginLoader spl(p, "sonusmodular");

  1576.     if (spl.ok())

  1577.     {

  1578.         p->addModel(modelAddiction);

  1579.         p->addModel(modelBitter);

  1580.         p->addModel(modelBymidside);

  1581.         p->addModel(modelCampione);

  1582.         p->addModel(modelChainsaw);

  1583.         p->addModel(modelCtrl);

  1584.         p->addModel(modelDeathcrush);

  1585.         p->addModel(modelFraction);

  1586.         p->addModel(modelHarmony);

  1587.         p->addModel(modelLadrone);

  1588.         p->addModel(modelLuppolo);

  1589.         p->addModel(modelLuppolo3);

  1590.         p->addModel(modelMicromacro);

  1591.         p->addModel(modelMrcheb);

  1592.         p->addModel(modelMultimulti);

  1593.         p->addModel(modelNeurosc);

  1594.         p->addModel(modelOktagon);

  1595.         p->addModel(modelOsculum);

  1596.         p->addModel(modelParamath);

  1597.         p->addModel(modelPiconoise);

  1598.         p->addModel(modelPith);

  1599.         p->addModel(modelPusher);

  1600.         p->addModel(modelRingo);

  1601.         p->addModel(modelScramblase);

  1602.         p->addModel(modelTropicana);

  1603.         p->addModel(modelTwoff);

  1604.         p->addModel(modelYabp);

  1605.     }

  1606. }

  1607. 

  1608. static void initStatic__ValleyAudio()

  1609. {

  1610.     Plugin* const p = new Plugin;

  1611.     pluginInstance__ValleyAudio = p;

  1612. 

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

  1614.     if (spl.ok())

  1615.     {

  1616.         p->addModel(modelTopograph);

  1617.         p->addModel(modelUGraph);

  1618.         p->addModel(modelDexter);

  1619.         p->addModel(modelPlateau);

  1620.         p->addModel(modelInterzone);

  1621.         p->addModel(modelAmalgam);

  1622.         p->addModel(modelFeline);

  1623.         p->addModel(modelTerrorform);

  1624.     }

  1625. }

  1626. 

  1627. static void initStatic__ZetaCarinaeModules()

  1628. {

  1629.     Plugin* p = new Plugin;

  1630.     pluginInstance__ZetaCarinaeModules = p;

  1631. 

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

  1633.     if (spl.ok())

  1634.     {

  1635.         p->addModel(modelBrownianBridge);

  1636.         p->addModel(modelOrnsteinUhlenbeck);

  1637.         p->addModel(modelIOU);

  1638.         p->addModel(modelWarbler);

  1639.         p->addModel(modelRosenchance);

  1640.         p->addModel(modelGuildensTurn);

  1641.         p->addModel(modelRosslerRustler);

  1642.         p->addModel(modelFirefly);

  1643.     }

  1644. }

  1645. 

  1646. static void initStatic__ZZC()

  1647. {

  1648.     Plugin* p = new Plugin;

  1649.     pluginInstance__ZZC = p;

  1650. 

  1651.     const StaticPluginLoader spl(p, "ZZC");

  1652.     if (spl.ok())

  1653.     {

  1654. #define modelClock modelZZCClock

  1655.         p->addModel(modelClock);

  1656.         p->addModel(modelDivider);

  1657.         p->addModel(modelFN3);

  1658.         p->addModel(modelSCVCA);

  1659.         p->addModel(modelSH8);

  1660.         p->addModel(modelSRC);

  1661.         p->addModel(modelDiv);

  1662.         p->addModel(modelDivExp);

  1663.         p->addModel(modelPolygate);

  1664. #undef modelClock

  1665.     }

  1666. }

  1667. #endif // NOPLUGINS

  1668. 

  1669. void initStaticPlugins()

  1670. {

  1671.     initStatic__Core();

  1672.     initStatic__Cardinal();

  1673. #ifndef NOPLUGINS

  1674.     initStatic__AmalgamatedHarmonics();

  1675.     initStatic__AnimatedCircuits();

  1676.     initStatic__Aria();

  1677.     initStatic__AS();

  1678.     initStatic__Atelier();

  1679.     initStatic__AudibleInstruments();

  1680.     initStatic__Bacon();

  1681.     initStatic__Befaco();

  1682.     initStatic__Bidoo();

  1683.     initStatic__BogaudioModules();

  1684.     initStatic__cf();

  1685.     initStatic__ChowDSP();

  1686.     initStatic__DrumKit();

  1687.     initStatic__ESeries();

  1688.     initStatic__FehlerFabrik();

  1689.     initStatic__Fundamental();

  1690.     initStatic__GlueTheGiant();

  1691.     initStatic__GrandeModular();

  1692.     initStatic__HetrickCV();

  1693.     initStatic__ImpromptuModular();

  1694.     initStatic__JW();

  1695.     initStatic__MindMeld();

  1696.     initStatic__Mog();

  1697.     initStatic__mscHack();

  1698.     initStatic__rackwindows();

  1699.     initStatic__repelzen();

  1700.     initStatic__sonusmodular();

  1701.     initStatic__ValleyAudio();

  1702.     initStatic__ZetaCarinaeModules();

  1703.     initStatic__ZZC();

  1704. #endif // NOPLUGINS

  1705. }

  1706. 

  1707. void destroyStaticPlugins()

  1708. {

  1709.     for (Plugin* p : plugins)

  1710.         delete p;

  1711.     plugins.clear();

  1712. }

  1713. 

  1714. }

  1715. }