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

2099 lines
57KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021-2022 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. // 21kHz

  28. #include "21kHz/src/21kHz.hpp"

  29. 

  30. // 8Mode

  31. #include "8Mode/src/8mode.hpp"

  32. 

  33. // AmalgamatedHarmonics

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

  35. 

  36. // AnimatedCircuits

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

  38. 

  39. // Aria

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

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

  42. */

  43. #define modelBlank modelAriaBlank

  44. extern Model* modelSplort;

  45. extern Model* modelSmerge;

  46. extern Model* modelSpleet;

  47. extern Model* modelSwerge;

  48. extern Model* modelSplirge;

  49. // extern Model* modelSrot;

  50. extern Model* modelQqqq;

  51. extern Model* modelQuack;

  52. extern Model* modelQ;

  53. extern Model* modelQuale;

  54. extern Model* modelDarius;

  55. extern Model* modelSolomon4;

  56. extern Model* modelSolomon8;

  57. extern Model* modelSolomon16;

  58. extern Model* modelPsychopump;

  59. extern Model* modelPokies4;

  60. extern Model* modelGrabby;

  61. extern Model* modelRotatoes4;

  62. extern Model* modelUndular;

  63. extern Model* modelBlank;

  64. #undef modelBlank

  65. 

  66. // AudibleInstruments

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

  68. 

  69. // Autinn

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

  71. // #include "Autinn/src/Autinn.hpp"

  72. */

  73. #define modelChord modelAutinnChord

  74. #define modelVibrato modelAutinnVibrato

  75. extern Model* modelJette;

  76. extern Model* modelFlora;

  77. extern Model* modelOxcart;

  78. extern Model* modelDeadband;

  79. extern Model* modelDigi;

  80. extern Model* modelFlopper;

  81. extern Model* modelAmp;

  82. extern Model* modelDC;

  83. extern Model* modelSjip;

  84. extern Model* modelBass;

  85. extern Model* modelSquare;

  86. extern Model* modelSaw;

  87. extern Model* modelBoomerang;

  88. extern Model* modelVibrato;

  89. extern Model* modelVectorDriver; //deprecated

  90. extern Model* modelCVConverter;

  91. extern Model* modelZod;

  92. extern Model* modelTriBand;

  93. extern Model* modelMixer6;

  94. extern Model* modelNon;

  95. extern Model* modelFil;

  96. extern Model* modelNap;

  97. extern Model* modelMelody;

  98. extern Model* modelChord;

  99. #undef modelChord

  100. #undef modelVibrato

  101. 

  102. // Axioma

  103. #include "Axioma/src/plugin.hpp"

  104. 

  105. // BaconPlugs

  106. #define INCLUDE_COMPONENTS_HPP

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

  108. #undef INCLUDE_COMPONENTS_HPP

  109. #undef SCREW_WIDTH

  110. #undef RACK_HEIGHT

  111. 

  112. // Befaco

  113. #define modelADSR modelBefacoADSR

  114. #define modelMixer modelBefacoMixer

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

  116. #undef modelADSR

  117. #undef modelMixer

  118. 

  119. // Bidoo

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

  121. 

  122. // BogaudioModules - force dark skin as default

  123. #include <mutex>

  124. #include <string>

  125. #include <unordered_map>

  126. #include <unordered_set>

  127. #include <vector>

  128. #define private public

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

  130. #undef private

  131. 

  132. // BogaudioModules

  133. #define modelADSR modelBogaudioADSR

  134. #define modelLFO modelBogaudioLFO

  135. #define modelNoise modelBogaudioNoise

  136. #define modelVCA modelBogaudioVCA

  137. #define modelVCF modelBogaudioVCF

  138. #define modelVCO modelBogaudioVCO

  139. extern Model* modelVCO;

  140. extern Model* modelLVCO;

  141. extern Model* modelSine;

  142. extern Model* modelPulse;

  143. extern Model* modelXCO;

  144. extern Model* modelAdditator;

  145. extern Model* modelFMOp;

  146. extern Model* modelChirp;

  147. extern Model* modelLFO;

  148. extern Model* modelLLFO;

  149. extern Model* modelFourFO;

  150. extern Model* modelEightFO;

  151. extern Model* modelVCF;

  152. extern Model* modelLVCF;

  153. extern Model* modelFFB;

  154. extern Model* modelEQ;

  155. extern Model* modelEQS;

  156. extern Model* modelLPG;

  157. extern Model* modelLLPG;

  158. extern Model* modelMegaGate;

  159. extern Model* modelPEQ;

  160. extern Model* modelPEQ6;

  161. extern Model* modelPEQ6XF;

  162. extern Model* modelPEQ14;

  163. extern Model* modelPEQ14XF;

  164. extern Model* modelDADSRH;

  165. extern Model* modelDADSRHPlus;

  166. extern Model* modelShaper;

  167. extern Model* modelShaperPlus;

  168. extern Model* modelAD;

  169. extern Model* modelASR;

  170. extern Model* modelADSR;

  171. extern Model* modelVish;

  172. extern Model* modelFollow;

  173. extern Model* modelDGate;

  174. extern Model* modelRGate;

  175. extern Model* modelEdge;

  176. extern Model* modelNoise;

  177. extern Model* modelSampleHold;

  178. extern Model* modelWalk2;

  179. extern Model* modelWalk;

  180. extern Model* modelMix8;

  181. extern Model* modelMix8x;

  182. extern Model* modelMix4;

  183. extern Model* modelMix4x;

  184. extern Model* modelMix2;

  185. extern Model* modelMix1;

  186. extern Model* modelVCM;

  187. extern Model* modelMute8;

  188. extern Model* modelPan;

  189. extern Model* modelXFade;

  190. extern Model* modelVCA;

  191. extern Model* modelVCAmp;

  192. extern Model* modelVelo;

  193. extern Model* modelUMix;

  194. extern Model* modelMumix;

  195. extern Model* modelMatrix81;

  196. extern Model* modelMatrix18;

  197. extern Model* modelMatrix44;

  198. extern Model* modelMatrix44Cvm;

  199. extern Model* modelMatrix88;

  200. extern Model* modelMatrix88Cv;

  201. extern Model* modelMatrix88M;

  202. extern Model* modelSwitch81;

  203. extern Model* modelSwitch18;

  204. extern Model* modelSwitch44;

  205. extern Model* modelSwitch88;

  206. extern Model* modelSwitch1616;

  207. extern Model* modelAMRM;

  208. extern Model* modelPressor;

  209. extern Model* modelClpr;

  210. extern Model* modelLmtr;

  211. extern Model* modelNsgt;

  212. extern Model* modelCmpDist;

  213. extern Model* modelOneEight;

  214. extern Model* modelEightOne;

  215. extern Model* modelAddrSeq;

  216. extern Model* modelAddrSeqX;

  217. extern Model* modelPgmr;

  218. extern Model* modelPgmrX;

  219. extern Model* modelVU;

  220. extern Model* modelAnalyzer;

  221. extern Model* modelAnalyzerXL;

  222. extern Model* modelRanalyzer;

  223. extern Model* modelDetune;

  224. extern Model* modelStack;

  225. extern Model* modelReftone;

  226. extern Model* modelMono;

  227. extern Model* modelArp;

  228. extern Model* modelAssign;

  229. extern Model* modelUnison;

  230. extern Model* modelPolyCon8;

  231. extern Model* modelPolyCon16;

  232. extern Model* modelPolyOff8;

  233. extern Model* modelPolyOff16;

  234. extern Model* modelPolyMult;

  235. extern Model* modelBool;

  236. extern Model* modelCmp;

  237. extern Model* modelCVD;

  238. extern Model* modelFlipFlop;

  239. extern Model* modelInv;

  240. extern Model* modelManual;

  241. extern Model* modelFourMan;

  242. extern Model* modelMult;

  243. extern Model* modelOffset;

  244. extern Model* modelSlew;

  245. extern Model* modelSums;

  246. extern Model* modelSwitch;

  247. extern Model* modelLgsw;

  248. extern Model* modelBlank3;

  249. extern Model* modelBlank6;

  250. #ifdef EXPERIMENTAL

  251. extern Model* modelLag;

  252. extern Model* modelPEQ14XR;

  253. extern Model* modelPEQ14XV;

  254. #endif

  255. #ifdef TEST

  256. extern Model* modelTest;

  257. extern Model* modelTest2;

  258. extern Model* modelTestExpanderBase;

  259. extern Model* modelTestExpanderExtension;

  260. extern Model* modelTestGl;

  261. extern Model* modelTestVCF;

  262. #endif

  263. #undef modelADSR

  264. #undef modelLFO

  265. #undef modelNoise

  266. #undef modelVCA

  267. #undef modelVCF

  268. #undef modelVCO

  269. 

  270. // cf

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

  272. 

  273. // ChowDSP

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

  275. #define init initChowDSP

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

  277. #undef init

  278. 

  279. // DrumKit

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

  281. void setupSamples();

  282. 

  283. // ESeries

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

  285. 

  286. // ExpertSleepers-Encoders

  287. #include "ExpertSleepers-Encoders/src/Encoders.hpp"

  288. 

  289. // Extratone

  290. #include "Extratone/src/plugin.hpp"

  291. 

  292. // FehlerFabrik

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

  294. 

  295. // Fundamental

  296. #ifdef WITH_FUNDAMENTAL

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

  298. #endif

  299. 

  300. // GlueTheGiant

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

  302. bool audition_mixer = false;

  303. bool audition_depot = false;

  304. int gtg_default_theme = 1;

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

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

  307. 

  308. // GrandeModular

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

  310. 

  311. // HetrickCV

  312. #define modelASR modelHetrickCVASR

  313. #define modelBlankPanel modelHetrickCVBlankPanel

  314. #define modelFlipFlop modelHetrickCVFlipFlop

  315. #define modelMidSide modelHetrickCVMidSide

  316. #define modelMinMax modelHetrickCVMinMax

  317. extern Model* modelTwoToFour;

  318. extern Model* modelAnalogToDigital;

  319. extern Model* modelASR;

  320. extern Model* modelBinaryGate;

  321. extern Model* modelBinaryNoise;

  322. extern Model* modelBitshift;

  323. extern Model* modelBlankPanel;

  324. extern Model* modelBoolean3;

  325. extern Model* modelChaos1Op;

  326. extern Model* modelChaos2Op;

  327. extern Model* modelChaos3Op;

  328. extern Model* modelChaoticAttractors;

  329. extern Model* modelClockedNoise;

  330. extern Model* modelComparator;

  331. extern Model* modelContrast;

  332. extern Model* modelCrackle;

  333. extern Model* modelDataCompander;

  334. extern Model* modelDelta;

  335. extern Model* modelDigitalToAnalog;

  336. extern Model* modelDust;

  337. extern Model* modelExponent;

  338. extern Model* modelFBSineChaos;

  339. extern Model* modelFlipFlop;

  340. extern Model* modelFlipPan;

  341. extern Model* modelGateJunction;

  342. extern Model* modelGingerbread;

  343. extern Model* modelLogicCombine;

  344. extern Model* modelMidSide;

  345. extern Model* modelMinMax;

  346. extern Model* modelRandomGates;

  347. extern Model* modelRotator;

  348. extern Model* modelRungler;

  349. extern Model* modelScanner;

  350. extern Model* modelWaveshape;

  351. extern Model* modelXYToPolar;

  352. #undef modelASR

  353. #undef modelBlankPanel

  354. #undef modelFlipFlop

  355. #undef modelMidSide

  356. #undef modelMinMax

  357. 

  358. // ImpromptuModular

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

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

  361. */

  362. extern Model* modelAdaptiveQuantizer;

  363. extern Model* modelBigButtonSeq;

  364. extern Model* modelBigButtonSeq2;

  365. extern Model* modelChordKey;

  366. extern Model* modelChordKeyExpander;

  367. extern Model* modelClocked;

  368. extern Model* modelClockedExpander;

  369. extern Model* modelClkd;

  370. extern Model* modelCvPad;

  371. extern Model* modelFoundry;

  372. extern Model* modelFoundryExpander;

  373. extern Model* modelFourView;

  374. extern Model* modelGateSeq64;

  375. extern Model* modelGateSeq64Expander;

  376. extern Model* modelHotkey;

  377. extern Model* modelPart;

  378. extern Model* modelPhraseSeq16;

  379. extern Model* modelPhraseSeq32;

  380. extern Model* modelPhraseSeqExpander;

  381. extern Model* modelProbKey;

  382. // extern Model* modelProbKeyExpander;

  383. extern Model* modelSemiModularSynth;

  384. extern Model* modelTact;

  385. extern Model* modelTact1;

  386. extern Model* modelTactG;

  387. extern Model* modelTwelveKey;

  388. extern Model* modelWriteSeq32;

  389. extern Model* modelWriteSeq64;

  390. extern Model* modelBlankPanel;

  391. 

  392. // ihtsyn

  393. #include "ihtsyn/src/plugin.hpp"

  394. 

  395. // JW-Modules

  396. #define modelQuantizer modelJWQuantizer

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

  398. #undef modelQuantizer

  399. 

  400. // LifeFormModular

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

  402. // #include "LifeFormModular/src/plugin.hpp"

  403. */

  404. extern Model* modelTimeDiktat;

  405. extern Model* modelSequenceModeler;

  406. extern Model* modelPitchDiktat;

  407. extern Model* modelPitchIntegrator;

  408. extern Model* modelBurstIntegrator;

  409. extern Model* modelQuadModulator;

  410. extern Model* modelImpulseControl;

  411. extern Model* modelQuadSteppedOffset;

  412. extern Model* modelPercussiveVibration;

  413. extern Model* modelQuadUtility;

  414. extern Model* modelAdditiveVibration;

  415. extern Model* modelComplexOsc;

  416. extern Model* modelDriftgen;

  417. 

  418. // LittleUtils

  419. #include "LittleUtils/src/plugin.hpp"

  420. 

  421. // LomasModules

  422. #include "LomasModules/src/plugin.hpp"

  423. #undef DR_WAV_IMPLEMENTATION

  424. 

  425. // LyraeModules

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

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

  428. */

  429. #define modelDelta modelLyraeDelta

  430. extern Model* modelSulafat;

  431. extern Model* modelGamma;

  432. extern Model* modelDelta;

  433. extern Model* modelVega;

  434. extern Model* modelBD383238;

  435. extern Model* modelZeta;

  436. #undef modelDelta

  437. 

  438. // MindMeldModular

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

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

  441. */

  442. extern Model* modelMixMasterJr;

  443. extern Model* modelAuxExpanderJr;

  444. extern Model* modelMixMaster;

  445. extern Model* modelAuxExpander;

  446. extern Model* modelMeld;

  447. extern Model* modelUnmeld;

  448. extern Model* modelMSMelder;

  449. extern Model* modelEqMaster;

  450. extern Model* modelEqExpander;

  451. extern Model* modelBassMaster;

  452. extern Model* modelBassMasterJr;

  453. extern Model* modelShapeMaster;

  454. 

  455. // MockbaModular

  456. #define modelBlank modelMockbaModularBlank

  457. #define modelComparator modelMockbaModularComparator

  458. #include "MockbaModular/src/plugin.hpp"

  459. #undef modelBlank

  460. #undef modelComparator

  461. #include "MockbaModular/src/MockbaModular.hpp"

  462. #undef min

  463. #define saveBack ignoreMockbaModular1

  464. #define loadBack ignoreMockbaModular2

  465. #include "MockbaModular/src/MockbaModular.cpp"

  466. #undef saveBack

  467. #undef loadBack

  468. std::string loadBack(int) { return "res/Empty_gray.svg"; }

  469. 

  470. // Mog

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

  472. 

  473. // mscHack

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

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

  476. */

  477. extern Model* modelCompressor;

  478. extern Model* modelSynthDrums;

  479. extern Model* modelSEQ_6x32x16;

  480. extern Model* modelMasterClockx8;

  481. extern Model* modelMasterClockx4;

  482. extern Model* modelSEQ_Envelope_8;

  483. extern Model* modelSeq_Triad2;

  484. extern Model* modelARP700;

  485. extern Model* modelMix_24_4_4;

  486. extern Model* modelMix_16_4_4;

  487. extern Model* modelMix_9_3_4;

  488. extern Model* modelMix_4_0_4;

  489. extern Model* modelASAF8;

  490. extern Model* modelPingPong;

  491. extern Model* modelStepDelay;

  492. extern Model* modelOsc_3Ch;

  493. extern Model* modelDronez;

  494. extern Model* modelMorze;

  495. extern Model* modelWindz;

  496. extern Model* modelLorenz;

  497. extern Model* modelAlienz;

  498. extern Model* modelOSC_WaveMorph_3;

  499. extern Model* modelMaude_221;

  500. 

  501. // Prism

  502. # include "Prism/src/plugin.hpp"

  503. 

  504. // rackwindows

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

  506. 

  507. // repelzen

  508. #define modelBlank modelrepelzenBlank

  509. #define modelMixer modelrepelzenMixer

  510. #define modelWerner modelrepelzenWerner

  511. #define tanh_pade repelzentanh_pade

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

  513. #undef modelBlank

  514. #undef modelMixer

  515. #undef modelWerner

  516. #undef tanh_pade

  517. 

  518. // sonusmodular

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

  520. 

  521. // substation

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

  523. // "substation-opensource/src/_plugin.hpp"

  524. */

  525. namespace slime {

  526. namespace plugin {

  527. namespace substation {

  528. extern Model* modelClock;

  529. extern Model* modelPolySequencer;

  530. extern Model* modelSubOscillator;

  531. extern Model* modelMixer;

  532. extern Model* modelFilter;

  533. extern Model* modelEnvelopes;

  534. extern Model* modelQuantizer;

  535. extern Model* modelVCA;

  536. extern Model* modelBlank4;

  537. extern Model* modelBlank7;

  538. extern Model* modelFilterPlus;

  539. }}}

  540. 

  541. // ValleyAudio

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

  543. 

  544. // ZetaCarinaeModules

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

  546. 

  547. // ZZC

  548. #define DISPLAYS_H

  549. #define ZZC_SHARED_H

  550. #define ZZC_WIDGETS_H

  551. #define modelClock modelZZCClock

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

  553. #undef modelClock

  554. 

  555. #endif // NOPLUGINS

  556. 

  557. // known terminal modules

  558. std::vector<Model*> hostTerminalModels;

  559. 

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

  561. int loadConsoleType() { return 0; }

  562. int loadDirectOutMode() { return 0; }

  563. void saveConsoleType(int) {}

  564. void saveDarkAsDefault(bool) {}

  565. void saveDirectOutMode(bool) {}

  566. void saveHighQualityAsDefault(bool) {}

  567. 

  568. // plugin instances

  569. Plugin* pluginInstance__Cardinal;

  570. #ifndef NOPLUGINS

  571. Plugin* pluginInstance__21kHz;

  572. Plugin* pluginInstance__8Mode;

  573. Plugin* pluginInstance__AmalgamatedHarmonics;

  574. Plugin* pluginInstance__AnimatedCircuits;

  575. Plugin* pluginInstance__Aria;

  576. Plugin* pluginInstance__AudibleInstruments;

  577. extern Plugin* pluginInstance__Autinn;

  578. Plugin* pluginInstance__Axioma;

  579. Plugin* pluginInstance__Bacon;

  580. Plugin* pluginInstance__Befaco;

  581. Plugin* pluginInstance__Bidoo;

  582. Plugin* pluginInstance__BogaudioModules;

  583. Plugin* pluginInstance__cf;

  584. Plugin* pluginInstance__ChowDSP;

  585. extern Plugin* pluginInstance__DrumKit;

  586. Plugin* pluginInstance__ESeries;

  587. Plugin* pluginInstance__ExpertSleepersEncoders;

  588. Plugin* pluginInstance__Extratone;

  589. Plugin* pluginInstance__FehlerFabrik;

  590. #ifdef WITH_FUNDAMENTAL

  591. Plugin* pluginInstance__Fundamental;

  592. #endif

  593. Plugin* pluginInstance__GrandeModular;

  594. Plugin* pluginInstance__GlueTheGiant;

  595. Plugin* pluginInstance__HetrickCV;

  596. extern Plugin* pluginInstance__ImpromptuModular;

  597. Plugin* pluginInstance__ihtsyn;

  598. Plugin* pluginInstance__JW;

  599. Plugin* pluginInstance__LifeFormModular;

  600. Plugin* pluginInstance__LittleUtils;

  601. Plugin* pluginInstance__Lomas;

  602. Plugin* pluginInstance__Lyrae;

  603. extern Plugin* pluginInstance__MindMeld;

  604. Plugin* pluginInstance__MockbaModular;

  605. Plugin* pluginInstance__Mog;

  606. extern Plugin* pluginInstance__mscHack;

  607. Plugin* pluginInstance__Prism;

  608. Plugin* pluginInstance__rackwindows;

  609. Plugin* pluginInstance__repelzen;

  610. Plugin* pluginInstance__sonusmodular;

  611. Plugin* pluginInstance__substation;

  612. Plugin* pluginInstance__ValleyAudio;

  613. Plugin* pluginInstance__ZetaCarinaeModules;

  614. Plugin* pluginInstance__ZZC;

  615. #endif // NOPLUGINS

  616. 

  617. namespace rack {

  618. 

  619. namespace asset {

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

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

  622. }

  623. 

  624. namespace plugin {

  625. 

  626. struct StaticPluginLoader {

  627.     Plugin* const plugin;

  628.     FILE* file;

  629.     json_t* rootJ;

  630. 

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

  632.         : plugin(p),

  633.           file(nullptr),

  634.           rootJ(nullptr)

  635.     {

  636. #ifdef DEBUG

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

  638. #endif

  639. 

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

  641. 

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

  643. 

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

  645.         {

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

  647.             return;

  648.         }

  649. 

  650.         json_error_t error;

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

  652.         {

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

  654.             return;

  655.         }

  656. 

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

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

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

  660.         json_decref(version);

  661.     }

  662. 

  663.     ~StaticPluginLoader()

  664.     {

  665.         if (rootJ != nullptr)

  666.         {

  667.             plugin->fromJson(rootJ);

  668.             json_decref(rootJ);

  669.             plugins.push_back(plugin);

  670.         }

  671. 

  672.         if (file != nullptr)

  673.             std::fclose(file);

  674.     }

  675. 

  676.     bool ok() const noexcept

  677.     {

  678.         return rootJ != nullptr;

  679.     }

  680. 

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

  682.     {

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

  684.         DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);

  685. 

  686.         size_t i;

  687.         json_t* v;

  688.         json_array_foreach(modules, i, v)

  689.         {

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

  691.             {

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

  693.                 {

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

  695.                     {

  696.                         json_array_remove(modules, i);

  697.                         break;

  698.                     }

  699.                 }

  700.             }

  701.         }

  702.     }

  703. };

  704. 

  705. static void initStatic__Cardinal()

  706. {

  707.     Plugin* const p = new Plugin;

  708.     pluginInstance__Cardinal = p;

  709. 

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

  711.     if (spl.ok())

  712.     {

  713.         p->addModel(modelCardinalBlank);

  714.         p->addModel(modelExpanderInputMIDI);

  715.         p->addModel(modelExpanderOutputMIDI);

  716.         p->addModel(modelGlBars);

  717.         p->addModel(modelHostAudio2);

  718.         p->addModel(modelHostAudio8);

  719.         p->addModel(modelHostCV);

  720.         p->addModel(modelHostMIDI);

  721.         p->addModel(modelHostMIDICC);

  722.         p->addModel(modelHostMIDIGate);

  723.         p->addModel(modelHostMIDIMap);

  724.         p->addModel(modelHostParameters);

  725.         p->addModel(modelHostTime);

  726.         p->addModel(modelTextEditor);

  727.        #ifndef STATIC_BUILD

  728.         p->addModel(modelAudioFile);

  729.         p->addModel(modelCarla);

  730.         p->addModel(modelIldaeil);

  731.        #else

  732.         spl.removeModule("AudioFile");

  733.         spl.removeModule("Carla");

  734.         spl.removeModule("Ildaeil");

  735.        #endif

  736.        #if defined(HAVE_X11) && !defined(HEADLESS) && !defined(STATIC_BUILD)

  737.         p->addModel(modelMPV);

  738.        #else

  739.         spl.removeModule("MPV");

  740.        #endif

  741. 

  742.         hostTerminalModels = {

  743.             modelHostAudio2,

  744.             modelHostAudio8,

  745.             modelHostCV,

  746.             modelHostMIDI,

  747.             modelHostMIDICC,

  748.             modelHostMIDIGate,

  749.             modelHostMIDIMap,

  750.             modelHostParameters,

  751.             modelHostTime,

  752.         };

  753.     }

  754. }

  755. 

  756. #ifndef NOPLUGINS

  757. static void initStatic__21kHz()

  758. {

  759.     Plugin* const p = new Plugin;

  760.     pluginInstance__21kHz = p;

  761. 

  762.     const StaticPluginLoader spl(p, "21kHz");

  763.     if (spl.ok())

  764.     {

  765.         p->addModel(modelPalmLoop);

  766.         p->addModel(modelD_Inf);

  767.         p->addModel(modelTachyonEntangler);

  768.     }

  769. }

  770. 

  771. static void initStatic__8Mode()

  772. {

  773.     Plugin* const p = new Plugin;

  774.     pluginInstance__8Mode = p;

  775. 

  776.     const StaticPluginLoader spl(p, "8Mode");

  777.     if (spl.ok())

  778.     {

  779.         p->addModel(modelsoftSN);

  780.     }

  781. }

  782. 

  783. static void initStatic__AmalgamatedHarmonics()

  784. {

  785.     Plugin* const p = new Plugin;

  786.     pluginInstance__AmalgamatedHarmonics = p;

  787. 

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

  789.     if (spl.ok())

  790.     {

  791.         p->addModel(modelArp31);

  792.         p->addModel(modelArp32);

  793.         p->addModel(modelBombe);

  794.         p->addModel(modelChord);

  795.         p->addModel(modelCircle);

  796.         p->addModel(modelGalaxy);

  797.         p->addModel(modelGenerative);

  798.         p->addModel(modelImp);

  799.         p->addModel(modelImperfect2);

  800.         p->addModel(modelProgress2);

  801.         p->addModel(modelRuckus);

  802.         p->addModel(modelScaleQuantizer2);

  803.         p->addModel(modelSLN);

  804.         p->addModel(modelMuxDeMux);

  805.         p->addModel(modelPolyProbe);

  806.         p->addModel(modelPolyScope);

  807.         p->addModel(modelPolyUtils);

  808.         p->addModel(modelPolyVolt);

  809.         p->addModel(modelScaleQuantizer);

  810.         p->addModel(modelArpeggiator2);

  811.         p->addModel(modelProgress);

  812.     }

  813. }

  814. 

  815. static void initStatic__AnimatedCircuits()

  816. {

  817.     Plugin* const p = new Plugin;

  818.     pluginInstance__AnimatedCircuits = p;

  819. 

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

  821.     if (spl.ok())

  822.     {

  823.         p->addModel(model_AC_Folding);

  824.         p->addModel(model_AC_LFold);

  825.     }

  826. }

  827. 

  828. static void initStatic__Aria()

  829. {

  830.     Plugin* const p = new Plugin;

  831.     pluginInstance__Aria = p;

  832. 

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

  834.     if (spl.ok())

  835.     {

  836. #define modelBlank modelAriaBlank

  837.         p->addModel(modelSplort);

  838.         p->addModel(modelSmerge);

  839.         p->addModel(modelSpleet);

  840.         p->addModel(modelSwerge);

  841.         p->addModel(modelSplirge);

  842.         p->addModel(modelQqqq);

  843.         p->addModel(modelQuack);

  844.         p->addModel(modelQ);

  845.         p->addModel(modelQuale);

  846.         p->addModel(modelDarius);

  847.         p->addModel(modelSolomon4);

  848.         p->addModel(modelSolomon8);

  849.         p->addModel(modelSolomon16);

  850.         p->addModel(modelPsychopump);

  851.         p->addModel(modelPokies4);

  852.         p->addModel(modelGrabby);

  853.         p->addModel(modelRotatoes4);

  854.         p->addModel(modelUndular);

  855.         p->addModel(modelBlank);

  856. #undef modelBlank

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

  858.         spl.removeModule("Arcane");

  859.         spl.removeModule("Atout");

  860.         spl.removeModule("Aleister");

  861.     }

  862. }

  863. 

  864. static void initStatic__AudibleInstruments()

  865. {

  866.     Plugin* const p = new Plugin;

  867.     pluginInstance__AudibleInstruments = p;

  868. 

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

  870.     if (spl.ok())

  871.     {

  872.         p->addModel(modelBraids);

  873.         p->addModel(modelPlaits);

  874.         p->addModel(modelElements);

  875.         p->addModel(modelTides);

  876.         p->addModel(modelTides2);

  877.         p->addModel(modelClouds);

  878.         p->addModel(modelWarps);

  879.         p->addModel(modelRings);

  880.         p->addModel(modelLinks);

  881.         p->addModel(modelKinks);

  882.         p->addModel(modelShades);

  883.         p->addModel(modelBranches);

  884.         p->addModel(modelBlinds);

  885.         p->addModel(modelVeils);

  886.         p->addModel(modelFrames);

  887.         p->addModel(modelMarbles);

  888.         p->addModel(modelStages);

  889.         p->addModel(modelRipples);

  890.         p->addModel(modelShelves);

  891.         p->addModel(modelStreams);

  892.     }

  893. }

  894. 

  895. static void initStatic__Autinn()

  896. {

  897.     Plugin* const p = new Plugin;

  898.     pluginInstance__Autinn = p;

  899. 

  900.     const StaticPluginLoader spl(p, "Autinn");

  901.     if (spl.ok())

  902.     {

  903. #define modelChord modelAutinnChord

  904. #define modelVibrato modelAutinnVibrato

  905.         p->addModel(modelAmp);

  906.         p->addModel(modelDeadband);

  907.         p->addModel(modelBass);

  908.         p->addModel(modelCVConverter);

  909.         p->addModel(modelDC);

  910.         p->addModel(modelDigi);

  911.         p->addModel(modelFlopper);

  912.         p->addModel(modelFlora);

  913.         p->addModel(modelJette);

  914.         p->addModel(modelBoomerang);

  915.         p->addModel(modelOxcart);

  916.         p->addModel(modelSaw);

  917.         p->addModel(modelSjip);

  918.         p->addModel(modelSquare);

  919.         p->addModel(modelVibrato);

  920.         p->addModel(modelVectorDriver);

  921.         p->addModel(modelZod);

  922.         p->addModel(modelTriBand);

  923.         p->addModel(modelMixer6);

  924.         p->addModel(modelNon);

  925.         p->addModel(modelFil);

  926.         p->addModel(modelNap);

  927.         p->addModel(modelMelody);

  928.         p->addModel(modelChord);

  929. #undef modelChord

  930. #undef modelVibrato

  931.     }

  932. }

  933. 

  934. static void initStatic__Axioma()

  935. {

  936.     Plugin* const p = new Plugin;

  937.     pluginInstance__Axioma = p;

  938. 

  939.     const StaticPluginLoader spl(p, "Axioma");

  940.     if (spl.ok())

  941.     {

  942.         p->addModel(modelTheBifurcator);

  943.         p->addModel(modelTesseract);

  944.         p->addModel(modelIkeda);

  945.         p->addModel(modelRhodonea);

  946.     }

  947. }

  948. 

  949. static void initStatic__Bacon()

  950. {

  951.     Plugin* const p = new Plugin;

  952.     pluginInstance__Bacon = p;

  953. 

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

  955.     if (spl.ok())

  956.     {

  957.         p->addModel(modelHarMoNee);

  958.         p->addModel(modelGlissinator);

  959.         p->addModel(modelPolyGnome);

  960.         p->addModel(modelQuantEyes);

  961.         p->addModel(modelSampleDelay);

  962. #ifdef BUILD_SORTACHORUS

  963.         p->addModel(modelSortaChorus);

  964. #endif

  965.         p->addModel(modelChipNoise);

  966.         p->addModel(modelChipWaves);

  967.         p->addModel(modelChipYourWave);

  968.         p->addModel(modelOpen303);

  969. #ifdef BUILD_GENERICLSFR

  970.         p->addModel(modelGenericLFSR);

  971. #endif

  972.         p->addModel(modelKarplusStrongPoly);

  973.         p->addModel(modelALingADing);

  974.         p->addModel(modelBitulator);

  975. #ifdef BUILD_PHASER

  976.         p->addModel(modelPhaser);

  977. #endif

  978.         p->addModel(modelPolyGenerator);

  979.     }

  980. }

  981. 

  982. static void initStatic__Befaco()

  983. {

  984.     Plugin* const p = new Plugin;

  985.     pluginInstance__Befaco = p;

  986. 

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

  988.     if (spl.ok())

  989.     {

  990. #define modelADSR modelBefacoADSR

  991. #define modelMixer modelBefacoMixer

  992.         p->addModel(modelEvenVCO);

  993.         p->addModel(modelRampage);

  994.         p->addModel(modelABC);

  995.         p->addModel(modelSpringReverb);

  996.         p->addModel(modelMixer);

  997.         p->addModel(modelSlewLimiter);

  998.         p->addModel(modelDualAtenuverter);

  999.         p->addModel(modelPercall);

  1000.         p->addModel(modelHexmixVCA);

  1001.         p->addModel(modelChoppingKinky);

  1002.         p->addModel(modelKickall);

  1003.         p->addModel(modelSamplingModulator);

  1004.         p->addModel(modelMorphader);

  1005.         p->addModel(modelADSR);

  1006.         p->addModel(modelSTMix);

  1007.         p->addModel(modelMuxlicer);

  1008.         p->addModel(modelMex);

  1009. #undef modelADSR

  1010. #undef modelMixer

  1011.     }

  1012. }

  1013. 

  1014. static void initStatic__Bidoo()

  1015. {

  1016.     Plugin* const p = new Plugin;

  1017.     pluginInstance__Bidoo = p;

  1018. 

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

  1020.     if (spl.ok())

  1021.     {

  1022.         p->addModel(modelTOCANTE);

  1023.         p->addModel(modelLATE);

  1024.         p->addModel(modelDIKTAT);

  1025.         p->addModel(modelDTROY);

  1026.         p->addModel(modelBORDL);

  1027.         p->addModel(modelZOUMAI);

  1028.         p->addModel(modelMU);

  1029.         p->addModel(modelCHUTE);

  1030.         p->addModel(modelLOURDE);

  1031.         p->addModel(modelDILEMO);

  1032.         p->addModel(modelLAMBDA);

  1033.         p->addModel(modelBANCAU);

  1034.         p->addModel(modelACNE);

  1035.         p->addModel(modelMS);

  1036.         p->addModel(modelDUKE);

  1037.         p->addModel(modelMOIRE);

  1038.         p->addModel(modelPILOT);

  1039.         p->addModel(modelHUITRE);

  1040.         p->addModel(modelOUAIVE);

  1041.         p->addModel(modelEDSAROS);

  1042.         p->addModel(modelPOUPRE);

  1043.         p->addModel(modelMAGMA);

  1044.         p->addModel(modelOAI);

  1045.         p->addModel(modelCANARD);

  1046.         p->addModel(modelEMILE);

  1047.         p->addModel(modelFORK);

  1048.         p->addModel(modelTIARE);

  1049.         p->addModel(modelLIMONADE);

  1050.         p->addModel(modelLIMBO);

  1051.         p->addModel(modelPERCO);

  1052.         p->addModel(modelBAFIS);

  1053.         p->addModel(modelBAR);

  1054.         p->addModel(modelMINIBAR);

  1055.         p->addModel(modelZINC);

  1056.         p->addModel(modelFREIN);

  1057.         p->addModel(modelHCTIP);

  1058.         p->addModel(modelSPORE);

  1059.         p->addModel(modelDFUZE);

  1060.         p->addModel(modelREI);

  1061.         p->addModel(modelRABBIT);

  1062.         p->addModel(modelBISTROT);

  1063.         p->addModel(modelSIGMA);

  1064.         p->addModel(modelFLAME);

  1065.         p->addModel(modelVOID);

  1066. 

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

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

  1069.         spl.removeModule("antN");

  1070.     }

  1071. }

  1072. 

  1073. static void initStatic__BogaudioModules()

  1074. {

  1075.     Plugin* const p = new Plugin;

  1076.     pluginInstance__BogaudioModules = p;

  1077. 

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

  1079.     if (spl.ok())

  1080.     {

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

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

  1083.         skins._default = "dark";

  1084. #define modelADSR modelBogaudioADSR

  1085. #define modelLFO modelBogaudioLFO

  1086. #define modelNoise modelBogaudioNoise

  1087. #define modelVCA modelBogaudioVCA

  1088. #define modelVCF modelBogaudioVCF

  1089. #define modelVCO modelBogaudioVCO

  1090.         p->addModel(modelVCO);

  1091.         p->addModel(modelLVCO);

  1092.         p->addModel(modelSine);

  1093.         p->addModel(modelPulse);

  1094.         p->addModel(modelXCO);

  1095.         p->addModel(modelAdditator);

  1096.         p->addModel(modelFMOp);

  1097.         p->addModel(modelChirp);

  1098.         p->addModel(modelLFO);

  1099.         p->addModel(modelLLFO);

  1100.         p->addModel(modelFourFO);

  1101.         p->addModel(modelEightFO);

  1102.         p->addModel(modelVCF);

  1103.         p->addModel(modelLVCF);

  1104.         p->addModel(modelFFB);

  1105.         p->addModel(modelEQ);

  1106.         p->addModel(modelEQS);

  1107.         p->addModel(modelLPG);

  1108.         p->addModel(modelLLPG);

  1109.         p->addModel(modelMegaGate);

  1110.         p->addModel(modelPEQ);

  1111.         p->addModel(modelPEQ6);

  1112.         p->addModel(modelPEQ6XF);

  1113.         p->addModel(modelPEQ14);

  1114.         p->addModel(modelPEQ14XF);

  1115.         p->addModel(modelDADSRH);

  1116.         p->addModel(modelDADSRHPlus);

  1117.         p->addModel(modelShaper);

  1118.         p->addModel(modelShaperPlus);

  1119.         p->addModel(modelAD);

  1120.         p->addModel(modelASR);

  1121.         p->addModel(modelADSR);

  1122.         p->addModel(modelVish);

  1123.         p->addModel(modelFollow);

  1124.         p->addModel(modelDGate);

  1125.         p->addModel(modelRGate);

  1126.         p->addModel(modelEdge);

  1127.         p->addModel(modelNoise);

  1128.         p->addModel(modelSampleHold);

  1129.         p->addModel(modelWalk2);

  1130.         p->addModel(modelWalk);

  1131.         p->addModel(modelMix8);

  1132.         p->addModel(modelMix8x);

  1133.         p->addModel(modelMix4);

  1134.         p->addModel(modelMix4x);

  1135.         p->addModel(modelMix2);

  1136.         p->addModel(modelMix1);

  1137.         p->addModel(modelVCM);

  1138.         p->addModel(modelMute8);

  1139.         p->addModel(modelPan);

  1140.         p->addModel(modelXFade);

  1141.         p->addModel(modelVCA);

  1142.         p->addModel(modelVCAmp);

  1143.         p->addModel(modelVelo);

  1144.         p->addModel(modelUMix);

  1145.         p->addModel(modelMumix);

  1146.         p->addModel(modelMatrix81);

  1147.         p->addModel(modelMatrix18);

  1148.         p->addModel(modelMatrix44);

  1149.         p->addModel(modelMatrix44Cvm);

  1150.         p->addModel(modelMatrix88);

  1151.         p->addModel(modelMatrix88Cv);

  1152.         p->addModel(modelMatrix88M);

  1153.         p->addModel(modelSwitch81);

  1154.         p->addModel(modelSwitch18);

  1155.         p->addModel(modelSwitch44);

  1156.         p->addModel(modelSwitch88);

  1157.         p->addModel(modelSwitch1616);

  1158.         p->addModel(modelAMRM);

  1159.         p->addModel(modelPressor);

  1160.         p->addModel(modelClpr);

  1161.         p->addModel(modelLmtr);

  1162.         p->addModel(modelNsgt);

  1163.         p->addModel(modelCmpDist);

  1164.         p->addModel(modelOneEight);

  1165.         p->addModel(modelEightOne);

  1166.         p->addModel(modelAddrSeq);

  1167.         p->addModel(modelAddrSeqX);

  1168.         p->addModel(modelPgmr);

  1169.         p->addModel(modelPgmrX);

  1170.         p->addModel(modelVU);

  1171.         p->addModel(modelAnalyzer);

  1172.         p->addModel(modelAnalyzerXL);

  1173.         p->addModel(modelRanalyzer);

  1174.         p->addModel(modelDetune);

  1175.         p->addModel(modelStack);

  1176.         p->addModel(modelReftone);

  1177.         p->addModel(modelMono);

  1178.         p->addModel(modelArp);

  1179.         p->addModel(modelAssign);

  1180.         p->addModel(modelUnison);

  1181.         p->addModel(modelPolyCon8);

  1182.         p->addModel(modelPolyCon16);

  1183.         p->addModel(modelPolyOff8);

  1184.         p->addModel(modelPolyOff16);

  1185.         p->addModel(modelPolyMult);

  1186.         p->addModel(modelBool);

  1187.         p->addModel(modelCmp);

  1188.         p->addModel(modelCVD);

  1189.         p->addModel(modelFlipFlop);

  1190.         p->addModel(modelInv);

  1191.         p->addModel(modelManual);

  1192.         p->addModel(modelFourMan);

  1193.         p->addModel(modelMult);

  1194.         p->addModel(modelOffset);

  1195.         p->addModel(modelSlew);

  1196.         p->addModel(modelSums);

  1197.         p->addModel(modelSwitch);

  1198.         p->addModel(modelLgsw);

  1199.         p->addModel(modelBlank3);

  1200.         p->addModel(modelBlank6);

  1201. #ifdef EXPERIMENTAL

  1202.         p->addModel(modelLag);

  1203.         p->addModel(modelPEQ14XR);

  1204.         p->addModel(modelPEQ14XV);

  1205. #endif

  1206. #ifdef TEST

  1207.         p->addModel(modelTest);

  1208.         p->addModel(modelTest2);

  1209.         p->addModel(modelTestExpanderBase);

  1210.         p->addModel(modelTestExpanderExtension);

  1211.         p->addModel(modelTestGl);

  1212.         p->addModel(modelTestVCF);

  1213. #endif

  1214. #undef modelADSR

  1215. #undef modelLFO

  1216. #undef modelNoise

  1217. #undef modelVCA

  1218. #undef modelVCF

  1219. #undef modelVCO

  1220.     }

  1221. }

  1222. 

  1223. static void initStatic__cf()

  1224. {

  1225.     Plugin* const p = new Plugin;

  1226.     pluginInstance__cf = p;

  1227. 

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

  1229.     if (spl.ok())

  1230.     {

  1231.         p->addModel(modelMETRO);

  1232.         p->addModel(modelEACH);

  1233.         p->addModel(modeltrSEQ);

  1234.         p->addModel(modelLEDSEQ);

  1235.         p->addModel(modelL3DS3Q);

  1236.         p->addModel(modelSLIDERSEQ);

  1237.         p->addModel(modelPLAYER);

  1238.         p->addModel(modelPLAY);

  1239.         p->addModel(modelMONO);

  1240.         p->addModel(modelSTEREO);

  1241.         p->addModel(modelSUB);

  1242.         p->addModel(modelMASTER);

  1243.         p->addModel(modelVARIABLE);

  1244.         p->addModel(modelALGEBRA);

  1245.         p->addModel(modelFUNKTION);

  1246.         p->addModel(modelCHOKE);

  1247.         p->addModel(modelFOUR);

  1248.         p->addModel(modelSTEPS);

  1249.         p->addModel(modelPEAK);

  1250.         p->addModel(modelCUTS);

  1251.         p->addModel(modelBUFFER);

  1252.         p->addModel(modelDISTO);

  1253.         p->addModel(modelCUBE);

  1254.         p->addModel(modelPATCH);

  1255.         p->addModel(modelLABEL);

  1256.         p->addModel(modelDAVE);

  1257.     }

  1258. }

  1259. 

  1260. static void initStatic__ChowDSP()

  1261. {

  1262.     Plugin* const p = new Plugin;

  1263.     pluginInstance__ChowDSP = p;

  1264. 

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

  1266.     if (spl.ok())

  1267.     {

  1268.         p->addModel(modelChowTape);

  1269.         p->addModel(modelChowPhaserFeedback);

  1270.         p->addModel(modelChowPhaserMod);

  1271.         p->addModel(modelChowFDN);

  1272.         p->addModel(modelChowRNN);

  1273.         p->addModel(modelChowModal);

  1274.         p->addModel(modelChowDer);

  1275.         p->addModel(modelWarp);

  1276.         p->addModel(modelWerner);

  1277.         p->addModel(modelChowPulse);

  1278.         p->addModel(modelChowTapeCompression);

  1279.         p->addModel(modelChowTapeChew);

  1280.         p->addModel(modelChowTapeDegrade);

  1281.         p->addModel(modelChowTapeLoss);

  1282.         p->addModel(modelChowChorus);

  1283. 

  1284.         // Credit crashes on save, see https://github.com/DISTRHO/Cardinal/issues/98

  1285.         // p->addModel(modelCredit);

  1286.         spl.removeModule("Credit");

  1287.     }

  1288. }

  1289. 

  1290. static void initStatic__DrumKit()

  1291. {

  1292.     Plugin* const p = new Plugin;

  1293.     pluginInstance__DrumKit = p;

  1294. 

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

  1296.     if (spl.ok())

  1297.     {

  1298.         setupSamples();

  1299.         p->addModel(modelBD9);

  1300.         p->addModel(modelSnare);

  1301.         p->addModel(modelClosedHH);

  1302.         p->addModel(modelOpenHH);

  1303.         p->addModel(modelDMX);

  1304.         p->addModel(modelCR78);

  1305.         p->addModel(modelSBD);

  1306.         p->addModel(modelGnome);

  1307.         p->addModel(modelSequencer);

  1308.         p->addModel(modelTomi);

  1309.         p->addModel(modelBaronial);

  1310.         p->addModel(modelMarionette);

  1311.     }

  1312. }

  1313. 

  1314. static void initStatic__ESeries()

  1315. {

  1316.     Plugin* const p = new Plugin;

  1317.     pluginInstance__ESeries = p;

  1318. 

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

  1320.     if (spl.ok())

  1321.     {

  1322.         p->addModel(modelE340);

  1323.     }

  1324. }

  1325. 

  1326. static void initStatic__ExpertSleepersEncoders()

  1327. {

  1328.     Plugin* const p = new Plugin;

  1329.     pluginInstance__ExpertSleepersEncoders = p;

  1330. 

  1331.     const StaticPluginLoader spl(p, "ExpertSleepers-Encoders");

  1332.     if (spl.ok())

  1333.     {

  1334.         p->addModel(model8GT);

  1335.         p->addModel(model8CV);

  1336.         p->addModel(modelES40);

  1337.         p->addModel(modelES5);

  1338.         p->addModel(modelSMUX);

  1339.         p->addModel(modelCalibrator);

  1340.     }

  1341. }

  1342. 

  1343. static void initStatic__Extratone()

  1344. {

  1345.     Plugin* const p = new Plugin;

  1346.     pluginInstance__Extratone = p;

  1347. 

  1348.     const StaticPluginLoader spl(p, "Extratone");

  1349.     if (spl.ok())

  1350.     {

  1351.         p->addModel(modelModulo);

  1352.         p->addModel(modelMesoglea);

  1353.         p->addModel(modelMesoglea2);

  1354.         p->addModel(modelOpabinia);

  1355.         p->addModel(modelSplitterburst);

  1356.         p->addModel(modelPuzzlebox);

  1357.         p->addModel(modelDarwinism);

  1358.         // p->addModel(modelHalluciMemory);

  1359.         p->addModel(modelIchneumonid);

  1360.         p->addModel(modelMeganeura);

  1361.         p->addModel(modelPureneura);

  1362.         p->addModel(modelMesohyl);

  1363.         p->addModel(modelXtrtnBlank);

  1364.     }

  1365. }

  1366. 

  1367. static void initStatic__FehlerFabrik()

  1368. {

  1369.     Plugin* const p = new Plugin;

  1370.     pluginInstance__FehlerFabrik = p;

  1371. 

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

  1373.     if (spl.ok())

  1374.     {

  1375.         p->addModel(modelPSIOP);

  1376.         p->addModel(modelPlanck);

  1377.         p->addModel(modelLuigi);

  1378.         p->addModel(modelAspect);

  1379.         p->addModel(modelMonte);

  1380.         p->addModel(modelArpanet);

  1381.         p->addModel(modelSigma);

  1382.         p->addModel(modelFax);

  1383.         p->addModel(modelRasoir);

  1384.         p->addModel(modelChi);

  1385.         p->addModel(modelNova);

  1386.         p->addModel(modelLilt);

  1387.         p->addModel(modelBotzinger);

  1388.     }

  1389. }

  1390. 

  1391. #ifdef WITH_FUNDAMENTAL

  1392. static void initStatic__Fundamental()

  1393. {

  1394.     Plugin* const p = new Plugin;

  1395.     pluginInstance__Fundamental = p;

  1396. 

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

  1398.     if (spl.ok())

  1399.     {

  1400.         p->addModel(modelVCO);

  1401.         p->addModel(modelVCO2);

  1402.         p->addModel(modelVCF);

  1403.         p->addModel(modelVCA_1);

  1404.         p->addModel(modelVCA);

  1405.         p->addModel(modelLFO);

  1406.         p->addModel(modelLFO2);

  1407.         p->addModel(modelDelay);

  1408.         p->addModel(modelADSR);

  1409.         p->addModel(modelMixer);

  1410.         p->addModel(modelVCMixer);

  1411.         p->addModel(model_8vert);

  1412.         p->addModel(modelUnity);

  1413.         p->addModel(modelMutes);

  1414.         p->addModel(modelPulses);

  1415.         p->addModel(modelScope);

  1416.         p->addModel(modelSEQ3);

  1417.         p->addModel(modelSequentialSwitch1);

  1418.         p->addModel(modelSequentialSwitch2);

  1419.         p->addModel(modelOctave);

  1420.         p->addModel(modelQuantizer);

  1421.         p->addModel(modelSplit);

  1422.         p->addModel(modelMerge);

  1423.         p->addModel(modelSum);

  1424.         p->addModel(modelViz);

  1425.         p->addModel(modelMidSide);

  1426.         p->addModel(modelNoise);

  1427.         p->addModel(modelRandom);

  1428. 

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

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

  1431.         {

  1432.             size_t i;

  1433.             json_t* v;

  1434.             json_array_foreach(modules, i, v)

  1435.             {

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

  1437.             }

  1438.         }

  1439.     }

  1440. }

  1441. #endif

  1442. 

  1443. static void initStatic__GlueTheGiant()

  1444. {

  1445.     Plugin* const p = new Plugin;

  1446.     pluginInstance__GlueTheGiant = p;

  1447. 

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

  1449.     if (spl.ok())

  1450.     {

  1451.         p->addModel(modelGigBus);

  1452.         p->addModel(modelMiniBus);

  1453.         p->addModel(modelSchoolBus);

  1454.         p->addModel(modelMetroCityBus);

  1455.         p->addModel(modelBusDepot);

  1456.         p->addModel(modelBusRoute);

  1457.         p->addModel(modelRoad);

  1458.         p->addModel(modelEnterBus);

  1459.         p->addModel(modelExitBus);

  1460.     }

  1461. }

  1462. 

  1463. static void initStatic__GrandeModular()

  1464. {

  1465.     Plugin* const p = new Plugin;

  1466.     pluginInstance__GrandeModular = p;

  1467. 

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

  1469.     if (spl.ok())

  1470.     {

  1471.         p->addModel(modelClip);

  1472.         p->addModel(modelLFO3);

  1473.         p->addModel(modelMerge8);

  1474.         p->addModel(modelMergeSplit4);

  1475.         p->addModel(modelMicrotonalChords);

  1476.         p->addModel(modelMicrotonalNotes);

  1477.         p->addModel(modelNoteMT);

  1478.         p->addModel(modelPolyMergeResplit);

  1479.         p->addModel(modelPolySplit);

  1480.         p->addModel(modelQuant);

  1481.         p->addModel(modelQuantIntervals);

  1482.         p->addModel(modelQuantMT);

  1483.         p->addModel(modelSampleDelays);

  1484.         p->addModel(modelScale);

  1485.         p->addModel(modelSplit8);

  1486.         p->addModel(modelTails);

  1487.         p->addModel(modelVarSampleDelays);

  1488.         p->addModel(modelVCA3);

  1489.     }

  1490. }

  1491. 

  1492. static void initStatic__HetrickCV()

  1493. {

  1494.     Plugin* const p = new Plugin;

  1495.     pluginInstance__HetrickCV = p;

  1496. 

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

  1498.     if (spl.ok())

  1499.     {

  1500. #define modelASR modelHetrickCVASR

  1501. #define modelBlankPanel modelHetrickCVBlankPanel

  1502. #define modelFlipFlop modelHetrickCVFlipFlop

  1503. #define modelMidSide modelHetrickCVMidSide

  1504. #define modelMinMax modelHetrickCVMinMax

  1505.         p->addModel(modelTwoToFour);

  1506.         p->addModel(modelAnalogToDigital);

  1507.         p->addModel(modelASR);

  1508.         p->addModel(modelBinaryGate);

  1509.         p->addModel(modelBinaryNoise);

  1510.         p->addModel(modelBitshift);

  1511.         p->addModel(modelBlankPanel);

  1512.         p->addModel(modelBoolean3);

  1513.         p->addModel(modelChaos1Op);

  1514.         p->addModel(modelChaos2Op);

  1515.         p->addModel(modelChaos3Op);

  1516.         p->addModel(modelChaoticAttractors);

  1517.         p->addModel(modelClockedNoise);

  1518.         p->addModel(modelComparator);

  1519.         p->addModel(modelContrast);

  1520.         p->addModel(modelCrackle);

  1521.         p->addModel(modelDataCompander);

  1522.         p->addModel(modelDelta);

  1523.         p->addModel(modelDigitalToAnalog);

  1524.         p->addModel(modelDust);

  1525.         p->addModel(modelExponent);

  1526.         p->addModel(modelFBSineChaos);

  1527.         p->addModel(modelFlipFlop);

  1528.         p->addModel(modelFlipPan);

  1529.         p->addModel(modelGateJunction);

  1530.         p->addModel(modelGingerbread);

  1531.         p->addModel(modelLogicCombine);

  1532.         p->addModel(modelMidSide);

  1533.         p->addModel(modelMinMax);

  1534.         p->addModel(modelRandomGates);

  1535.         p->addModel(modelRotator);

  1536.         p->addModel(modelRungler);

  1537.         p->addModel(modelScanner);

  1538.         p->addModel(modelWaveshape);

  1539.         p->addModel(modelXYToPolar);

  1540. #undef modelASR

  1541. #undef modelBlankPanel

  1542. #undef modelFlipFlop

  1543. #undef modelMidSide

  1544. #undef modelMinMax

  1545.     }

  1546. }

  1547. 

  1548. static void initStatic__ImpromptuModular()

  1549. {

  1550.     Plugin* const p = new Plugin;

  1551.     pluginInstance__ImpromptuModular = p;

  1552. 

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

  1554.     if (spl.ok())

  1555.     {

  1556.         p->addModel(modelAdaptiveQuantizer);

  1557.         p->addModel(modelBigButtonSeq);

  1558.         p->addModel(modelBigButtonSeq2);

  1559.         p->addModel(modelChordKey);

  1560.         p->addModel(modelChordKeyExpander);

  1561.         p->addModel(modelClocked);

  1562.         p->addModel(modelClockedExpander);

  1563.         p->addModel(modelClkd);

  1564.         p->addModel(modelCvPad);

  1565.         p->addModel(modelFoundry);

  1566.         p->addModel(modelFoundryExpander);

  1567.         p->addModel(modelFourView);

  1568.         p->addModel(modelGateSeq64);

  1569.         p->addModel(modelGateSeq64Expander);

  1570.         p->addModel(modelHotkey);

  1571.         p->addModel(modelPart);

  1572.         p->addModel(modelPhraseSeq16);

  1573.         p->addModel(modelPhraseSeq32);

  1574.         p->addModel(modelPhraseSeqExpander);

  1575.         p->addModel(modelProbKey);

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

  1577.         p->addModel(modelSemiModularSynth);

  1578.         p->addModel(modelTact);

  1579.         p->addModel(modelTact1);

  1580.         p->addModel(modelTactG);

  1581.         p->addModel(modelTwelveKey);

  1582.         p->addModel(modelWriteSeq32);

  1583.         p->addModel(modelWriteSeq64);

  1584.         p->addModel(modelBlankPanel);

  1585.     }

  1586. }

  1587. 

  1588. static void initStatic__ihtsyn()

  1589. {

  1590.     Plugin* const p = new Plugin;

  1591.     pluginInstance__ihtsyn = p;

  1592. 

  1593.     const StaticPluginLoader spl(p, "ihtsyn");

  1594.     if (spl.ok())

  1595.     {

  1596.         p->addModel(modelPitchMangler);

  1597.         p->addModel(modelTwistedVerb);

  1598.         p->addModel(modelHiVerb);

  1599.         p->addModel(modelMVerb);

  1600.     }

  1601. }

  1602. 

  1603. static void initStatic__JW()

  1604. {

  1605.     Plugin* const p = new Plugin;

  1606.     pluginInstance__JW = p;

  1607. 

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

  1609.     if (spl.ok())

  1610.     {

  1611. #define modelQuantizer modelJWQuantizer

  1612.         p->addModel(modelAdd5);

  1613.         p->addModel(modelBouncyBalls);

  1614.         p->addModel(modelCat);

  1615.         p->addModel(modelTree);

  1616.         p->addModel(modelFullScope);

  1617.         p->addModel(modelGridSeq);

  1618.         p->addModel(modelEightSeq);

  1619.         p->addModel(modelDivSeq);

  1620.         p->addModel(modelMinMax);

  1621.         p->addModel(modelNoteSeq);

  1622.         p->addModel(modelNoteSeqFu);

  1623.         p->addModel(modelNoteSeq16);

  1624.         p->addModel(modelTrigs);

  1625.         p->addModel(modelOnePattern);

  1626.         p->addModel(modelPatterns);

  1627.         p->addModel(modelQuantizer);

  1628.         p->addModel(modelSimpleClock);

  1629.         p->addModel(modelD1v1de);

  1630.         p->addModel(modelPres1t);

  1631.         p->addModel(modelThingThing);

  1632.         p->addModel(modelWavHead);

  1633.         p->addModel(modelXYPad);

  1634.         p->addModel(modelBlankPanel1hp);

  1635.         p->addModel(modelBlankPanelSmall);

  1636.         p->addModel(modelBlankPanelMedium);

  1637.         p->addModel(modelBlankPanelLarge);

  1638.         p->addModel(modelCoolBreeze);

  1639.         p->addModel(modelPete);

  1640.        #ifndef STATIC_BUILD

  1641.         p->addModel(modelStr1ker);

  1642.        #else

  1643.         spl.removeModule("Str1ker");

  1644.        #endif

  1645. #undef modelQuantizer

  1646.     }

  1647. }

  1648. 

  1649. static void initStatic__LifeFormModular()

  1650. {

  1651.     Plugin* const p = new Plugin;

  1652.     pluginInstance__LifeFormModular= p;

  1653. 

  1654.     const StaticPluginLoader spl(p, "LifeFormModular");

  1655.     if (spl.ok())

  1656.     {

  1657.         p->addModel(modelTimeDiktat);

  1658.         p->addModel(modelSequenceModeler);

  1659.         p->addModel(modelPitchDiktat);

  1660.         p->addModel(modelPitchIntegrator);

  1661.         p->addModel(modelBurstIntegrator);

  1662.         p->addModel(modelQuadModulator);

  1663.         p->addModel(modelImpulseControl);

  1664.         p->addModel(modelQuadSteppedOffset);

  1665.         p->addModel(modelPercussiveVibration);

  1666.         p->addModel(modelQuadUtility);

  1667.         p->addModel(modelAdditiveVibration);

  1668.         p->addModel(modelComplexOsc);

  1669.         p->addModel(modelDriftgen);

  1670.     }

  1671. }

  1672. 

  1673. static void initStatic__LittleUtils()

  1674. {

  1675.     Plugin* const p = new Plugin;

  1676.     pluginInstance__LittleUtils = p;

  1677. 

  1678.     const StaticPluginLoader spl(p, "LittleUtils");

  1679.     if (spl.ok())

  1680.     {

  1681.         p->addModel(modelButtonModule);

  1682.         p->addModel(modelPulseGenerator);

  1683.         p->addModel(modelBias_Semitone);

  1684.         p->addModel(modelMulDiv);

  1685.         p->addModel(modelTeleportInModule);

  1686.         p->addModel(modelTeleportOutModule);

  1687.     }

  1688. }

  1689. 

  1690. static void initStatic__Lomas()

  1691. {

  1692.     Plugin* const p = new Plugin;

  1693.     pluginInstance__Lomas = p;

  1694. 

  1695.     const StaticPluginLoader spl(p, "LomasModules");

  1696.     if (spl.ok())

  1697.     {

  1698.         p->addModel(modelAdvancedSampler);

  1699.         p->addModel(modelGateSequencer);

  1700.     }

  1701. }

  1702. 

  1703. static void initStatic__Lyrae()

  1704. {

  1705.     Plugin* const p = new Plugin;

  1706.     pluginInstance__Lyrae = p;

  1707. 

  1708.     const StaticPluginLoader spl(p, "LyraeModules");

  1709.     if (spl.ok())

  1710.     {

  1711. #define modelDelta modelLyraeDelta

  1712.         p->addModel(modelSulafat);

  1713.         p->addModel(modelGamma);

  1714.         p->addModel(modelDelta);

  1715.         p->addModel(modelVega);

  1716.         p->addModel(modelBD383238);

  1717.         p->addModel(modelZeta);

  1718. #undef modelDelta

  1719.     }

  1720. }

  1721. 

  1722. static void initStatic__MindMeld()

  1723. {

  1724.     Plugin* const p = new Plugin;

  1725.     pluginInstance__MindMeld = p;

  1726. 

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

  1728.     if (spl.ok())

  1729.     {

  1730.         p->addModel(modelMixMasterJr);

  1731.         p->addModel(modelAuxExpanderJr);

  1732.         p->addModel(modelMixMaster);

  1733.         p->addModel(modelAuxExpander);

  1734.         p->addModel(modelMeld);

  1735.         p->addModel(modelUnmeld);

  1736.         p->addModel(modelMSMelder);

  1737.         p->addModel(modelEqMaster);

  1738.         p->addModel(modelEqExpander);

  1739.         p->addModel(modelBassMaster);

  1740.         p->addModel(modelBassMasterJr);

  1741.         p->addModel(modelShapeMaster);

  1742.     }

  1743. }

  1744. 

  1745. static void initStatic__Mog()

  1746. {

  1747.     Plugin* const p = new Plugin;

  1748.     pluginInstance__Mog = p;

  1749. 

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

  1751.     if (spl.ok())

  1752.     {

  1753.         p->addModel(modelNetwork);

  1754.         p->addModel(modelNexus);

  1755.     }

  1756. }

  1757. 

  1758. static void initStatic__MockbaModular()

  1759. {

  1760.     Plugin* const p = new Plugin;

  1761.     pluginInstance__MockbaModular = p;

  1762. 

  1763.     const StaticPluginLoader spl(p, "MockbaModular");

  1764.     if (spl.ok())

  1765.     {

  1766. #define modelBlank modelMockbaModularBlank

  1767. #define modelComparator modelMockbaModularComparator

  1768.         p->addModel(modelBlank);

  1769.         p->addModel(modelFeidah);

  1770.         p->addModel(modelFeidahS);

  1771.         p->addModel(modelFiltah);

  1772.         p->addModel(modelMixah);

  1773.         p->addModel(modelMixah3);

  1774.         p->addModel(modelDividah);

  1775.         p->addModel(modelCountah);

  1776.         p->addModel(modelSelectah);

  1777.         p->addModel(modelShapah);

  1778.         p->addModel(modelHoldah);

  1779.         p->addModel(modelPannah);

  1780.         p->addModel(modelReVoltah);

  1781.         p->addModel(modelCZSaw);

  1782.         p->addModel(modelCZSquare);

  1783.         p->addModel(modelCZPulse);

  1784.         p->addModel(modelCZDblSine);

  1785.         p->addModel(modelCZSawPulse);

  1786.         p->addModel(modelCZReso1);

  1787.         p->addModel(modelCZReso2);

  1788.         p->addModel(modelCZReso3);

  1789.         p->addModel(modelCZOsc);

  1790.         p->addModel(modelMaugTriangle);

  1791.         p->addModel(modelMaugShark);

  1792.         p->addModel(modelMaugSaw);

  1793.         p->addModel(modelMaugSaw2);

  1794.         p->addModel(modelMaugSquare);

  1795.         p->addModel(modelMaugSquare2);

  1796.         p->addModel(modelMaugSquare3);

  1797.         p->addModel(modelMaugOsc);

  1798.         p->addModel(modelComparator);

  1799.         p->addModel(modelDualBUFFER);

  1800.         p->addModel(modelDualNOT);

  1801.         p->addModel(modelDualOR);

  1802.         p->addModel(modelDualNOR);

  1803.         p->addModel(modelDualAND);

  1804.         p->addModel(modelDualNAND);

  1805.         p->addModel(modelDualXOR);

  1806.         p->addModel(modelDualXNOR);

  1807.         p->addModel(modelPSelectah);

  1808. 

  1809.         // require input files to work

  1810.         spl.removeModule("UDPClockMaster");

  1811.         spl.removeModule("UDPClockSlave");

  1812. #undef modelBlank

  1813. #undef modelComparator

  1814.     }

  1815. }

  1816. 

  1817. static void initStatic__mscHack()

  1818. {

  1819.     Plugin* const p = new Plugin;

  1820.     pluginInstance__mscHack = p;

  1821. 

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

  1823.     if (spl.ok())

  1824.     {

  1825.         p->addModel(modelCompressor);

  1826.         p->addModel(modelSynthDrums);

  1827.         p->addModel(modelSEQ_6x32x16);

  1828.         p->addModel(modelMasterClockx4);

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

  1830.         p->addModel(modelSEQ_Envelope_8);

  1831.         p->addModel(modelSeq_Triad2);

  1832.         p->addModel(modelARP700);

  1833.         p->addModel(modelMix_4_0_4);

  1834.         p->addModel(modelMix_9_3_4);

  1835.         p->addModel(modelMix_16_4_4);

  1836.         p->addModel(modelMix_24_4_4);

  1837.         p->addModel(modelASAF8);

  1838.         p->addModel(modelPingPong);

  1839.         p->addModel(modelStepDelay);

  1840.         p->addModel(modelOsc_3Ch);

  1841.         p->addModel(modelDronez);

  1842.         p->addModel(modelMorze);

  1843.         p->addModel(modelWindz);

  1844.         p->addModel(modelLorenz);

  1845.         p->addModel(modelAlienz);

  1846.         p->addModel(modelOSC_WaveMorph_3);

  1847.         p->addModel(modelMaude_221);

  1848.     }

  1849. }

  1850. 

  1851. static void initStatic__Prism()

  1852. {

  1853.     Plugin* const p = new Plugin;

  1854.     pluginInstance__Prism = p;

  1855. 

  1856.     const StaticPluginLoader spl(p, "Prism");

  1857.     if (spl.ok())

  1858.     {

  1859.         p->addModel(modelRainbow);

  1860.         p->addModel(modelRainbowScaleExpander);

  1861.         p->addModel(modelDroplet);

  1862.     }

  1863. }

  1864. 

  1865. static void initStatic__rackwindows()

  1866. {

  1867.     Plugin* const p = new Plugin;

  1868.     pluginInstance__rackwindows = p;

  1869. 

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

  1871.     if (spl.ok())

  1872.     {

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

  1874.         p->addModel(modelBitshiftgain);

  1875.         p->addModel(modelCapacitor);

  1876.         p->addModel(modelCapacitor_stereo);

  1877.         p->addModel(modelChorus);

  1878.         p->addModel(modelConsole);

  1879.         p->addModel(modelConsole_mm);

  1880.         p->addModel(modelDistance);

  1881.         p->addModel(modelGolem);

  1882.         p->addModel(modelHolt);

  1883.         p->addModel(modelHombre);

  1884.         p->addModel(modelInterstage);

  1885.         p->addModel(modelMonitoring);

  1886.         p->addModel(modelMv);

  1887.         p->addModel(modelRasp);

  1888.         p->addModel(modelReseq);

  1889.         p->addModel(modelTape);

  1890.         p->addModel(modelTremolo);

  1891.         p->addModel(modelVibrato);

  1892.     }

  1893. }

  1894. 

  1895. static void initStatic__repelzen()

  1896. {

  1897.     Plugin* const p = new Plugin;

  1898.     pluginInstance__repelzen = p;

  1899. 

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

  1901.     if (spl.ok())

  1902.     {

  1903. #define modelBlank modelrepelzenBlank

  1904. #define modelMixer modelrepelzenMixer

  1905. #define modelWerner modelrepelzenWerner

  1906.         p->addModel(modelBlank);

  1907.         p->addModel(modelBurst);

  1908.         p->addModel(modelFolder);

  1909.         p->addModel(modelErwin);

  1910.         p->addModel(modelWerner);

  1911.         p->addModel(modelMixer);

  1912. #undef modelBlank

  1913. #undef modelMixer

  1914. #undef modelWerner

  1915.     }

  1916. }

  1917. 

  1918. static void initStatic__sonusmodular()

  1919. {

  1920.     Plugin* const p = new Plugin;

  1921.     pluginInstance__sonusmodular = p;

  1922. 

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

  1924.     if (spl.ok())

  1925.     {

  1926.         p->addModel(modelAddiction);

  1927.         p->addModel(modelBitter);

  1928.         p->addModel(modelBymidside);

  1929.         p->addModel(modelCampione);

  1930.         p->addModel(modelChainsaw);

  1931.         p->addModel(modelCtrl);

  1932.         p->addModel(modelDeathcrush);

  1933.         p->addModel(modelFraction);

  1934.         p->addModel(modelHarmony);

  1935.         p->addModel(modelLadrone);

  1936.         p->addModel(modelLuppolo);

  1937.         p->addModel(modelLuppolo3);

  1938.         p->addModel(modelMicromacro);

  1939.         p->addModel(modelMrcheb);

  1940.         p->addModel(modelMultimulti);

  1941.         p->addModel(modelNeurosc);

  1942.         p->addModel(modelOktagon);

  1943.         p->addModel(modelOsculum);

  1944.         p->addModel(modelParamath);

  1945.         p->addModel(modelPiconoise);

  1946.         p->addModel(modelPith);

  1947.         p->addModel(modelPusher);

  1948.         p->addModel(modelRingo);

  1949.         p->addModel(modelScramblase);

  1950.         p->addModel(modelTropicana);

  1951.         p->addModel(modelTwoff);

  1952.         p->addModel(modelYabp);

  1953.     }

  1954. }

  1955. 

  1956. static void initStatic__substation()

  1957. {

  1958.     Plugin* const p = new Plugin;

  1959.     pluginInstance__substation = p;

  1960. 

  1961.     const StaticPluginLoader spl(p, "substation-opensource");

  1962.     if (spl.ok())

  1963.     {

  1964.         p->addModel(slime::plugin::substation::modelClock);

  1965.         p->addModel(slime::plugin::substation::modelEnvelopes);

  1966.         p->addModel(slime::plugin::substation::modelFilter);

  1967.         p->addModel(slime::plugin::substation::modelMixer);

  1968.         p->addModel(slime::plugin::substation::modelQuantizer);

  1969.         p->addModel(slime::plugin::substation::modelPolySequencer);

  1970.         p->addModel(slime::plugin::substation::modelVCA);

  1971.         p->addModel(slime::plugin::substation::modelSubOscillator);

  1972.         p->addModel(slime::plugin::substation::modelBlank4);

  1973.         p->addModel(slime::plugin::substation::modelBlank7);

  1974.         p->addModel(slime::plugin::substation::modelFilterPlus);

  1975.     }

  1976. }

  1977. 

  1978. static void initStatic__ValleyAudio()

  1979. {

  1980.     Plugin* const p = new Plugin;

  1981.     pluginInstance__ValleyAudio = p;

  1982. 

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

  1984.     if (spl.ok())

  1985.     {

  1986.         p->addModel(modelTopograph);

  1987.         p->addModel(modelUGraph);

  1988.         p->addModel(modelDexter);

  1989.         p->addModel(modelPlateau);

  1990.         p->addModel(modelInterzone);

  1991.         p->addModel(modelAmalgam);

  1992.         p->addModel(modelFeline);

  1993.         p->addModel(modelTerrorform);

  1994.     }

  1995. }

  1996. 

  1997. static void initStatic__ZetaCarinaeModules()

  1998. {

  1999.     Plugin* p = new Plugin;

  2000.     pluginInstance__ZetaCarinaeModules = p;

  2001. 

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

  2003.     if (spl.ok())

  2004.     {

  2005.         p->addModel(modelBrownianBridge);

  2006.         p->addModel(modelOrnsteinUhlenbeck);

  2007.         p->addModel(modelIOU);

  2008.         p->addModel(modelWarbler);

  2009.         p->addModel(modelRosenchance);

  2010.         p->addModel(modelGuildensTurn);

  2011.         p->addModel(modelRosslerRustler);

  2012.         p->addModel(modelFirefly);

  2013.     }

  2014. }

  2015. 

  2016. static void initStatic__ZZC()

  2017. {

  2018.     Plugin* p = new Plugin;

  2019.     pluginInstance__ZZC = p;

  2020. 

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

  2022.     if (spl.ok())

  2023.     {

  2024. #define modelClock modelZZCClock

  2025.         p->addModel(modelClock);

  2026.         p->addModel(modelDivider);

  2027.         p->addModel(modelFN3);

  2028.         p->addModel(modelSCVCA);

  2029.         p->addModel(modelSH8);

  2030.         p->addModel(modelSRC);

  2031.         p->addModel(modelDiv);

  2032.         p->addModel(modelDivExp);

  2033.         p->addModel(modelPolygate);

  2034. #undef modelClock

  2035.     }

  2036. }

  2037. #endif // NOPLUGINS

  2038. 

  2039. void initStaticPlugins()

  2040. {

  2041.     initStatic__Cardinal();

  2042. #ifndef NOPLUGINS

  2043.     initStatic__21kHz();

  2044.     initStatic__8Mode();

  2045.     initStatic__AmalgamatedHarmonics();

  2046.     initStatic__AnimatedCircuits();

  2047.     initStatic__Aria();

  2048.     initStatic__AudibleInstruments();

  2049.     initStatic__Autinn();

  2050.     initStatic__Axioma();

  2051.     initStatic__Bacon();

  2052.     initStatic__Befaco();

  2053.     initStatic__Bidoo();

  2054.     initStatic__BogaudioModules();

  2055.     initStatic__cf();

  2056.     initStatic__ChowDSP();

  2057.     initStatic__DrumKit();

  2058.     initStatic__ESeries();

  2059.     initStatic__ExpertSleepersEncoders();

  2060.     initStatic__Extratone();

  2061.     initStatic__FehlerFabrik();

  2062.    #ifdef WITH_FUNDAMENTAL

  2063.     initStatic__Fundamental();

  2064.    #endif

  2065.     initStatic__GlueTheGiant();

  2066.     initStatic__GrandeModular();

  2067.     initStatic__HetrickCV();

  2068.     initStatic__ImpromptuModular();

  2069.     initStatic__ihtsyn();

  2070.     initStatic__JW();

  2071.     initStatic__LifeFormModular();

  2072.     initStatic__LittleUtils();

  2073.     initStatic__Lomas();

  2074.     initStatic__Lyrae();

  2075.     initStatic__MindMeld();

  2076.     initStatic__MockbaModular();

  2077.     initStatic__Mog();

  2078.     initStatic__mscHack();

  2079.     initStatic__Prism();

  2080.     initStatic__rackwindows();

  2081.     initStatic__repelzen();

  2082.     initStatic__sonusmodular();

  2083.     initStatic__substation();

  2084.     initStatic__ValleyAudio();

  2085.     initStatic__ZetaCarinaeModules();

  2086.     initStatic__ZZC();

  2087. #endif // NOPLUGINS

  2088. }

  2089. 

  2090. void destroyStaticPlugins()

  2091. {

  2092.     for (Plugin* p : plugins)

  2093.         delete p;

  2094.     plugins.clear();

  2095. }

  2096. 

  2097. }

  2098. }