DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 20 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.
1951 Commits
12 Branches
277MB
Tree: 77d9d574ea
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '77d9d574ea'
${ noResults }
Cardinal/plugins/plugins.cpp

3916 lines
107KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

  3.  * Copyright (C) 2021-2024 Filipe Coelho <falktx@falktx.com>

  4.  * SPDX-License-Identifier: GPL-3.0-or-later

  5.  */

  6. 

  7. #include "rack.hpp"

  8. #include "plugin.hpp"

  9. 

  10. #include "DistrhoUtils.hpp"

  11. 

  12. // Cardinal (built-in)

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

  14. 

  15. // Fundamental (always enabled)

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

  17. 

  18. // ZamAudio (always enabled) - TODO

  19. // #include "ZamAudio/src/plugin.hpp"

  20. 

  21. // 21kHz

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

  23. 

  24. // 8Mode

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

  26. 

  27. // Aaron Static

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

  29. 

  30. // Admiral

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

  32. // #include "admiral/src/plugin.hpp"

  33. */

  34. extern Model* modelWatches;

  35. extern Model* modelShifts;

  36. extern Model* modelTables;

  37. extern Model* modelDivisions;

  38. 

  39. // Alef's Bits

  40. #define modelSteps modelalefsbitsSteps

  41. #define modelLogic modelalefsbitsLogic

  42. #include "alefsbits/src/plugin.hpp"

  43. #undef modelSteps

  44. #undef modelLogic

  45. 

  46. // Algoritmarte

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

  48. 

  49. // AmalgamatedHarmonics

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

  51. 

  52. // AnimatedCircuits

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

  54. 

  55. // ArableInstruments

  56. #define modelClouds modelArableClouds

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

  58. #undef modelClouds

  59. 

  60. // Aria

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

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

  63. */

  64. #define modelBlank modelAriaBlank

  65. extern Model* modelSplort;

  66. extern Model* modelSmerge;

  67. extern Model* modelSpleet;

  68. extern Model* modelSwerge;

  69. extern Model* modelSplirge;

  70. // extern Model* modelSrot;

  71. extern Model* modelQqqq;

  72. extern Model* modelQuack;

  73. extern Model* modelQ;

  74. extern Model* modelQuale;

  75. extern Model* modelDarius;

  76. extern Model* modelSolomon4;

  77. extern Model* modelSolomon8;

  78. extern Model* modelSolomon16;

  79. extern Model* modelPsychopump;

  80. extern Model* modelPokies4;

  81. extern Model* modelGrabby;

  82. extern Model* modelRotatoes4;

  83. extern Model* modelUndular;

  84. extern Model* modelBlank;

  85. #undef modelBlank

  86. 

  87. // AS

  88. #define modelADSR modelASADSR

  89. #define modelVCA modelASVCA

  90. #define modelWaveShaper modelASWaveShaper

  91. #define LedLight ASLedLight

  92. #define YellowRedLight ASYellowRedLight

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

  94. #undef modelADSR

  95. #undef modelVCA

  96. #undef modelWaveShaper

  97. #undef LedLight

  98. #undef YellowRedLight

  99. 

  100. // AudibleInstruments

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

  102. 

  103. // Autinn

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

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

  106. */

  107. #define modelChord modelAutinnChord

  108. #define modelVibrato modelAutinnVibrato

  109. extern Model* modelJette;

  110. extern Model* modelFlora;

  111. extern Model* modelOxcart;

  112. extern Model* modelDeadband;

  113. extern Model* modelDigi;

  114. extern Model* modelFlopper;

  115. extern Model* modelAmp;

  116. extern Model* modelDC;

  117. extern Model* modelSjip;

  118. extern Model* modelBass;

  119. extern Model* modelSquare;

  120. extern Model* modelSaw;

  121. extern Model* modelBoomerang;

  122. extern Model* modelVibrato;

  123. extern Model* modelVectorDriver; //deprecated

  124. extern Model* modelCVConverter;

  125. extern Model* modelZod;

  126. extern Model* modelTriBand;

  127. extern Model* modelMixer6;

  128. extern Model* modelNon;

  129. extern Model* modelFil;

  130. extern Model* modelNap;

  131. extern Model* modelMelody;

  132. extern Model* modelChord;

  133. #undef modelChord

  134. #undef modelVibrato

  135. 

  136. // Axioma

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

  138. 

  139. // BaconPlugs

  140. #define INCLUDE_COMPONENTS_HPP

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

  142. #undef INCLUDE_COMPONENTS_HPP

  143. #undef SCREW_WIDTH

  144. #undef RACK_HEIGHT

  145. 

  146. // Befaco

  147. #define modelADSR modelBefacoADSR

  148. #define modelMixer modelBefacoMixer

  149. #define modelBurst modelBefacoBurst

  150. #define modelMixer2 modelBefacoMixer2

  151. #define modelSlew modelBefacoSlew

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

  153. #undef modelADSR

  154. #undef modelMixer

  155. #undef modelBurst

  156. #undef modelMixer2

  157. #undef modelSlew

  158. 

  159. // Bidoo

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

  161. 

  162. // Biset

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

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

  165. */

  166. #define modelBlank modelBisetBlank

  167. #define modelTree modelBisetTree

  168. extern Model* modelTracker;

  169. extern Model* modelTrackerSynth;

  170. extern Model* modelTrackerDrum;

  171. extern Model* modelTrackerClock;

  172. extern Model* modelTrackerPhase;

  173. extern Model* modelTrackerQuant;

  174. extern Model* modelTrackerState;

  175. extern Model* modelTrackerControl;

  176. extern Model* modelRegex;

  177. extern Model* modelRegexCondensed;

  178. extern Model* modelRegexExp;

  179. extern Model* modelTree;

  180. extern Model* modelTreeSeed;

  181. extern Model* modelGbu;

  182. extern Model* modelPkm;

  183. extern Model* modelIgc;

  184. extern Model* modelOmega3;

  185. extern Model* modelOmega6;

  186. extern Model* modelSegfault;

  187. extern Model* modelBlank;

  188. #undef modelBlank

  189. #undef modelTree

  190. 

  191. // BogaudioModules - integrate theme/skin support

  192. #include <mutex>

  193. #include <string>

  194. #include <unordered_map>

  195. #include <unordered_set>

  196. #include <vector>

  197. #define private public

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

  199. #undef private

  200. 

  201. // BogaudioModules

  202. #define modelADSR modelBogaudioADSR

  203. #define modelLFO modelBogaudioLFO

  204. #define modelNoise modelBogaudioNoise

  205. #define modelVCA modelBogaudioVCA

  206. #define modelVCF modelBogaudioVCF

  207. #define modelVCO modelBogaudioVCO

  208. extern Model* modelVCO;

  209. extern Model* modelLVCO;

  210. extern Model* modelSine;

  211. extern Model* modelPulse;

  212. extern Model* modelXCO;

  213. extern Model* modelAdditator;

  214. extern Model* modelFMOp;

  215. extern Model* modelChirp;

  216. extern Model* modelLFO;

  217. extern Model* modelLLFO;

  218. extern Model* modelFourFO;

  219. extern Model* modelEightFO;

  220. extern Model* modelVCF;

  221. extern Model* modelLVCF;

  222. extern Model* modelFFB;

  223. extern Model* modelEQ;

  224. extern Model* modelEQS;

  225. extern Model* modelLPG;

  226. extern Model* modelLLPG;

  227. extern Model* modelMegaGate;

  228. extern Model* modelPEQ;

  229. extern Model* modelPEQ6;

  230. extern Model* modelPEQ6XF;

  231. extern Model* modelPEQ14;

  232. extern Model* modelPEQ14XF;

  233. extern Model* modelDADSRH;

  234. extern Model* modelDADSRHPlus;

  235. extern Model* modelShaper;

  236. extern Model* modelShaperPlus;

  237. extern Model* modelAD;

  238. extern Model* modelASR;

  239. extern Model* modelADSR;

  240. extern Model* modelVish;

  241. extern Model* modelFollow;

  242. extern Model* modelDGate;

  243. extern Model* modelRGate;

  244. extern Model* modelEdge;

  245. extern Model* modelNoise;

  246. extern Model* modelSampleHold;

  247. extern Model* modelWalk2;

  248. extern Model* modelWalk;

  249. extern Model* modelMix8;

  250. extern Model* modelMix8x;

  251. extern Model* modelMix4;

  252. extern Model* modelMix4x;

  253. extern Model* modelMix2;

  254. extern Model* modelMix1;

  255. extern Model* modelVCM;

  256. extern Model* modelMute8;

  257. extern Model* modelPan;

  258. extern Model* modelXFade;

  259. extern Model* modelVCA;

  260. extern Model* modelVCAmp;

  261. extern Model* modelVelo;

  262. extern Model* modelUMix;

  263. extern Model* modelMumix;

  264. extern Model* modelMatrix81;

  265. extern Model* modelMatrix18;

  266. extern Model* modelMatrix44;

  267. extern Model* modelMatrix44Cvm;

  268. extern Model* modelMatrix88;

  269. extern Model* modelMatrix88Cv;

  270. extern Model* modelMatrix88M;

  271. extern Model* modelSwitch81;

  272. extern Model* modelSwitch18;

  273. extern Model* modelSwitch44;

  274. extern Model* modelSwitch88;

  275. extern Model* modelSwitch1616;

  276. extern Model* modelAMRM;

  277. extern Model* modelPressor;

  278. extern Model* modelClpr;

  279. extern Model* modelLmtr;

  280. extern Model* modelNsgt;

  281. extern Model* modelCmpDist;

  282. extern Model* modelOneEight;

  283. extern Model* modelEightOne;

  284. extern Model* modelAddrSeq;

  285. extern Model* modelAddrSeqX;

  286. extern Model* modelPgmr;

  287. extern Model* modelPgmrX;

  288. extern Model* modelVU;

  289. extern Model* modelAnalyzer;

  290. extern Model* modelAnalyzerXL;

  291. extern Model* modelRanalyzer;

  292. extern Model* modelDetune;

  293. extern Model* modelStack;

  294. extern Model* modelReftone;

  295. extern Model* modelMono;

  296. extern Model* modelArp;

  297. extern Model* modelAssign;

  298. extern Model* modelUnison;

  299. extern Model* modelPolyCon8;

  300. extern Model* modelPolyCon16;

  301. extern Model* modelPolyOff8;

  302. extern Model* modelPolyOff16;

  303. extern Model* modelPolyMult;

  304. extern Model* modelBool;

  305. extern Model* modelCmp;

  306. extern Model* modelCVD;

  307. extern Model* modelFlipFlop;

  308. extern Model* modelInv;

  309. extern Model* modelManual;

  310. extern Model* modelFourMan;

  311. extern Model* modelMult;

  312. extern Model* modelOffset;

  313. extern Model* modelSlew;

  314. extern Model* modelSums;

  315. extern Model* modelSwitch;

  316. extern Model* modelLgsw;

  317. extern Model* modelBlank3;

  318. extern Model* modelBlank6;

  319. #ifdef EXPERIMENTAL

  320. extern Model* modelLag;

  321. extern Model* modelPEQ14XR;

  322. extern Model* modelPEQ14XV;

  323. #endif

  324. #ifdef TEST

  325. extern Model* modelTest;

  326. extern Model* modelTest2;

  327. extern Model* modelTestExpanderBase;

  328. extern Model* modelTestExpanderExtension;

  329. extern Model* modelTestGl;

  330. extern Model* modelTestVCF;

  331. #endif

  332. #undef modelADSR

  333. #undef modelLFO

  334. #undef modelNoise

  335. #undef modelVCA

  336. #undef modelVCF

  337. #undef modelVCO

  338. 

  339. // CatroModulo

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

  341. 

  342. // cf

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

  344. 

  345. // CVfunk

  346. #define modelSteps modelCVfunkSteps

  347. #include "CVfunk/src/plugin.hpp"

  348. #undef modelSteps

  349. 

  350. // ChowDSP

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

  352. #define init initChowDSP

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

  354. #undef init

  355. 

  356. // Computerscare

  357. #include "Computerscare/src/Computerscare.hpp"

  358. 

  359. // dBiz

  360. #define DarkDefaultItem dBizDarkDefaultItem

  361. #define OrangeLight dBizOrangeLight

  362. #define darkPanelID dBizdarkPanelID

  363. #define lightPanelID dBizlightPanelID

  364. #define modelChord modeldBizChord

  365. #define modelDivider modeldBizDivider

  366. #define modelFourSeq modeldBizFourSeq

  367. #define modelVCA4 modeldBizVCA4

  368. #include "dBiz/src/plugin.hpp"

  369. #undef DarkDefaultItem

  370. #undef OrangeLight

  371. #undef darkPanelID

  372. #undef lightPanelID

  373. #undef modelChord

  374. #undef modelDivider

  375. #undef modelFourSeq

  376. #undef modelVCA4

  377. 

  378. // dbRackModules

  379. #define modelSKF modeldbRackModulesSKF

  380. #define modelX4 modeldbRackModulesX4

  381. #define modelMVerb modeldbRackModulesMVerb

  382. #define modelOsc3 modeldbRackModulesOsc3

  383. extern Model* modelGeneticTerrain;

  384. extern Model* modelGeneticSuperTerrain;

  385. extern Model* modelDCBlock;

  386. extern Model* modelRndHvs3;

  387. extern Model* modelJTScaler;

  388. extern Model* modelAddSynth;

  389. extern Model* modelRndH;

  390. extern Model* modelRndC;

  391. extern Model* modelGenScale;

  392. extern Model* modelJTKeys;

  393. extern Model* modelHopa;

  394. extern Model* modelFrac;

  395. extern Model* modelHexSeq;

  396. extern Model* modelInterface;

  397. extern Model* modelHexSeqP;

  398. extern Model* modelMVerb;

  399. extern Model* modelPShift;

  400. extern Model* modelFLA;

  401. extern Model* modelFLL;

  402. extern Model* modelGendy;

  403. extern Model* modelRtrig;

  404. extern Model* modelSTrig;

  405. extern Model* modelRSC;

  406. extern Model* modelPad;

  407. extern Model* modelRndG;

  408. extern Model* modelPlotter;

  409. extern Model* modelSuperLFO;

  410. extern Model* modelHexSeqExp;

  411. extern Model* modelPad2;

  412. extern Model* modelPHSR;

  413. extern Model* modelPhS;

  414. extern Model* modelSPL;

  415. extern Model* modelPhO;

  416. extern Model* modelFaders;

  417. extern Model* modelYC;

  418. extern Model* modelPLC;

  419. extern Model* modelMPad2;

  420. extern Model* modelPHSR2;

  421. extern Model* modelEVA;

  422. extern Model* modelRatio;

  423. extern Model* modelCSOSC;

  424. extern Model* modelBWF;

  425. extern Model* modelPRB;

  426. extern Model* modelOsc2;

  427. extern Model* modelRndH2;

  428. extern Model* modelOFS;

  429. extern Model* modelOFS3;

  430. extern Model* modelOsc1;

  431. extern Model* modelOsc3;

  432. extern Model* modelOsc4;

  433. extern Model* modelOsc5;

  434. extern Model* modelL4P;

  435. extern Model* modelSKF;

  436. extern Model* modelSPF;

  437. extern Model* modelUSVF;

  438. extern Model* modelAP;

  439. extern Model* modelWS;

  440. extern Model* modelAUX;

  441. extern Model* modelCHBY;

  442. extern Model* modelCLP;

  443. extern Model* modelLWF;

  444. extern Model* modelDRM;

  445. extern Model* modelCWS;

  446. extern Model* modelSWF;

  447. extern Model* modelOsc6;

  448. /*extern Model* modelDrums;*/

  449. extern Model* modelPPD;

  450. extern Model* modelOsc7;

  451. extern Model* modelOsc8;

  452. extern Model* modelOsc9;

  453. extern Model* modelFS6;

  454. extern Model* modelPulsar;

  455. extern Model* modelOscA1;

  456. extern Model* modelOscS;

  457. extern Model* modelOscP;

  458. extern Model* modelX16;

  459. extern Model* modelX8;

  460. extern Model* modelX4;

  461. extern Model* modelX6;

  462. extern Model* modelCVS;

  463. extern Model* modelDTrig;

  464. #undef modelSKF

  465. #undef modelX4

  466. #undef modelMVerb

  467. #undef modelOsc3

  468. 

  469. // DHEModules

  470. // NOTE very unique way of handling init, needs special handling

  471. namespace dhe {

  472. namespace blossom { void init(Plugin*); }

  473. namespace buttons { void init(Plugin*); }

  474. namespace cubic { void init(Plugin*); }

  475. namespace curve_sequencer { void init(Plugin*); }

  476. namespace envelope { void init(Plugin*); }

  477. namespace func { void init(Plugin*); }

  478. namespace fuzzy_logic { void init(Plugin*); }

  479. namespace gator { void init(Plugin*); }

  480. namespace ranger { void init(Plugin*); }

  481. namespace scannibal { void init(Plugin*); }

  482. namespace sequencizer { void init(Plugin*); }

  483. namespace swave { void init(Plugin*); }

  484. namespace tapers { void init(Plugin*); }

  485. namespace truth { void init(Plugin*); }

  486. namespace xycloid { void init(Plugin*); }

  487. }

  488. 

  489. // eightfold

  490. #include "eightfold/src/plugin.hpp"

  491. 

  492. // EnigmaCurry

  493. #define modelPulse modelEnigmaCurryPulse

  494. #include "EnigmaCurry/src/plugin.hpp"

  495. #undef modelPulse

  496. 

  497. // ESeries

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

  499. 

  500. // ExpertSleepers-Encoders

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

  502. 

  503. // Extratone

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

  505. 

  506. // FehlerFabrik

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

  508. 

  509. // forsitan modulare

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

  511. 

  512. // GlueTheGiant

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

  514. bool audition_mixer = false;

  515. bool audition_depot = false;

  516. int gtg_default_theme = 1;

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

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

  519. 

  520. // GoodSheperd

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

  522. 

  523. // GrandeModular

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

  525. 

  526. // H4N4 Modules

  527. #include "h4n4-modules/src/plugin.hpp"

  528. 

  529. // Hampton Harmonics

  530. #define modelArp modelHamptonHarmonicsArp

  531. #define modelProgress modelHamptonHarmonicsProgress

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

  533. #undef modelProgress

  534. #undef modelArp

  535. 

  536. // HetrickCV

  537. #define modelASR modelHetrickCVASR

  538. #define modelBlankPanel modelHetrickCVBlankPanel

  539. #define modelFlipFlop modelHetrickCVFlipFlop

  540. #define modelMidSide modelHetrickCVMidSide

  541. #define modelMinMax modelHetrickCVMinMax

  542. #define PanelBaseWidget HetrickCVPanelBaseWidget

  543. #define InverterWidget HetrickCVInverterWidget

  544. extern Model* modelTwoToFour;

  545. extern Model* modelAnalogToDigital;

  546. extern Model* modelASR;

  547. extern Model* modelBinaryCounter;

  548. extern Model* modelBinaryGate;

  549. extern Model* modelBinaryNoise;

  550. extern Model* modelBitshift;

  551. extern Model* modelBlankPanel;

  552. extern Model* modelBoolean3;

  553. extern Model* modelChaos1Op;

  554. extern Model* modelChaos2Op;

  555. extern Model* modelChaos3Op;

  556. extern Model* modelChaoticAttractors;

  557. extern Model* modelClockedNoise;

  558. extern Model* modelClockToPhasor;

  559. extern Model* modelComparator;

  560. extern Model* modelContrast;

  561. extern Model* modelCrackle;

  562. extern Model* modelDataCompander;

  563. extern Model* modelDelta;

  564. extern Model* modelDigitalToAnalog;

  565. extern Model* modelDust;

  566. extern Model* modelExponent;

  567. extern Model* modelFBSineChaos;

  568. extern Model* modelFlipFlop;

  569. extern Model* modelFlipPan;

  570. extern Model* modelGateDelay;

  571. extern Model* modelGateJunction;

  572. extern Model* modelGateJunctionExp;

  573. extern Model* modelGingerbread;

  574. extern Model* modelLogicCombine;

  575. extern Model* modelMidSide;

  576. extern Model* modelMinMax;

  577. extern Model* modelNormals;

  578. extern Model* modelPhaseDrivenSequencer;

  579. extern Model* modelPhaseDrivenSequencer32;

  580. extern Model* modelPhasorAnalyzer;

  581. extern Model* modelPhasorBurstGen;

  582. extern Model* modelPhasorDivMult;

  583. extern Model* modelPhasorEuclidean;

  584. extern Model* modelPhasorFreezer;

  585. extern Model* modelPhasorGates;

  586. extern Model* modelPhasorGates32;

  587. extern Model* modelPhasorGates64;

  588. extern Model* modelPhasorGen;

  589. extern Model* modelPhasorGeometry;

  590. extern Model* modelPhasorHumanizer;

  591. extern Model* modelPhasorMixer;

  592. extern Model* modelPhasorOctature;

  593. extern Model* modelPhasorProbability;

  594. extern Model* modelPhasorQuadrature;

  595. extern Model* modelPhasorRandom;

  596. extern Model* modelPhasorRanger;

  597. extern Model* modelPhasorReset;

  598. extern Model* modelPhasorRhythmGroup;

  599. extern Model* modelPhasorShape;

  600. extern Model* modelPhasorShift;

  601. extern Model* modelPhasorSplitter;

  602. extern Model* modelPhasorStutter;

  603. extern Model* modelPhasorSubstepShape;

  604. extern Model* modelPhasorSwing;

  605. extern Model* modelPhasorTimetable;

  606. extern Model* modelPhasorToClock;

  607. extern Model* modelPhasorToRandom;

  608. extern Model* modelPhasorToLFO;

  609. extern Model* modelPhasorToWaveforms;

  610. extern Model* modelPolymetricPhasors;

  611. extern Model* modelProbability;

  612. extern Model* modelRandomGates;

  613. extern Model* modelRotator;

  614. extern Model* modelRungler;

  615. extern Model* modelScanner;

  616. extern Model* modelTrigShaper;

  617. extern Model* modelVectorMix;

  618. extern Model* modelWaveshape;

  619. extern Model* modelXYToPolar;

  620. #undef modelASR

  621. #undef modelBlankPanel

  622. #undef modelFlipFlop

  623. #undef modelMidSide

  624. #undef modelMinMax

  625. #undef PanelBaseWidget

  626. #undef InverterWidget

  627. 

  628. // ImpromptuModular

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

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

  631. */

  632. extern Model* modelAdaptiveQuantizer;

  633. extern Model* modelBigButtonSeq;

  634. extern Model* modelBigButtonSeq2;

  635. extern Model* modelChordKey;

  636. extern Model* modelChordKeyExpander;

  637. extern Model* modelClocked;

  638. extern Model* modelClockedExpander;

  639. extern Model* modelClkd;

  640. extern Model* modelCvPad;

  641. extern Model* modelFoundry;

  642. extern Model* modelFoundryExpander;

  643. extern Model* modelFourView;

  644. extern Model* modelGateSeq64;

  645. extern Model* modelGateSeq64Expander;

  646. extern Model* modelHotkey;

  647. extern Model* modelPart;

  648. extern Model* modelPhraseSeq16;

  649. extern Model* modelPhraseSeq32;

  650. extern Model* modelPhraseSeqExpander;

  651. extern Model* modelProbKey;

  652. extern Model* modelSemiModularSynth;

  653. extern Model* modelSygen;

  654. extern Model* modelTact;

  655. extern Model* modelTact1;

  656. extern Model* modelTactG;

  657. extern Model* modelTwelveKey;

  658. extern Model* modelVariations;

  659. extern Model* modelWriteSeq32;

  660. extern Model* modelWriteSeq64;

  661. extern Model* modelBlankPanel;

  662. 

  663. // ihtsyn

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

  665. 

  666. // JW-Modules

  667. #define modelQuantizer modelJWQuantizer

  668. #define modelArrange modelJWArrange

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

  670. #undef modelQuantizer

  671. #undef modelArrange

  672. 

  673. // kocmoc

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

  675. 

  676. // LifeFormModular

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

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

  679. */

  680. extern Model* modelTimeDiktat;

  681. extern Model* modelSequenceModeler;

  682. extern Model* modelPitchDiktat;

  683. extern Model* modelPitchIntegrator;

  684. extern Model* modelBurstIntegrator;

  685. extern Model* modelQuadModulator;

  686. extern Model* modelImpulseControl;

  687. extern Model* modelQuadSteppedOffset;

  688. extern Model* modelPercussiveVibration;

  689. extern Model* modelQuadUtility;

  690. extern Model* modelAdditiveVibration;

  691. extern Model* modelComplexOsc;

  692. extern Model* modelDriftgen;

  693. 

  694. // LittleUtils

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

  696. 

  697. // Lilac Loop

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

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

  700. */

  701. extern Model* modelLooperOne;

  702. extern Model* modelLooperTwo;

  703. 

  704. // LomasModules

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

  706. #undef DR_WAV_IMPLEMENTATION

  707. 

  708. // LyraeModules

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

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

  711. */

  712. #define modelDelta modelLyraeDelta

  713. extern Model* modelSulafat;

  714. extern Model* modelGamma;

  715. extern Model* modelDelta;

  716. extern Model* modelVega;

  717. extern Model* modelBD383238;

  718. extern Model* modelZeta;

  719. extern Model* modelSheliak;

  720. extern Model* modelBeta;

  721. #undef modelDelta

  722. 

  723. // Meander

  724. extern int Meander_panelTheme;

  725. extern int MSQ_panelTheme;

  726. extern int MSP_panelTheme;

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

  728. 

  729. // MindMeldModular

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

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

  732. */

  733. extern Model *modelPatchMaster;

  734. extern Model *modelPatchMasterBlank;

  735. extern Model *modelRouteMasterMono5to1;

  736. extern Model *modelRouteMasterStereo5to1;

  737. extern Model *modelRouteMasterMono1to5;

  738. extern Model *modelRouteMasterStereo1to5;

  739. extern Model *modelMasterChannel;

  740. extern Model *modelMeld;

  741. extern Model *modelUnmeld;

  742. extern Model *modelMSMelder;

  743. extern Model *modelEqMaster;

  744. extern Model *modelEqExpander;

  745. extern Model *modelBassMaster;

  746. extern Model *modelBassMasterJr;

  747. extern Model *modelShapeMaster;

  748. extern Model *modelMixMasterJr;

  749. extern Model *modelAuxExpanderJr;

  750. extern Model *modelMixMaster;

  751. extern Model *modelAuxExpander;

  752. 

  753. // ML_modules

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

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

  756. */

  757. #define modelQuantizer modelMLQuantizer

  758. #define modelSH8 modelMLSH8

  759. extern Model* modelQuantizer;

  760. extern Model* modelQuantum;

  761. extern Model* modelTrigBuf;

  762. extern Model* modelSeqSwitch;

  763. extern Model* modelSeqSwitch2;

  764. extern Model* modelShiftRegister;

  765. extern Model* modelShiftRegister2;

  766. extern Model* modelFreeVerb;

  767. extern Model* modelSum8;

  768. extern Model* modelSum8mk2;

  769. extern Model* modelSum8mk3;

  770. extern Model* modelSH8;

  771. extern Model* modelConstants;

  772. extern Model* modelCounter;

  773. extern Model* modelTrigDelay;

  774. extern Model* modelBPMdetect;

  775. extern Model* modelVoltMeter;

  776. extern Model* modelOctaFlop;

  777. extern Model* modelOctaTrig;

  778. extern Model* modelOctaSwitch;

  779. extern Model* modelTrigSwitch;

  780. extern Model* modelTrigSwitch2;

  781. extern Model* modelTrigSwitch3;

  782. extern Model* modelTrigSwitch3_2;

  783. extern Model* modelOctaPlus;

  784. extern Model* modelOctaTimes;

  785. extern Model* modelCloner;

  786. extern Model* modelPolySplitter;

  787. extern Model* modelArpeggiator;

  788. #undef modelQuantizer

  789. #undef modelSH8

  790. 

  791. // MockbaModular

  792. #define modelBlank modelMockbaModularBlank

  793. #define modelComparator modelMockbaModularComparator

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

  795. #undef modelBlank

  796. #undef modelComparator

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

  798. #undef min

  799. #undef max

  800. #define saveBack ignoreMockbaModular1

  801. #define loadBack ignoreMockbaModular2

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

  803. #undef saveBack

  804. #undef loadBack

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

  806. 

  807. // Mog

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

  809. 

  810. // mscHack

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

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

  813. */

  814. extern Model* modelCompressor;

  815. extern Model* modelSynthDrums;

  816. extern Model* modelSEQ_6x32x16;

  817. extern Model* modelMasterClockx8;

  818. extern Model* modelMasterClockx4;

  819. extern Model* modelSEQ_Envelope_8;

  820. extern Model* modelSeq_Triad2;

  821. extern Model* modelARP700;

  822. extern Model* modelMix_24_4_4;

  823. extern Model* modelMix_16_4_4;

  824. extern Model* modelMix_9_3_4;

  825. extern Model* modelMix_4_0_4;

  826. extern Model* modelASAF8;

  827. extern Model* modelPingPong;

  828. extern Model* modelStepDelay;

  829. extern Model* modelOsc_3Ch;

  830. extern Model* modelDronez;

  831. extern Model* modelMorze;

  832. extern Model* modelWindz;

  833. extern Model* modelLorenz;

  834. extern Model* modelAlienz;

  835. extern Model* modelOSC_WaveMorph_3;

  836. extern Model* modelMaude_221;

  837. 

  838. // MSM

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

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

  841. */

  842. #define modelADSR modelMSMADSR

  843. #define modelBlankPanel modelMSMBlankPanel

  844. #define modelDelay modelMSMDelay

  845. #define modelLFO modelMSMLFO

  846. #define modelMult modelMSMMult

  847. #define modelNoise modelMSMNoise

  848. #define modelVCA modelMSMVCA

  849. #define modelVCO modelMSMVCO

  850. extern Model* modelVCO;

  851. extern Model* modelBVCO;

  852. extern Model* modelExperimentalVCO;

  853. extern Model* modelNoise;

  854. extern Model* modelLFO;

  855. extern Model* modelVCA;

  856. extern Model* modelADSR;

  857. extern Model* modelDelay;

  858. extern Model* modelWaveShaper;

  859. extern Model* modelWavefolder;

  860. extern Model* modelBitcrusher;

  861. extern Model* modelPhaserModule;

  862. extern Model* modelMorpher;

  863. extern Model* modelRingMod;

  864. extern Model* modelRandomSource;

  865. extern Model* modelMult;

  866. extern Model* modelCrazyMult;

  867. extern Model* modelFade;

  868. extern Model* modelSimpleSlider;

  869. extern Model* modelxseq;

  870. extern Model* modelBlankPanel;

  871. #undef modelADSR

  872. #undef modelBlankPanel

  873. #undef modelDelay

  874. #undef modelLFO

  875. #undef modelMult

  876. #undef modelNoise

  877. #undef modelVCA

  878. #undef modelVCO

  879. 

  880. // MUS-X

  881. #include "MUS-X/src/plugin.hpp"

  882. 

  883. // myth-modules

  884. #include "myth-modules/src/plugin.hpp"

  885. 

  886. // Nonlinear Circuits

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

  888. 

  889. // Orbits

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

  891. 

  892. // ParableInstruments

  893. #define modelClouds modelParableClouds

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

  895. #undef modelClouds

  896. 

  897. // Path Set

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

  899. 

  900. // PdArray

  901. #define TextBox PdArrayTextBox

  902. #define CustomTrimpot PdArrayCustomTrimpot

  903. #define MsDisplayWidget PdArrayMsDisplayWidget

  904. #define MAX_POLY_CHANNELS PDARRAY_MAX_POLY_CHANNELS

  905. #include "PdArray/src/plugin.hpp"

  906. #undef Textbox

  907. #undef CustomTrimpot

  908. #undef MsDisplayWidget

  909. #undef MAX_POLY_CHANNELS

  910. 

  911. // PinkTrombone

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

  913. 

  914. // Prism

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

  916. 

  917. // rackwindows

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

  919. 

  920. // RCM

  921. #include "rcm-modules/src/plugin.hpp"

  922. 

  923. // RebelTech

  924. #define BefacoInputPort BefacoInputPortRebelTech

  925. #define BefacoOutputPort BefacoOutputPortRebelTech

  926. #include "RebelTech/src/plugin.hpp"

  927. #undef BefacoInputPort

  928. #undef BefacoOutputPort

  929. ModuleTheme defaultPanelTheme = DARK_THEME;

  930. void addThemeMenuItems(Menu*, ModuleTheme*) {}

  931. 

  932. // repelzen

  933. #define modelBlank modelrepelzenBlank

  934. #define modelMixer modelrepelzenMixer

  935. #define modelWerner modelrepelzenWerner

  936. #define tanh_pade repelzentanh_pade

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

  938. #undef modelBlank

  939. #undef modelMixer

  940. #undef modelWerner

  941. #undef tanh_pade

  942. 

  943. // Sapphire

  944. #include "Sapphire/src/plugin.hpp"

  945. 

  946. // sonusmodular

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

  948. 

  949. // Starling Via

  950. #define modelScanner modelStarlingViaScanner

  951. #define Scale starlingViaScale

  952. #define Wavetable starlingViaWavetable

  953. #include "StarlingVia/src/starling.hpp"

  954. #undef modelScanner

  955. #undef Scale

  956. #undef Wavetable

  957. 

  958. // stocaudio

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

  960. 

  961. // stoermelder-packone

  962. #include "stoermelder-packone/src/plugin.hpp"

  963. Model* modelAudioInterface64;

  964. Model* modelMidiCat;

  965. Model* modelMidiCatCtx;

  966. Model* modelMidiCatMem;

  967. Model* modelMidiKey;

  968. Model* modelMidiMon;

  969. Model* modelMidiPlug;

  970. Model* modelMidiStep;

  971. StoermelderSettings pluginSettings;

  972. void StoermelderSettings::saveToJson() {}

  973. void StoermelderSettings::readFromJson() {}

  974. 

  975. // surgext

  976. #include "surgext/src/SurgeXT.h"

  977. void surgext_rack_initialize();

  978. void surgext_rack_update_theme();

  979. 

  980. // unless_modules

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

  982. 

  983. // ValleyAudio

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

  985. 

  986. // Voxglitch

  987. #define modelLooper modelVoxglitchLooper

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

  989. #undef modelLooper

  990. 

  991. // WhatTheRack

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

  993. 

  994. // WSTD-Drums

  995. #include "WSTD-Drums/src/WSTD_Drums.hpp"

  996. void setupSamples();

  997. 

  998. // ZetaCarinaeModules

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

  1000. 

  1001. // ZZC

  1002. #define DISPLAYS_H

  1003. #define ZZC_SHARED_H

  1004. #define ZZC_WIDGETS_H

  1005. #define modelClock modelZZCClock

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

  1007. #undef modelClock

  1008. 

  1009. // known terminal modules

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

  1011. 

  1012. // stuff that reads config files, we don't want that

  1013. int loadConsoleType() { return 0; }

  1014. bool loadDarkAsDefault() { return settings::preferDarkPanels; }

  1015. ModuleTheme loadDefaultTheme() { return settings::preferDarkPanels ? DARK_THEME : LIGHT_THEME; }

  1016. int loadDirectOutMode() { return 0; }

  1017. void readDefaultTheme() { defaultPanelTheme = loadDefaultTheme(); }

  1018. void saveConsoleType(int) {}

  1019. void saveDarkAsDefault(bool) {}

  1020. void saveDefaultTheme(ModuleTheme) {}

  1021. void saveDirectOutMode(bool) {}

  1022. void saveHighQualityAsDefault(bool) {}

  1023. void writeDefaultTheme() {}

  1024. 

  1025. // plugin instances

  1026. Plugin* pluginInstance__Cardinal;

  1027. Plugin* pluginInstance__Fundamental;

  1028. // Plugin* pluginInstance__ZamAudio;

  1029. Plugin* pluginInstance__21kHz;

  1030. Plugin* pluginInstance__8Mode;

  1031. extern Plugin* pluginInstance__AaronStatic;

  1032. Plugin* pluginInstance__admiral;

  1033. Plugin* pluginInstance__alefsbits;

  1034. Plugin* pluginInstance__Algoritmarte;

  1035. Plugin* pluginInstance__AmalgamatedHarmonics;

  1036. Plugin* pluginInstance__ArableInstruments;

  1037. Plugin* pluginInstance__AnimatedCircuits;

  1038. Plugin* pluginInstance__Aria;

  1039. Plugin* pluginInstance__AS;

  1040. Plugin* pluginInstance__AudibleInstruments;

  1041. extern Plugin* pluginInstance__Autinn;

  1042. Plugin* pluginInstance__Axioma;

  1043. Plugin* pluginInstance__Bacon;

  1044. Plugin* pluginInstance__Befaco;

  1045. Plugin* pluginInstance__Bidoo;

  1046. Plugin* pluginInstance__Biset;

  1047. Plugin* pluginInstance__BogaudioModules;

  1048. Plugin* pluginInstance__CatroModulo;

  1049. Plugin* pluginInstance__cf;

  1050. Plugin* pluginInstance__ChowDSP;

  1051. Plugin* pluginInstance__Computerscare;

  1052. Plugin* pluginInstance__CVfunk;

  1053. Plugin* pluginInstance__dBiz;

  1054. Plugin* pluginInstance__dbRackModules;

  1055. Plugin* pluginInstance__DHE;

  1056. Plugin* pluginInstance__eightfold;

  1057. Plugin* pluginInstance__EnigmaCurry;

  1058. Plugin* pluginInstance__ESeries;

  1059. Plugin* pluginInstance__ExpertSleepersEncoders;

  1060. Plugin* pluginInstance__Extratone;

  1061. Plugin* pluginInstance__FehlerFabrik;

  1062. Plugin* pluginInstance__forsitan;

  1063. Plugin* pluginInstance__GlueTheGiant;

  1064. Plugin* pluginInstance__GoodSheperd;

  1065. Plugin* pluginInstance__GrandeModular;

  1066. Plugin* pluginInstance__H4N4;

  1067. Plugin* pluginInstance__HamptonHarmonics;

  1068. Plugin* pluginInstance__HetrickCV;

  1069. extern Plugin* pluginInstance__ImpromptuModular;

  1070. Plugin* pluginInstance__ihtsyn;

  1071. Plugin* pluginInstance__JW;

  1072. Plugin* pluginInstance__kocmoc;

  1073. Plugin* pluginInstance__LifeFormModular;

  1074. Plugin* pluginInstance__LilacLoop;

  1075. Plugin* pluginInstance__LittleUtils;

  1076. Plugin* pluginInstance__Lomas;

  1077. Plugin* pluginInstance__Lyrae;

  1078. Plugin* pluginInstance__Meander;

  1079. extern Plugin* pluginInstance__MindMeld;

  1080. Plugin* pluginInstance__ML;

  1081. Plugin* pluginInstance__MockbaModular;

  1082. Plugin* pluginInstance__Mog;

  1083. extern Plugin* pluginInstance__mscHack;

  1084. Plugin* pluginInstance__MSM;

  1085. Plugin* pluginInstance__MUS_X;

  1086. Plugin* pluginInstance__myth_modules;

  1087. Plugin* pluginInstance__nonlinearcircuits;

  1088. Plugin* pluginInstance__Orbits;

  1089. Plugin* pluginInstance__ParableInstruments;

  1090. Plugin* pluginInstance__PathSet;

  1091. Plugin* pluginInstance__PdArray;

  1092. Plugin* pluginInstance__PinkTrombone;

  1093. Plugin* pluginInstance__Prism;

  1094. Plugin* pluginInstance__rackwindows;

  1095. Plugin* pluginInstance__RCM;

  1096. Plugin* pluginInstance__RebelTech;

  1097. Plugin* pluginInstance__repelzen;

  1098. Plugin* pluginInstance__sapphire;

  1099. Plugin* pluginInstance__sonusmodular;

  1100. Plugin* pluginInstance__StarlingVia;

  1101. Plugin* pluginInstance__stocaudio;

  1102. extern Plugin* pluginInstance__stoermelder_p1;

  1103. Plugin* pluginInstance__surgext;

  1104. Plugin* pluginInstance__unless_modules;

  1105. Plugin* pluginInstance__ValleyAudio;

  1106. Plugin* pluginInstance__Voxglitch;

  1107. Plugin* pluginInstance__WhatTheRack;

  1108. extern Plugin* pluginInstance__WSTD_Drums;

  1109. Plugin* pluginInstance__ZetaCarinaeModules;

  1110. Plugin* pluginInstance__ZZC;

  1111. 

  1112. namespace rack {

  1113. 

  1114. namespace asset {

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

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

  1117. }

  1118. 

  1119. namespace plugin {

  1120. 

  1121. static uint32_t numPluginModules = 0;

  1122. 

  1123. struct StaticPluginLoader {

  1124.     Plugin* const plugin;

  1125.     FILE* file;

  1126.     json_t* rootJ;

  1127. 

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

  1129.         : plugin(p),

  1130.           file(nullptr),

  1131.           rootJ(nullptr)

  1132.     {

  1133. #ifdef DEBUG

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

  1135. #endif

  1136. 

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

  1138. 

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

  1140. 

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

  1142.         {

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

  1144.             return;

  1145.         }

  1146. 

  1147.         json_error_t error;

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

  1149.         {

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

  1151.             return;

  1152.         }

  1153. 

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

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

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

  1157.         json_decref(version);

  1158. 

  1159.         // Load manifest

  1160.         p->fromJson(rootJ);

  1161. 

  1162.         // Reject plugin if slug already exists

  1163.         if (Plugin* const existingPlugin = getPlugin(p->slug))

  1164.             throw Exception("Plugin %s is already loaded, not attempting to load it again", p->slug.c_str());

  1165.     }

  1166. 

  1167.     ~StaticPluginLoader()

  1168.     {

  1169.         if (rootJ != nullptr)

  1170.         {

  1171.             // Load modules manifest

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

  1173.             plugin->modulesFromJson(modulesJ);

  1174. 

  1175.             json_decref(rootJ);

  1176.             plugins.push_back(plugin);

  1177. 

  1178.             numPluginModules += plugin->models.size();

  1179.         }

  1180. 

  1181.         if (file != nullptr)

  1182.             std::fclose(file);

  1183.     }

  1184. 

  1185.     bool ok() const noexcept

  1186.     {

  1187.         return rootJ != nullptr;

  1188.     }

  1189. 

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

  1191.     {

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

  1193.         DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);

  1194. 

  1195.         size_t i;

  1196.         json_t* v;

  1197.         json_array_foreach(modules, i, v)

  1198.         {

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

  1200.             {

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

  1202.                 {

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

  1204.                     {

  1205.                         json_array_remove(modules, i);

  1206.                         break;

  1207.                     }

  1208.                 }

  1209.             }

  1210.         }

  1211.     }

  1212. };

  1213. 

  1214. static void initStatic__Cardinal()

  1215. {

  1216.     Plugin* const p = new Plugin;

  1217.     pluginInstance__Cardinal = p;

  1218. 

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

  1220.     if (spl.ok())

  1221.     {

  1222.         p->addModel(modelAidaX);

  1223.         p->addModel(modelCardinalBlank);

  1224.         p->addModel(modelExpanderInputMIDI);

  1225.         p->addModel(modelExpanderOutputMIDI);

  1226.         p->addModel(modelHostAudio2);

  1227.         p->addModel(modelHostAudio8);

  1228.         p->addModel(modelHostCV);

  1229.         p->addModel(modelHostMIDI);

  1230.         p->addModel(modelHostMIDICC);

  1231.         p->addModel(modelHostMIDIGate);

  1232.         p->addModel(modelHostMIDIMap);

  1233.         p->addModel(modelHostParameters);

  1234.         p->addModel(modelHostParametersMap);

  1235.         p->addModel(modelHostTime);

  1236.         p->addModel(modelTextEditor);

  1237.        #ifndef DGL_USE_GLES

  1238.         p->addModel(modelGlBars);

  1239.        #else

  1240.         spl.removeModule("glBars");

  1241.        #endif

  1242.        #ifndef STATIC_BUILD

  1243.         p->addModel(modelAudioFile);

  1244.        #else

  1245.         spl.removeModule("AudioFile");

  1246.        #endif

  1247.        #if !(defined(DISTRHO_OS_WASM) || defined(STATIC_BUILD))

  1248.         p->addModel(modelCarla);

  1249.         p->addModel(modelIldaeil);

  1250.        #else

  1251.         spl.removeModule("Carla");

  1252.         spl.removeModule("Ildaeil");

  1253.        #endif

  1254.        #ifndef HEADLESS

  1255.         p->addModel(modelSassyScope);

  1256.        #else

  1257.         spl.removeModule("SassyScope");

  1258.        #endif

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

  1260.         p->addModel(modelMPV);

  1261.        #else

  1262.         spl.removeModule("MPV");

  1263.        #endif

  1264.        #ifdef HAVE_FFTW3F

  1265.         p->addModel(modelAudioToCVPitch);

  1266.        #else

  1267.         spl.removeModule("AudioToCVPitch");

  1268.        #endif

  1269. 

  1270.         hostTerminalModels = {

  1271.             modelHostAudio2,

  1272.             modelHostAudio8,

  1273.             modelHostCV,

  1274.             modelHostMIDI,

  1275.             modelHostMIDICC,

  1276.             modelHostMIDIGate,

  1277.             modelHostMIDIMap,

  1278.             modelHostParameters,

  1279.             modelHostParametersMap,

  1280.             modelHostTime,

  1281.         };

  1282.     }

  1283. }

  1284. 

  1285. static void initStatic__Fundamental()

  1286. {

  1287.     Plugin* const p = new Plugin;

  1288.     pluginInstance__Fundamental = p;

  1289. 

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

  1291.     if (spl.ok())

  1292.     {

  1293.         p->addModel(model_8vert);

  1294.         p->addModel(modelADSR);

  1295.         p->addModel(modelDelay);

  1296.         p->addModel(modelLFO);

  1297.         p->addModel(modelLFO2);

  1298.         p->addModel(modelMerge);

  1299.         p->addModel(modelMidSide);

  1300.         p->addModel(modelMixer);

  1301.         p->addModel(modelMutes);

  1302.         p->addModel(modelNoise);

  1303.         p->addModel(modelOctave);

  1304.         p->addModel(modelPulses);

  1305.         p->addModel(modelQuantizer);

  1306.         p->addModel(modelRandom);

  1307.         p->addModel(modelScope);

  1308.         p->addModel(modelSEQ3);

  1309.         p->addModel(modelSequentialSwitch1);

  1310.         p->addModel(modelSequentialSwitch2);

  1311.         p->addModel(modelSplit);

  1312.         p->addModel(modelSum);

  1313.         p->addModel(modelVCA);

  1314.         p->addModel(modelVCA_1);

  1315.         p->addModel(modelVCF);

  1316.         p->addModel(modelVCMixer);

  1317.         p->addModel(modelVCO);

  1318.         p->addModel(modelVCO2);

  1319.     }

  1320. }

  1321. 

  1322. /*

  1323. static void initStatic__ZamAudio()

  1324. {

  1325.     Plugin* const p = new Plugin;

  1326.     pluginInstance__ZamAudio = p;

  1327. 

  1328.     const StaticPluginLoader spl(p, "ZamAudio");

  1329.     if (spl.ok())

  1330.     {

  1331.         p->addModel(modelZamComp);

  1332.     }

  1333. }

  1334. */

  1335. 

  1336. static void initStatic__21kHz()

  1337. {

  1338.     Plugin* const p = new Plugin;

  1339.     pluginInstance__21kHz = p;

  1340. 

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

  1342.     if (spl.ok())

  1343.     {

  1344.         p->addModel(modelPalmLoop);

  1345.         p->addModel(modelD_Inf);

  1346.         p->addModel(modelTachyonEntangler);

  1347.     }

  1348. }

  1349. 

  1350. static void initStatic__8Mode()

  1351. {

  1352.     Plugin* const p = new Plugin;

  1353.     pluginInstance__8Mode = p;

  1354. 

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

  1356.     if (spl.ok())

  1357.     {

  1358.         p->addModel(modelsoftSN);

  1359.     }

  1360. }

  1361. 

  1362. static void initStatic__AaronStatic()

  1363. {

  1364.     Plugin* const p = new Plugin;

  1365.     pluginInstance__AaronStatic = p;

  1366. 

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

  1368.     if (spl.ok())

  1369.     {

  1370.         p->addModel(modelChordCV);

  1371.         p->addModel(modelScaleCV);

  1372.         p->addModel(modelRandomNoteCV);

  1373.         p->addModel(modelDiatonicCV);

  1374.     }

  1375. }

  1376. 

  1377. static void initStatic__admiral()

  1378. {

  1379.     Plugin* const p = new Plugin;

  1380.     pluginInstance__admiral = p;

  1381. 

  1382.     const StaticPluginLoader spl(p, "admiral");

  1383.     if (spl.ok())

  1384.     {

  1385.         p->addModel(modelWatches);

  1386.         p->addModel(modelShifts);

  1387.         p->addModel(modelTables);

  1388.         p->addModel(modelDivisions);

  1389.     }

  1390. }

  1391. 

  1392. static void initStatic__alefsbits()

  1393. {

  1394.     Plugin* const p = new Plugin;

  1395.     pluginInstance__alefsbits = p;

  1396. 

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

  1398.     if (spl.ok())

  1399.     {

  1400. #define modelSteps modelalefsbitsSteps

  1401. #define modelLogic modelalefsbitsLogic

  1402.         p->addModel(modelSimplexandhold);

  1403.         p->addModel(modelBlank6hp);

  1404.         p->addModel(modelPolyrand);

  1405.         p->addModel(modelNoize);

  1406.         p->addModel(modelSteps);

  1407.         p->addModel(modelFibb);

  1408.         p->addModel(modelOctsclr);

  1409.         p->addModel(modelShift);

  1410.         p->addModel(modelMlt);

  1411.         p->addModel(modelMath);

  1412.         p->addModel(modelLogic);

  1413.         p->addModel(modelProbablynot);

  1414. #undef modelSteps

  1415. #undef modelLogic

  1416.     }

  1417. }

  1418. 

  1419. static void initStatic__Algoritmarte()

  1420. {

  1421.     Plugin* const p = new Plugin;

  1422.     pluginInstance__Algoritmarte = p;

  1423. 

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

  1425.     if (spl.ok())

  1426.     {

  1427.         p->addModel(modelClockkky);

  1428.         p->addModel(modelPlanetz);

  1429.         p->addModel(modelMusiFrog);

  1430.         p->addModel(modelZefiro);

  1431.         p->addModel(modelHoldMeTight);

  1432.         p->addModel(modelCyclicCA);

  1433.         p->addModel(modelMusiMath);

  1434.     }

  1435. }

  1436. 

  1437. static void initStatic__AmalgamatedHarmonics()

  1438. {

  1439.     Plugin* const p = new Plugin;

  1440.     pluginInstance__AmalgamatedHarmonics = p;

  1441. 

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

  1443.     if (spl.ok())

  1444.     {

  1445.         p->addModel(modelArp31);

  1446.         p->addModel(modelArp32);

  1447.         p->addModel(modelBombe);

  1448.         p->addModel(modelChord);

  1449.         p->addModel(modelCircle);

  1450.         p->addModel(modelGalaxy);

  1451.         p->addModel(modelGenerative);

  1452.         p->addModel(modelImp);

  1453.         p->addModel(modelImperfect2);

  1454.         p->addModel(modelProgress2);

  1455.         p->addModel(modelRuckus);

  1456.         p->addModel(modelScaleQuantizer2);

  1457.         p->addModel(modelSLN);

  1458.         p->addModel(modelMuxDeMux);

  1459.         p->addModel(modelPolyProbe);

  1460.         p->addModel(modelPolyScope);

  1461.         p->addModel(modelPolyUtils);

  1462.         p->addModel(modelPolyVolt);

  1463.         p->addModel(modelScaleQuantizer);

  1464.         p->addModel(modelArpeggiator2);

  1465.         p->addModel(modelProgress);

  1466.     }

  1467. }

  1468. 

  1469. static void initStatic__AnimatedCircuits()

  1470. {

  1471.     Plugin* const p = new Plugin;

  1472.     pluginInstance__AnimatedCircuits = p;

  1473. 

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

  1475.     if (spl.ok())

  1476.     {

  1477.         p->addModel(model_AC_Folding);

  1478.         p->addModel(model_AC_LFold);

  1479.     }

  1480. }

  1481. 

  1482. static void initStatic__ArableInstruments()

  1483. {

  1484.     Plugin* const p = new Plugin;

  1485.     pluginInstance__ArableInstruments = p;

  1486. 

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

  1488.     if (spl.ok())

  1489.     {

  1490. #define modelClouds modelArableClouds

  1491.         p->addModel(modelClouds);

  1492. #undef modelClouds

  1493.     }

  1494. }

  1495. 

  1496. static void initStatic__Aria()

  1497. {

  1498.     Plugin* const p = new Plugin;

  1499.     pluginInstance__Aria = p;

  1500. 

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

  1502.     if (spl.ok())

  1503.     {

  1504. #define modelBlank modelAriaBlank

  1505.         p->addModel(modelSplort);

  1506.         p->addModel(modelSmerge);

  1507.         p->addModel(modelSpleet);

  1508.         p->addModel(modelSwerge);

  1509.         p->addModel(modelSplirge);

  1510.         p->addModel(modelQqqq);

  1511.         p->addModel(modelQuack);

  1512.         p->addModel(modelQ);

  1513.         p->addModel(modelQuale);

  1514.         p->addModel(modelDarius);

  1515.         p->addModel(modelSolomon4);

  1516.         p->addModel(modelSolomon8);

  1517.         p->addModel(modelSolomon16);

  1518.         p->addModel(modelPsychopump);

  1519.         p->addModel(modelPokies4);

  1520.         p->addModel(modelGrabby);

  1521.         p->addModel(modelRotatoes4);

  1522.         p->addModel(modelUndular);

  1523.         p->addModel(modelBlank);

  1524. #undef modelBlank

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

  1526.         spl.removeModule("Arcane");

  1527.         spl.removeModule("Atout");

  1528.         spl.removeModule("Aleister");

  1529.     }

  1530. }

  1531. 

  1532. static void initStatic__AS()

  1533. {

  1534.     Plugin* const p = new Plugin;

  1535.     pluginInstance__AS = p;

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

  1537.     if (spl.ok())

  1538.     {

  1539. #define modelADSR modelASADSR

  1540. #define modelVCA modelASVCA

  1541. #define modelWaveShaper modelASWaveShaper

  1542.         //OSCILLATORS

  1543.         p->addModel(modelSineOsc);

  1544.         p->addModel(modelSawOsc);

  1545.         //TOOLS

  1546.         p->addModel(modelADSR);

  1547.         p->addModel(modelVCA);

  1548.         p->addModel(modelQuadVCA);

  1549.         p->addModel(modelTriLFO);

  1550.         p->addModel(modelAtNuVrTr);

  1551.         p->addModel(modelBPMClock);

  1552.         p->addModel(modelSEQ16);

  1553.         p->addModel(modelMixer2ch);

  1554.         p->addModel(modelMixer4ch);

  1555.         p->addModel(modelMixer8ch);

  1556.         p->addModel(modelMonoVUmeter);

  1557.         p->addModel(modelStereoVUmeter);

  1558.         p->addModel(modelMultiple2_5);

  1559.         p->addModel(modelMerge2_5);

  1560.         p->addModel(modelSteps);

  1561.         p->addModel(modelLaunchGate);

  1562.         p->addModel(modelKillGate);

  1563.         p->addModel(modelFlow);

  1564.         p->addModel(modelSignalDelay);

  1565.         p->addModel(modelTriggersMKI);

  1566.         p->addModel(modelTriggersMKII);

  1567.         p->addModel(modelTriggersMKIII);

  1568.         p->addModel(modelBPMCalc);

  1569.         p->addModel(modelBPMCalc2);

  1570.         p->addModel(modelCv2T);

  1571.         p->addModel(modelZeroCV2T);

  1572.         p->addModel(modelReScale);

  1573.         //EFFECTS

  1574.         p->addModel(modelDelayPlusFx);

  1575.         p->addModel(modelDelayPlusStereoFx);

  1576.         p->addModel(modelPhaserFx);

  1577.         p->addModel(modelReverbFx);

  1578.         p->addModel(modelReverbStereoFx);

  1579.         p->addModel(modelSuperDriveFx);

  1580.         p->addModel(modelSuperDriveStereoFx);

  1581.         p->addModel(modelTremoloFx);

  1582.         p->addModel(modelTremoloStereoFx);

  1583.         p->addModel(modelWaveShaper);

  1584.         p->addModel(modelWaveShaperStereo);

  1585.         //BLANK PANELS

  1586.         p->addModel(modelBlankPanel4);

  1587.         p->addModel(modelBlankPanel6);

  1588.         p->addModel(modelBlankPanel8);

  1589.         p->addModel(modelBlankPanelSpecial);

  1590. #undef modelADSR

  1591. #undef modelVCA

  1592. #undef modelWaveShaper

  1593.     }

  1594. }

  1595. 

  1596. static void initStatic__AudibleInstruments()

  1597. {

  1598.     Plugin* const p = new Plugin;

  1599.     pluginInstance__AudibleInstruments = p;

  1600. 

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

  1602.     if (spl.ok())

  1603.     {

  1604.         p->addModel(modelBraids);

  1605.         p->addModel(modelPlaits);

  1606.         p->addModel(modelElements);

  1607.         p->addModel(modelTides);

  1608.         p->addModel(modelTides2);

  1609.         p->addModel(modelClouds);

  1610.         p->addModel(modelWarps);

  1611.         p->addModel(modelRings);

  1612.         p->addModel(modelLinks);

  1613.         p->addModel(modelKinks);

  1614.         p->addModel(modelShades);

  1615.         p->addModel(modelBranches);

  1616.         p->addModel(modelBlinds);

  1617.         p->addModel(modelVeils);

  1618.         p->addModel(modelFrames);

  1619.         p->addModel(modelMarbles);

  1620.         p->addModel(modelStages);

  1621.         p->addModel(modelRipples);

  1622.         p->addModel(modelShelves);

  1623.         p->addModel(modelStreams);

  1624.     }

  1625. }

  1626. 

  1627. static void initStatic__Autinn()

  1628. {

  1629.     Plugin* const p = new Plugin;

  1630.     pluginInstance__Autinn = p;

  1631. 

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

  1633.     if (spl.ok())

  1634.     {

  1635. #define modelChord modelAutinnChord

  1636. #define modelVibrato modelAutinnVibrato

  1637.         p->addModel(modelAmp);

  1638.         p->addModel(modelDeadband);

  1639.         p->addModel(modelBass);

  1640.         p->addModel(modelCVConverter);

  1641.         p->addModel(modelDC);

  1642.         p->addModel(modelDigi);

  1643.         p->addModel(modelFlopper);

  1644.         p->addModel(modelFlora);

  1645.         p->addModel(modelJette);

  1646.         p->addModel(modelBoomerang);

  1647.         p->addModel(modelOxcart);

  1648.         p->addModel(modelSaw);

  1649.         p->addModel(modelSjip);

  1650.         p->addModel(modelSquare);

  1651.         p->addModel(modelVibrato);

  1652.         p->addModel(modelVectorDriver);

  1653.         p->addModel(modelZod);

  1654.         p->addModel(modelTriBand);

  1655.         p->addModel(modelMixer6);

  1656.         p->addModel(modelNon);

  1657.         p->addModel(modelFil);

  1658.         p->addModel(modelNap);

  1659.         p->addModel(modelMelody);

  1660.         p->addModel(modelChord);

  1661. #undef modelChord

  1662. #undef modelVibrato

  1663.     }

  1664. }

  1665. 

  1666. static void initStatic__Axioma()

  1667. {

  1668.     Plugin* const p = new Plugin;

  1669.     pluginInstance__Axioma = p;

  1670. 

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

  1672.     if (spl.ok())

  1673.     {

  1674.         p->addModel(modelTheBifurcator);

  1675.         p->addModel(modelTesseract);

  1676.         p->addModel(modelIkeda);

  1677.         p->addModel(modelRhodonea);

  1678.     }

  1679. }

  1680. 

  1681. static void initStatic__Bacon()

  1682. {

  1683.     Plugin* const p = new Plugin;

  1684.     pluginInstance__Bacon = p;

  1685. 

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

  1687.     if (spl.ok())

  1688.     {

  1689.         p->addModel(modelHarMoNee);

  1690.         p->addModel(modelGlissinator);

  1691.         p->addModel(modelPolyGnome);

  1692.         p->addModel(modelQuantEyes);

  1693.         p->addModel(modelSampleDelay);

  1694.         p->addModel(modelChipNoise);

  1695.         p->addModel(modelChipWaves);

  1696.         p->addModel(modelChipYourWave);

  1697.         p->addModel(modelOpen303);

  1698.         p->addModel(modelKarplusStrongPoly);

  1699.         p->addModel(modelALingADing);

  1700.         p->addModel(modelBitulator);

  1701.         p->addModel(modelPolyGenerator);

  1702.         p->addModel(modelLintBuddy);

  1703.         p->addModel(modelLuckyHold);

  1704.         p->addModel(modelPatchNameDisplay);

  1705. 

  1706.         // Used for testing or not practical

  1707.         spl.removeModule("ContrastBNDEditor");

  1708.         spl.removeModule("BaconTest");

  1709.         spl.removeModule("PleaseQuit");

  1710.     }

  1711. }

  1712. 

  1713. static void initStatic__Befaco()

  1714. {

  1715.     Plugin* const p = new Plugin;

  1716.     pluginInstance__Befaco = p;

  1717. 

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

  1719.     if (spl.ok())

  1720.     {

  1721. #define modelADSR modelBefacoADSR

  1722. #define modelMixer modelBefacoMixer

  1723. #define modelBurst modelBefacoBurst

  1724. #define modelMixer2 modelBefacoMixer2

  1725. #define modelSlew modelBefacoSlew

  1726.         p->addModel(modelEvenVCO);

  1727.         p->addModel(modelRampage);

  1728.         p->addModel(modelABC);

  1729.         p->addModel(modelSpringReverb);

  1730.         p->addModel(modelMixer);

  1731.         p->addModel(modelSlewLimiter);

  1732.         p->addModel(modelDualAtenuverter);

  1733.         p->addModel(modelPercall);

  1734.         p->addModel(modelHexmixVCA);

  1735.         p->addModel(modelChoppingKinky);

  1736.         p->addModel(modelKickall);

  1737.         p->addModel(modelSamplingModulator);

  1738.         p->addModel(modelMorphader);

  1739.         p->addModel(modelADSR);

  1740.         p->addModel(modelSTMix);

  1741.         p->addModel(modelMuxlicer);

  1742.         p->addModel(modelMex);

  1743.         p->addModel(modelNoisePlethora);

  1744.         p->addModel(modelChannelStrip);

  1745.         p->addModel(modelPonyVCO);

  1746.         p->addModel(modelMotionMTR);

  1747.         p->addModel(modelBurst);

  1748.         p->addModel(modelVoltio);

  1749.         p->addModel(modelOctaves);

  1750.         p->addModel(modelBypass);

  1751.         p->addModel(modelBandit);

  1752.         p->addModel(modelAtte);

  1753.         p->addModel(modelAxBC);

  1754.         p->addModel(modelMixer2);

  1755.         p->addModel(modelMuDi);

  1756.         p->addModel(modelSlew);

  1757. #undef modelADSR

  1758. #undef modelMixer

  1759. #undef modelBurst

  1760. #undef modelMixer2

  1761. #undef modelSlew

  1762. 

  1763.         // NOTE disabled in Cardinal due to MIDI usage

  1764.         spl.removeModule("MidiThingV2");

  1765.     }

  1766. }

  1767. 

  1768. static void initStatic__Bidoo()

  1769. {

  1770.     Plugin* const p = new Plugin;

  1771.     pluginInstance__Bidoo = p;

  1772. 

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

  1774.     if (spl.ok())

  1775.     {

  1776.         p->addModel(modelTOCANTE);

  1777.         p->addModel(modelLATE);

  1778.         p->addModel(modelDIKTAT);

  1779.         p->addModel(modelDTROY);

  1780.         p->addModel(modelBORDL);

  1781.         p->addModel(modelZOUMAI);

  1782.         p->addModel(modelZOUMAIExpander);

  1783.         p->addModel(modelENCORE);

  1784.         p->addModel(modelENCOREExpander);

  1785.         p->addModel(modelMU);

  1786.         p->addModel(modelCHUTE);

  1787.         p->addModel(modelLOURDE);

  1788.         p->addModel(modelDILEMO);

  1789.         p->addModel(modelLAMBDA);

  1790.         p->addModel(modelBANCAU);

  1791.         p->addModel(modelACNE);

  1792.         p->addModel(modelMS);

  1793.         p->addModel(modelDUKE);

  1794.         p->addModel(modelMOIRE);

  1795.         p->addModel(modelPILOT);

  1796.         p->addModel(modelHUITRE);

  1797.         p->addModel(modelOUAIVE);

  1798.         p->addModel(modelEDSAROS);

  1799.         p->addModel(modelPOUPRE);

  1800.         p->addModel(modelMAGMA);

  1801.         p->addModel(modelOAI);

  1802.         p->addModel(modelCANARD);

  1803.         p->addModel(modelEMILE);

  1804.         p->addModel(modelFORK);

  1805.         p->addModel(modelTIARE);

  1806.         p->addModel(modelLIMONADE);

  1807.         p->addModel(modelLIMBO);

  1808.         p->addModel(modelPERCO);

  1809.         p->addModel(modelBAFIS);

  1810.         p->addModel(modelBAR);

  1811.         p->addModel(modelMINIBAR);

  1812.         p->addModel(modelZINC);

  1813.         p->addModel(modelFREIN);

  1814.         p->addModel(modelHCTIP);

  1815.         p->addModel(modelSPORE);

  1816.         p->addModel(modelDFUZE);

  1817.         p->addModel(modelREI);

  1818.         p->addModel(modelRABBIT);

  1819.         p->addModel(modelBISTROT);

  1820.         p->addModel(modelSIGMA);

  1821.         p->addModel(modelFLAME);

  1822.         p->addModel(modelVOID);

  1823.         p->addModel(modelRATEAU);

  1824. 

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

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

  1827.         spl.removeModule("antN");

  1828.     }

  1829. }

  1830. 

  1831. static void initStatic__Biset()

  1832. {

  1833.     Plugin* const p = new Plugin;

  1834.     pluginInstance__Biset = p;

  1835. 

  1836.     const StaticPluginLoader spl(p, "Biset");

  1837.     if (spl.ok())

  1838.     {

  1839. #define modelBlank modelBisetBlank

  1840. #define modelTree modelBisetTree

  1841.         p->addModel(modelTracker);

  1842.         p->addModel(modelTrackerSynth);

  1843.         p->addModel(modelTrackerDrum);

  1844.         p->addModel(modelTrackerClock);

  1845.         p->addModel(modelTrackerPhase);

  1846.         p->addModel(modelTrackerQuant);

  1847.         p->addModel(modelTrackerState);

  1848.         p->addModel(modelTrackerControl);

  1849. 

  1850.         p->addModel(modelRegex);

  1851.         p->addModel(modelRegexCondensed);

  1852.         p->addModel(modelRegexExp);

  1853. 

  1854.         p->addModel(modelTree);

  1855.         p->addModel(modelTreeSeed);

  1856. 

  1857.         p->addModel(modelGbu);

  1858.         p->addModel(modelPkm);

  1859. 

  1860.         p->addModel(modelIgc);

  1861.         p->addModel(modelOmega3);

  1862.         p->addModel(modelOmega6);

  1863. 

  1864.         p->addModel(modelSegfault);

  1865.         p->addModel(modelBlank);

  1866. #undef modelBlank

  1867. #undef modelTree

  1868.     }

  1869. }

  1870. 

  1871. static void initStatic__BogaudioModules()

  1872. {

  1873.     Plugin* const p = new Plugin;

  1874.     pluginInstance__BogaudioModules = p;

  1875. 

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

  1877.     if (spl.ok())

  1878.     {

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

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

  1881.         skins._default = settings::preferDarkPanels ? "dark" : "light";

  1882. #define modelADSR modelBogaudioADSR

  1883. #define modelLFO modelBogaudioLFO

  1884. #define modelNoise modelBogaudioNoise

  1885. #define modelVCA modelBogaudioVCA

  1886. #define modelVCF modelBogaudioVCF

  1887. #define modelVCO modelBogaudioVCO

  1888.         p->addModel(modelVCO);

  1889.         p->addModel(modelLVCO);

  1890.         p->addModel(modelSine);

  1891.         p->addModel(modelPulse);

  1892.         p->addModel(modelXCO);

  1893.         p->addModel(modelAdditator);

  1894.         p->addModel(modelFMOp);

  1895.         p->addModel(modelChirp);

  1896.         p->addModel(modelLFO);

  1897.         p->addModel(modelLLFO);

  1898.         p->addModel(modelFourFO);

  1899.         p->addModel(modelEightFO);

  1900.         p->addModel(modelVCF);

  1901.         p->addModel(modelLVCF);

  1902.         p->addModel(modelFFB);

  1903.         p->addModel(modelEQ);

  1904.         p->addModel(modelEQS);

  1905.         p->addModel(modelLPG);

  1906.         p->addModel(modelLLPG);

  1907.         p->addModel(modelMegaGate);

  1908.         p->addModel(modelPEQ);

  1909.         p->addModel(modelPEQ6);

  1910.         p->addModel(modelPEQ6XF);

  1911.         p->addModel(modelPEQ14);

  1912.         p->addModel(modelPEQ14XF);

  1913.         p->addModel(modelDADSRH);

  1914.         p->addModel(modelDADSRHPlus);

  1915.         p->addModel(modelShaper);

  1916.         p->addModel(modelShaperPlus);

  1917.         p->addModel(modelAD);

  1918.         p->addModel(modelASR);

  1919.         p->addModel(modelADSR);

  1920.         p->addModel(modelVish);

  1921.         p->addModel(modelFollow);

  1922.         p->addModel(modelDGate);

  1923.         p->addModel(modelRGate);

  1924.         p->addModel(modelEdge);

  1925.         p->addModel(modelNoise);

  1926.         p->addModel(modelSampleHold);

  1927.         p->addModel(modelWalk2);

  1928.         p->addModel(modelWalk);

  1929.         p->addModel(modelMix8);

  1930.         p->addModel(modelMix8x);

  1931.         p->addModel(modelMix4);

  1932.         p->addModel(modelMix4x);

  1933.         p->addModel(modelMix2);

  1934.         p->addModel(modelMix1);

  1935.         p->addModel(modelVCM);

  1936.         p->addModel(modelMute8);

  1937.         p->addModel(modelPan);

  1938.         p->addModel(modelXFade);

  1939.         p->addModel(modelVCA);

  1940.         p->addModel(modelVCAmp);

  1941.         p->addModel(modelVelo);

  1942.         p->addModel(modelUMix);

  1943.         p->addModel(modelMumix);

  1944.         p->addModel(modelMatrix81);

  1945.         p->addModel(modelMatrix18);

  1946.         p->addModel(modelMatrix44);

  1947.         p->addModel(modelMatrix44Cvm);

  1948.         p->addModel(modelMatrix88);

  1949.         p->addModel(modelMatrix88Cv);

  1950.         p->addModel(modelMatrix88M);

  1951.         p->addModel(modelSwitch81);

  1952.         p->addModel(modelSwitch18);

  1953.         p->addModel(modelSwitch44);

  1954.         p->addModel(modelSwitch88);

  1955.         p->addModel(modelSwitch1616);

  1956.         p->addModel(modelAMRM);

  1957.         p->addModel(modelPressor);

  1958.         p->addModel(modelClpr);

  1959.         p->addModel(modelLmtr);

  1960.         p->addModel(modelNsgt);

  1961.         p->addModel(modelCmpDist);

  1962.         p->addModel(modelOneEight);

  1963.         p->addModel(modelEightOne);

  1964.         p->addModel(modelAddrSeq);

  1965.         p->addModel(modelAddrSeqX);

  1966.         p->addModel(modelPgmr);

  1967.         p->addModel(modelPgmrX);

  1968.         p->addModel(modelVU);

  1969.         p->addModel(modelAnalyzer);

  1970.         p->addModel(modelAnalyzerXL);

  1971.         p->addModel(modelRanalyzer);

  1972.         p->addModel(modelDetune);

  1973.         p->addModel(modelStack);

  1974.         p->addModel(modelReftone);

  1975.         p->addModel(modelMono);

  1976.         p->addModel(modelArp);

  1977.         p->addModel(modelAssign);

  1978.         p->addModel(modelUnison);

  1979.         p->addModel(modelPolyCon8);

  1980.         p->addModel(modelPolyCon16);

  1981.         p->addModel(modelPolyOff8);

  1982.         p->addModel(modelPolyOff16);

  1983.         p->addModel(modelPolyMult);

  1984.         p->addModel(modelBool);

  1985.         p->addModel(modelCmp);

  1986.         p->addModel(modelCVD);

  1987.         p->addModel(modelFlipFlop);

  1988.         p->addModel(modelInv);

  1989.         p->addModel(modelManual);

  1990.         p->addModel(modelFourMan);

  1991.         p->addModel(modelMult);

  1992.         p->addModel(modelOffset);

  1993.         p->addModel(modelSlew);

  1994.         p->addModel(modelSums);

  1995.         p->addModel(modelSwitch);

  1996.         p->addModel(modelLgsw);

  1997.         p->addModel(modelBlank3);

  1998.         p->addModel(modelBlank6);

  1999. #ifdef EXPERIMENTAL

  2000.         p->addModel(modelLag);

  2001.         p->addModel(modelPEQ14XR);

  2002.         p->addModel(modelPEQ14XV);

  2003. #endif

  2004. #ifdef TEST

  2005.         p->addModel(modelTest);

  2006.         p->addModel(modelTest2);

  2007.         p->addModel(modelTestExpanderBase);

  2008.         p->addModel(modelTestExpanderExtension);

  2009.         p->addModel(modelTestGl);

  2010.         p->addModel(modelTestVCF);

  2011. #endif

  2012. #undef modelADSR

  2013. #undef modelLFO

  2014. #undef modelNoise

  2015. #undef modelVCA

  2016. #undef modelVCF

  2017. #undef modelVCO

  2018.     }

  2019. }

  2020. 

  2021. static void initStatic__CatroModulo()

  2022. {

  2023.     Plugin* const p = new Plugin;

  2024.     pluginInstance__CatroModulo = p;

  2025. 

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

  2027.     if (spl.ok())

  2028.     {

  2029.         p->addModel(modelCM1Module);

  2030.         p->addModel(modelCM2Module);

  2031.         p->addModel(modelCM3Module);

  2032.         p->addModel(modelCM4Module);

  2033.         p->addModel(modelCM5Module);

  2034.         p->addModel(modelCM6Module);

  2035.         p->addModel(modelCM7Module);

  2036.         p->addModel(modelCM8Module);

  2037.         p->addModel(modelCM9Module);

  2038.         p->addModel(modelCM10Module);

  2039.     }

  2040. }

  2041. 

  2042. static void initStatic__cf()

  2043. {

  2044.     Plugin* const p = new Plugin;

  2045.     pluginInstance__cf = p;

  2046. 

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

  2048.     if (spl.ok())

  2049.     {

  2050.         p->addModel(modelMETRO);

  2051.         p->addModel(modelEACH);

  2052.         p->addModel(modeltrSEQ);

  2053.         p->addModel(modelLEDSEQ);

  2054.         p->addModel(modelL3DS3Q);

  2055.         p->addModel(modelSLIDERSEQ);

  2056.         p->addModel(modelPLAYER);

  2057.         p->addModel(modelPLAY);

  2058.         p->addModel(modelMONO);

  2059.         p->addModel(modelSTEREO);

  2060.         p->addModel(modelSUB);

  2061.         p->addModel(modelMASTER);

  2062.         p->addModel(modelVARIABLE);

  2063.         p->addModel(modelALGEBRA);

  2064.         p->addModel(modelFUNKTION);

  2065.         p->addModel(modelCHOKE);

  2066.         p->addModel(modelFOUR);

  2067.         p->addModel(modelSTEPS);

  2068.         p->addModel(modelPEAK);

  2069.         p->addModel(modelCUTS);

  2070.         p->addModel(modelBUFFER);

  2071.         p->addModel(modelDISTO);

  2072.         p->addModel(modelCUBE);

  2073.         p->addModel(modelPATCH);

  2074.         p->addModel(modelLABEL);

  2075.         p->addModel(modelDAVE);

  2076.     }

  2077. }

  2078. 

  2079. static void initStatic__ChowDSP()

  2080. {

  2081.     Plugin* const p = new Plugin;

  2082.     pluginInstance__ChowDSP = p;

  2083. 

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

  2085.     if (spl.ok())

  2086.     {

  2087.         p->addModel(modelChowTape);

  2088.         p->addModel(modelChowPhaserFeedback);

  2089.         p->addModel(modelChowPhaserMod);

  2090.         p->addModel(modelChowFDN);

  2091.         p->addModel(modelChowRNN);

  2092.         p->addModel(modelChowModal);

  2093.         p->addModel(modelChowDer);

  2094.         p->addModel(modelWarp);

  2095.         p->addModel(modelWerner);

  2096.         p->addModel(modelCredit);

  2097.         p->addModel(modelChowPulse);

  2098.         p->addModel(modelChowTapeCompression);

  2099.         p->addModel(modelChowTapeChew);

  2100.         p->addModel(modelChowTapeDegrade);

  2101.         p->addModel(modelChowTapeLoss);

  2102.         p->addModel(modelChowChorus);

  2103.     }

  2104. }

  2105. 

  2106. static void initStatic__Computerscare()

  2107. {

  2108.     Plugin* const p = new Plugin;

  2109.     pluginInstance__Computerscare = p;

  2110. 

  2111.     const StaticPluginLoader spl(p, "Computerscare");

  2112.     if (spl.ok())

  2113.     {

  2114.     	p->addModel(modelComputerscarePatchSequencer);

  2115.         p->addModel(modelComputerscareDebug);

  2116.         p->addModel(modelComputerscareLaundrySoup);

  2117.         p->addModel(modelComputerscareILoveCookies);

  2118.         p->addModel(modelComputerscareOhPeas);

  2119.         p->addModel(modelComputerscareHorseADoodleDoo);

  2120.         p->addModel(modelComputerscareKnolyPobs);

  2121.         p->addModel(modelComputerscareBolyPuttons);

  2122.         p->addModel(modelComputerscareRolyPouter);

  2123.         p->addModel(modelComputerscareSolyPequencer);

  2124.         p->addModel(modelComputerscareTolyPools);

  2125.         p->addModel(modelComputerscareMolyPatrix);

  2126.         p->addModel(modelComputerscareGolyPenerator);

  2127.         p->addModel(modelComputerscareFolyPace);

  2128.         p->addModel(modelComputerscareStolyFickPigure);

  2129.         p->addModel(modelComputerscareBlank);

  2130.         p->addModel(modelComputerscareBlankExpander);

  2131.     }

  2132. }

  2133. 

  2134. static void initStatic__CVfunk()

  2135. {

  2136.     Plugin* const p = new Plugin;

  2137.     pluginInstance__CVfunk = p;

  2138. 

  2139.     const StaticPluginLoader spl(p, "CVfunk");

  2140.     if (spl.ok())

  2141.     {

  2142.         #define modelSteps modelCVfunkSteps

  2143.         p->addModel(modelSteps);

  2144.         p->addModel(modelEnvelopeArray);

  2145.         p->addModel(modelPentaSequencer);

  2146.         p->addModel(modelImpulseController);

  2147.         p->addModel(modelSignals);

  2148.         p->addModel(modelRanges);

  2149.         p->addModel(modelHexMod);

  2150.         p->addModel(modelCollatz);

  2151.         p->addModel(modelStrings);

  2152.         p->addModel(modelMagnets);

  2153.         p->addModel(modelOuros);

  2154.         p->addModel(modelPressedDuck);

  2155.         p->addModel(modelFlowerPatch);

  2156.         p->addModel(modelSyncro);

  2157.         p->addModel(modelNona);

  2158.         p->addModel(modelDecima);

  2159.         p->addModel(modelMorta);

  2160.         p->addModel(modelStepWave);

  2161.         p->addModel(modelPreeeeeeeeeeessedDuck);

  2162.         p->addModel(modelArrange);

  2163.         p->addModel(modelTriDelay);

  2164.         #undef modelSteps

  2165.     }

  2166. }

  2167. 

  2168. static void initStatic__dBiz()

  2169. {

  2170.     Plugin* const p = new Plugin;

  2171.     pluginInstance__dBiz = p;

  2172. 

  2173.     const StaticPluginLoader spl(p, "dBiz");

  2174.     if (spl.ok())

  2175.     {

  2176. #define modelChord modeldBizChord

  2177. #define modelDivider modeldBizDivider

  2178. #define modelFourSeq modeldBizFourSeq

  2179. #define modelVCA4 modeldBizVCA4

  2180.         p->addModel(modelNavControl);

  2181.         p->addModel(modelBench);

  2182.         p->addModel(modelContorno);

  2183.         //p->addModel(modelContornoMK2);

  2184.         p->addModel(modelTranspose);

  2185.         p->addModel(modelUtility);

  2186.         p->addModel(modelChord);

  2187.         p->addModel(modelBene);

  2188.         p->addModel(modelBenePads);

  2189.         p->addModel(modelPerfMixer);

  2190.         p->addModel(modelDrMix);

  2191.         p->addModel(modelPerfMixer4);

  2192.         p->addModel(modelVCA4);

  2193.         p->addModel(modelVCA530);

  2194.         p->addModel(modelRemix);

  2195.         p->addModel(modelSmixer);

  2196.         p->addModel(modelVerbo);

  2197.         p->addModel(modelDVCO);

  2198.         p->addModel(modelDAOSC);

  2199.         p->addModel(modelTROSC);

  2200.         p->addModel(modelTROSCMK2);

  2201.         p->addModel(modelSuHa);

  2202.         p->addModel(modelSuHaMK2);

  2203.         p->addModel(modelFourSeq);

  2204.         p->addModel(modelDivider);

  2205.         p->addModel(modelUtil2);

  2206.         p->addModel(modelSmorph);

  2207.         p->addModel(modelBigSmorph);

  2208.         p->addModel(modelSPan);

  2209.         p->addModel(modelQuePasa);

  2210.         p->addModel(modelDualFilter);

  2211.         p->addModel(modelOrder);

  2212.         p->addModel(modelDualMatrix);

  2213. #undef modelChord

  2214. #undef modelDivider

  2215. #undef modelFourSeq

  2216. #undef modelVCA4

  2217.     }

  2218. }

  2219. 

  2220. static void initStatic__dbRackModules()

  2221. {

  2222.     Plugin* const p = new Plugin;

  2223.     pluginInstance__dbRackModules = p;

  2224. 

  2225.     const StaticPluginLoader spl(p, "dbRackModules");

  2226.     if (spl.ok())

  2227.     {

  2228. #define modelSKF modeldbRackModulesSKF

  2229. #define modelX4 modeldbRackModulesX4

  2230. #define modelMVerb modeldbRackModulesMVerb

  2231. #define modelOsc3 modeldbRackModulesOsc3

  2232.         p->addModel(modelGeneticTerrain);

  2233.         p->addModel(modelGeneticSuperTerrain);

  2234.         p->addModel(modelDCBlock);

  2235.         p->addModel(modelRndHvs3);

  2236.         p->addModel(modelJTScaler);

  2237.         p->addModel(modelAddSynth);

  2238.         p->addModel(modelRndH);

  2239.         p->addModel(modelRndC);

  2240.         p->addModel(modelGenScale);

  2241.         p->addModel(modelJTKeys);

  2242.         p->addModel(modelHopa);

  2243.         p->addModel(modelFrac);

  2244.         p->addModel(modelHexSeq);

  2245.         p->addModel(modelInterface);

  2246.         p->addModel(modelHexSeqP);

  2247.         p->addModel(modelMVerb);

  2248.         p->addModel(modelPShift);

  2249.         p->addModel(modelFLA);

  2250.         p->addModel(modelFLL);

  2251.         p->addModel(modelGendy);

  2252.         p->addModel(modelRtrig);

  2253.         p->addModel(modelSTrig);

  2254.         p->addModel(modelRSC);

  2255.         p->addModel(modelPad);

  2256.         p->addModel(modelRndG);

  2257.         p->addModel(modelPlotter);

  2258.         p->addModel(modelSuperLFO);

  2259.         p->addModel(modelHexSeqExp);

  2260.         p->addModel(modelPad2);

  2261.         p->addModel(modelPHSR);

  2262.         p->addModel(modelPhS);

  2263.         p->addModel(modelSPL);

  2264.         p->addModel(modelPhO);

  2265.         p->addModel(modelFaders);

  2266.         p->addModel(modelYC);

  2267.         p->addModel(modelPLC);

  2268.         p->addModel(modelMPad2);

  2269.         p->addModel(modelPHSR2);

  2270.         p->addModel(modelEVA);

  2271.         p->addModel(modelCSOSC);

  2272.         p->addModel(modelRatio);

  2273.         p->addModel(modelBWF);

  2274.         p->addModel(modelPRB);

  2275.         p->addModel(modelOsc2);

  2276.         p->addModel(modelRndH2);

  2277.         p->addModel(modelOFS);

  2278.         p->addModel(modelOFS3);

  2279.         p->addModel(modelOsc1);

  2280.         p->addModel(modelOsc3);

  2281.         p->addModel(modelOsc4);

  2282.         p->addModel(modelOsc5);

  2283.         p->addModel(modelSKF);

  2284.         p->addModel(modelSPF);

  2285.         p->addModel(modelL4P);

  2286.         p->addModel(modelUSVF);

  2287.         p->addModel(modelAP);

  2288.         p->addModel(modelAUX);

  2289.         p->addModel(modelWS);

  2290.         p->addModel(modelCHBY);

  2291.         p->addModel(modelCLP);

  2292.         p->addModel(modelLWF);

  2293.         p->addModel(modelDRM);

  2294.         p->addModel(modelCWS);

  2295.         p->addModel(modelSWF);

  2296.         p->addModel(modelOsc6);

  2297.         /*p->addModel(modelDrums);*/

  2298.         p->addModel(modelPPD);

  2299.         p->addModel(modelOsc7);

  2300.         p->addModel(modelOsc8);

  2301.         p->addModel(modelOsc9);

  2302.         p->addModel(modelFS6);

  2303.         p->addModel(modelPulsar);

  2304.         p->addModel(modelOscA1);

  2305.         p->addModel(modelOscS);

  2306.         p->addModel(modelOscP);

  2307.         p->addModel(modelX16);

  2308.         p->addModel(modelX8);

  2309.         p->addModel(modelX4);

  2310.         p->addModel(modelX6);

  2311.         p->addModel(modelCVS);

  2312.         p->addModel(modelDTrig);

  2313. 

  2314.         // Defined in manifest but not in plugin 

  2315.         spl.removeModule("Drums");

  2316. 

  2317. #undef modelSKF

  2318. #undef modelX4

  2319. #undef modelMVerb

  2320. #undef modelOsc3

  2321.     }

  2322. }

  2323. 

  2324. static void initStatic__DHE()

  2325. {

  2326.     Plugin* const p = new Plugin;

  2327.     pluginInstance__DHE = p;

  2328. 

  2329.     const StaticPluginLoader spl(p, "DHE-Modules");

  2330.     if (spl.ok())

  2331.     {

  2332.         dhe::blossom::init(p);

  2333.         dhe::buttons::init(p);

  2334.         dhe::cubic::init(p);

  2335.         dhe::curve_sequencer::init(p);

  2336.         dhe::envelope::init(p);

  2337.         dhe::func::init(p);

  2338.         dhe::fuzzy_logic::init(p);

  2339.         dhe::gator::init(p);

  2340.         dhe::ranger::init(p);

  2341.         dhe::scannibal::init(p);

  2342.         dhe::sequencizer::init(p);

  2343.         dhe::swave::init(p);

  2344.         dhe::tapers::init(p);

  2345.         dhe::truth::init(p);

  2346.         dhe::xycloid::init(p);

  2347.     }

  2348. }

  2349. 

  2350. static void initStatic__eightfold()

  2351. {

  2352.     Plugin* const p = new Plugin;

  2353.     pluginInstance__eightfold = p;

  2354. 

  2355.     const StaticPluginLoader spl(p, "eightfold");

  2356.     if (spl.ok())

  2357.     {

  2358.         p->addModel(modelSDOrcasHeartV2);

  2359.         p->addModel(modelSDFormation);

  2360.         p->addModel(modelSDLines);

  2361.         p->addModel(modelSDTransgate);

  2362.         p->addModel(modelSDComparator);

  2363.     }

  2364. }

  2365. 

  2366. static void initStatic__EnigmaCurry()

  2367. {

  2368.     Plugin* const p = new Plugin;

  2369.     pluginInstance__EnigmaCurry = p;

  2370. 

  2371.     const StaticPluginLoader spl(p, "EnigmaCurry");

  2372.     if (spl.ok())

  2373.     {

  2374. #define modelPulse modelEnigmaCurryPulse

  2375.       p->addModel(modelTransport);

  2376.       p->addModel(modelLatch);

  2377.       p->addModel(modelPulse);

  2378.       p->addModel(modelRange);

  2379.       p->addModel(modelNegativeHarmony);

  2380. #undef modelPulse

  2381.     }

  2382. }

  2383. 

  2384. 

  2385. static void initStatic__ESeries()

  2386. {

  2387.     Plugin* const p = new Plugin;

  2388.     pluginInstance__ESeries = p;

  2389. 

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

  2391.     if (spl.ok())

  2392.     {

  2393.         p->addModel(modelE340);

  2394.     }

  2395. }

  2396. 

  2397. static void initStatic__ExpertSleepersEncoders()

  2398. {

  2399.     Plugin* const p = new Plugin;

  2400.     pluginInstance__ExpertSleepersEncoders = p;

  2401. 

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

  2403.     if (spl.ok())

  2404.     {

  2405.         p->addModel(model8GT);

  2406.         p->addModel(model8CV);

  2407.         p->addModel(modelES40);

  2408.         p->addModel(modelES5);

  2409.         p->addModel(modelSMUX);

  2410.         p->addModel(modelCalibrator);

  2411.     }

  2412. }

  2413. 

  2414. static void initStatic__Extratone()

  2415. {

  2416.     Plugin* const p = new Plugin;

  2417.     pluginInstance__Extratone = p;

  2418. 

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

  2420.     if (spl.ok())

  2421.     {

  2422.         p->addModel(modelModulo);

  2423.         p->addModel(modelMesoglea);

  2424.         p->addModel(modelMesoglea2);

  2425.         p->addModel(modelOpabinia);

  2426.         p->addModel(modelSplitterburst);

  2427.         p->addModel(modelPuzzlebox);

  2428.         p->addModel(modelDarwinism);

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

  2430.         p->addModel(modelIchneumonid);

  2431.         p->addModel(modelMeganeura);

  2432.         p->addModel(modelPureneura);

  2433.         p->addModel(modelMesohyl);

  2434.         p->addModel(modelXtrtnBlank);

  2435.     }

  2436. }

  2437. 

  2438. static void initStatic__FehlerFabrik()

  2439. {

  2440.     Plugin* const p = new Plugin;

  2441.     pluginInstance__FehlerFabrik = p;

  2442. 

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

  2444.     if (spl.ok())

  2445.     {

  2446.         p->addModel(modelPSIOP);

  2447.         p->addModel(modelPlanck);

  2448.         p->addModel(modelLuigi);

  2449.         p->addModel(modelAspect);

  2450.         p->addModel(modelMonte);

  2451.         p->addModel(modelArpanet);

  2452.         p->addModel(modelSigma);

  2453.         p->addModel(modelFax);

  2454.         p->addModel(modelRasoir);

  2455.         p->addModel(modelChi);

  2456.         p->addModel(modelNova);

  2457.         p->addModel(modelLilt);

  2458.         p->addModel(modelBotzinger);

  2459.     }

  2460. }

  2461. 

  2462. static void initStatic__forsitan()

  2463. {

  2464.     Plugin* const p = new Plugin;

  2465.     pluginInstance__forsitan = p;

  2466. 

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

  2468.     if (spl.ok())

  2469.     {

  2470.         p->addModel(alea);

  2471.         p->addModel(interea);

  2472.         p->addModel(cumuli);

  2473.         p->addModel(deinde);

  2474.         p->addModel(pavo);

  2475.     }

  2476. }

  2477. 

  2478. static void initStatic__GlueTheGiant()

  2479. {

  2480.     Plugin* const p = new Plugin;

  2481.     pluginInstance__GlueTheGiant = p;

  2482. 

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

  2484.     if (spl.ok())

  2485.     {

  2486.         p->addModel(modelGigBus);

  2487.         p->addModel(modelMiniBus);

  2488.         p->addModel(modelSchoolBus);

  2489.         p->addModel(modelMetroCityBus);

  2490.         p->addModel(modelBusDepot);

  2491.         p->addModel(modelBusRoute);

  2492.         p->addModel(modelRoad);

  2493.         p->addModel(modelEnterBus);

  2494.         p->addModel(modelExitBus);

  2495.     }

  2496. }

  2497. 

  2498. static void initStatic__GoodSheperd()

  2499. {

  2500.     Plugin* const p = new Plugin;

  2501.     pluginInstance__GoodSheperd = p;

  2502. 

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

  2504.     if (spl.ok())

  2505.     {

  2506.         p->addModel(modelHurdle);

  2507.         p->addModel(modelSEQ3st);

  2508.         p->addModel(modelStable16);

  2509.         p->addModel(modelStall);

  2510.         p->addModel(modelSwitch1);

  2511.         p->addModel(modelSeqtrol);

  2512.     }

  2513. }

  2514. 

  2515. static void initStatic__GrandeModular()

  2516. {

  2517.     Plugin* const p = new Plugin;

  2518.     pluginInstance__GrandeModular = p;

  2519. 

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

  2521.     if (spl.ok())

  2522.     {

  2523.         p->addModel(modelClip);

  2524.         p->addModel(modelCompare3);

  2525.         p->addModel(modelLFO3);

  2526.         p->addModel(modelLFO4);

  2527.         p->addModel(modelLogic);

  2528.         p->addModel(modelMerge8);

  2529.         p->addModel(modelMergeSplit4);

  2530.         p->addModel(modelMicrotonalChords);

  2531.         p->addModel(modelMicrotonalNotes);

  2532.         p->addModel(modelNoteMT);

  2533.         p->addModel(modelPeak);

  2534.         p->addModel(modelPolyMergeResplit);

  2535.         p->addModel(modelPolySplit);

  2536.         p->addModel(modelPush);

  2537.         p->addModel(modelQuant);

  2538.         p->addModel(modelQuantIntervals);

  2539.         p->addModel(modelQuantMT);

  2540.         p->addModel(modelSampleDelays);

  2541.         p->addModel(modelScale);

  2542.         p->addModel(modelSplit8);

  2543.         p->addModel(modelTails);

  2544.         p->addModel(modelTails4);

  2545.         p->addModel(modelVarSampleDelays);

  2546.         p->addModel(modelVCA3);

  2547.         p->addModel(modelVCA4);

  2548.     }

  2549. }

  2550. 

  2551. static void initStatic__H4N4()

  2552. {

  2553.     Plugin* const p = new Plugin;

  2554.     pluginInstance__H4N4 = p;

  2555. 

  2556.     const StaticPluginLoader spl(p, "h4n4-modules");

  2557.     if (spl.ok())

  2558.     {

  2559.         p->addModel(modelXenQnt);

  2560.     }

  2561. }

  2562. 

  2563. static void initStatic__HamptonHarmonics()

  2564. {

  2565.     Plugin* const p = new Plugin;

  2566.     pluginInstance__HamptonHarmonics = p;

  2567. 

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

  2569.     if (spl.ok())

  2570.     {

  2571. #define modelArp modelHamptonHarmonicsArp

  2572. #define modelProgress modelHamptonHarmonicsProgress

  2573.         p->addModel(modelArp);

  2574.         p->addModel(modelProgress);

  2575. #undef modelProgress

  2576. #undef modelArp

  2577.     }

  2578. }

  2579. 

  2580. static void initStatic__HetrickCV()

  2581. {

  2582.     Plugin* const p = new Plugin;

  2583.     pluginInstance__HetrickCV = p;

  2584. 

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

  2586.     if (spl.ok())

  2587.     {

  2588. #define modelASR modelHetrickCVASR

  2589. #define modelBlankPanel modelHetrickCVBlankPanel

  2590. #define modelFlipFlop modelHetrickCVFlipFlop

  2591. #define modelMidSide modelHetrickCVMidSide

  2592. #define modelMinMax modelHetrickCVMinMax

  2593. #define PanelBaseWidget HetrickCVPanelBaseWidget

  2594. #define InverterWidget HetrickCVInverterWidget

  2595.         p->addModel(modelTwoToFour);

  2596.         p->addModel(modelAnalogToDigital);

  2597.         p->addModel(modelASR);

  2598.         p->addModel(modelBinaryCounter);

  2599.         p->addModel(modelBinaryGate);

  2600.         p->addModel(modelBinaryNoise);

  2601.         p->addModel(modelBitshift);

  2602.         p->addModel(modelBlankPanel);

  2603.         p->addModel(modelBoolean3);

  2604.         p->addModel(modelChaos1Op);

  2605.         p->addModel(modelChaos2Op);

  2606.         p->addModel(modelChaos3Op);

  2607.         p->addModel(modelChaoticAttractors);

  2608.         p->addModel(modelClockedNoise);

  2609.         p->addModel(modelClockToPhasor);

  2610.         p->addModel(modelComparator);

  2611.         p->addModel(modelContrast);

  2612.         p->addModel(modelCrackle);

  2613.         p->addModel(modelDataCompander);

  2614.         p->addModel(modelDelta);

  2615.         p->addModel(modelDigitalToAnalog);

  2616.         p->addModel(modelDust);

  2617.         p->addModel(modelExponent);

  2618.         p->addModel(modelFBSineChaos);

  2619.         p->addModel(modelFlipFlop);

  2620.         p->addModel(modelFlipPan);

  2621.         p->addModel(modelGateDelay);

  2622.         p->addModel(modelGateJunction);

  2623.         p->addModel(modelGateJunctionExp);

  2624.         p->addModel(modelGingerbread);

  2625.         p->addModel(modelLogicCombine);

  2626.         p->addModel(modelMidSide);

  2627.         p->addModel(modelMinMax);

  2628.         p->addModel(modelNormals);

  2629.         p->addModel(modelPhaseDrivenSequencer);

  2630.         p->addModel(modelPhaseDrivenSequencer32);

  2631.         p->addModel(modelPhasorAnalyzer);

  2632.         p->addModel(modelPhasorBurstGen);

  2633.         p->addModel(modelPhasorDivMult);

  2634.         p->addModel(modelPhasorEuclidean);

  2635.         p->addModel(modelPhasorFreezer);

  2636.         p->addModel(modelPhasorGates);

  2637.         p->addModel(modelPhasorGates32);

  2638.         p->addModel(modelPhasorGates64);

  2639.         p->addModel(modelPhasorGen);

  2640.         p->addModel(modelPhasorGeometry);

  2641.         p->addModel(modelPhasorHumanizer);

  2642.         p->addModel(modelPhasorMixer);

  2643.         p->addModel(modelPhasorOctature);

  2644.         p->addModel(modelPhasorProbability);

  2645.         p->addModel(modelPhasorQuadrature);

  2646.         p->addModel(modelPhasorRandom);

  2647.         p->addModel(modelPhasorRanger);

  2648.         p->addModel(modelPhasorReset);

  2649.         p->addModel(modelPhasorRhythmGroup);

  2650.         p->addModel(modelPhasorShape);

  2651.         p->addModel(modelPhasorShift);

  2652.         p->addModel(modelPhasorSplitter);

  2653.         p->addModel(modelPhasorStutter);

  2654.         p->addModel(modelPhasorSubstepShape);

  2655.         p->addModel(modelPhasorSwing);

  2656.         p->addModel(modelPhasorTimetable);

  2657.         p->addModel(modelPhasorToClock);

  2658.         p->addModel(modelPhasorToRandom);

  2659.         p->addModel(modelPhasorToLFO);

  2660.         p->addModel(modelPhasorToWaveforms);

  2661.         p->addModel(modelPolymetricPhasors);

  2662.         p->addModel(modelProbability);

  2663.         p->addModel(modelRandomGates);

  2664.         p->addModel(modelRotator);

  2665.         p->addModel(modelRungler);

  2666.         p->addModel(modelScanner);

  2667.         p->addModel(modelTrigShaper);

  2668.         p->addModel(modelVectorMix);

  2669.         p->addModel(modelWaveshape);

  2670.         p->addModel(modelXYToPolar);

  2671. #undef modelASR

  2672. #undef modelBlankPanel

  2673. #undef modelFlipFlop

  2674. #undef modelMidSide

  2675. #undef modelMinMax

  2676. #undef PanelBaseWidget

  2677. #undef InverterWidget

  2678.     }

  2679. }

  2680. 

  2681. static void initStatic__ImpromptuModular()

  2682. {

  2683.     Plugin* const p = new Plugin;

  2684.     pluginInstance__ImpromptuModular = p;

  2685. 

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

  2687.     if (spl.ok())

  2688.     {

  2689.         p->addModel(modelAdaptiveQuantizer);

  2690.         p->addModel(modelBigButtonSeq);

  2691.         p->addModel(modelBigButtonSeq2);

  2692.         p->addModel(modelChordKey);

  2693.         p->addModel(modelChordKeyExpander);

  2694.         p->addModel(modelClocked);

  2695.         p->addModel(modelClockedExpander);

  2696.         p->addModel(modelClkd);

  2697.         p->addModel(modelCvPad);

  2698.         p->addModel(modelFoundry);

  2699.         p->addModel(modelFoundryExpander);

  2700.         p->addModel(modelFourView);

  2701.         p->addModel(modelGateSeq64);

  2702.         p->addModel(modelGateSeq64Expander);

  2703.         p->addModel(modelHotkey);

  2704.         p->addModel(modelPart);

  2705.         p->addModel(modelPhraseSeq16);

  2706.         p->addModel(modelPhraseSeq32);

  2707.         p->addModel(modelPhraseSeqExpander);

  2708.         p->addModel(modelProbKey);

  2709.         p->addModel(modelSemiModularSynth);

  2710.         p->addModel(modelSygen);

  2711.         p->addModel(modelTact);

  2712.         p->addModel(modelTact1);

  2713.         p->addModel(modelTactG);

  2714.         p->addModel(modelTwelveKey);

  2715.         p->addModel(modelVariations);

  2716.         p->addModel(modelWriteSeq32);

  2717.         p->addModel(modelWriteSeq64);

  2718.         p->addModel(modelBlankPanel);

  2719.     }

  2720. }

  2721. 

  2722. static void initStatic__ihtsyn()

  2723. {

  2724.     Plugin* const p = new Plugin;

  2725.     pluginInstance__ihtsyn = p;

  2726. 

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

  2728.     if (spl.ok())

  2729.     {

  2730.         p->addModel(modelPitchMangler);

  2731.         p->addModel(modelTwistedVerb);

  2732.         p->addModel(modelHiVerb);

  2733.         p->addModel(modelMVerb);

  2734.     }

  2735. }

  2736. 

  2737. static void initStatic__JW()

  2738. {

  2739.     Plugin* const p = new Plugin;

  2740.     pluginInstance__JW = p;

  2741. 

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

  2743.     if (spl.ok())

  2744.     {

  2745. #define modelQuantizer modelJWQuantizer

  2746. #define modelArrange modelJWArrange

  2747.         p->addModel(modelAdd5);

  2748.         p->addModel(modelAbcdSeq);

  2749.         p->addModel(modelBouncyBalls);

  2750.         p->addModel(modelCat);

  2751.         p->addModel(modelTree);

  2752.         p->addModel(modelFullScope);

  2753.         p->addModel(modelGridSeq);

  2754.         p->addModel(modelEightSeq);

  2755.         p->addModel(modelDivSeq);

  2756.         p->addModel(modelMinMax);

  2757.         p->addModel(modelNoteSeq);

  2758.         p->addModel(modelNoteSeqFu);

  2759.         p->addModel(modelNoteSeq16);

  2760.         p->addModel(modelTrigs);

  2761.         p->addModel(modelOnePattern);

  2762.         p->addModel(modelPatterns);

  2763.         p->addModel(modelQuantizer);

  2764.         p->addModel(modelSimpleClock);

  2765.         p->addModel(modelD1v1de);

  2766.         p->addModel(modelPres1t);

  2767.         p->addModel(modelThingThing);

  2768.         p->addModel(modelWavHead);

  2769.         p->addModel(modelXYPad);

  2770.         p->addModel(modelBlankPanel1hp);

  2771.         p->addModel(modelBlankPanelSmall);

  2772.         p->addModel(modelBlankPanelMedium);

  2773.         p->addModel(modelBlankPanelLarge);

  2774.         p->addModel(modelCoolBreeze);

  2775.         p->addModel(modelPete);

  2776.         p->addModel(modelTimer);

  2777.        #ifndef STATIC_BUILD

  2778.         p->addModel(modelStr1ker);

  2779.        #else

  2780.         spl.removeModule("Str1ker");

  2781.        #endif

  2782.        p->addModel(modelArrange);

  2783. #undef modelQuantizer

  2784. #undef modelArrange

  2785.     }

  2786. }

  2787. 

  2788. static void initStatic__kocmoc()

  2789. {

  2790.     Plugin* const p = new Plugin;

  2791.     pluginInstance__kocmoc= p;

  2792. 

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

  2794.     if (spl.ok())

  2795.     {

  2796.         p->addModel(modelSVF_1);

  2797.         p->addModel(modeluSVF);

  2798.         p->addModel(modelTRG);

  2799.         p->addModel(modelLADR);

  2800.         p->addModel(modeluLADR);

  2801.         p->addModel(modelDIOD);

  2802.         p->addModel(modelOP);

  2803.         p->addModel(modelPHASR);

  2804.         p->addModel(modelMUL);

  2805.         p->addModel(modelSKF);

  2806.         p->addModel(modelDDLY);

  2807.     }

  2808. }

  2809. 

  2810. static void initStatic__LifeFormModular()

  2811. {

  2812.     Plugin* const p = new Plugin;

  2813.     pluginInstance__LifeFormModular= p;

  2814. 

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

  2816.     if (spl.ok())

  2817.     {

  2818.         p->addModel(modelTimeDiktat);

  2819.         p->addModel(modelSequenceModeler);

  2820.         p->addModel(modelPitchDiktat);

  2821.         p->addModel(modelPitchIntegrator);

  2822.         p->addModel(modelBurstIntegrator);

  2823.         p->addModel(modelQuadModulator);

  2824.         p->addModel(modelImpulseControl);

  2825.         p->addModel(modelQuadSteppedOffset);

  2826.         p->addModel(modelPercussiveVibration);

  2827.         p->addModel(modelQuadUtility);

  2828.         p->addModel(modelAdditiveVibration);

  2829.         p->addModel(modelComplexOsc);

  2830.         p->addModel(modelDriftgen);

  2831.     }

  2832. }

  2833. 

  2834. static void initStatic__LilacLoop()

  2835. {

  2836.     Plugin* const p = new Plugin;

  2837.     pluginInstance__LilacLoop = p;

  2838. 

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

  2840.     if (spl.ok())

  2841.     {

  2842.         p->addModel(modelLooperOne);

  2843.     }

  2844. }

  2845. 

  2846. static void initStatic__LittleUtils()

  2847. {

  2848.     Plugin* const p = new Plugin;

  2849.     pluginInstance__LittleUtils = p;

  2850. 

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

  2852.     if (spl.ok())

  2853.     {

  2854.         p->addModel(modelButtonModule);

  2855.         p->addModel(modelPulseGenerator);

  2856.         p->addModel(modelBias_Semitone);

  2857.         p->addModel(modelMulDiv);

  2858.         p->addModel(modelTeleportInModule);

  2859.         p->addModel(modelTeleportOutModule);

  2860.     }

  2861. }

  2862. 

  2863. static void initStatic__Lomas()

  2864. {

  2865.     Plugin* const p = new Plugin;

  2866.     pluginInstance__Lomas = p;

  2867. 

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

  2869.     if (spl.ok())

  2870.     {

  2871.         p->addModel(modelAdvancedSampler);

  2872.         p->addModel(modelGateSequencer);

  2873.     }

  2874. }

  2875. 

  2876. static void initStatic__Lyrae()

  2877. {

  2878.     Plugin* const p = new Plugin;

  2879.     pluginInstance__Lyrae = p;

  2880. 

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

  2882.     if (spl.ok())

  2883.     {

  2884. #define modelDelta modelLyraeDelta

  2885.         p->addModel(modelSulafat);

  2886.         p->addModel(modelGamma);

  2887.         p->addModel(modelDelta);

  2888.         p->addModel(modelVega);

  2889.         p->addModel(modelBD383238);

  2890.         p->addModel(modelZeta);

  2891.         p->addModel(modelSheliak);

  2892.         p->addModel(modelBeta);

  2893. #undef modelDelta

  2894.     }

  2895. }

  2896. 

  2897. static void initStatic__Meander()

  2898. {

  2899.     Plugin* const p = new Plugin;

  2900.     pluginInstance__Meander = p;

  2901. 

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

  2903.     if (spl.ok())

  2904.     {

  2905.         // for dark theme

  2906.         Meander_panelTheme = 1;

  2907.         MSQ_panelTheme = 1;

  2908.         MSP_panelTheme = 1;

  2909.         p->addModel(modelMeander);

  2910.         p->addModel(modelModeScaleQuant);

  2911.         p->addModel(modelModeScaleProgressions);

  2912.     }

  2913. }

  2914. 

  2915. static void initStatic__MindMeld()

  2916. {

  2917.     Plugin* const p = new Plugin;

  2918.     pluginInstance__MindMeld = p;

  2919. 

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

  2921.     if (spl.ok())

  2922.     {

  2923.         p->addModel(modelPatchMaster);

  2924.         p->addModel(modelPatchMasterBlank);

  2925.         p->addModel(modelRouteMasterMono5to1);

  2926.         p->addModel(modelRouteMasterStereo5to1);

  2927.         p->addModel(modelRouteMasterMono1to5);

  2928.         p->addModel(modelRouteMasterStereo1to5);

  2929.         p->addModel(modelMasterChannel);

  2930.         p->addModel(modelMeld);

  2931.         p->addModel(modelUnmeld);

  2932.         p->addModel(modelMSMelder);

  2933.         p->addModel(modelEqMaster);

  2934.         p->addModel(modelEqExpander);

  2935.         p->addModel(modelBassMaster);

  2936.         p->addModel(modelBassMasterJr);

  2937.         p->addModel(modelShapeMaster);

  2938.         p->addModel(modelMixMasterJr);

  2939.         p->addModel(modelAuxExpanderJr);

  2940.         p->addModel(modelMixMaster);

  2941.         p->addModel(modelAuxExpander);

  2942.     }

  2943. }

  2944. 

  2945. static void initStatic__ML()

  2946. {

  2947.     Plugin* const p = new Plugin;

  2948.     pluginInstance__ML = p;

  2949. 

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

  2951.     if (spl.ok())

  2952.     {

  2953. #define modelQuantizer modelMLQuantizer

  2954. #define modelSH8 modelMLSH8

  2955.         p->addModel(modelQuantizer);

  2956.         p->addModel(modelQuantum);

  2957.         p->addModel(modelTrigBuf);

  2958.         p->addModel(modelSeqSwitch);

  2959.         p->addModel(modelSeqSwitch2);

  2960.         p->addModel(modelShiftRegister);

  2961.         p->addModel(modelShiftRegister2);

  2962.         p->addModel(modelFreeVerb);

  2963.         p->addModel(modelSum8);

  2964.         p->addModel(modelSum8mk2);

  2965.         p->addModel(modelSum8mk3);

  2966.         p->addModel(modelSH8);

  2967.         p->addModel(modelConstants);

  2968.         p->addModel(modelCounter);

  2969.         p->addModel(modelTrigDelay);

  2970.         p->addModel(modelBPMdetect);

  2971.         p->addModel(modelVoltMeter);

  2972.         p->addModel(modelOctaFlop);

  2973.         p->addModel(modelOctaTrig);

  2974.         p->addModel(modelOctaSwitch);

  2975.         p->addModel(modelTrigSwitch);

  2976.         p->addModel(modelTrigSwitch2);

  2977.         p->addModel(modelTrigSwitch3);

  2978.         p->addModel(modelTrigSwitch3_2);

  2979.         p->addModel(modelOctaPlus);

  2980.         p->addModel(modelOctaTimes);

  2981.         p->addModel(modelCloner);

  2982.         p->addModel(modelPolySplitter);

  2983.         p->addModel(modelArpeggiator);

  2984. #undef modelQuantizer

  2985. #undef modelSH8

  2986.     }

  2987. }

  2988. 

  2989. static void initStatic__MockbaModular()

  2990. {

  2991.     Plugin* const p = new Plugin;

  2992.     pluginInstance__MockbaModular = p;

  2993. 

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

  2995.     if (spl.ok())

  2996.     {

  2997. #define modelBlank modelMockbaModularBlank

  2998. #define modelComparator modelMockbaModularComparator

  2999.         p->addModel(modelBlank);

  3000.         p->addModel(modelFeidah);

  3001.         p->addModel(modelFeidahS);

  3002.         p->addModel(modelFiltah);

  3003.         p->addModel(modelMixah);

  3004.         p->addModel(modelMixah3);

  3005.         p->addModel(modelDividah);

  3006.         p->addModel(modelCountah);

  3007.         p->addModel(modelSelectah);

  3008.         p->addModel(modelShapah);

  3009.         p->addModel(modelHoldah);

  3010.         p->addModel(modelPannah);

  3011.         p->addModel(modelReVoltah);

  3012.         p->addModel(modelCZSaw);

  3013.         p->addModel(modelCZSquare);

  3014.         p->addModel(modelCZPulse);

  3015.         p->addModel(modelCZDblSine);

  3016.         p->addModel(modelCZSawPulse);

  3017.         p->addModel(modelCZReso1);

  3018.         p->addModel(modelCZReso2);

  3019.         p->addModel(modelCZReso3);

  3020.         p->addModel(modelCZOsc);

  3021.         p->addModel(modelMaugTriangle);

  3022.         p->addModel(modelMaugShark);

  3023.         p->addModel(modelMaugSaw);

  3024.         p->addModel(modelMaugSaw2);

  3025.         p->addModel(modelMaugSquare);

  3026.         p->addModel(modelMaugSquare2);

  3027.         p->addModel(modelMaugSquare3);

  3028.         p->addModel(modelMaugOsc);

  3029.         p->addModel(modelComparator);

  3030.         p->addModel(modelDualBUFFER);

  3031.         p->addModel(modelDualNOT);

  3032.         p->addModel(modelDualOR);

  3033.         p->addModel(modelDualNOR);

  3034.         p->addModel(modelDualAND);

  3035.         p->addModel(modelDualNAND);

  3036.         p->addModel(modelDualXOR);

  3037.         p->addModel(modelDualXNOR);

  3038.         p->addModel(modelPSelectah);

  3039. 

  3040.         // require input files to work

  3041.         spl.removeModule("UDPClockMaster");

  3042.         spl.removeModule("UDPClockSlave");

  3043. #undef modelBlank

  3044. #undef modelComparator

  3045.     }

  3046. }

  3047. 

  3048. static void initStatic__Mog()

  3049. {

  3050.     Plugin* const p = new Plugin;

  3051.     pluginInstance__Mog = p;

  3052. 

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

  3054.     if (spl.ok())

  3055.     {

  3056.         p->addModel(modelNetwork);

  3057.         p->addModel(modelNexus);

  3058.     }

  3059. }

  3060. 

  3061. static void initStatic__mscHack()

  3062. {

  3063.     Plugin* const p = new Plugin;

  3064.     pluginInstance__mscHack = p;

  3065. 

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

  3067.     if (spl.ok())

  3068.     {

  3069.         p->addModel(modelCompressor);

  3070.         p->addModel(modelSynthDrums);

  3071.         p->addModel(modelSEQ_6x32x16);

  3072.         p->addModel(modelMasterClockx4);

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

  3074.         p->addModel(modelSEQ_Envelope_8);

  3075.         p->addModel(modelSeq_Triad2);

  3076.         p->addModel(modelARP700);

  3077.         p->addModel(modelMix_4_0_4);

  3078.         p->addModel(modelMix_9_3_4);

  3079.         p->addModel(modelMix_16_4_4);

  3080.         p->addModel(modelMix_24_4_4);

  3081.         p->addModel(modelASAF8);

  3082.         p->addModel(modelPingPong);

  3083.         p->addModel(modelStepDelay);

  3084.         p->addModel(modelOsc_3Ch);

  3085.         p->addModel(modelDronez);

  3086.         p->addModel(modelMorze);

  3087.         p->addModel(modelWindz);

  3088.         p->addModel(modelLorenz);

  3089.         p->addModel(modelAlienz);

  3090.         p->addModel(modelOSC_WaveMorph_3);

  3091.         p->addModel(modelMaude_221);

  3092.     }

  3093. }

  3094. 

  3095. static void initStatic__MSM()

  3096. {

  3097.     Plugin* const p = new Plugin;

  3098.     pluginInstance__MSM = p;

  3099. 

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

  3101.     if (spl.ok())

  3102.     {

  3103. #define modelADSR modelMSMADSR

  3104. #define modelBlankPanel modelMSMBlankPanel

  3105. #define modelDelay modelMSMDelay

  3106. #define modelLFO modelMSMLFO

  3107. #define modelMult modelMSMMult

  3108. #define modelNoise modelMSMNoise

  3109. #define modelVCA modelMSMVCA

  3110. #define modelVCO modelMSMVCO

  3111.         p->addModel(modelVCO);

  3112.         p->addModel(modelBVCO);

  3113.         p->addModel(modelExperimentalVCO);

  3114.         p->addModel(modelNoise);

  3115.         p->addModel(modelLFO);

  3116.         p->addModel(modelVCA);

  3117.         p->addModel(modelADSR);

  3118.         p->addModel(modelDelay);

  3119.         p->addModel(modelWaveShaper);

  3120.         p->addModel(modelWavefolder);

  3121.         p->addModel(modelBitcrusher);

  3122.         p->addModel(modelPhaserModule);

  3123.         p->addModel(modelMorpher);

  3124.         p->addModel(modelRingMod);

  3125.         p->addModel(modelRandomSource);

  3126.         p->addModel(modelMult);

  3127.         p->addModel(modelCrazyMult);

  3128.         p->addModel(modelFade);

  3129.         p->addModel(modelSimpleSlider);

  3130.         p->addModel(modelxseq);

  3131.         p->addModel(modelBlankPanel);

  3132. #undef modelADSR

  3133. #undef modelBlankPanel

  3134. #undef modelDelay

  3135. #undef modelLFO

  3136. #undef modelMult

  3137. #undef modelNoise

  3138. #undef modelVCA

  3139. #undef modelVCO

  3140.     }

  3141. }

  3142. 

  3143. static void initStatic__MUS_X()

  3144. {

  3145.     Plugin* const p = new Plugin;

  3146.     pluginInstance__MUS_X = p;

  3147. 

  3148.     const StaticPluginLoader spl(p, "MUS-X");

  3149.     if (spl.ok())

  3150.     {

  3151.     	p->addModel(musx::modelADSR);

  3152.     	p->addModel(musx::modelDelay);

  3153.     	p->addModel(musx::modelDrift);

  3154.     	p->addModel(musx::modelFilter);

  3155.     	p->addModel(musx::modelLast);

  3156.     	p->addModel(musx::modelLFO);

  3157.     	p->addModel(musx::modelModMatrix);

  3158.     	p->addModel(musx::modelOnePole);

  3159.     	p->addModel(musx::modelOnePoleLP);

  3160.     	p->addModel(musx::modelOscillators);

  3161.     	p->addModel(musx::modelSplitStack);

  3162.     	p->addModel(musx::modelSynth);

  3163.     	p->addModel(musx::modelTuner);

  3164.     }

  3165. }

  3166. 

  3167. static void initStatic__myth_modules()

  3168. {

  3169.     Plugin* const p = new Plugin;

  3170.     pluginInstance__myth_modules = p;

  3171. 

  3172.     const StaticPluginLoader spl(p, "myth-modules");

  3173.     if (spl.ok())

  3174.     {

  3175.         p->addModel(modelMavka);

  3176.         p->addModel(modelMolphar);

  3177.     }

  3178. }

  3179. 

  3180. static void initStatic__nonlinearcircuits()

  3181. {

  3182.     Plugin* const p = new Plugin;

  3183.     pluginInstance__nonlinearcircuits = p;

  3184. 

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

  3186.     if (spl.ok())

  3187.     {

  3188.         p->addModel(model4Seq);

  3189.         p->addModel(modelCipher);

  3190.         p->addModel(modelBOOLs);

  3191.         p->addModel(modelDivideConquer);

  3192.         p->addModel(modelDivineCMOS);

  3193.         p->addModel(modelDoubleNeuron);

  3194.         p->addModel(modelGenie);

  3195.         p->addModel(modelLetsSplosh);

  3196.         p->addModel(modelNeuron);

  3197.         p->addModel(modelNumberwang);

  3198.         p->addModel(modelRouter);

  3199.         p->addModel(modelSegue);

  3200.         p->addModel(modelSlothApathy);

  3201.         p->addModel(modelSlothInertia);

  3202.         p->addModel(modelSlothTorpor);

  3203.         p->addModel(modelSplish);

  3204.         p->addModel(modelSquidAxon);

  3205.         p->addModel(modelStatues);

  3206.         p->addModel(modelTripleSloth);

  3207.     }

  3208. }

  3209. 

  3210. static void initStatic__Orbits()

  3211. {

  3212.     Plugin* const p = new Plugin;

  3213.     pluginInstance__Orbits = p;

  3214. 

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

  3216.     if (spl.ok())

  3217.     {

  3218.         p->addModel(modelRareBreeds_Orbits_Eugene);

  3219.         p->addModel(modelRareBreeds_Orbits_Polygene);

  3220.     }

  3221. }

  3222. 

  3223. static void initStatic__ParableInstruments()

  3224. {

  3225.     Plugin* const p = new Plugin;

  3226.     pluginInstance__ParableInstruments = p;

  3227. 

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

  3229.     if (spl.ok())

  3230.     {

  3231. #define modelClouds modelParableClouds

  3232.         p->addModel(modelClouds);

  3233. #undef modelClouds

  3234.     }

  3235. }

  3236. 

  3237. static void initStatic__PathSet()

  3238. {

  3239.     Plugin* const p = new Plugin;

  3240.     pluginInstance__PathSet = p;

  3241. 

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

  3243.     if (spl.ok())

  3244.     {

  3245.         p->addModel(modelShiftyMod);

  3246.         p->addModel(modelShiftyExpander);

  3247.         p->addModel(modelIceTray);

  3248.         p->addModel(modelAstroVibe);

  3249.         p->addModel(modelGlassPane);

  3250. 	    p->addModel(modelPlusPane);

  3251.         p->addModel(modelNudge);

  3252.         p->addModel(modelOneShot);

  3253.     }

  3254. }

  3255. 

  3256. static void initStatic__PdArray()

  3257. {

  3258.     Plugin* const p = new Plugin;

  3259.     pluginInstance__PdArray = p;

  3260. 

  3261.     const StaticPluginLoader spl(p, "PdArray");

  3262.     if (spl.ok())

  3263.     {

  3264.         p->addModel(modelArray);

  3265.         p->addModel(modelMiniramp);

  3266.         p->addModel(modelMinistep);

  3267.     }

  3268. }

  3269. 

  3270. static void initStatic__PinkTrombone()

  3271. {

  3272.     Plugin* const p = new Plugin;

  3273.     pluginInstance__PinkTrombone = p;

  3274. 

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

  3276.     if (spl.ok())

  3277.     {

  3278.         p->addModel(modelPinkTrombone);

  3279.     }

  3280. }

  3281. 

  3282. static void initStatic__Prism()

  3283. {

  3284.     Plugin* const p = new Plugin;

  3285.     pluginInstance__Prism = p;

  3286. 

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

  3288.     if (spl.ok())

  3289.     {

  3290.         p->addModel(modelRainbow);

  3291.         p->addModel(modelRainbowScaleExpander);

  3292.         p->addModel(modelDroplet);

  3293.     }

  3294. }

  3295. 

  3296. static void initStatic__rackwindows()

  3297. {

  3298.     Plugin* const p = new Plugin;

  3299.     pluginInstance__rackwindows = p;

  3300. 

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

  3302.     if (spl.ok())

  3303.     {

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

  3305.         p->addModel(modelBitshiftgain);

  3306.         p->addModel(modelCapacitor);

  3307.         p->addModel(modelCapacitor_stereo);

  3308.         p->addModel(modelChorus);

  3309.         p->addModel(modelConsole);

  3310.         p->addModel(modelConsole_mm);

  3311.         p->addModel(modelDistance);

  3312.         p->addModel(modelGolem);

  3313.         p->addModel(modelHolt);

  3314.         p->addModel(modelHombre);

  3315.         p->addModel(modelInterstage);

  3316.         p->addModel(modelMonitoring);

  3317.         p->addModel(modelMv);

  3318.         p->addModel(modelRasp);

  3319.         p->addModel(modelReseq);

  3320.         p->addModel(modelTape);

  3321.         p->addModel(modelTremolo);

  3322.         p->addModel(modelVibrato);

  3323.     }

  3324. }

  3325. 

  3326. static void initStatic__RCM()

  3327. {

  3328.     Plugin* const p = new Plugin;

  3329.     pluginInstance__RCM = p;

  3330. 

  3331.     const StaticPluginLoader spl(p, "rcm-modules");

  3332.     if (spl.ok())

  3333.     {

  3334.         p->addModel(modelGVerbModule);

  3335.         p->addModel(modelCV0to10Module);

  3336.         p->addModel(modelCVS0to10Module);

  3337.         p->addModel(modelCV5to5Module);

  3338.         p->addModel(modelCVMmtModule);

  3339.         p->addModel(modelCVTglModule);

  3340.         p->addModel(modelPianoRollModule);

  3341.         p->addModel(modelDuckModule);

  3342.         p->addModel(modelSEQAdapterModule);

  3343.         p->addModel(modelSyncModule);

  3344.         p->addModel(modelPolyNosModule);

  3345.     }

  3346. }

  3347. 

  3348. static void initStatic__RebelTech()

  3349. {

  3350.     Plugin* const p = new Plugin;

  3351.     pluginInstance__RebelTech = p;

  3352. 

  3353.     const StaticPluginLoader spl(p, "RebelTech");

  3354.     if (spl.ok())

  3355.     {

  3356.         p->addModel(modelStoicheia);

  3357.         p->addModel(modelTonic);

  3358.         p->addModel(modelKlasmata);

  3359.         p->addModel(modelCLK);

  3360.         p->addModel(modelLogoi);

  3361.         p->addModel(modelPhoreo);

  3362.     }

  3363. }

  3364. 

  3365. static void initStatic__repelzen()

  3366. {

  3367.     Plugin* const p = new Plugin;

  3368.     pluginInstance__repelzen = p;

  3369. 

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

  3371.     if (spl.ok())

  3372.     {

  3373. #define modelBlank modelrepelzenBlank

  3374. #define modelMixer modelrepelzenMixer

  3375. #define modelWerner modelrepelzenWerner

  3376.         p->addModel(modelBlank);

  3377.         p->addModel(modelBurst);

  3378.         p->addModel(modelFolder);

  3379.         p->addModel(modelErwin);

  3380.         p->addModel(modelWerner);

  3381.         p->addModel(modelMixer);

  3382. #undef modelBlank

  3383. #undef modelMixer

  3384. #undef modelWerner

  3385.     }

  3386. }

  3387. 

  3388. static void initStatic__Sapphire()

  3389. {

  3390.     Plugin* const p = new Plugin;

  3391.     pluginInstance__sapphire = p;

  3392. 

  3393.     const StaticPluginLoader spl(p, "Sapphire");

  3394.     if (spl.ok())

  3395.     {

  3396.         p->addModel(modelSapphireChaops);

  3397.         p->addModel(modelSapphireEcho);

  3398.         p->addModel(modelSapphireEchoOut);

  3399.         p->addModel(modelSapphireEchoTap);

  3400.         p->addModel(modelSapphireElastika);

  3401.         p->addModel(modelSapphireEnv);

  3402.         p->addModel(modelSapphireFrolic);

  3403.         p->addModel(modelSapphireGalaxy);

  3404.         p->addModel(modelSapphireGlee);

  3405.         p->addModel(modelSapphireGravy);

  3406.         p->addModel(modelSapphireHiss);

  3407.         p->addModel(modelSapphireLark);

  3408.         p->addModel(modelSapphireMoots);

  3409.         p->addModel(modelSapphireNucleus);

  3410.         p->addModel(modelSapphirePivot);

  3411.         p->addModel(modelSapphirePolynucleus);

  3412.         p->addModel(modelSapphirePop);

  3413.         p->addModel(modelSapphireRotini);

  3414.         p->addModel(modelSapphireSam);

  3415.         p->addModel(modelSapphireSauce);

  3416.         p->addModel(modelSapphireTin);

  3417.         p->addModel(modelSapphireTout);

  3418.         p->addModel(modelSapphireTricorder);

  3419.         p->addModel(modelSapphireTubeUnit);

  3420.     }

  3421. }

  3422. 

  3423. static void initStatic__sonusmodular()

  3424. {

  3425.     Plugin* const p = new Plugin;

  3426.     pluginInstance__sonusmodular = p;

  3427. 

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

  3429.     if (spl.ok())

  3430.     {

  3431.         p->addModel(modelAddiction);

  3432.         p->addModel(modelBitter);

  3433.         p->addModel(modelBymidside);

  3434.         p->addModel(modelCampione);

  3435.         p->addModel(modelChainsaw);

  3436.         p->addModel(modelCtrl);

  3437.         p->addModel(modelDeathcrush);

  3438.         p->addModel(modelFraction);

  3439.         p->addModel(modelHarmony);

  3440.         p->addModel(modelLadrone);

  3441.         p->addModel(modelLuppolo);

  3442.         p->addModel(modelLuppolo3);

  3443.         p->addModel(modelMicromacro);

  3444.         p->addModel(modelMrcheb);

  3445.         p->addModel(modelMultimulti);

  3446.         p->addModel(modelNeurosc);

  3447.         p->addModel(modelOktagon);

  3448.         p->addModel(modelOsculum);

  3449.         p->addModel(modelParamath);

  3450.         p->addModel(modelPiconoise);

  3451.         p->addModel(modelPith);

  3452.         p->addModel(modelPusher);

  3453.         p->addModel(modelRingo);

  3454.         p->addModel(modelScramblase);

  3455.         p->addModel(modelTropicana);

  3456.         p->addModel(modelTwoff);

  3457.         p->addModel(modelYabp);

  3458.     }

  3459. }

  3460. 

  3461. static void initStatic__StarlingVia()

  3462. {

  3463.     Plugin* const p = new Plugin;

  3464.     pluginInstance__StarlingVia = p;

  3465. 

  3466.     const StaticPluginLoader spl(p, "StarlingVia");

  3467.     if (spl.ok())

  3468.     {

  3469. #define modelScanner modelStarlingViaScanner

  3470.         p->addModel(modelMeta);

  3471.         p->addModel(modelGateseq);

  3472.         p->addModel(modelScanner);

  3473.         p->addModel(modelSync);

  3474.         p->addModel(modelAtsr);

  3475.         p->addModel(modelOsc3);

  3476.         p->addModel(modelSync3);

  3477.         p->addModel(modelSync3XL);

  3478.         p->addModel(modelSync3XLLevels);

  3479. #undef modelScanner

  3480.     }

  3481. }

  3482. 

  3483. static void initStatic__stocaudio()

  3484. {

  3485.     Plugin* const p = new Plugin;

  3486.     pluginInstance__stocaudio = p;

  3487. 

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

  3489.     if (spl.ok())

  3490.     {

  3491.         p->addModel(modelPolyturing);

  3492.         p->addModel(modelPolydelay);

  3493.         p->addModel(modelSpread);

  3494.     }

  3495. }

  3496. 

  3497. static void initStatic__stoermelder_p1()

  3498. {

  3499.     Plugin* const p = new Plugin;

  3500.     pluginInstance__stoermelder_p1 = p;

  3501. 

  3502.     const StaticPluginLoader spl(p, "stoermelder-packone");

  3503.     if (spl.ok())

  3504.     {

  3505.         p->addModel(modelCVMap);

  3506.         p->addModel(modelCVMapCtx);

  3507.         p->addModel(modelCVMapMicro);

  3508.         p->addModel(modelCVPam);

  3509.         p->addModel(modelRotorA);

  3510.         p->addModel(modelReMoveLite);

  3511.         p->addModel(modelBolt);

  3512.         p->addModel(modelInfix);

  3513.         p->addModel(modelInfixMicro);

  3514.         p->addModel(modelEightFace);

  3515.         p->addModel(modelEightFaceX2);

  3516.         p->addModel(modelSipo);

  3517.         p->addModel(modelFourRounds);

  3518.         p->addModel(modelArena);

  3519.         p->addModel(modelMaze);

  3520.         p->addModel(modelHive);

  3521.         p->addModel(modelIntermix);

  3522.         p->addModel(modelIntermixGate);

  3523.         p->addModel(modelIntermixEnv);

  3524.         p->addModel(modelIntermixFade);

  3525.         p->addModel(modelSail);

  3526.         p->addModel(modelPile);

  3527.         p->addModel(modelPilePoly);

  3528.         p->addModel(modelMirror);

  3529.         p->addModel(modelAffix);

  3530.         p->addModel(modelAffixMicro);

  3531.         p->addModel(modelGrip);

  3532.         p->addModel(modelGlue);

  3533.         p->addModel(modelGoto);

  3534.         p->addModel(modelStroke);

  3535.         p->addModel(modelSpin);

  3536.         p->addModel(modelTransit);

  3537.         p->addModel(modelTransitEx);

  3538.         p->addModel(modelX4);

  3539.         p->addModel(modelMacro);

  3540.         p->addModel(modelOrbit);

  3541.         p->addModel(modelEightFaceMk2);

  3542.         p->addModel(modelEightFaceMk2Ex);

  3543.         p->addModel(modelDirt);

  3544.         p->addModel(modelMb);

  3545.         p->addModel(modelMe);

  3546.         p->addModel(modelRaw);

  3547.         p->addModel(modelStrip);

  3548.         p->addModel(modelStripBay4);

  3549.         p->addModel(modelStripPp);

  3550. 

  3551.         spl.removeModule("AudioInterface64");

  3552.         spl.removeModule("MidiCat");

  3553.         spl.removeModule("MidiCatEx");

  3554.         spl.removeModule("MidiCatCtx");

  3555.         spl.removeModule("MidiKey");

  3556.         spl.removeModule("MidiMon");

  3557.         spl.removeModule("MidiPlug");

  3558.         spl.removeModule("MidiStep");

  3559.     }

  3560. }

  3561. 

  3562. static void initStatic__surgext()

  3563. {

  3564.     Plugin* const p = new Plugin;

  3565.     pluginInstance__surgext = p;

  3566. 

  3567.     const StaticPluginLoader spl(p, "surgext");

  3568.     if (spl.ok())

  3569.     {

  3570.         p->addModel(modelVCOClassic);

  3571.         p->addModel(modelVCOModern);

  3572.         p->addModel(modelVCOWavetable);

  3573.         p->addModel(modelVCOWindow);

  3574.         p->addModel(modelVCOSine);

  3575.         p->addModel(modelVCOFM2);

  3576.         p->addModel(modelVCOFM3);

  3577.         p->addModel(modelVCOSHNoise);

  3578.         p->addModel(modelVCOAlias);

  3579.         p->addModel(modelVCOString);

  3580.         p->addModel(modelVCOTwist);

  3581. 

  3582.         // Add the ported ones

  3583.         p->addModel(modelSurgeVCF);

  3584.         p->addModel(modelSurgeDelay);

  3585.         p->addModel(modelSurgeDelayLineByFreq);

  3586.         p->addModel(modelSurgeDelayLineByFreqExpanded);

  3587.         p->addModel(modelSurgeDigitalRingMods);

  3588.         p->addModel(modelSurgeWaveshaper);

  3589.         p->addModel(modelSurgeLFO);

  3590.         p->addModel(modelSurgeMixer);

  3591.         p->addModel(modelSurgeMixerSlider);

  3592.         p->addModel(modelSurgeModMatrix);

  3593. 

  3594.         p->addModel(modelFXReverb);

  3595.         p->addModel(modelFXPhaser);

  3596.         p->addModel(modelFXRotarySpeaker);

  3597.         p->addModel(modelFXDistortion);

  3598.         p->addModel(modelFXFrequencyShifter);

  3599.         p->addModel(modelFXChorus);

  3600.         p->addModel(modelFXVocoder);

  3601.         p->addModel(modelFXReverb2);

  3602.         p->addModel(modelFXFlanger);

  3603.         p->addModel(modelFXRingMod);

  3604.         p->addModel(modelFXNeuron);

  3605.         p->addModel(modelFXResonator);

  3606.         p->addModel(modelFXChow);

  3607.         p->addModel(modelFXExciter);

  3608.         p->addModel(modelFXEnsemble);

  3609.         p->addModel(modelFXCombulator);

  3610.         p->addModel(modelFXNimbus);

  3611.         p->addModel(modelFXSpringReverb);

  3612.         p->addModel(modelFXTreeMonster);

  3613.         p->addModel(modelFXBonsai);

  3614. 

  3615.         p->addModel(modelEGxVCA);

  3616.         p->addModel(modelQuadAD);

  3617.         p->addModel(modelQuadLFO);

  3618.         p->addModel(modelUnisonHelper);

  3619.         p->addModel(modelUnisonHelperCVExpander);

  3620. 

  3621.         surgext_rack_initialize();

  3622.     }

  3623. }

  3624. 

  3625. static void initStatic__unless_modules()

  3626. {

  3627.     Plugin* const p = new Plugin;

  3628.     pluginInstance__unless_modules = p;

  3629. 

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

  3631.     if (spl.ok())

  3632.     {

  3633.         // unless_modules::init_theme();

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

  3635.         p->addModel(modelPiong);

  3636.         p->addModel(modelChainkov);

  3637.         p->addModel(modelAtoms);

  3638.         p->addModel(modelCantor);

  3639.         p->addModel(modelRoom);

  3640.         p->addModel(modelSnake);

  3641.         p->addModel(modelTowers);

  3642.         p->addModel(modelPianoid);

  3643.         p->addModel(modelPremuter);

  3644.         p->addModel(modelAvoider);

  3645.     }

  3646. }

  3647. 

  3648. static void initStatic__ValleyAudio()

  3649. {

  3650.     Plugin* const p = new Plugin;

  3651.     pluginInstance__ValleyAudio = p;

  3652. 

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

  3654.     if (spl.ok())

  3655.     {

  3656.         p->addModel(modelTopograph);

  3657.         p->addModel(modelUGraph);

  3658.         p->addModel(modelDexter);

  3659.         p->addModel(modelPlateau);

  3660.         p->addModel(modelInterzone);

  3661.         p->addModel(modelAmalgam);

  3662.         p->addModel(modelFeline);

  3663.         p->addModel(modelTerrorform);

  3664.     }

  3665. }

  3666. 

  3667. static void initStatic__Voxglitch()

  3668. {

  3669.     Plugin* p = new Plugin;

  3670.     pluginInstance__Voxglitch = p;

  3671. 

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

  3673.     if (spl.ok())

  3674.     {

  3675. #define modelLooper modelVoxglitchLooper

  3676.         p->addModel(modelArpSeq);

  3677.         p->addModel(modelAutobreak);

  3678.         p->addModel(modelAutobreakStudio);

  3679.         p->addModel(modelByteBeat);

  3680.         p->addModel(modelDigitalProgrammer);

  3681.         p->addModel(modelDigitalSequencer);

  3682.         p->addModel(modelDigitalSequencerXP);

  3683.         p->addModel(modelDrumRandomizer);

  3684.         p->addModel(modelGlitchSequencer);

  3685.         p->addModel(modelGhosts);

  3686.         p->addModel(modelGrainEngineMK2);

  3687.         p->addModel(modelGrainEngineMK2Expander);

  3688.         p->addModel(modelGrainFx);

  3689.         p->addModel(modelGrooveBox);

  3690.         p->addModel(modelGrooveBoxExpander);

  3691.         p->addModel(modelHazumi);

  3692.         p->addModel(modelOnePoint);

  3693.         p->addModel(modelOneZero);

  3694.         p->addModel(modelLooper);

  3695.         p->addModel(modelNoteDetector);

  3696.         p->addModel(modelRepeater);

  3697.         p->addModel(modelSamplerX8);

  3698.         p->addModel(modelSampler16P);

  3699.         p->addModel(modelSatanonaut);

  3700.         p->addModel(modelWavBank);

  3701.         p->addModel(modelWavBankMC);

  3702.         p->addModel(modelXY);

  3703. #undef modelLooper

  3704.     }

  3705. }

  3706. 

  3707. static void initStatic__WhatTheRack()

  3708. {

  3709.     Plugin* p = new Plugin;

  3710.     pluginInstance__WhatTheRack = p;

  3711. 

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

  3713.     if (spl.ok())

  3714.     {

  3715.       p->addModel(modelWhatTheRack);

  3716.       p->addModel(modelWhatTheMod);

  3717.       p->addModel(modelWhatTheJack);

  3718.     }

  3719. }

  3720. 

  3721. static void initStatic__WSTD_Drums()

  3722. {

  3723.     Plugin* const p = new Plugin;

  3724.     pluginInstance__WSTD_Drums = p;

  3725. 

  3726.     const StaticPluginLoader spl(p, "WSTD-Drums");

  3727.     if (spl.ok())

  3728.     {

  3729.         setupSamples();

  3730.         p->addModel(modelBD9);

  3731.         p->addModel(modelSnare);

  3732.         p->addModel(modelClosedHH);

  3733.         p->addModel(modelOpenHH);

  3734.         p->addModel(modelDMX);

  3735.         p->addModel(modelCR78);

  3736.         p->addModel(modelSBD);

  3737.         p->addModel(modelGnome);

  3738.         p->addModel(modelSequencer);

  3739.         p->addModel(modelTomi);

  3740.         p->addModel(modelBaronial);

  3741.         p->addModel(modelMarionette);

  3742.     }

  3743. }

  3744. 

  3745. static void initStatic__ZetaCarinaeModules()

  3746. {

  3747.     Plugin* p = new Plugin;

  3748.     pluginInstance__ZetaCarinaeModules = p;

  3749. 

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

  3751.     if (spl.ok())

  3752.     {

  3753.         p->addModel(modelBrownianBridge);

  3754.         p->addModel(modelOrnsteinUhlenbeck);

  3755.         p->addModel(modelIOU);

  3756.         p->addModel(modelWarbler);

  3757.         p->addModel(modelRosenchance);

  3758.         p->addModel(modelGuildensTurn);

  3759.         p->addModel(modelRosslerRustler);

  3760.         p->addModel(modelFirefly);

  3761.     }

  3762. }

  3763. 

  3764. static void initStatic__ZZC()

  3765. {

  3766.     Plugin* p = new Plugin;

  3767.     pluginInstance__ZZC = p;

  3768. 

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

  3770.     if (spl.ok())

  3771.     {

  3772. #define modelClock modelZZCClock

  3773.         p->addModel(modelClock);

  3774.         p->addModel(modelDivider);

  3775.         p->addModel(modelFN3);

  3776.         p->addModel(modelSCVCA);

  3777.         p->addModel(modelSH8);

  3778.         p->addModel(modelSRC);

  3779.         p->addModel(modelDiv);

  3780.         p->addModel(modelDivExp);

  3781.         p->addModel(modelPolygate);

  3782. #undef modelClock

  3783.     }

  3784. }

  3785. 

  3786. void initStaticPlugins()

  3787. {

  3788.     initStatic__Cardinal();

  3789.     initStatic__Fundamental();

  3790.     // initStatic__ZamAudio();

  3791.     initStatic__21kHz();

  3792.     initStatic__8Mode();

  3793.     initStatic__AaronStatic();

  3794.     initStatic__admiral();

  3795.     initStatic__alefsbits();

  3796.     initStatic__Algoritmarte();

  3797.     initStatic__AmalgamatedHarmonics();

  3798.     initStatic__AnimatedCircuits();

  3799.     initStatic__ArableInstruments();

  3800.     initStatic__Aria();

  3801.     initStatic__AS();

  3802.     initStatic__AudibleInstruments();

  3803.     initStatic__Autinn();

  3804.     initStatic__Axioma();

  3805.     initStatic__Bacon();

  3806.     initStatic__Befaco();

  3807.     initStatic__Bidoo();

  3808.     initStatic__Biset();

  3809.     initStatic__BogaudioModules();

  3810.     initStatic__CatroModulo();

  3811.     initStatic__cf();

  3812.     initStatic__ChowDSP();

  3813.     initStatic__Computerscare();

  3814.     initStatic__CVfunk();

  3815.     initStatic__dBiz();

  3816.     initStatic__dbRackModules();

  3817.     initStatic__DHE();

  3818.     initStatic__eightfold();

  3819.     initStatic__EnigmaCurry();

  3820.     initStatic__ESeries();

  3821.     initStatic__ExpertSleepersEncoders();

  3822.     initStatic__Extratone();

  3823.     initStatic__FehlerFabrik();

  3824.     initStatic__forsitan();

  3825.     initStatic__GlueTheGiant();

  3826.     initStatic__GoodSheperd();

  3827.     initStatic__GrandeModular();

  3828.     initStatic__H4N4();

  3829.     initStatic__HamptonHarmonics();

  3830.     initStatic__HetrickCV();

  3831.     initStatic__ImpromptuModular();

  3832.     initStatic__ihtsyn();

  3833.     initStatic__JW();

  3834.     initStatic__kocmoc();

  3835.     initStatic__LifeFormModular();

  3836.     initStatic__LilacLoop();

  3837.     initStatic__LittleUtils();

  3838.     initStatic__Lomas();

  3839.     initStatic__Lyrae();

  3840.     initStatic__Meander();

  3841.     initStatic__MindMeld();

  3842.     initStatic__ML();

  3843.     initStatic__MockbaModular();

  3844.     initStatic__Mog();

  3845.     initStatic__mscHack();

  3846.     initStatic__MSM();

  3847.     initStatic__MUS_X();

  3848.     initStatic__myth_modules();

  3849.     initStatic__nonlinearcircuits();

  3850.     initStatic__Orbits();

  3851.     initStatic__ParableInstruments();

  3852.     initStatic__PathSet();

  3853.     initStatic__PdArray();

  3854.     initStatic__PinkTrombone();

  3855.     initStatic__Prism();

  3856.     initStatic__rackwindows();

  3857.     initStatic__RCM();

  3858.     initStatic__RebelTech();

  3859.     initStatic__repelzen();

  3860.     initStatic__Sapphire();

  3861.     initStatic__sonusmodular();

  3862.     initStatic__StarlingVia();

  3863.     initStatic__stocaudio();

  3864.     initStatic__stoermelder_p1();

  3865.     initStatic__surgext();

  3866.     initStatic__unless_modules();

  3867.     initStatic__ValleyAudio();

  3868.     initStatic__Voxglitch();

  3869.     initStatic__WhatTheRack();

  3870.     initStatic__WSTD_Drums();

  3871.     initStatic__ZetaCarinaeModules();

  3872.     initStatic__ZZC();

  3873. 

  3874.     INFO("Have %u modules from %u plugin collections",

  3875.          numPluginModules, static_cast<uint32_t>(plugins.size()));

  3876. }

  3877. 

  3878. void destroyStaticPlugins()

  3879. {

  3880.     for (Plugin* p : plugins)

  3881.         delete p;

  3882.     plugins.clear();

  3883. }

  3884. 

  3885. void updateStaticPluginsDarkMode()

  3886. {

  3887.     const bool darkMode = settings::preferDarkPanels;

  3888.     // bogaudio

  3889.     {

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

  3891.         skins._default = darkMode ? "dark" : "light";

  3892. 

  3893.         std::lock_guard<std::mutex> lock(skins._defaultSkinListenersLock);

  3894.         for (auto listener : skins._defaultSkinListeners) {

  3895.             listener->defaultSkinChanged(skins._default);

  3896.         }

  3897.     }

  3898.     // meander

  3899.     {

  3900.         Meander_panelTheme = darkMode ? 1 : 0;

  3901.         MSQ_panelTheme = darkMode ? 1 : 0;

  3902.         MSP_panelTheme = darkMode ? 1 : 0;

  3903.     }

  3904.     // glue the giant

  3905.     {

  3906.         gtg_default_theme = darkMode ? 1 : 0;

  3907.     }

  3908.     // surgext

  3909.     {

  3910.         surgext_rack_update_theme();

  3911.     }

  3912. }

  3913. 

  3914. }

  3915. }