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

2740 lines
73KB
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. // Fundamental (always enabled)

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

  28. 

  29. #ifndef NOPLUGINS

  30. // 21kHz

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

  32. 

  33. // 8Mode

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

  35. 

  36. // Aaron Static

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

  38. 

  39. // Algoritmarte

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

  41. 

  42. // AmalgamatedHarmonics

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

  44. 

  45. // AnimatedCircuits

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

  47. 

  48. // ArableInstruments

  49. #define modelClouds modelArableClouds

  50. #include "ArableInstruments/src/ArableInstruments.hpp"

  51. #undef modelClouds

  52. 

  53. // Aria

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

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

  56. */

  57. #define modelBlank modelAriaBlank

  58. extern Model* modelSplort;

  59. extern Model* modelSmerge;

  60. extern Model* modelSpleet;

  61. extern Model* modelSwerge;

  62. extern Model* modelSplirge;

  63. // extern Model* modelSrot;

  64. extern Model* modelQqqq;

  65. extern Model* modelQuack;

  66. extern Model* modelQ;

  67. extern Model* modelQuale;

  68. extern Model* modelDarius;

  69. extern Model* modelSolomon4;

  70. extern Model* modelSolomon8;

  71. extern Model* modelSolomon16;

  72. extern Model* modelPsychopump;

  73. extern Model* modelPokies4;

  74. extern Model* modelGrabby;

  75. extern Model* modelRotatoes4;

  76. extern Model* modelUndular;

  77. extern Model* modelBlank;

  78. #undef modelBlank

  79. 

  80. // AS

  81. #define modelADSR modelASADSR

  82. #define modelVCA modelASVCA

  83. #define LedLight ASLedLight

  84. #define YellowRedLight ASYellowRedLight

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

  86. #undef modelADSR

  87. #undef modelVCA

  88. #undef LedLight

  89. #undef YellowRedLight

  90. 

  91. // AudibleInstruments

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

  93. 

  94. // Autinn

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

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

  97. */

  98. #define modelChord modelAutinnChord

  99. #define modelVibrato modelAutinnVibrato

  100. extern Model* modelJette;

  101. extern Model* modelFlora;

  102. extern Model* modelOxcart;

  103. extern Model* modelDeadband;

  104. extern Model* modelDigi;

  105. extern Model* modelFlopper;

  106. extern Model* modelAmp;

  107. extern Model* modelDC;

  108. extern Model* modelSjip;

  109. extern Model* modelBass;

  110. extern Model* modelSquare;

  111. extern Model* modelSaw;

  112. extern Model* modelBoomerang;

  113. extern Model* modelVibrato;

  114. extern Model* modelVectorDriver; //deprecated

  115. extern Model* modelCVConverter;

  116. extern Model* modelZod;

  117. extern Model* modelTriBand;

  118. extern Model* modelMixer6;

  119. extern Model* modelNon;

  120. extern Model* modelFil;

  121. extern Model* modelNap;

  122. extern Model* modelMelody;

  123. extern Model* modelChord;

  124. #undef modelChord

  125. #undef modelVibrato

  126. 

  127. // Axioma

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

  129. 

  130. // BaconPlugs

  131. #define INCLUDE_COMPONENTS_HPP

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

  133. #undef INCLUDE_COMPONENTS_HPP

  134. #undef SCREW_WIDTH

  135. #undef RACK_HEIGHT

  136. 

  137. // Befaco

  138. #define modelADSR modelBefacoADSR

  139. #define modelMixer modelBefacoMixer

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

  141. #undef modelADSR

  142. #undef modelMixer

  143. 

  144. // Bidoo

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

  146. 

  147. // BogaudioModules - force dark skin as default

  148. #include <mutex>

  149. #include <string>

  150. #include <unordered_map>

  151. #include <unordered_set>

  152. #include <vector>

  153. #define private public

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

  155. #undef private

  156. 

  157. // BogaudioModules

  158. #define modelADSR modelBogaudioADSR

  159. #define modelLFO modelBogaudioLFO

  160. #define modelNoise modelBogaudioNoise

  161. #define modelVCA modelBogaudioVCA

  162. #define modelVCF modelBogaudioVCF

  163. #define modelVCO modelBogaudioVCO

  164. extern Model* modelVCO;

  165. extern Model* modelLVCO;

  166. extern Model* modelSine;

  167. extern Model* modelPulse;

  168. extern Model* modelXCO;

  169. extern Model* modelAdditator;

  170. extern Model* modelFMOp;

  171. extern Model* modelChirp;

  172. extern Model* modelLFO;

  173. extern Model* modelLLFO;

  174. extern Model* modelFourFO;

  175. extern Model* modelEightFO;

  176. extern Model* modelVCF;

  177. extern Model* modelLVCF;

  178. extern Model* modelFFB;

  179. extern Model* modelEQ;

  180. extern Model* modelEQS;

  181. extern Model* modelLPG;

  182. extern Model* modelLLPG;

  183. extern Model* modelMegaGate;

  184. extern Model* modelPEQ;

  185. extern Model* modelPEQ6;

  186. extern Model* modelPEQ6XF;

  187. extern Model* modelPEQ14;

  188. extern Model* modelPEQ14XF;

  189. extern Model* modelDADSRH;

  190. extern Model* modelDADSRHPlus;

  191. extern Model* modelShaper;

  192. extern Model* modelShaperPlus;

  193. extern Model* modelAD;

  194. extern Model* modelASR;

  195. extern Model* modelADSR;

  196. extern Model* modelVish;

  197. extern Model* modelFollow;

  198. extern Model* modelDGate;

  199. extern Model* modelRGate;

  200. extern Model* modelEdge;

  201. extern Model* modelNoise;

  202. extern Model* modelSampleHold;

  203. extern Model* modelWalk2;

  204. extern Model* modelWalk;

  205. extern Model* modelMix8;

  206. extern Model* modelMix8x;

  207. extern Model* modelMix4;

  208. extern Model* modelMix4x;

  209. extern Model* modelMix2;

  210. extern Model* modelMix1;

  211. extern Model* modelVCM;

  212. extern Model* modelMute8;

  213. extern Model* modelPan;

  214. extern Model* modelXFade;

  215. extern Model* modelVCA;

  216. extern Model* modelVCAmp;

  217. extern Model* modelVelo;

  218. extern Model* modelUMix;

  219. extern Model* modelMumix;

  220. extern Model* modelMatrix81;

  221. extern Model* modelMatrix18;

  222. extern Model* modelMatrix44;

  223. extern Model* modelMatrix44Cvm;

  224. extern Model* modelMatrix88;

  225. extern Model* modelMatrix88Cv;

  226. extern Model* modelMatrix88M;

  227. extern Model* modelSwitch81;

  228. extern Model* modelSwitch18;

  229. extern Model* modelSwitch44;

  230. extern Model* modelSwitch88;

  231. extern Model* modelSwitch1616;

  232. extern Model* modelAMRM;

  233. extern Model* modelPressor;

  234. extern Model* modelClpr;

  235. extern Model* modelLmtr;

  236. extern Model* modelNsgt;

  237. extern Model* modelCmpDist;

  238. extern Model* modelOneEight;

  239. extern Model* modelEightOne;

  240. extern Model* modelAddrSeq;

  241. extern Model* modelAddrSeqX;

  242. extern Model* modelPgmr;

  243. extern Model* modelPgmrX;

  244. extern Model* modelVU;

  245. extern Model* modelAnalyzer;

  246. extern Model* modelAnalyzerXL;

  247. extern Model* modelRanalyzer;

  248. extern Model* modelDetune;

  249. extern Model* modelStack;

  250. extern Model* modelReftone;

  251. extern Model* modelMono;

  252. extern Model* modelArp;

  253. extern Model* modelAssign;

  254. extern Model* modelUnison;

  255. extern Model* modelPolyCon8;

  256. extern Model* modelPolyCon16;

  257. extern Model* modelPolyOff8;

  258. extern Model* modelPolyOff16;

  259. extern Model* modelPolyMult;

  260. extern Model* modelBool;

  261. extern Model* modelCmp;

  262. extern Model* modelCVD;

  263. extern Model* modelFlipFlop;

  264. extern Model* modelInv;

  265. extern Model* modelManual;

  266. extern Model* modelFourMan;

  267. extern Model* modelMult;

  268. extern Model* modelOffset;

  269. extern Model* modelSlew;

  270. extern Model* modelSums;

  271. extern Model* modelSwitch;

  272. extern Model* modelLgsw;

  273. extern Model* modelBlank3;

  274. extern Model* modelBlank6;

  275. #ifdef EXPERIMENTAL

  276. extern Model* modelLag;

  277. extern Model* modelPEQ14XR;

  278. extern Model* modelPEQ14XV;

  279. #endif

  280. #ifdef TEST

  281. extern Model* modelTest;

  282. extern Model* modelTest2;

  283. extern Model* modelTestExpanderBase;

  284. extern Model* modelTestExpanderExtension;

  285. extern Model* modelTestGl;

  286. extern Model* modelTestVCF;

  287. #endif

  288. #undef modelADSR

  289. #undef modelLFO

  290. #undef modelNoise

  291. #undef modelVCA

  292. #undef modelVCF

  293. #undef modelVCO

  294. 

  295. // CatroModulo

  296. #include "CatroModulo/src/CatroModulo.hpp"

  297. 

  298. // cf

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

  300. 

  301. // ChowDSP

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

  303. #define init initChowDSP

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

  305. #undef init

  306. 

  307. // DrumKit

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

  309. void setupSamples();

  310. 

  311. // ESeries

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

  313. 

  314. // ExpertSleepers-Encoders

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

  316. 

  317. // Extratone

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

  319. 

  320. // FehlerFabrik

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

  322. 

  323. // forsitan modulare

  324. #include "forsitan-modulare/src/forsitan.hpp"

  325. 

  326. // GlueTheGiant

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

  328. bool audition_mixer = false;

  329. bool audition_depot = false;

  330. int gtg_default_theme = 1;

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

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

  333. 

  334. // GoodSheperd

  335. #include "GoodSheperd/src/plugin.hpp"

  336. 

  337. // GrandeModular

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

  339. 

  340. // Hampton Harmonics

  341. #define modelArp modelHamptonHarmonicsArp

  342. #define modelProgress modelHamptonHarmonicsProgress

  343. #include "HamptonHarmonics/src/plugin.hpp"

  344. #undef modelProgress

  345. #undef modelArp

  346. 

  347. // HetrickCV

  348. #define modelASR modelHetrickCVASR

  349. #define modelBlankPanel modelHetrickCVBlankPanel

  350. #define modelFlipFlop modelHetrickCVFlipFlop

  351. #define modelMidSide modelHetrickCVMidSide

  352. #define modelMinMax modelHetrickCVMinMax

  353. extern Model* modelTwoToFour;

  354. extern Model* modelAnalogToDigital;

  355. extern Model* modelASR;

  356. extern Model* modelBinaryGate;

  357. extern Model* modelBinaryNoise;

  358. extern Model* modelBitshift;

  359. extern Model* modelBlankPanel;

  360. extern Model* modelBoolean3;

  361. extern Model* modelChaos1Op;

  362. extern Model* modelChaos2Op;

  363. extern Model* modelChaos3Op;

  364. extern Model* modelChaoticAttractors;

  365. extern Model* modelClockedNoise;

  366. extern Model* modelComparator;

  367. extern Model* modelContrast;

  368. extern Model* modelCrackle;

  369. extern Model* modelDataCompander;

  370. extern Model* modelDelta;

  371. extern Model* modelDigitalToAnalog;

  372. extern Model* modelDust;

  373. extern Model* modelExponent;

  374. extern Model* modelFBSineChaos;

  375. extern Model* modelFlipFlop;

  376. extern Model* modelFlipPan;

  377. extern Model* modelGateJunction;

  378. extern Model* modelGingerbread;

  379. extern Model* modelLogicCombine;

  380. extern Model* modelMidSide;

  381. extern Model* modelMinMax;

  382. extern Model* modelRandomGates;

  383. extern Model* modelRotator;

  384. extern Model* modelRungler;

  385. extern Model* modelScanner;

  386. extern Model* modelWaveshape;

  387. extern Model* modelXYToPolar;

  388. #undef modelASR

  389. #undef modelBlankPanel

  390. #undef modelFlipFlop

  391. #undef modelMidSide

  392. #undef modelMinMax

  393. 

  394. // ImpromptuModular

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

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

  397. */

  398. extern Model* modelAdaptiveQuantizer;

  399. extern Model* modelBigButtonSeq;

  400. extern Model* modelBigButtonSeq2;

  401. extern Model* modelChordKey;

  402. extern Model* modelChordKeyExpander;

  403. extern Model* modelClocked;

  404. extern Model* modelClockedExpander;

  405. extern Model* modelClkd;

  406. extern Model* modelCvPad;

  407. extern Model* modelFoundry;

  408. extern Model* modelFoundryExpander;

  409. extern Model* modelFourView;

  410. extern Model* modelGateSeq64;

  411. extern Model* modelGateSeq64Expander;

  412. extern Model* modelHotkey;

  413. extern Model* modelPart;

  414. extern Model* modelPhraseSeq16;

  415. extern Model* modelPhraseSeq32;

  416. extern Model* modelPhraseSeqExpander;

  417. extern Model* modelProbKey;

  418. extern Model* modelSemiModularSynth;

  419. extern Model* modelSygen;

  420. extern Model* modelTact;

  421. extern Model* modelTact1;

  422. extern Model* modelTactG;

  423. extern Model* modelTwelveKey;

  424. extern Model* modelVariations;

  425. extern Model* modelWriteSeq32;

  426. extern Model* modelWriteSeq64;

  427. extern Model* modelBlankPanel;

  428. 

  429. // ihtsyn

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

  431. 

  432. // JW-Modules

  433. #define modelQuantizer modelJWQuantizer

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

  435. #undef modelQuantizer

  436. 

  437. // kocmoc

  438. #include "kocmoc/src/plugin.hpp"

  439. 

  440. // LifeFormModular

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

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

  443. */

  444. extern Model* modelTimeDiktat;

  445. extern Model* modelSequenceModeler;

  446. extern Model* modelPitchDiktat;

  447. extern Model* modelPitchIntegrator;

  448. extern Model* modelBurstIntegrator;

  449. extern Model* modelQuadModulator;

  450. extern Model* modelImpulseControl;

  451. extern Model* modelQuadSteppedOffset;

  452. extern Model* modelPercussiveVibration;

  453. extern Model* modelQuadUtility;

  454. extern Model* modelAdditiveVibration;

  455. extern Model* modelComplexOsc;

  456. extern Model* modelDriftgen;

  457. 

  458. // LittleUtils

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

  460. 

  461. // Lilac Loop

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

  463. // #include "LilacLoop/src/plugin.hpp"

  464. */

  465. extern Model* modelLooperOne;

  466. extern Model* modelLooperTwo;

  467. 

  468. // LomasModules

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

  470. #undef DR_WAV_IMPLEMENTATION

  471. 

  472. // LyraeModules

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

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

  475. */

  476. #define modelDelta modelLyraeDelta

  477. extern Model* modelSulafat;

  478. extern Model* modelGamma;

  479. extern Model* modelDelta;

  480. extern Model* modelVega;

  481. extern Model* modelBD383238;

  482. extern Model* modelZeta;

  483. #undef modelDelta

  484. 

  485. // Meander

  486. extern int panelTheme;

  487. #include "Meander/src/plugin.hpp"

  488. 

  489. // MindMeldModular

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

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

  492. */

  493. extern Model* modelMixMasterJr;

  494. extern Model* modelAuxExpanderJr;

  495. extern Model* modelMixMaster;

  496. extern Model* modelAuxExpander;

  497. extern Model* modelMeld;

  498. extern Model* modelUnmeld;

  499. extern Model* modelMSMelder;

  500. extern Model* modelEqMaster;

  501. extern Model* modelEqExpander;

  502. extern Model* modelBassMaster;

  503. extern Model* modelBassMasterJr;

  504. extern Model* modelShapeMaster;

  505. 

  506. // ML_modules

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

  508. // #include "ML_modules/src/ML_modules.hpp"

  509. */

  510. #define modelQuantizer modelMLQuantizer

  511. #define modelSH8 modelMLSH8

  512. extern Model* modelQuantizer;

  513. extern Model* modelQuantum;

  514. extern Model* modelTrigBuf;

  515. extern Model* modelSeqSwitch;

  516. extern Model* modelSeqSwitch2;

  517. extern Model* modelShiftRegister;

  518. extern Model* modelShiftRegister2;

  519. extern Model* modelFreeVerb;

  520. extern Model* modelSum8;

  521. extern Model* modelSum8mk2;

  522. extern Model* modelSum8mk3;

  523. extern Model* modelSH8;

  524. extern Model* modelConstants;

  525. extern Model* modelCounter;

  526. extern Model* modelTrigDelay;

  527. extern Model* modelBPMdetect;

  528. extern Model* modelVoltMeter;

  529. extern Model* modelOctaFlop;

  530. extern Model* modelOctaTrig;

  531. extern Model* modelOctaSwitch;

  532. extern Model* modelTrigSwitch;

  533. extern Model* modelTrigSwitch2;

  534. extern Model* modelTrigSwitch3;

  535. extern Model* modelTrigSwitch3_2;

  536. extern Model* modelOctaPlus;

  537. extern Model* modelOctaTimes;

  538. extern Model* modelCloner;

  539. extern Model* modelPolySplitter;

  540. extern Model* modelArpeggiator;

  541. #undef modelQuantizer

  542. #undef modelSH8

  543. 

  544. // MockbaModular

  545. #define modelBlank modelMockbaModularBlank

  546. #define modelComparator modelMockbaModularComparator

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

  548. #undef modelBlank

  549. #undef modelComparator

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

  551. #undef min

  552. #define saveBack ignoreMockbaModular1

  553. #define loadBack ignoreMockbaModular2

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

  555. #undef saveBack

  556. #undef loadBack

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

  558. 

  559. // Mog

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

  561. 

  562. // mscHack

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

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

  565. */

  566. extern Model* modelCompressor;

  567. extern Model* modelSynthDrums;

  568. extern Model* modelSEQ_6x32x16;

  569. extern Model* modelMasterClockx8;

  570. extern Model* modelMasterClockx4;

  571. extern Model* modelSEQ_Envelope_8;

  572. extern Model* modelSeq_Triad2;

  573. extern Model* modelARP700;

  574. extern Model* modelMix_24_4_4;

  575. extern Model* modelMix_16_4_4;

  576. extern Model* modelMix_9_3_4;

  577. extern Model* modelMix_4_0_4;

  578. extern Model* modelASAF8;

  579. extern Model* modelPingPong;

  580. extern Model* modelStepDelay;

  581. extern Model* modelOsc_3Ch;

  582. extern Model* modelDronez;

  583. extern Model* modelMorze;

  584. extern Model* modelWindz;

  585. extern Model* modelLorenz;

  586. extern Model* modelAlienz;

  587. extern Model* modelOSC_WaveMorph_3;

  588. extern Model* modelMaude_221;

  589. 

  590. // MSM

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

  592. // #include "MSM/src/MSM.hpp"

  593. */

  594. #define modelADSR modelMSMADSR

  595. #define modelBlankPanel modelMSMBlankPanel

  596. #define modelDelay modelMSMDelay

  597. #define modelLFO modelMSMLFO

  598. #define modelMult modelMSMMult

  599. #define modelNoise modelMSMNoise

  600. #define modelVCA modelMSMVCA

  601. #define modelVCO modelMSMVCO

  602. extern Model* modelVCO;

  603. extern Model* modelBVCO;

  604. extern Model* modelExperimentalVCO;

  605. extern Model* modelNoise;

  606. extern Model* modelLFO;

  607. extern Model* modelVCA;

  608. extern Model* modelADSR;

  609. extern Model* modelDelay;

  610. extern Model* modelWaveShaper;

  611. extern Model* modelWavefolder;

  612. extern Model* modelBitcrusher;

  613. extern Model* modelPhaserModule;

  614. extern Model* modelMorpher;

  615. extern Model* modelRingMod;

  616. extern Model* modelRandomSource;

  617. extern Model* modelMult;

  618. extern Model* modelCrazyMult;

  619. extern Model* modelFade;

  620. extern Model* modelSimpleSlider;

  621. extern Model* modelxseq;

  622. extern Model* modelBlankPanel;

  623. #undef modelADSR

  624. #undef modelBlankPanel

  625. #undef modelDelay

  626. #undef modelLFO

  627. #undef modelMult

  628. #undef modelNoise

  629. #undef modelVCA

  630. #undef modelVCO

  631. 

  632. // Nonlinear Circuits

  633. #include "nonlinearcircuits/src/NLC.hpp"

  634. 

  635. // Orbits

  636. #include "Orbits/src/plugin.hpp"

  637. 

  638. // ParableInstruments

  639. #define modelClouds modelParableClouds

  640. #include "ParableInstruments/src/ArableInstruments.hpp"

  641. #undef modelClouds

  642. 

  643. // Path Set

  644. #include "PathSet/src/plugin.hpp"

  645. 

  646. // PinkTrombone

  647. #include "PinkTrombone/src/plugin.hpp"

  648. 

  649. // Prism

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

  651. 

  652. // rackwindows

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

  654. 

  655. // repelzen

  656. #define modelBlank modelrepelzenBlank

  657. #define modelMixer modelrepelzenMixer

  658. #define modelWerner modelrepelzenWerner

  659. #define tanh_pade repelzentanh_pade

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

  661. #undef modelBlank

  662. #undef modelMixer

  663. #undef modelWerner

  664. #undef tanh_pade

  665. 

  666. // sonusmodular

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

  668. 

  669. // stocaudio

  670. #include "stocaudio/src/plugin.hpp"

  671. 

  672. // unless_modules

  673. #include "unless_modules/src/unless.hpp"

  674. 

  675. // ValleyAudio

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

  677. 

  678. // Voxglitch

  679. #define modelLooper modelVoxglitchLooper

  680. #include "voxglitch/src/plugin.hpp"

  681. #undef modelLooper

  682. 

  683. // WhatTheRack

  684. #include "WhatTheRack/src/WhatTheRack.hpp"

  685. 

  686. // ZetaCarinaeModules

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

  688. 

  689. // ZZC

  690. #define DISPLAYS_H

  691. #define ZZC_SHARED_H

  692. #define ZZC_WIDGETS_H

  693. #define modelClock modelZZCClock

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

  695. #undef modelClock

  696. 

  697. #endif // NOPLUGINS

  698. 

  699. // known terminal modules

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

  701. 

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

  703. int loadConsoleType() { return 0; }

  704. int loadDirectOutMode() { return 0; }

  705. void saveConsoleType(int) {}

  706. void saveDarkAsDefault(bool) {}

  707. void saveDirectOutMode(bool) {}

  708. void saveHighQualityAsDefault(bool) {}

  709. 

  710. // plugin instances

  711. Plugin* pluginInstance__Cardinal;

  712. Plugin* pluginInstance__Fundamental;

  713. #ifndef NOPLUGINS

  714. Plugin* pluginInstance__21kHz;

  715. Plugin* pluginInstance__8Mode;

  716. extern Plugin* pluginInstance__AaronStatic;

  717. Plugin* pluginInstance__Algoritmarte;

  718. Plugin* pluginInstance__AmalgamatedHarmonics;

  719. Plugin* pluginInstance__ArableInstruments;

  720. Plugin* pluginInstance__AnimatedCircuits;

  721. Plugin* pluginInstance__Aria;

  722. Plugin* pluginInstance__AS;

  723. Plugin* pluginInstance__AudibleInstruments;

  724. extern Plugin* pluginInstance__Autinn;

  725. Plugin* pluginInstance__Axioma;

  726. Plugin* pluginInstance__Bacon;

  727. Plugin* pluginInstance__Befaco;

  728. Plugin* pluginInstance__Bidoo;

  729. Plugin* pluginInstance__BogaudioModules;

  730. Plugin* pluginInstance__CatroModulo;

  731. Plugin* pluginInstance__cf;

  732. Plugin* pluginInstance__ChowDSP;

  733. extern Plugin* pluginInstance__DrumKit;

  734. Plugin* pluginInstance__ESeries;

  735. Plugin* pluginInstance__ExpertSleepersEncoders;

  736. Plugin* pluginInstance__Extratone;

  737. Plugin* pluginInstance__FehlerFabrik;

  738. Plugin* pluginInstance__forsitan;

  739. Plugin* pluginInstance__GlueTheGiant;

  740. Plugin* pluginInstance__GoodSheperd;

  741. Plugin* pluginInstance__GrandeModular;

  742. Plugin* pluginInstance__HamptonHarmonics;

  743. Plugin* pluginInstance__HetrickCV;

  744. extern Plugin* pluginInstance__ImpromptuModular;

  745. Plugin* pluginInstance__ihtsyn;

  746. Plugin* pluginInstance__JW;

  747. Plugin* pluginInstance__kocmoc;

  748. Plugin* pluginInstance__LifeFormModular;

  749. Plugin* pluginInstance__LilacLoop;

  750. Plugin* pluginInstance__LittleUtils;

  751. Plugin* pluginInstance__Lomas;

  752. Plugin* pluginInstance__Lyrae;

  753. Plugin* pluginInstance__Meander;

  754. extern Plugin* pluginInstance__MindMeld;

  755. Plugin* pluginInstance__ML;

  756. Plugin* pluginInstance__MockbaModular;

  757. Plugin* pluginInstance__Mog;

  758. extern Plugin* pluginInstance__mscHack;

  759. Plugin* pluginInstance__MSM;

  760. Plugin* pluginInstance__nonlinearcircuits;

  761. Plugin* pluginInstance__Orbits;

  762. Plugin* pluginInstance__ParableInstruments;

  763. Plugin* pluginInstance__PathSet;

  764. Plugin* pluginInstance__PinkTrombone;

  765. Plugin* pluginInstance__Prism;

  766. Plugin* pluginInstance__rackwindows;

  767. Plugin* pluginInstance__repelzen;

  768. Plugin* pluginInstance__sonusmodular;

  769. Plugin* pluginInstance__stocaudio;

  770. Plugin* pluginInstance__unless_modules;

  771. Plugin* pluginInstance__ValleyAudio;

  772. Plugin* pluginInstance__Voxglitch;

  773. Plugin* pluginInstance__WhatTheRack;

  774. Plugin* pluginInstance__ZetaCarinaeModules;

  775. Plugin* pluginInstance__ZZC;

  776. #endif // NOPLUGINS

  777. 

  778. namespace rack {

  779. 

  780. namespace asset {

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

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

  783. }

  784. 

  785. namespace plugin {

  786. 

  787. struct StaticPluginLoader {

  788.     Plugin* const plugin;

  789.     FILE* file;

  790.     json_t* rootJ;

  791. 

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

  793.         : plugin(p),

  794.           file(nullptr),

  795.           rootJ(nullptr)

  796.     {

  797. #ifdef DEBUG

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

  799. #endif

  800. 

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

  802. 

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

  804. 

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

  806.         {

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

  808.             return;

  809.         }

  810. 

  811.         json_error_t error;

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

  813.         {

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

  815.             return;

  816.         }

  817. 

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

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

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

  821.         json_decref(version);

  822.     }

  823. 

  824.     ~StaticPluginLoader()

  825.     {

  826.         if (rootJ != nullptr)

  827.         {

  828.             plugin->fromJson(rootJ);

  829.             json_decref(rootJ);

  830.             plugins.push_back(plugin);

  831.         }

  832. 

  833.         if (file != nullptr)

  834.             std::fclose(file);

  835.     }

  836. 

  837.     bool ok() const noexcept

  838.     {

  839.         return rootJ != nullptr;

  840.     }

  841. 

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

  843.     {

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

  845.         DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);

  846. 

  847.         size_t i;

  848.         json_t* v;

  849.         json_array_foreach(modules, i, v)

  850.         {

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

  852.             {

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

  854.                 {

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

  856.                     {

  857.                         json_array_remove(modules, i);

  858.                         break;

  859.                     }

  860.                 }

  861.             }

  862.         }

  863.     }

  864. };

  865. 

  866. static void initStatic__Cardinal()

  867. {

  868.     Plugin* const p = new Plugin;

  869.     pluginInstance__Cardinal = p;

  870. 

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

  872.     if (spl.ok())

  873.     {

  874.         p->addModel(modelCardinalBlank);

  875.         p->addModel(modelExpanderInputMIDI);

  876.         p->addModel(modelExpanderOutputMIDI);

  877.         p->addModel(modelGlBars);

  878.         p->addModel(modelHostAudio2);

  879.         p->addModel(modelHostAudio8);

  880.         p->addModel(modelHostCV);

  881.         p->addModel(modelHostMIDI);

  882.         p->addModel(modelHostMIDICC);

  883.         p->addModel(modelHostMIDIGate);

  884.         p->addModel(modelHostMIDIMap);

  885.         p->addModel(modelHostParameters);

  886.         p->addModel(modelHostTime);

  887.         p->addModel(modelTextEditor);

  888.        #ifndef STATIC_BUILD

  889.         p->addModel(modelAudioFile);

  890.         p->addModel(modelCarla);

  891.         p->addModel(modelIldaeil);

  892.        #else

  893.         spl.removeModule("AudioFile");

  894.         spl.removeModule("Carla");

  895.         spl.removeModule("Ildaeil");

  896.        #endif

  897.        #ifndef HEADLESS

  898.         p->addModel(modelSassyScope);

  899.        #else

  900.         spl.removeModule("SassyScope");

  901.        #endif

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

  903.         p->addModel(modelMPV);

  904.        #else

  905.         spl.removeModule("MPV");

  906.        #endif

  907.        #ifdef HAVE_FFTW3F

  908.         p->addModel(modelAudioToCVPitch);

  909.        #else

  910.         spl.removeModule("AudioToCVPitch");

  911.        #endif

  912. 

  913.         hostTerminalModels = {

  914.             modelHostAudio2,

  915.             modelHostAudio8,

  916.             modelHostCV,

  917.             modelHostMIDI,

  918.             modelHostMIDICC,

  919.             modelHostMIDIGate,

  920.             modelHostMIDIMap,

  921.             modelHostParameters,

  922.             modelHostTime,

  923.         };

  924.     }

  925. }

  926. 

  927. static void initStatic__Fundamental()

  928. {

  929.     Plugin* const p = new Plugin;

  930.     pluginInstance__Fundamental = p;

  931. 

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

  933.     if (spl.ok())

  934.     {

  935.         p->addModel(model_8vert);

  936.         p->addModel(modelADSR);

  937.         p->addModel(modelDelay);

  938.         p->addModel(modelLFO);

  939.         p->addModel(modelLFO2);

  940.         p->addModel(modelMerge);

  941.         p->addModel(modelMidSide);

  942.         p->addModel(modelMixer);

  943.         p->addModel(modelMutes);

  944.         p->addModel(modelNoise);

  945.         p->addModel(modelOctave);

  946.         p->addModel(modelPulses);

  947.         p->addModel(modelQuantizer);

  948.         p->addModel(modelRandom);

  949.         p->addModel(modelScope);

  950.         p->addModel(modelSEQ3);

  951.         p->addModel(modelSequentialSwitch1);

  952.         p->addModel(modelSequentialSwitch2);

  953.         p->addModel(modelSplit);

  954.         p->addModel(modelSum);

  955.         p->addModel(modelVCA);

  956.         p->addModel(modelVCA_1);

  957.         p->addModel(modelVCF);

  958.         p->addModel(modelVCMixer);

  959.         p->addModel(modelVCO);

  960.         p->addModel(modelVCO2);

  961.     }

  962. }

  963. 

  964. #ifndef NOPLUGINS

  965. static void initStatic__21kHz()

  966. {

  967.     Plugin* const p = new Plugin;

  968.     pluginInstance__21kHz = p;

  969. 

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

  971.     if (spl.ok())

  972.     {

  973.         p->addModel(modelPalmLoop);

  974.         p->addModel(modelD_Inf);

  975.         p->addModel(modelTachyonEntangler);

  976.     }

  977. }

  978. 

  979. static void initStatic__8Mode()

  980. {

  981.     Plugin* const p = new Plugin;

  982.     pluginInstance__8Mode = p;

  983. 

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

  985.     if (spl.ok())

  986.     {

  987.         p->addModel(modelsoftSN);

  988.     }

  989. }

  990. 

  991. static void initStatic__AaronStatic()

  992. {

  993.     Plugin* const p = new Plugin;

  994.     pluginInstance__AaronStatic = p;

  995. 

  996.     const StaticPluginLoader spl(p, "AaronStatic");

  997.     if (spl.ok())

  998.     {

  999.         p->addModel(modelChordCV);

  1000.         p->addModel(modelScaleCV);

  1001.         p->addModel(modelRandomNoteCV);

  1002.         p->addModel(modelDiatonicCV);

  1003.     }

  1004. }

  1005. 

  1006. static void initStatic__Algoritmarte()

  1007. {

  1008.     Plugin* const p = new Plugin;

  1009.     pluginInstance__Algoritmarte = p;

  1010. 

  1011.     const StaticPluginLoader spl(p, "Algoritmarte");

  1012.     if (spl.ok())

  1013.     {

  1014.         p->addModel(modelClockkky);

  1015.         p->addModel(modelPlanetz);

  1016.         p->addModel(modelMusiFrog);

  1017.         p->addModel(modelZefiro);

  1018.         p->addModel(modelHoldMeTight);

  1019.         p->addModel(modelCyclicCA);

  1020.         p->addModel(modelMusiMath);

  1021.     }

  1022. }

  1023. 

  1024. static void initStatic__AmalgamatedHarmonics()

  1025. {

  1026.     Plugin* const p = new Plugin;

  1027.     pluginInstance__AmalgamatedHarmonics = p;

  1028. 

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

  1030.     if (spl.ok())

  1031.     {

  1032.         p->addModel(modelArp31);

  1033.         p->addModel(modelArp32);

  1034.         p->addModel(modelBombe);

  1035.         p->addModel(modelChord);

  1036.         p->addModel(modelCircle);

  1037.         p->addModel(modelGalaxy);

  1038.         p->addModel(modelGenerative);

  1039.         p->addModel(modelImp);

  1040.         p->addModel(modelImperfect2);

  1041.         p->addModel(modelProgress2);

  1042.         p->addModel(modelRuckus);

  1043.         p->addModel(modelScaleQuantizer2);

  1044.         p->addModel(modelSLN);

  1045.         p->addModel(modelMuxDeMux);

  1046.         p->addModel(modelPolyProbe);

  1047.         p->addModel(modelPolyScope);

  1048.         p->addModel(modelPolyUtils);

  1049.         p->addModel(modelPolyVolt);

  1050.         p->addModel(modelScaleQuantizer);

  1051.         p->addModel(modelArpeggiator2);

  1052.         p->addModel(modelProgress);

  1053.     }

  1054. }

  1055. 

  1056. static void initStatic__AnimatedCircuits()

  1057. {

  1058.     Plugin* const p = new Plugin;

  1059.     pluginInstance__AnimatedCircuits = p;

  1060. 

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

  1062.     if (spl.ok())

  1063.     {

  1064.         p->addModel(model_AC_Folding);

  1065.         p->addModel(model_AC_LFold);

  1066.     }

  1067. }

  1068. 

  1069. static void initStatic__ArableInstruments()

  1070. {

  1071.     Plugin* const p = new Plugin;

  1072.     pluginInstance__ArableInstruments = p;

  1073. 

  1074.     const StaticPluginLoader spl(p, "ArableInstruments");

  1075.     if (spl.ok())

  1076.     {

  1077. #define modelClouds modelArableClouds

  1078.         p->addModel(modelClouds);

  1079. #undef modelClouds

  1080.     }

  1081. }

  1082. 

  1083. static void initStatic__Aria()

  1084. {

  1085.     Plugin* const p = new Plugin;

  1086.     pluginInstance__Aria = p;

  1087. 

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

  1089.     if (spl.ok())

  1090.     {

  1091. #define modelBlank modelAriaBlank

  1092.         p->addModel(modelSplort);

  1093.         p->addModel(modelSmerge);

  1094.         p->addModel(modelSpleet);

  1095.         p->addModel(modelSwerge);

  1096.         p->addModel(modelSplirge);

  1097.         p->addModel(modelQqqq);

  1098.         p->addModel(modelQuack);

  1099.         p->addModel(modelQ);

  1100.         p->addModel(modelQuale);

  1101.         p->addModel(modelDarius);

  1102.         p->addModel(modelSolomon4);

  1103.         p->addModel(modelSolomon8);

  1104.         p->addModel(modelSolomon16);

  1105.         p->addModel(modelPsychopump);

  1106.         p->addModel(modelPokies4);

  1107.         p->addModel(modelGrabby);

  1108.         p->addModel(modelRotatoes4);

  1109.         p->addModel(modelUndular);

  1110.         p->addModel(modelBlank);

  1111. #undef modelBlank

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

  1113.         spl.removeModule("Arcane");

  1114.         spl.removeModule("Atout");

  1115.         spl.removeModule("Aleister");

  1116.     }

  1117. }

  1118. 

  1119. static void initStatic__AS()

  1120. {

  1121.     Plugin* const p = new Plugin;

  1122.     pluginInstance__AS = p;

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

  1124.     if (spl.ok())

  1125.     {

  1126. #define modelADSR modelASADSR

  1127. #define modelVCA modelASVCA

  1128.         //OSCILLATORS

  1129.         p->addModel(modelSineOsc);

  1130.         p->addModel(modelSawOsc);

  1131.         //TOOLS

  1132.         p->addModel(modelADSR);

  1133.         p->addModel(modelVCA);

  1134.         p->addModel(modelQuadVCA);

  1135.         p->addModel(modelTriLFO);

  1136.         p->addModel(modelAtNuVrTr);

  1137.         p->addModel(modelBPMClock);

  1138.         p->addModel(modelSEQ16);

  1139.         p->addModel(modelMixer2ch);

  1140.         p->addModel(modelMixer4ch);

  1141.         p->addModel(modelMixer8ch);

  1142.         p->addModel(modelMonoVUmeter);

  1143.         p->addModel(modelStereoVUmeter);

  1144.         p->addModel(modelMultiple2_5);

  1145.         p->addModel(modelMerge2_5);

  1146.         p->addModel(modelSteps);

  1147.         p->addModel(modelLaunchGate);

  1148.         p->addModel(modelKillGate);

  1149.         p->addModel(modelFlow);

  1150.         p->addModel(modelSignalDelay);

  1151.         p->addModel(modelTriggersMKI);

  1152.         p->addModel(modelTriggersMKII);

  1153.         p->addModel(modelTriggersMKIII);

  1154.         p->addModel(modelBPMCalc);

  1155.         p->addModel(modelBPMCalc2);

  1156.         p->addModel(modelCv2T);

  1157.         p->addModel(modelZeroCV2T);

  1158.         p->addModel(modelReScale);

  1159.         //EFFECTS

  1160.         p->addModel(modelDelayPlusFx);

  1161.         p->addModel(modelDelayPlusStereoFx);

  1162.         p->addModel(modelPhaserFx);

  1163.         p->addModel(modelReverbFx);

  1164.         p->addModel(modelReverbStereoFx);

  1165.         p->addModel(modelSuperDriveFx);

  1166.         p->addModel(modelSuperDriveStereoFx);

  1167.         p->addModel(modelTremoloFx);

  1168.         p->addModel(modelTremoloStereoFx);

  1169.         p->addModel(modelWaveShaper);

  1170.         p->addModel(modelWaveShaperStereo);

  1171.         //BLANK PANELS

  1172.         p->addModel(modelBlankPanel4);

  1173.         p->addModel(modelBlankPanel6);

  1174.         p->addModel(modelBlankPanel8);

  1175.         p->addModel(modelBlankPanelSpecial);

  1176. #undef modelADSR

  1177. #undef modelVCA

  1178.     }

  1179. }

  1180. 

  1181. static void initStatic__AudibleInstruments()

  1182. {

  1183.     Plugin* const p = new Plugin;

  1184.     pluginInstance__AudibleInstruments = p;

  1185. 

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

  1187.     if (spl.ok())

  1188.     {

  1189.         p->addModel(modelBraids);

  1190.         p->addModel(modelPlaits);

  1191.         p->addModel(modelElements);

  1192.         p->addModel(modelTides);

  1193.         p->addModel(modelTides2);

  1194.         p->addModel(modelClouds);

  1195.         p->addModel(modelWarps);

  1196.         p->addModel(modelRings);

  1197.         p->addModel(modelLinks);

  1198.         p->addModel(modelKinks);

  1199.         p->addModel(modelShades);

  1200.         p->addModel(modelBranches);

  1201.         p->addModel(modelBlinds);

  1202.         p->addModel(modelVeils);

  1203.         p->addModel(modelFrames);

  1204.         p->addModel(modelMarbles);

  1205.         p->addModel(modelStages);

  1206.         p->addModel(modelRipples);

  1207.         p->addModel(modelShelves);

  1208.         p->addModel(modelStreams);

  1209.     }

  1210. }

  1211. 

  1212. static void initStatic__Autinn()

  1213. {

  1214.     Plugin* const p = new Plugin;

  1215.     pluginInstance__Autinn = p;

  1216. 

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

  1218.     if (spl.ok())

  1219.     {

  1220. #define modelChord modelAutinnChord

  1221. #define modelVibrato modelAutinnVibrato

  1222.         p->addModel(modelAmp);

  1223.         p->addModel(modelDeadband);

  1224.         p->addModel(modelBass);

  1225.         p->addModel(modelCVConverter);

  1226.         p->addModel(modelDC);

  1227.         p->addModel(modelDigi);

  1228.         p->addModel(modelFlopper);

  1229.         p->addModel(modelFlora);

  1230.         p->addModel(modelJette);

  1231.         p->addModel(modelBoomerang);

  1232.         p->addModel(modelOxcart);

  1233.         p->addModel(modelSaw);

  1234.         p->addModel(modelSjip);

  1235.         p->addModel(modelSquare);

  1236.         p->addModel(modelVibrato);

  1237.         p->addModel(modelVectorDriver);

  1238.         p->addModel(modelZod);

  1239.         p->addModel(modelTriBand);

  1240.         p->addModel(modelMixer6);

  1241.         p->addModel(modelNon);

  1242.         p->addModel(modelFil);

  1243.         p->addModel(modelNap);

  1244.         p->addModel(modelMelody);

  1245.         p->addModel(modelChord);

  1246. #undef modelChord

  1247. #undef modelVibrato

  1248.     }

  1249. }

  1250. 

  1251. static void initStatic__Axioma()

  1252. {

  1253.     Plugin* const p = new Plugin;

  1254.     pluginInstance__Axioma = p;

  1255. 

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

  1257.     if (spl.ok())

  1258.     {

  1259.         p->addModel(modelTheBifurcator);

  1260.         p->addModel(modelTesseract);

  1261.         p->addModel(modelIkeda);

  1262.         p->addModel(modelRhodonea);

  1263.     }

  1264. }

  1265. 

  1266. static void initStatic__Bacon()

  1267. {

  1268.     Plugin* const p = new Plugin;

  1269.     pluginInstance__Bacon = p;

  1270. 

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

  1272.     if (spl.ok())

  1273.     {

  1274.         p->addModel(modelHarMoNee);

  1275.         p->addModel(modelGlissinator);

  1276.         p->addModel(modelPolyGnome);

  1277.         p->addModel(modelQuantEyes);

  1278.         p->addModel(modelSampleDelay);

  1279. #ifdef BUILD_SORTACHORUS

  1280.         p->addModel(modelSortaChorus);

  1281. #endif

  1282.         p->addModel(modelChipNoise);

  1283.         p->addModel(modelChipWaves);

  1284.         p->addModel(modelChipYourWave);

  1285.         p->addModel(modelOpen303);

  1286. #ifdef BUILD_GENERICLSFR

  1287.         p->addModel(modelGenericLFSR);

  1288. #endif

  1289.         p->addModel(modelKarplusStrongPoly);

  1290.         p->addModel(modelALingADing);

  1291.         p->addModel(modelBitulator);

  1292. #ifdef BUILD_PHASER

  1293.         p->addModel(modelPhaser);

  1294. #endif

  1295.         p->addModel(modelPolyGenerator);

  1296.     }

  1297. }

  1298. 

  1299. static void initStatic__Befaco()

  1300. {

  1301.     Plugin* const p = new Plugin;

  1302.     pluginInstance__Befaco = p;

  1303. 

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

  1305.     if (spl.ok())

  1306.     {

  1307. #define modelADSR modelBefacoADSR

  1308. #define modelMixer modelBefacoMixer

  1309.         p->addModel(modelEvenVCO);

  1310.         p->addModel(modelRampage);

  1311.         p->addModel(modelABC);

  1312.         p->addModel(modelSpringReverb);

  1313.         p->addModel(modelMixer);

  1314.         p->addModel(modelSlewLimiter);

  1315.         p->addModel(modelDualAtenuverter);

  1316.         p->addModel(modelPercall);

  1317.         p->addModel(modelHexmixVCA);

  1318.         p->addModel(modelChoppingKinky);

  1319.         p->addModel(modelKickall);

  1320.         p->addModel(modelSamplingModulator);

  1321.         p->addModel(modelMorphader);

  1322.         p->addModel(modelADSR);

  1323.         p->addModel(modelSTMix);

  1324.         p->addModel(modelMuxlicer);

  1325.         p->addModel(modelMex);

  1326.         p->addModel(modelNoisePlethora);

  1327.         p->addModel(modelChannelStrip);

  1328. #undef modelADSR

  1329. #undef modelMixer

  1330.     }

  1331. }

  1332. 

  1333. static void initStatic__Bidoo()

  1334. {

  1335.     Plugin* const p = new Plugin;

  1336.     pluginInstance__Bidoo = p;

  1337. 

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

  1339.     if (spl.ok())

  1340.     {

  1341.         p->addModel(modelTOCANTE);

  1342.         p->addModel(modelLATE);

  1343.         p->addModel(modelDIKTAT);

  1344.         p->addModel(modelDTROY);

  1345.         p->addModel(modelBORDL);

  1346.         p->addModel(modelZOUMAI);

  1347.         p->addModel(modelZOUMAIExpander);

  1348.         p->addModel(modelMU);

  1349.         p->addModel(modelCHUTE);

  1350.         p->addModel(modelLOURDE);

  1351.         p->addModel(modelDILEMO);

  1352.         p->addModel(modelLAMBDA);

  1353.         p->addModel(modelBANCAU);

  1354.         p->addModel(modelACNE);

  1355.         p->addModel(modelMS);

  1356.         p->addModel(modelDUKE);

  1357.         p->addModel(modelMOIRE);

  1358.         p->addModel(modelPILOT);

  1359.         p->addModel(modelHUITRE);

  1360.         p->addModel(modelOUAIVE);

  1361.         p->addModel(modelEDSAROS);

  1362.         p->addModel(modelPOUPRE);

  1363.         p->addModel(modelMAGMA);

  1364.         p->addModel(modelOAI);

  1365.         p->addModel(modelCANARD);

  1366.         p->addModel(modelEMILE);

  1367.         p->addModel(modelFORK);

  1368.         p->addModel(modelTIARE);

  1369.         p->addModel(modelLIMONADE);

  1370.         p->addModel(modelLIMBO);

  1371.         p->addModel(modelPERCO);

  1372.         p->addModel(modelBAFIS);

  1373.         p->addModel(modelBAR);

  1374.         p->addModel(modelMINIBAR);

  1375.         p->addModel(modelZINC);

  1376.         p->addModel(modelFREIN);

  1377.         p->addModel(modelHCTIP);

  1378.         p->addModel(modelSPORE);

  1379.         p->addModel(modelDFUZE);

  1380.         p->addModel(modelREI);

  1381.         p->addModel(modelRABBIT);

  1382.         p->addModel(modelBISTROT);

  1383.         p->addModel(modelSIGMA);

  1384.         p->addModel(modelFLAME);

  1385.         p->addModel(modelVOID);

  1386. 

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

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

  1389.         spl.removeModule("antN");

  1390.     }

  1391. }

  1392. 

  1393. static void initStatic__BogaudioModules()

  1394. {

  1395.     Plugin* const p = new Plugin;

  1396.     pluginInstance__BogaudioModules = p;

  1397. 

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

  1399.     if (spl.ok())

  1400.     {

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

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

  1403.         skins._default = "dark";

  1404. #define modelADSR modelBogaudioADSR

  1405. #define modelLFO modelBogaudioLFO

  1406. #define modelNoise modelBogaudioNoise

  1407. #define modelVCA modelBogaudioVCA

  1408. #define modelVCF modelBogaudioVCF

  1409. #define modelVCO modelBogaudioVCO

  1410.         p->addModel(modelVCO);

  1411.         p->addModel(modelLVCO);

  1412.         p->addModel(modelSine);

  1413.         p->addModel(modelPulse);

  1414.         p->addModel(modelXCO);

  1415.         p->addModel(modelAdditator);

  1416.         p->addModel(modelFMOp);

  1417.         p->addModel(modelChirp);

  1418.         p->addModel(modelLFO);

  1419.         p->addModel(modelLLFO);

  1420.         p->addModel(modelFourFO);

  1421.         p->addModel(modelEightFO);

  1422.         p->addModel(modelVCF);

  1423.         p->addModel(modelLVCF);

  1424.         p->addModel(modelFFB);

  1425.         p->addModel(modelEQ);

  1426.         p->addModel(modelEQS);

  1427.         p->addModel(modelLPG);

  1428.         p->addModel(modelLLPG);

  1429.         p->addModel(modelMegaGate);

  1430.         p->addModel(modelPEQ);

  1431.         p->addModel(modelPEQ6);

  1432.         p->addModel(modelPEQ6XF);

  1433.         p->addModel(modelPEQ14);

  1434.         p->addModel(modelPEQ14XF);

  1435.         p->addModel(modelDADSRH);

  1436.         p->addModel(modelDADSRHPlus);

  1437.         p->addModel(modelShaper);

  1438.         p->addModel(modelShaperPlus);

  1439.         p->addModel(modelAD);

  1440.         p->addModel(modelASR);

  1441.         p->addModel(modelADSR);

  1442.         p->addModel(modelVish);

  1443.         p->addModel(modelFollow);

  1444.         p->addModel(modelDGate);

  1445.         p->addModel(modelRGate);

  1446.         p->addModel(modelEdge);

  1447.         p->addModel(modelNoise);

  1448.         p->addModel(modelSampleHold);

  1449.         p->addModel(modelWalk2);

  1450.         p->addModel(modelWalk);

  1451.         p->addModel(modelMix8);

  1452.         p->addModel(modelMix8x);

  1453.         p->addModel(modelMix4);

  1454.         p->addModel(modelMix4x);

  1455.         p->addModel(modelMix2);

  1456.         p->addModel(modelMix1);

  1457.         p->addModel(modelVCM);

  1458.         p->addModel(modelMute8);

  1459.         p->addModel(modelPan);

  1460.         p->addModel(modelXFade);

  1461.         p->addModel(modelVCA);

  1462.         p->addModel(modelVCAmp);

  1463.         p->addModel(modelVelo);

  1464.         p->addModel(modelUMix);

  1465.         p->addModel(modelMumix);

  1466.         p->addModel(modelMatrix81);

  1467.         p->addModel(modelMatrix18);

  1468.         p->addModel(modelMatrix44);

  1469.         p->addModel(modelMatrix44Cvm);

  1470.         p->addModel(modelMatrix88);

  1471.         p->addModel(modelMatrix88Cv);

  1472.         p->addModel(modelMatrix88M);

  1473.         p->addModel(modelSwitch81);

  1474.         p->addModel(modelSwitch18);

  1475.         p->addModel(modelSwitch44);

  1476.         p->addModel(modelSwitch88);

  1477.         p->addModel(modelSwitch1616);

  1478.         p->addModel(modelAMRM);

  1479.         p->addModel(modelPressor);

  1480.         p->addModel(modelClpr);

  1481.         p->addModel(modelLmtr);

  1482.         p->addModel(modelNsgt);

  1483.         p->addModel(modelCmpDist);

  1484.         p->addModel(modelOneEight);

  1485.         p->addModel(modelEightOne);

  1486.         p->addModel(modelAddrSeq);

  1487.         p->addModel(modelAddrSeqX);

  1488.         p->addModel(modelPgmr);

  1489.         p->addModel(modelPgmrX);

  1490.         p->addModel(modelVU);

  1491.         p->addModel(modelAnalyzer);

  1492.         p->addModel(modelAnalyzerXL);

  1493.         p->addModel(modelRanalyzer);

  1494.         p->addModel(modelDetune);

  1495.         p->addModel(modelStack);

  1496.         p->addModel(modelReftone);

  1497.         p->addModel(modelMono);

  1498.         p->addModel(modelArp);

  1499.         p->addModel(modelAssign);

  1500.         p->addModel(modelUnison);

  1501.         p->addModel(modelPolyCon8);

  1502.         p->addModel(modelPolyCon16);

  1503.         p->addModel(modelPolyOff8);

  1504.         p->addModel(modelPolyOff16);

  1505.         p->addModel(modelPolyMult);

  1506.         p->addModel(modelBool);

  1507.         p->addModel(modelCmp);

  1508.         p->addModel(modelCVD);

  1509.         p->addModel(modelFlipFlop);

  1510.         p->addModel(modelInv);

  1511.         p->addModel(modelManual);

  1512.         p->addModel(modelFourMan);

  1513.         p->addModel(modelMult);

  1514.         p->addModel(modelOffset);

  1515.         p->addModel(modelSlew);

  1516.         p->addModel(modelSums);

  1517.         p->addModel(modelSwitch);

  1518.         p->addModel(modelLgsw);

  1519.         p->addModel(modelBlank3);

  1520.         p->addModel(modelBlank6);

  1521. #ifdef EXPERIMENTAL

  1522.         p->addModel(modelLag);

  1523.         p->addModel(modelPEQ14XR);

  1524.         p->addModel(modelPEQ14XV);

  1525. #endif

  1526. #ifdef TEST

  1527.         p->addModel(modelTest);

  1528.         p->addModel(modelTest2);

  1529.         p->addModel(modelTestExpanderBase);

  1530.         p->addModel(modelTestExpanderExtension);

  1531.         p->addModel(modelTestGl);

  1532.         p->addModel(modelTestVCF);

  1533. #endif

  1534. #undef modelADSR

  1535. #undef modelLFO

  1536. #undef modelNoise

  1537. #undef modelVCA

  1538. #undef modelVCF

  1539. #undef modelVCO

  1540.     }

  1541. }

  1542. 

  1543. static void initStatic__CatroModulo()

  1544. {

  1545.     Plugin* const p = new Plugin;

  1546.     pluginInstance__CatroModulo = p;

  1547. 

  1548.     const StaticPluginLoader spl(p, "CatroModulo");

  1549.     if (spl.ok())

  1550.     {

  1551.         p->addModel(modelCM1Module);

  1552.         p->addModel(modelCM2Module);

  1553.         p->addModel(modelCM3Module);

  1554.         p->addModel(modelCM4Module);

  1555.         p->addModel(modelCM5Module);

  1556.         p->addModel(modelCM6Module);

  1557.         p->addModel(modelCM7Module);

  1558.         p->addModel(modelCM8Module);

  1559.         p->addModel(modelCM9Module);

  1560.         p->addModel(modelCM10Module);

  1561.     }

  1562. }

  1563. 

  1564. static void initStatic__cf()

  1565. {

  1566.     Plugin* const p = new Plugin;

  1567.     pluginInstance__cf = p;

  1568. 

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

  1570.     if (spl.ok())

  1571.     {

  1572.         p->addModel(modelMETRO);

  1573.         p->addModel(modelEACH);

  1574.         p->addModel(modeltrSEQ);

  1575.         p->addModel(modelLEDSEQ);

  1576.         p->addModel(modelL3DS3Q);

  1577.         p->addModel(modelSLIDERSEQ);

  1578.         p->addModel(modelPLAYER);

  1579.         p->addModel(modelPLAY);

  1580.         p->addModel(modelMONO);

  1581.         p->addModel(modelSTEREO);

  1582.         p->addModel(modelSUB);

  1583.         p->addModel(modelMASTER);

  1584.         p->addModel(modelVARIABLE);

  1585.         p->addModel(modelALGEBRA);

  1586.         p->addModel(modelFUNKTION);

  1587.         p->addModel(modelCHOKE);

  1588.         p->addModel(modelFOUR);

  1589.         p->addModel(modelSTEPS);

  1590.         p->addModel(modelPEAK);

  1591.         p->addModel(modelCUTS);

  1592.         p->addModel(modelBUFFER);

  1593.         p->addModel(modelDISTO);

  1594.         p->addModel(modelCUBE);

  1595.         p->addModel(modelPATCH);

  1596.         p->addModel(modelLABEL);

  1597.         p->addModel(modelDAVE);

  1598.     }

  1599. }

  1600. 

  1601. static void initStatic__ChowDSP()

  1602. {

  1603.     Plugin* const p = new Plugin;

  1604.     pluginInstance__ChowDSP = p;

  1605. 

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

  1607.     if (spl.ok())

  1608.     {

  1609.         p->addModel(modelChowTape);

  1610.         p->addModel(modelChowPhaserFeedback);

  1611.         p->addModel(modelChowPhaserMod);

  1612.         p->addModel(modelChowFDN);

  1613.         p->addModel(modelChowRNN);

  1614.         p->addModel(modelChowModal);

  1615.         p->addModel(modelChowDer);

  1616.         p->addModel(modelWarp);

  1617.         p->addModel(modelWerner);

  1618.         p->addModel(modelCredit);

  1619.         p->addModel(modelChowPulse);

  1620.         p->addModel(modelChowTapeCompression);

  1621.         p->addModel(modelChowTapeChew);

  1622.         p->addModel(modelChowTapeDegrade);

  1623.         p->addModel(modelChowTapeLoss);

  1624.         p->addModel(modelChowChorus);

  1625.     }

  1626. }

  1627. 

  1628. static void initStatic__DrumKit()

  1629. {

  1630.     Plugin* const p = new Plugin;

  1631.     pluginInstance__DrumKit = p;

  1632. 

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

  1634.     if (spl.ok())

  1635.     {

  1636.         setupSamples();

  1637.         p->addModel(modelBD9);

  1638.         p->addModel(modelSnare);

  1639.         p->addModel(modelClosedHH);

  1640.         p->addModel(modelOpenHH);

  1641.         p->addModel(modelDMX);

  1642.         p->addModel(modelCR78);

  1643.         p->addModel(modelSBD);

  1644.         p->addModel(modelGnome);

  1645.         p->addModel(modelSequencer);

  1646.         p->addModel(modelTomi);

  1647.         p->addModel(modelBaronial);

  1648.         p->addModel(modelMarionette);

  1649.     }

  1650. }

  1651. 

  1652. static void initStatic__ESeries()

  1653. {

  1654.     Plugin* const p = new Plugin;

  1655.     pluginInstance__ESeries = p;

  1656. 

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

  1658.     if (spl.ok())

  1659.     {

  1660.         p->addModel(modelE340);

  1661.     }

  1662. }

  1663. 

  1664. static void initStatic__ExpertSleepersEncoders()

  1665. {

  1666.     Plugin* const p = new Plugin;

  1667.     pluginInstance__ExpertSleepersEncoders = p;

  1668. 

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

  1670.     if (spl.ok())

  1671.     {

  1672.         p->addModel(model8GT);

  1673.         p->addModel(model8CV);

  1674.         p->addModel(modelES40);

  1675.         p->addModel(modelES5);

  1676.         p->addModel(modelSMUX);

  1677.         p->addModel(modelCalibrator);

  1678.     }

  1679. }

  1680. 

  1681. static void initStatic__Extratone()

  1682. {

  1683.     Plugin* const p = new Plugin;

  1684.     pluginInstance__Extratone = p;

  1685. 

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

  1687.     if (spl.ok())

  1688.     {

  1689.         p->addModel(modelModulo);

  1690.         p->addModel(modelMesoglea);

  1691.         p->addModel(modelMesoglea2);

  1692.         p->addModel(modelOpabinia);

  1693.         p->addModel(modelSplitterburst);

  1694.         p->addModel(modelPuzzlebox);

  1695.         p->addModel(modelDarwinism);

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

  1697.         p->addModel(modelIchneumonid);

  1698.         p->addModel(modelMeganeura);

  1699.         p->addModel(modelPureneura);

  1700.         p->addModel(modelMesohyl);

  1701.         p->addModel(modelXtrtnBlank);

  1702.     }

  1703. }

  1704. 

  1705. static void initStatic__FehlerFabrik()

  1706. {

  1707.     Plugin* const p = new Plugin;

  1708.     pluginInstance__FehlerFabrik = p;

  1709. 

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

  1711.     if (spl.ok())

  1712.     {

  1713.         p->addModel(modelPSIOP);

  1714.         p->addModel(modelPlanck);

  1715.         p->addModel(modelLuigi);

  1716.         p->addModel(modelAspect);

  1717.         p->addModel(modelMonte);

  1718.         p->addModel(modelArpanet);

  1719.         p->addModel(modelSigma);

  1720.         p->addModel(modelFax);

  1721.         p->addModel(modelRasoir);

  1722.         p->addModel(modelChi);

  1723.         p->addModel(modelNova);

  1724.         p->addModel(modelLilt);

  1725.         p->addModel(modelBotzinger);

  1726.     }

  1727. }

  1728. 

  1729. static void initStatic__forsitan()

  1730. {

  1731.     Plugin* const p = new Plugin;

  1732.     pluginInstance__forsitan = p;

  1733. 

  1734.     const StaticPluginLoader spl(p, "forsitan-modulare");

  1735.     if (spl.ok())

  1736.     {

  1737.         p->addModel(alea);

  1738.         p->addModel(interea);

  1739.         p->addModel(cumuli);

  1740.         p->addModel(deinde);

  1741.         p->addModel(pavo);

  1742.     }

  1743. }

  1744. 

  1745. static void initStatic__GlueTheGiant()

  1746. {

  1747.     Plugin* const p = new Plugin;

  1748.     pluginInstance__GlueTheGiant = p;

  1749. 

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

  1751.     if (spl.ok())

  1752.     {

  1753.         p->addModel(modelGigBus);

  1754.         p->addModel(modelMiniBus);

  1755.         p->addModel(modelSchoolBus);

  1756.         p->addModel(modelMetroCityBus);

  1757.         p->addModel(modelBusDepot);

  1758.         p->addModel(modelBusRoute);

  1759.         p->addModel(modelRoad);

  1760.         p->addModel(modelEnterBus);

  1761.         p->addModel(modelExitBus);

  1762.     }

  1763. }

  1764. 

  1765. static void initStatic__GoodSheperd()

  1766. {

  1767.     Plugin* const p = new Plugin;

  1768.     pluginInstance__GoodSheperd = p;

  1769. 

  1770.     const StaticPluginLoader spl(p, "GoodSheperd");

  1771.     if (spl.ok())

  1772.     {

  1773.         p->addModel(modelHurdle);

  1774.         p->addModel(modelSEQ3st);

  1775.         p->addModel(modelStable16);

  1776.         p->addModel(modelStall);

  1777.         p->addModel(modelSwitch1);

  1778.         p->addModel(modelSeqtrol);

  1779.     }

  1780. }

  1781. 

  1782. static void initStatic__GrandeModular()

  1783. {

  1784.     Plugin* const p = new Plugin;

  1785.     pluginInstance__GrandeModular = p;

  1786. 

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

  1788.     if (spl.ok())

  1789.     {

  1790.         p->addModel(modelClip);

  1791.         p->addModel(modelLFO3);

  1792.         p->addModel(modelLFO4);

  1793.         p->addModel(modelLogic);

  1794.         p->addModel(modelMerge8);

  1795.         p->addModel(modelMergeSplit4);

  1796.         p->addModel(modelMicrotonalChords);

  1797.         p->addModel(modelMicrotonalNotes);

  1798.         p->addModel(modelNoteMT);

  1799.         p->addModel(modelPeak);

  1800.         p->addModel(modelPolyMergeResplit);

  1801.         p->addModel(modelPolySplit);

  1802.         p->addModel(modelPush);

  1803.         p->addModel(modelQuant);

  1804.         p->addModel(modelQuantIntervals);

  1805.         p->addModel(modelQuantMT);

  1806.         p->addModel(modelSampleDelays);

  1807.         p->addModel(modelScale);

  1808.         p->addModel(modelSplit8);

  1809.         p->addModel(modelTails);

  1810.         p->addModel(modelVarSampleDelays);

  1811.         p->addModel(modelVCA3);

  1812.         p->addModel(modelVCA4);

  1813.     }

  1814. }

  1815. 

  1816. static void initStatic__HamptonHarmonics()

  1817. {

  1818.     Plugin* const p = new Plugin;

  1819.     pluginInstance__HamptonHarmonics = p;

  1820. 

  1821.     const StaticPluginLoader spl(p, "HamptonHarmonics");

  1822.     if (spl.ok())

  1823.     {

  1824. #define modelArp modelHamptonHarmonicsArp

  1825. #define modelProgress modelHamptonHarmonicsProgress

  1826.         p->addModel(modelArp);

  1827.         p->addModel(modelProgress);

  1828. #undef modelProgress

  1829. #undef modelArp

  1830.     }

  1831. }

  1832. 

  1833. static void initStatic__HetrickCV()

  1834. {

  1835.     Plugin* const p = new Plugin;

  1836.     pluginInstance__HetrickCV = p;

  1837. 

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

  1839.     if (spl.ok())

  1840.     {

  1841. #define modelASR modelHetrickCVASR

  1842. #define modelBlankPanel modelHetrickCVBlankPanel

  1843. #define modelFlipFlop modelHetrickCVFlipFlop

  1844. #define modelMidSide modelHetrickCVMidSide

  1845. #define modelMinMax modelHetrickCVMinMax

  1846.         p->addModel(modelTwoToFour);

  1847.         p->addModel(modelAnalogToDigital);

  1848.         p->addModel(modelASR);

  1849.         p->addModel(modelBinaryGate);

  1850.         p->addModel(modelBinaryNoise);

  1851.         p->addModel(modelBitshift);

  1852.         p->addModel(modelBlankPanel);

  1853.         p->addModel(modelBoolean3);

  1854.         p->addModel(modelChaos1Op);

  1855.         p->addModel(modelChaos2Op);

  1856.         p->addModel(modelChaos3Op);

  1857.         p->addModel(modelChaoticAttractors);

  1858.         p->addModel(modelClockedNoise);

  1859.         p->addModel(modelComparator);

  1860.         p->addModel(modelContrast);

  1861.         p->addModel(modelCrackle);

  1862.         p->addModel(modelDataCompander);

  1863.         p->addModel(modelDelta);

  1864.         p->addModel(modelDigitalToAnalog);

  1865.         p->addModel(modelDust);

  1866.         p->addModel(modelExponent);

  1867.         p->addModel(modelFBSineChaos);

  1868.         p->addModel(modelFlipFlop);

  1869.         p->addModel(modelFlipPan);

  1870.         p->addModel(modelGateJunction);

  1871.         p->addModel(modelGingerbread);

  1872.         p->addModel(modelLogicCombine);

  1873.         p->addModel(modelMidSide);

  1874.         p->addModel(modelMinMax);

  1875.         p->addModel(modelRandomGates);

  1876.         p->addModel(modelRotator);

  1877.         p->addModel(modelRungler);

  1878.         p->addModel(modelScanner);

  1879.         p->addModel(modelWaveshape);

  1880.         p->addModel(modelXYToPolar);

  1881. #undef modelASR

  1882. #undef modelBlankPanel

  1883. #undef modelFlipFlop

  1884. #undef modelMidSide

  1885. #undef modelMinMax

  1886.     }

  1887. }

  1888. 

  1889. static void initStatic__ImpromptuModular()

  1890. {

  1891.     Plugin* const p = new Plugin;

  1892.     pluginInstance__ImpromptuModular = p;

  1893. 

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

  1895.     if (spl.ok())

  1896.     {

  1897.         p->addModel(modelAdaptiveQuantizer);

  1898.         p->addModel(modelBigButtonSeq);

  1899.         p->addModel(modelBigButtonSeq2);

  1900.         p->addModel(modelChordKey);

  1901.         p->addModel(modelChordKeyExpander);

  1902.         p->addModel(modelClocked);

  1903.         p->addModel(modelClockedExpander);

  1904.         p->addModel(modelClkd);

  1905.         p->addModel(modelCvPad);

  1906.         p->addModel(modelFoundry);

  1907.         p->addModel(modelFoundryExpander);

  1908.         p->addModel(modelFourView);

  1909.         p->addModel(modelGateSeq64);

  1910.         p->addModel(modelGateSeq64Expander);

  1911.         p->addModel(modelHotkey);

  1912.         p->addModel(modelPart);

  1913.         p->addModel(modelPhraseSeq16);

  1914.         p->addModel(modelPhraseSeq32);

  1915.         p->addModel(modelPhraseSeqExpander);

  1916.         p->addModel(modelProbKey);

  1917.         p->addModel(modelSemiModularSynth);

  1918.         p->addModel(modelSygen);

  1919.         p->addModel(modelTact);

  1920.         p->addModel(modelTact1);

  1921.         p->addModel(modelTactG);

  1922.         p->addModel(modelTwelveKey);

  1923.         p->addModel(modelVariations);

  1924.         p->addModel(modelWriteSeq32);

  1925.         p->addModel(modelWriteSeq64);

  1926.         p->addModel(modelBlankPanel);

  1927.     }

  1928. }

  1929. 

  1930. static void initStatic__ihtsyn()

  1931. {

  1932.     Plugin* const p = new Plugin;

  1933.     pluginInstance__ihtsyn = p;

  1934. 

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

  1936.     if (spl.ok())

  1937.     {

  1938.         p->addModel(modelPitchMangler);

  1939.         p->addModel(modelTwistedVerb);

  1940.         p->addModel(modelHiVerb);

  1941.         p->addModel(modelMVerb);

  1942.     }

  1943. }

  1944. 

  1945. static void initStatic__JW()

  1946. {

  1947.     Plugin* const p = new Plugin;

  1948.     pluginInstance__JW = p;

  1949. 

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

  1951.     if (spl.ok())

  1952.     {

  1953. #define modelQuantizer modelJWQuantizer

  1954.         p->addModel(modelAdd5);

  1955.         p->addModel(modelBouncyBalls);

  1956.         p->addModel(modelCat);

  1957.         p->addModel(modelTree);

  1958.         p->addModel(modelFullScope);

  1959.         p->addModel(modelGridSeq);

  1960.         p->addModel(modelEightSeq);

  1961.         p->addModel(modelDivSeq);

  1962.         p->addModel(modelMinMax);

  1963.         p->addModel(modelNoteSeq);

  1964.         p->addModel(modelNoteSeqFu);

  1965.         p->addModel(modelNoteSeq16);

  1966.         p->addModel(modelTrigs);

  1967.         p->addModel(modelOnePattern);

  1968.         p->addModel(modelPatterns);

  1969.         p->addModel(modelQuantizer);

  1970.         p->addModel(modelSimpleClock);

  1971.         p->addModel(modelD1v1de);

  1972.         p->addModel(modelPres1t);

  1973.         p->addModel(modelThingThing);

  1974.         p->addModel(modelWavHead);

  1975.         p->addModel(modelXYPad);

  1976.         p->addModel(modelBlankPanel1hp);

  1977.         p->addModel(modelBlankPanelSmall);

  1978.         p->addModel(modelBlankPanelMedium);

  1979.         p->addModel(modelBlankPanelLarge);

  1980.         p->addModel(modelCoolBreeze);

  1981.         p->addModel(modelPete);

  1982.        #ifndef STATIC_BUILD

  1983.         p->addModel(modelStr1ker);

  1984.        #else

  1985.         spl.removeModule("Str1ker");

  1986.        #endif

  1987. #undef modelQuantizer

  1988.     }

  1989. }

  1990. 

  1991. static void initStatic__kocmoc()

  1992. {

  1993.     Plugin* const p = new Plugin;

  1994.     pluginInstance__kocmoc= p;

  1995. 

  1996.     const StaticPluginLoader spl(p, "kocmoc");

  1997.     if (spl.ok())

  1998.     {

  1999.         p->addModel(modelSVF_1);

  2000.         p->addModel(modelTRG);

  2001.         p->addModel(modelLADR);

  2002.         p->addModel(modelOP);

  2003.         p->addModel(modelPHASR);

  2004.         p->addModel(modelMUL);

  2005.         p->addModel(modelSKF);

  2006.         p->addModel(modelDDLY);

  2007.     }

  2008. }

  2009. 

  2010. static void initStatic__LifeFormModular()

  2011. {

  2012.     Plugin* const p = new Plugin;

  2013.     pluginInstance__LifeFormModular= p;

  2014. 

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

  2016.     if (spl.ok())

  2017.     {

  2018.         p->addModel(modelTimeDiktat);

  2019.         p->addModel(modelSequenceModeler);

  2020.         p->addModel(modelPitchDiktat);

  2021.         p->addModel(modelPitchIntegrator);

  2022.         p->addModel(modelBurstIntegrator);

  2023.         p->addModel(modelQuadModulator);

  2024.         p->addModel(modelImpulseControl);

  2025.         p->addModel(modelQuadSteppedOffset);

  2026.         p->addModel(modelPercussiveVibration);

  2027.         p->addModel(modelQuadUtility);

  2028.         p->addModel(modelAdditiveVibration);

  2029.         p->addModel(modelComplexOsc);

  2030.         p->addModel(modelDriftgen);

  2031.     }

  2032. }

  2033. 

  2034. static void initStatic__LilacLoop()

  2035. {

  2036.     Plugin* const p = new Plugin;

  2037.     pluginInstance__LilacLoop = p;

  2038. 

  2039.     const StaticPluginLoader spl(p, "LilacLoop");

  2040.     if (spl.ok())

  2041.     {

  2042.         p->addModel(modelLooperOne);

  2043.     }

  2044. }

  2045. 

  2046. static void initStatic__LittleUtils()

  2047. {

  2048.     Plugin* const p = new Plugin;

  2049.     pluginInstance__LittleUtils = p;

  2050. 

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

  2052.     if (spl.ok())

  2053.     {

  2054.         p->addModel(modelButtonModule);

  2055.         p->addModel(modelPulseGenerator);

  2056.         p->addModel(modelBias_Semitone);

  2057.         p->addModel(modelMulDiv);

  2058.         p->addModel(modelTeleportInModule);

  2059.         p->addModel(modelTeleportOutModule);

  2060.     }

  2061. }

  2062. 

  2063. static void initStatic__Lomas()

  2064. {

  2065.     Plugin* const p = new Plugin;

  2066.     pluginInstance__Lomas = p;

  2067. 

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

  2069.     if (spl.ok())

  2070.     {

  2071.         p->addModel(modelAdvancedSampler);

  2072.         p->addModel(modelGateSequencer);

  2073.     }

  2074. }

  2075. 

  2076. static void initStatic__Lyrae()

  2077. {

  2078.     Plugin* const p = new Plugin;

  2079.     pluginInstance__Lyrae = p;

  2080. 

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

  2082.     if (spl.ok())

  2083.     {

  2084. #define modelDelta modelLyraeDelta

  2085.         p->addModel(modelSulafat);

  2086.         p->addModel(modelGamma);

  2087.         p->addModel(modelDelta);

  2088.         p->addModel(modelVega);

  2089.         p->addModel(modelBD383238);

  2090.         p->addModel(modelZeta);

  2091. #undef modelDelta

  2092.     }

  2093. }

  2094. 

  2095. static void initStatic__Meander()

  2096. {

  2097.     Plugin* const p = new Plugin;

  2098.     pluginInstance__Meander = p;

  2099. 

  2100.     const StaticPluginLoader spl(p, "Meander");

  2101.     if (spl.ok())

  2102.     {

  2103.         // for dark theme

  2104.         panelTheme = 1;

  2105.         p->addModel(modelMeander);

  2106.     }

  2107. }

  2108. 

  2109. static void initStatic__MindMeld()

  2110. {

  2111.     Plugin* const p = new Plugin;

  2112.     pluginInstance__MindMeld = p;

  2113. 

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

  2115.     if (spl.ok())

  2116.     {

  2117.         p->addModel(modelMixMasterJr);

  2118.         p->addModel(modelAuxExpanderJr);

  2119.         p->addModel(modelMixMaster);

  2120.         p->addModel(modelAuxExpander);

  2121.         p->addModel(modelMeld);

  2122.         p->addModel(modelUnmeld);

  2123.         p->addModel(modelMSMelder);

  2124.         p->addModel(modelEqMaster);

  2125.         p->addModel(modelEqExpander);

  2126.         p->addModel(modelBassMaster);

  2127.         p->addModel(modelBassMasterJr);

  2128.         p->addModel(modelShapeMaster);

  2129.     }

  2130. }

  2131. 

  2132. static void initStatic__ML()

  2133. {

  2134.     Plugin* const p = new Plugin;

  2135.     pluginInstance__ML = p;

  2136. 

  2137.     const StaticPluginLoader spl(p, "ML_modules");

  2138.     if (spl.ok())

  2139.     {

  2140. #define modelQuantizer modelMLQuantizer

  2141. #define modelSH8 modelMLSH8

  2142.         p->addModel(modelQuantizer);

  2143.         p->addModel(modelQuantum);

  2144.         p->addModel(modelTrigBuf);

  2145.         p->addModel(modelSeqSwitch);

  2146.         p->addModel(modelSeqSwitch2);

  2147.         p->addModel(modelShiftRegister);

  2148.         p->addModel(modelShiftRegister2);

  2149.         p->addModel(modelFreeVerb);

  2150.         p->addModel(modelSum8);

  2151.         p->addModel(modelSum8mk2);

  2152.         p->addModel(modelSum8mk3);

  2153.         p->addModel(modelSH8);

  2154.         p->addModel(modelConstants);

  2155.         p->addModel(modelCounter);

  2156.         p->addModel(modelTrigDelay);

  2157.         p->addModel(modelBPMdetect);

  2158.         p->addModel(modelVoltMeter);

  2159.         p->addModel(modelOctaFlop);

  2160.         p->addModel(modelOctaTrig);

  2161.         p->addModel(modelOctaSwitch);

  2162.         p->addModel(modelTrigSwitch);

  2163.         p->addModel(modelTrigSwitch2);

  2164.         p->addModel(modelTrigSwitch3);

  2165.         p->addModel(modelTrigSwitch3_2);

  2166.         p->addModel(modelOctaPlus);

  2167.         p->addModel(modelOctaTimes);

  2168.         p->addModel(modelCloner);

  2169.         p->addModel(modelPolySplitter);

  2170.         p->addModel(modelArpeggiator);

  2171. #undef modelQuantizer

  2172. #undef modelSH8

  2173.     }

  2174. }

  2175. 

  2176. static void initStatic__MockbaModular()

  2177. {

  2178.     Plugin* const p = new Plugin;

  2179.     pluginInstance__MockbaModular = p;

  2180. 

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

  2182.     if (spl.ok())

  2183.     {

  2184. #define modelBlank modelMockbaModularBlank

  2185. #define modelComparator modelMockbaModularComparator

  2186.         p->addModel(modelBlank);

  2187.         p->addModel(modelFeidah);

  2188.         p->addModel(modelFeidahS);

  2189.         p->addModel(modelFiltah);

  2190.         p->addModel(modelMixah);

  2191.         p->addModel(modelMixah3);

  2192.         p->addModel(modelDividah);

  2193.         p->addModel(modelCountah);

  2194.         p->addModel(modelSelectah);

  2195.         p->addModel(modelShapah);

  2196.         p->addModel(modelHoldah);

  2197.         p->addModel(modelPannah);

  2198.         p->addModel(modelReVoltah);

  2199.         p->addModel(modelCZSaw);

  2200.         p->addModel(modelCZSquare);

  2201.         p->addModel(modelCZPulse);

  2202.         p->addModel(modelCZDblSine);

  2203.         p->addModel(modelCZSawPulse);

  2204.         p->addModel(modelCZReso1);

  2205.         p->addModel(modelCZReso2);

  2206.         p->addModel(modelCZReso3);

  2207.         p->addModel(modelCZOsc);

  2208.         p->addModel(modelMaugTriangle);

  2209.         p->addModel(modelMaugShark);

  2210.         p->addModel(modelMaugSaw);

  2211.         p->addModel(modelMaugSaw2);

  2212.         p->addModel(modelMaugSquare);

  2213.         p->addModel(modelMaugSquare2);

  2214.         p->addModel(modelMaugSquare3);

  2215.         p->addModel(modelMaugOsc);

  2216.         p->addModel(modelComparator);

  2217.         p->addModel(modelDualBUFFER);

  2218.         p->addModel(modelDualNOT);

  2219.         p->addModel(modelDualOR);

  2220.         p->addModel(modelDualNOR);

  2221.         p->addModel(modelDualAND);

  2222.         p->addModel(modelDualNAND);

  2223.         p->addModel(modelDualXOR);

  2224.         p->addModel(modelDualXNOR);

  2225.         p->addModel(modelPSelectah);

  2226. 

  2227.         // require input files to work

  2228.         spl.removeModule("UDPClockMaster");

  2229.         spl.removeModule("UDPClockSlave");

  2230. #undef modelBlank

  2231. #undef modelComparator

  2232.     }

  2233. }

  2234. 

  2235. static void initStatic__Mog()

  2236. {

  2237.     Plugin* const p = new Plugin;

  2238.     pluginInstance__Mog = p;

  2239. 

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

  2241.     if (spl.ok())

  2242.     {

  2243.         p->addModel(modelNetwork);

  2244.         p->addModel(modelNexus);

  2245.     }

  2246. }

  2247. 

  2248. static void initStatic__mscHack()

  2249. {

  2250.     Plugin* const p = new Plugin;

  2251.     pluginInstance__mscHack = p;

  2252. 

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

  2254.     if (spl.ok())

  2255.     {

  2256.         p->addModel(modelCompressor);

  2257.         p->addModel(modelSynthDrums);

  2258.         p->addModel(modelSEQ_6x32x16);

  2259.         p->addModel(modelMasterClockx4);

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

  2261.         p->addModel(modelSEQ_Envelope_8);

  2262.         p->addModel(modelSeq_Triad2);

  2263.         p->addModel(modelARP700);

  2264.         p->addModel(modelMix_4_0_4);

  2265.         p->addModel(modelMix_9_3_4);

  2266.         p->addModel(modelMix_16_4_4);

  2267.         p->addModel(modelMix_24_4_4);

  2268.         p->addModel(modelASAF8);

  2269.         p->addModel(modelPingPong);

  2270.         p->addModel(modelStepDelay);

  2271.         p->addModel(modelOsc_3Ch);

  2272.         p->addModel(modelDronez);

  2273.         p->addModel(modelMorze);

  2274.         p->addModel(modelWindz);

  2275.         p->addModel(modelLorenz);

  2276.         p->addModel(modelAlienz);

  2277.         p->addModel(modelOSC_WaveMorph_3);

  2278.         p->addModel(modelMaude_221);

  2279.     }

  2280. }

  2281. 

  2282. static void initStatic__MSM()

  2283. {

  2284.     Plugin* const p = new Plugin;

  2285.     pluginInstance__MSM = p;

  2286. 

  2287.     const StaticPluginLoader spl(p, "MSM");

  2288.     if (spl.ok())

  2289.     {

  2290. #define modelADSR modelMSMADSR

  2291. #define modelBlankPanel modelMSMBlankPanel

  2292. #define modelDelay modelMSMDelay

  2293. #define modelLFO modelMSMLFO

  2294. #define modelMult modelMSMMult

  2295. #define modelNoise modelMSMNoise

  2296. #define modelVCA modelMSMVCA

  2297. #define modelVCO modelMSMVCO

  2298.         p->addModel(modelVCO);

  2299.         p->addModel(modelBVCO);

  2300.         p->addModel(modelExperimentalVCO);

  2301.         p->addModel(modelNoise);

  2302.         p->addModel(modelLFO);

  2303.         p->addModel(modelVCA);

  2304.         p->addModel(modelADSR);

  2305.         p->addModel(modelDelay);

  2306.         p->addModel(modelWaveShaper);

  2307.         p->addModel(modelWavefolder);

  2308.         p->addModel(modelBitcrusher);

  2309.         p->addModel(modelPhaserModule);

  2310.         p->addModel(modelMorpher);

  2311.         p->addModel(modelRingMod);

  2312.         p->addModel(modelRandomSource);

  2313.         p->addModel(modelMult);

  2314.         p->addModel(modelCrazyMult);

  2315.         p->addModel(modelFade);

  2316.         p->addModel(modelSimpleSlider);

  2317.         p->addModel(modelxseq);

  2318.         p->addModel(modelBlankPanel);

  2319. #undef modelADSR

  2320. #undef modelBlankPanel

  2321. #undef modelDelay

  2322. #undef modelLFO

  2323. #undef modelMult

  2324. #undef modelNoise

  2325. #undef modelVCA

  2326. #undef modelVCO

  2327.     }

  2328. }

  2329. 

  2330. static void initStatic__nonlinearcircuits()

  2331. {

  2332.     Plugin* const p = new Plugin;

  2333.     pluginInstance__nonlinearcircuits = p;

  2334. 

  2335.     const StaticPluginLoader spl(p, "nonlinearcircuits");

  2336.     if (spl.ok())

  2337.     {

  2338.         p->addModel(model4Seq);

  2339.         p->addModel(modelCipher);

  2340.         p->addModel(modelBOOLs);

  2341.         p->addModel(modelDivideConquer);

  2342.         p->addModel(modelDivineCMOS);

  2343.         p->addModel(modelDoubleNeuron);

  2344.         p->addModel(modelGenie);

  2345.         p->addModel(modelLetsSplosh);

  2346.         p->addModel(modelNeuron);

  2347.         p->addModel(modelNumberwang);

  2348.         p->addModel(modelSegue);

  2349.         p->addModel(modelSquidAxon);

  2350.         p->addModel(modelStatues);

  2351.     }

  2352. }

  2353. 

  2354. static void initStatic__Orbits()

  2355. {

  2356.     Plugin* const p = new Plugin;

  2357.     pluginInstance__Orbits = p;

  2358. 

  2359.     const StaticPluginLoader spl(p, "Orbits");

  2360.     if (spl.ok())

  2361.     {

  2362.         p->addModel(modelRareBreeds_Orbits_Eugene);

  2363.         p->addModel(modelRareBreeds_Orbits_Polygene);

  2364.     }

  2365. }

  2366. 

  2367. static void initStatic__ParableInstruments()

  2368. {

  2369.     Plugin* const p = new Plugin;

  2370.     pluginInstance__ParableInstruments = p;

  2371. 

  2372.     const StaticPluginLoader spl(p, "ParableInstruments");

  2373.     if (spl.ok())

  2374.     {

  2375. #define modelClouds modelParableClouds

  2376.         p->addModel(modelClouds);

  2377. #undef modelClouds

  2378.     }

  2379. }

  2380. 

  2381. static void initStatic__PathSet()

  2382. {

  2383.     Plugin* const p = new Plugin;

  2384.     pluginInstance__PathSet = p;

  2385. 

  2386.     const StaticPluginLoader spl(p, "PathSet");

  2387.     if (spl.ok())

  2388.     {

  2389.         p->addModel(modelShiftyMod);

  2390.         p->addModel(modelShiftyExpander);

  2391.         p->addModel(modelIceTray);

  2392.         p->addModel(modelAstroVibe);

  2393.         p->addModel(modelGlassPane);

  2394.         p->addModel(modelNudge);

  2395.     }

  2396. }

  2397. 

  2398. static void initStatic__PinkTrombone()

  2399. {

  2400.     Plugin* const p = new Plugin;

  2401.     pluginInstance__PinkTrombone = p;

  2402. 

  2403.     const StaticPluginLoader spl(p, "PinkTrombone");

  2404.     if (spl.ok())

  2405.     {

  2406.         p->addModel(modelPinkTrombone);

  2407.     }

  2408. }

  2409. 

  2410. static void initStatic__Prism()

  2411. {

  2412.     Plugin* const p = new Plugin;

  2413.     pluginInstance__Prism = p;

  2414. 

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

  2416.     if (spl.ok())

  2417.     {

  2418.         p->addModel(modelRainbow);

  2419.         p->addModel(modelRainbowScaleExpander);

  2420.         p->addModel(modelDroplet);

  2421.     }

  2422. }

  2423. 

  2424. static void initStatic__rackwindows()

  2425. {

  2426.     Plugin* const p = new Plugin;

  2427.     pluginInstance__rackwindows = p;

  2428. 

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

  2430.     if (spl.ok())

  2431.     {

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

  2433.         p->addModel(modelBitshiftgain);

  2434.         p->addModel(modelCapacitor);

  2435.         p->addModel(modelCapacitor_stereo);

  2436.         p->addModel(modelChorus);

  2437.         p->addModel(modelConsole);

  2438.         p->addModel(modelConsole_mm);

  2439.         p->addModel(modelDistance);

  2440.         p->addModel(modelGolem);

  2441.         p->addModel(modelHolt);

  2442.         p->addModel(modelHombre);

  2443.         p->addModel(modelInterstage);

  2444.         p->addModel(modelMonitoring);

  2445.         p->addModel(modelMv);

  2446.         p->addModel(modelRasp);

  2447.         p->addModel(modelReseq);

  2448.         p->addModel(modelTape);

  2449.         p->addModel(modelTremolo);

  2450.         p->addModel(modelVibrato);

  2451.     }

  2452. }

  2453. 

  2454. static void initStatic__repelzen()

  2455. {

  2456.     Plugin* const p = new Plugin;

  2457.     pluginInstance__repelzen = p;

  2458. 

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

  2460.     if (spl.ok())

  2461.     {

  2462. #define modelBlank modelrepelzenBlank

  2463. #define modelMixer modelrepelzenMixer

  2464. #define modelWerner modelrepelzenWerner

  2465.         p->addModel(modelBlank);

  2466.         p->addModel(modelBurst);

  2467.         p->addModel(modelFolder);

  2468.         p->addModel(modelErwin);

  2469.         p->addModel(modelWerner);

  2470.         p->addModel(modelMixer);

  2471. #undef modelBlank

  2472. #undef modelMixer

  2473. #undef modelWerner

  2474.     }

  2475. }

  2476. 

  2477. static void initStatic__sonusmodular()

  2478. {

  2479.     Plugin* const p = new Plugin;

  2480.     pluginInstance__sonusmodular = p;

  2481. 

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

  2483.     if (spl.ok())

  2484.     {

  2485.         p->addModel(modelAddiction);

  2486.         p->addModel(modelBitter);

  2487.         p->addModel(modelBymidside);

  2488.         p->addModel(modelCampione);

  2489.         p->addModel(modelChainsaw);

  2490.         p->addModel(modelCtrl);

  2491.         p->addModel(modelDeathcrush);

  2492.         p->addModel(modelFraction);

  2493.         p->addModel(modelHarmony);

  2494.         p->addModel(modelLadrone);

  2495.         p->addModel(modelLuppolo);

  2496.         p->addModel(modelLuppolo3);

  2497.         p->addModel(modelMicromacro);

  2498.         p->addModel(modelMrcheb);

  2499.         p->addModel(modelMultimulti);

  2500.         p->addModel(modelNeurosc);

  2501.         p->addModel(modelOktagon);

  2502.         p->addModel(modelOsculum);

  2503.         p->addModel(modelParamath);

  2504.         p->addModel(modelPiconoise);

  2505.         p->addModel(modelPith);

  2506.         p->addModel(modelPusher);

  2507.         p->addModel(modelRingo);

  2508.         p->addModel(modelScramblase);

  2509.         p->addModel(modelTropicana);

  2510.         p->addModel(modelTwoff);

  2511.         p->addModel(modelYabp);

  2512.     }

  2513. }

  2514. 

  2515. static void initStatic__stocaudio()

  2516. {

  2517.     Plugin* const p = new Plugin;

  2518.     pluginInstance__stocaudio = p;

  2519. 

  2520.     const StaticPluginLoader spl(p, "stocaudio");

  2521.     if (spl.ok())

  2522.     {

  2523.         p->addModel(modelPolyturing);

  2524.         p->addModel(modelPolydelay);

  2525.         p->addModel(modelSpread);

  2526.     }

  2527. }

  2528. 

  2529. static void initStatic__unless_modules()

  2530. {

  2531.     Plugin* const p = new Plugin;

  2532.     pluginInstance__unless_modules = p;

  2533. 

  2534.     const StaticPluginLoader spl(p, "unless_modules");

  2535.     if (spl.ok())

  2536.     {

  2537.         // unless_modules::init_theme();

  2538.         // theme = _less::Theme();

  2539.         p->addModel(modelPiong);

  2540.         p->addModel(modelChainkov);

  2541.         p->addModel(modelAtoms);

  2542.         p->addModel(modelCantor);

  2543.         p->addModel(modelRoom);

  2544.         p->addModel(modelSnake);

  2545.         p->addModel(modelTowers);

  2546.         p->addModel(modelPianoid);

  2547.         p->addModel(modelPremuter);

  2548.         p->addModel(modelAvoider);

  2549.     }

  2550. }

  2551. 

  2552. static void initStatic__ValleyAudio()

  2553. {

  2554.     Plugin* const p = new Plugin;

  2555.     pluginInstance__ValleyAudio = p;

  2556. 

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

  2558.     if (spl.ok())

  2559.     {

  2560.         p->addModel(modelTopograph);

  2561.         p->addModel(modelUGraph);

  2562.         p->addModel(modelDexter);

  2563.         p->addModel(modelPlateau);

  2564.         p->addModel(modelInterzone);

  2565.         p->addModel(modelAmalgam);

  2566.         p->addModel(modelFeline);

  2567.         p->addModel(modelTerrorform);

  2568.     }

  2569. }

  2570. 

  2571. static void initStatic__Voxglitch()

  2572. {

  2573.     Plugin* p = new Plugin;

  2574.     pluginInstance__Voxglitch = p;

  2575. 

  2576.     const StaticPluginLoader spl(p, "voxglitch");

  2577.     if (spl.ok())

  2578.     {

  2579. #define modelLooper modelVoxglitchLooper

  2580.       p->addModel(modelAutobreak);

  2581.       p->addModel(modelByteBeat);

  2582.       p->addModel(modelDigitalProgrammer);

  2583.       p->addModel(modelDigitalSequencer);

  2584.       p->addModel(modelDigitalSequencerXP);

  2585.       p->addModel(modelGlitchSequencer);

  2586.       p->addModel(modelGhosts);

  2587.       p->addModel(modelGoblins);

  2588.       p->addModel(modelGrainEngine);

  2589.       p->addModel(modelGrainEngineMK2);

  2590.       p->addModel(modelGrainEngineMK2Expander);

  2591.       p->addModel(modelGrainFx);

  2592.       p->addModel(modelHazumi);

  2593.       p->addModel(modelLooper);

  2594.       p->addModel(modelRepeater);

  2595.       p->addModel(modelSamplerX8);

  2596.       p->addModel(modelSatanonaut);

  2597.       p->addModel(modelGrooveBox);

  2598.       p->addModel(modelWavBank);

  2599.       p->addModel(modelWavBankMC);

  2600.       p->addModel(modelXY);

  2601. #undef modelLooper

  2602.     }

  2603. }

  2604. 

  2605. static void initStatic__WhatTheRack()

  2606. {

  2607.     Plugin* p = new Plugin;

  2608.     pluginInstance__WhatTheRack = p;

  2609. 

  2610.     const StaticPluginLoader spl(p, "WhatTheRack");

  2611.     if (spl.ok())

  2612.     {

  2613.       p->addModel(modelWhatTheRack);

  2614.       p->addModel(modelWhatTheMod);

  2615.       p->addModel(modelWhatTheJack);

  2616.     }

  2617. }

  2618. 

  2619. static void initStatic__ZetaCarinaeModules()

  2620. {

  2621.     Plugin* p = new Plugin;

  2622.     pluginInstance__ZetaCarinaeModules = p;

  2623. 

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

  2625.     if (spl.ok())

  2626.     {

  2627.         p->addModel(modelBrownianBridge);

  2628.         p->addModel(modelOrnsteinUhlenbeck);

  2629.         p->addModel(modelIOU);

  2630.         p->addModel(modelWarbler);

  2631.         p->addModel(modelRosenchance);

  2632.         p->addModel(modelGuildensTurn);

  2633.         p->addModel(modelRosslerRustler);

  2634.         p->addModel(modelFirefly);

  2635.     }

  2636. }

  2637. 

  2638. static void initStatic__ZZC()

  2639. {

  2640.     Plugin* p = new Plugin;

  2641.     pluginInstance__ZZC = p;

  2642. 

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

  2644.     if (spl.ok())

  2645.     {

  2646. #define modelClock modelZZCClock

  2647.         p->addModel(modelClock);

  2648.         p->addModel(modelDivider);

  2649.         p->addModel(modelFN3);

  2650.         p->addModel(modelSCVCA);

  2651.         p->addModel(modelSH8);

  2652.         p->addModel(modelSRC);

  2653.         p->addModel(modelDiv);

  2654.         p->addModel(modelDivExp);

  2655.         p->addModel(modelPolygate);

  2656. #undef modelClock

  2657.     }

  2658. }

  2659. #endif // NOPLUGINS

  2660. 

  2661. void initStaticPlugins()

  2662. {

  2663.     initStatic__Cardinal();

  2664.     initStatic__Fundamental();

  2665. #ifndef NOPLUGINS

  2666.     initStatic__21kHz();

  2667.     initStatic__8Mode();

  2668.     initStatic__AaronStatic();

  2669.     initStatic__Algoritmarte();

  2670.     initStatic__AmalgamatedHarmonics();

  2671.     initStatic__AnimatedCircuits();

  2672.     initStatic__ArableInstruments();

  2673.     initStatic__Aria();

  2674.     initStatic__AS();

  2675.     initStatic__AudibleInstruments();

  2676.     initStatic__Autinn();

  2677.     initStatic__Axioma();

  2678.     initStatic__Bacon();

  2679.     initStatic__Befaco();

  2680.     initStatic__Bidoo();

  2681.     initStatic__BogaudioModules();

  2682.     initStatic__CatroModulo();

  2683.     initStatic__cf();

  2684.     initStatic__ChowDSP();

  2685.     initStatic__DrumKit();

  2686.     initStatic__ESeries();

  2687.     initStatic__ExpertSleepersEncoders();

  2688.     initStatic__Extratone();

  2689.     initStatic__FehlerFabrik();

  2690.     initStatic__forsitan();

  2691.     initStatic__GlueTheGiant();

  2692.     initStatic__GoodSheperd();

  2693.     initStatic__GrandeModular();

  2694.     initStatic__HamptonHarmonics();

  2695.     initStatic__HetrickCV();

  2696.     initStatic__ImpromptuModular();

  2697.     initStatic__ihtsyn();

  2698.     initStatic__JW();

  2699.     initStatic__kocmoc();

  2700.     initStatic__LifeFormModular();

  2701.     initStatic__LilacLoop();

  2702.     initStatic__LittleUtils();

  2703.     initStatic__Lomas();

  2704.     initStatic__Lyrae();

  2705.     initStatic__Meander();

  2706.     initStatic__MindMeld();

  2707.     initStatic__ML();

  2708.     initStatic__MockbaModular();

  2709.     initStatic__Mog();

  2710.     initStatic__mscHack();

  2711.     initStatic__MSM();

  2712.     initStatic__nonlinearcircuits();

  2713.     initStatic__Orbits();

  2714.     initStatic__ParableInstruments();

  2715.     initStatic__PathSet();

  2716.     initStatic__PinkTrombone();

  2717.     initStatic__Prism();

  2718.     initStatic__rackwindows();

  2719.     initStatic__repelzen();

  2720.     initStatic__sonusmodular();

  2721.     initStatic__stocaudio();

  2722.     initStatic__unless_modules();

  2723.     initStatic__ValleyAudio();

  2724.     initStatic__Voxglitch();

  2725.     initStatic__WhatTheRack();

  2726.     initStatic__ZetaCarinaeModules();

  2727.     initStatic__ZZC();

  2728. #endif // NOPLUGINS

  2729. }

  2730. 

  2731. void destroyStaticPlugins()

  2732. {

  2733.     for (Plugin* p : plugins)

  2734.         delete p;

  2735.     plugins.clear();

  2736. }

  2737. 

  2738. }

  2739. }