DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 18 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1815 Commits
6 Branches
280MB
Tree: fe1e7d3311
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fe1e7d3311'
${ noResults }
Cardinal/plugins/plugins.cpp

3513 lines
95KB
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. // Alef's Bits

  31. #define modelSteps modelalefsbitsSteps

  32. #define modelLogic modelalefsbitsLogic

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

  34. #undef modelSteps

  35. #undef modelLogic

  36. 

  37. // Algoritmarte

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

  39. 

  40. // AmalgamatedHarmonics

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

  42. 

  43. // AnimatedCircuits

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

  45. 

  46. // ArableInstruments

  47. #define modelClouds modelArableClouds

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

  49. #undef modelClouds

  50. 

  51. // Aria

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

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

  54. */

  55. #define modelBlank modelAriaBlank

  56. extern Model* modelSplort;

  57. extern Model* modelSmerge;

  58. extern Model* modelSpleet;

  59. extern Model* modelSwerge;

  60. extern Model* modelSplirge;

  61. // extern Model* modelSrot;

  62. extern Model* modelQqqq;

  63. extern Model* modelQuack;

  64. extern Model* modelQ;

  65. extern Model* modelQuale;

  66. extern Model* modelDarius;

  67. extern Model* modelSolomon4;

  68. extern Model* modelSolomon8;

  69. extern Model* modelSolomon16;

  70. extern Model* modelPsychopump;

  71. extern Model* modelPokies4;

  72. extern Model* modelGrabby;

  73. extern Model* modelRotatoes4;

  74. extern Model* modelUndular;

  75. extern Model* modelBlank;

  76. #undef modelBlank

  77. 

  78. // AS

  79. #define modelADSR modelASADSR

  80. #define modelVCA modelASVCA

  81. #define modelWaveShaper modelASWaveShaper

  82. #define LedLight ASLedLight

  83. #define YellowRedLight ASYellowRedLight

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

  85. #undef modelADSR

  86. #undef modelVCA

  87. #undef modelWaveShaper

  88. #undef LedLight

  89. #undef YellowRedLight

  90. 

  91. // AudibleInstruments

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

  93. 

  94. // Autinn

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

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

  97. */

  98. #define modelChord modelAutinnChord

  99. #define modelVibrato modelAutinnVibrato

  100. extern Model* modelJette;

  101. extern Model* modelFlora;

  102. extern Model* modelOxcart;

  103. extern Model* modelDeadband;

  104. extern Model* modelDigi;

  105. extern Model* modelFlopper;

  106. extern Model* modelAmp;

  107. extern Model* modelDC;

  108. extern Model* modelSjip;

  109. extern Model* modelBass;

  110. extern Model* modelSquare;

  111. extern Model* modelSaw;

  112. extern Model* modelBoomerang;

  113. extern Model* modelVibrato;

  114. extern Model* modelVectorDriver; //deprecated

  115. extern Model* modelCVConverter;

  116. extern Model* modelZod;

  117. extern Model* modelTriBand;

  118. extern Model* modelMixer6;

  119. extern Model* modelNon;

  120. extern Model* modelFil;

  121. extern Model* modelNap;

  122. extern Model* modelMelody;

  123. extern Model* modelChord;

  124. #undef modelChord

  125. #undef modelVibrato

  126. 

  127. // Axioma

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

  129. 

  130. // BaconPlugs

  131. #define INCLUDE_COMPONENTS_HPP

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

  133. #undef INCLUDE_COMPONENTS_HPP

  134. #undef SCREW_WIDTH

  135. #undef RACK_HEIGHT

  136. 

  137. // Befaco

  138. #define modelADSR modelBefacoADSR

  139. #define modelMixer modelBefacoMixer

  140. #define modelBurst modelBefacoBurst

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

  142. #undef modelADSR

  143. #undef modelMixer

  144. #undef modelBurst

  145. 

  146. // Bidoo

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

  148. 

  149. // Biset

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

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

  152. */

  153. #define modelBlank modelBisetBlank

  154. #define modelTree modelBisetTree

  155. extern Model* modelTracker;

  156. extern Model* modelTrackerSynth;

  157. extern Model* modelTrackerDrum;

  158. extern Model* modelTrackerClock;

  159. extern Model* modelTrackerPhase;

  160. extern Model* modelTrackerQuant;

  161. extern Model* modelTrackerState;

  162. extern Model* modelTrackerControl;

  163. extern Model* modelRegex;

  164. extern Model* modelRegexCondensed;

  165. extern Model* modelRegexExp;

  166. extern Model* modelTree;

  167. extern Model* modelTreeSeed;

  168. extern Model* modelGbu;

  169. extern Model* modelPkm;

  170. extern Model* modelIgc;

  171. extern Model* modelOmega3;

  172. extern Model* modelOmega6;

  173. extern Model* modelSegfault;

  174. extern Model* modelBlank;

  175. #undef modelBlank

  176. #undef modelTree

  177. 

  178. // BogaudioModules - integrate theme/skin support

  179. #include <mutex>

  180. #include <string>

  181. #include <unordered_map>

  182. #include <unordered_set>

  183. #include <vector>

  184. #define private public

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

  186. #undef private

  187. 

  188. // BogaudioModules

  189. #define modelADSR modelBogaudioADSR

  190. #define modelLFO modelBogaudioLFO

  191. #define modelNoise modelBogaudioNoise

  192. #define modelVCA modelBogaudioVCA

  193. #define modelVCF modelBogaudioVCF

  194. #define modelVCO modelBogaudioVCO

  195. extern Model* modelVCO;

  196. extern Model* modelLVCO;

  197. extern Model* modelSine;

  198. extern Model* modelPulse;

  199. extern Model* modelXCO;

  200. extern Model* modelAdditator;

  201. extern Model* modelFMOp;

  202. extern Model* modelChirp;

  203. extern Model* modelLFO;

  204. extern Model* modelLLFO;

  205. extern Model* modelFourFO;

  206. extern Model* modelEightFO;

  207. extern Model* modelVCF;

  208. extern Model* modelLVCF;

  209. extern Model* modelFFB;

  210. extern Model* modelEQ;

  211. extern Model* modelEQS;

  212. extern Model* modelLPG;

  213. extern Model* modelLLPG;

  214. extern Model* modelMegaGate;

  215. extern Model* modelPEQ;

  216. extern Model* modelPEQ6;

  217. extern Model* modelPEQ6XF;

  218. extern Model* modelPEQ14;

  219. extern Model* modelPEQ14XF;

  220. extern Model* modelDADSRH;

  221. extern Model* modelDADSRHPlus;

  222. extern Model* modelShaper;

  223. extern Model* modelShaperPlus;

  224. extern Model* modelAD;

  225. extern Model* modelASR;

  226. extern Model* modelADSR;

  227. extern Model* modelVish;

  228. extern Model* modelFollow;

  229. extern Model* modelDGate;

  230. extern Model* modelRGate;

  231. extern Model* modelEdge;

  232. extern Model* modelNoise;

  233. extern Model* modelSampleHold;

  234. extern Model* modelWalk2;

  235. extern Model* modelWalk;

  236. extern Model* modelMix8;

  237. extern Model* modelMix8x;

  238. extern Model* modelMix4;

  239. extern Model* modelMix4x;

  240. extern Model* modelMix2;

  241. extern Model* modelMix1;

  242. extern Model* modelVCM;

  243. extern Model* modelMute8;

  244. extern Model* modelPan;

  245. extern Model* modelXFade;

  246. extern Model* modelVCA;

  247. extern Model* modelVCAmp;

  248. extern Model* modelVelo;

  249. extern Model* modelUMix;

  250. extern Model* modelMumix;

  251. extern Model* modelMatrix81;

  252. extern Model* modelMatrix18;

  253. extern Model* modelMatrix44;

  254. extern Model* modelMatrix44Cvm;

  255. extern Model* modelMatrix88;

  256. extern Model* modelMatrix88Cv;

  257. extern Model* modelMatrix88M;

  258. extern Model* modelSwitch81;

  259. extern Model* modelSwitch18;

  260. extern Model* modelSwitch44;

  261. extern Model* modelSwitch88;

  262. extern Model* modelSwitch1616;

  263. extern Model* modelAMRM;

  264. extern Model* modelPressor;

  265. extern Model* modelClpr;

  266. extern Model* modelLmtr;

  267. extern Model* modelNsgt;

  268. extern Model* modelCmpDist;

  269. extern Model* modelOneEight;

  270. extern Model* modelEightOne;

  271. extern Model* modelAddrSeq;

  272. extern Model* modelAddrSeqX;

  273. extern Model* modelPgmr;

  274. extern Model* modelPgmrX;

  275. extern Model* modelVU;

  276. extern Model* modelAnalyzer;

  277. extern Model* modelAnalyzerXL;

  278. extern Model* modelRanalyzer;

  279. extern Model* modelDetune;

  280. extern Model* modelStack;

  281. extern Model* modelReftone;

  282. extern Model* modelMono;

  283. extern Model* modelArp;

  284. extern Model* modelAssign;

  285. extern Model* modelUnison;

  286. extern Model* modelPolyCon8;

  287. extern Model* modelPolyCon16;

  288. extern Model* modelPolyOff8;

  289. extern Model* modelPolyOff16;

  290. extern Model* modelPolyMult;

  291. extern Model* modelBool;

  292. extern Model* modelCmp;

  293. extern Model* modelCVD;

  294. extern Model* modelFlipFlop;

  295. extern Model* modelInv;

  296. extern Model* modelManual;

  297. extern Model* modelFourMan;

  298. extern Model* modelMult;

  299. extern Model* modelOffset;

  300. extern Model* modelSlew;

  301. extern Model* modelSums;

  302. extern Model* modelSwitch;

  303. extern Model* modelLgsw;

  304. extern Model* modelBlank3;

  305. extern Model* modelBlank6;

  306. #ifdef EXPERIMENTAL

  307. extern Model* modelLag;

  308. extern Model* modelPEQ14XR;

  309. extern Model* modelPEQ14XV;

  310. #endif

  311. #ifdef TEST

  312. extern Model* modelTest;

  313. extern Model* modelTest2;

  314. extern Model* modelTestExpanderBase;

  315. extern Model* modelTestExpanderExtension;

  316. extern Model* modelTestGl;

  317. extern Model* modelTestVCF;

  318. #endif

  319. #undef modelADSR

  320. #undef modelLFO

  321. #undef modelNoise

  322. #undef modelVCA

  323. #undef modelVCF

  324. #undef modelVCO

  325. 

  326. // CatroModulo

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

  328. 

  329. // cf

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

  331. 

  332. // CVfunk

  333. #define modelSteps modelCVfunkSteps

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

  335. #undef modelSteps

  336. 

  337. // ChowDSP

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

  339. #define init initChowDSP

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

  341. #undef init

  342. 

  343. // Computerscare

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

  345. 

  346. // dBiz

  347. #define DarkDefaultItem dBizDarkDefaultItem

  348. #define OrangeLight dBizOrangeLight

  349. #define darkPanelID dBizdarkPanelID

  350. #define lightPanelID dBizlightPanelID

  351. #define modelChord modeldBizChord

  352. #define modelDivider modeldBizDivider

  353. #define modelFourSeq modeldBizFourSeq

  354. #define modelVCA4 modeldBizVCA4

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

  356. #undef DarkDefaultItem

  357. #undef OrangeLight

  358. #undef darkPanelID

  359. #undef lightPanelID

  360. #undef modelChord

  361. #undef modelDivider

  362. #undef modelFourSeq

  363. #undef modelVCA4

  364. 

  365. // DHEModules

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

  367. namespace dhe {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  383. }

  384. 

  385. // DrumKit

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

  387. void setupSamples();

  388. 

  389. // EnigmaCurry

  390. #define modelPulse modelEnigmaCurryPulse

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

  392. #undef modelPulse

  393. 

  394. // ESeries

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

  396. 

  397. // ExpertSleepers-Encoders

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

  399. 

  400. // Extratone

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

  402. 

  403. // FehlerFabrik

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

  405. 

  406. // forsitan modulare

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

  408. 

  409. // GlueTheGiant

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

  411. bool audition_mixer = false;

  412. bool audition_depot = false;

  413. int gtg_default_theme = 1;

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

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

  416. 

  417. // GoodSheperd

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

  419. 

  420. // GrandeModular

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

  422. 

  423. // H4N4 Modules

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

  425. 

  426. // Hampton Harmonics

  427. #define modelArp modelHamptonHarmonicsArp

  428. #define modelProgress modelHamptonHarmonicsProgress

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

  430. #undef modelProgress

  431. #undef modelArp

  432. 

  433. // HetrickCV

  434. #define modelASR modelHetrickCVASR

  435. #define modelBlankPanel modelHetrickCVBlankPanel

  436. #define modelFlipFlop modelHetrickCVFlipFlop

  437. #define modelMidSide modelHetrickCVMidSide

  438. #define modelMinMax modelHetrickCVMinMax

  439. #define PanelBaseWidget HetrickCVPanelBaseWidget

  440. #define InverterWidget HetrickCVInverterWidget

  441. extern Model* modelTwoToFour;

  442. extern Model* modelAnalogToDigital;

  443. extern Model* modelASR;

  444. extern Model* modelBinaryGate;

  445. extern Model* modelBinaryNoise;

  446. extern Model* modelBitshift;

  447. extern Model* modelBlankPanel;

  448. extern Model* modelBoolean3;

  449. extern Model* modelChaos1Op;

  450. extern Model* modelChaos2Op;

  451. extern Model* modelChaos3Op;

  452. extern Model* modelChaoticAttractors;

  453. extern Model* modelClockedNoise;

  454. extern Model* modelComparator;

  455. extern Model* modelContrast;

  456. extern Model* modelCrackle;

  457. extern Model* modelDataCompander;

  458. extern Model* modelDelta;

  459. extern Model* modelDigitalToAnalog;

  460. extern Model* modelDust;

  461. extern Model* modelExponent;

  462. extern Model* modelFBSineChaos;

  463. extern Model* modelFlipFlop;

  464. extern Model* modelFlipPan;

  465. extern Model* modelGateDelay;

  466. extern Model* modelGateJunction;

  467. extern Model* modelGateJunctionExp;

  468. extern Model* modelGingerbread;

  469. extern Model* modelLogicCombine;

  470. extern Model* modelMidSide;

  471. extern Model* modelMinMax;

  472. extern Model* modelPhaseDrivenSequencer;

  473. extern Model* modelPhaseDrivenSequencer32;

  474. extern Model* modelPhasorAnalyzer;

  475. extern Model* modelPhasorBurstGen;

  476. extern Model* modelPhasorDivMult;

  477. extern Model* modelPhasorEuclidean;

  478. extern Model* modelPhasorGates;

  479. extern Model* modelPhasorGates32;

  480. extern Model* modelPhasorGates64;

  481. extern Model* modelPhasorGen;

  482. extern Model* modelPhasorGeometry;

  483. extern Model* modelPhasorHumanizer;

  484. extern Model* modelPhasorMixer;

  485. extern Model* modelPhasorOctature;

  486. extern Model* modelPhasorQuadrature;

  487. extern Model* modelPhasorRandom;

  488. extern Model* modelPhasorRanger;

  489. extern Model* modelPhasorReset;

  490. extern Model* modelPhasorRhythmGroup;

  491. extern Model* modelPhasorShape;

  492. extern Model* modelPhasorShift;

  493. extern Model* modelPhasorStutter;

  494. extern Model* modelPhasorSubstepShape;

  495. extern Model* modelPhasorSwing;

  496. extern Model* modelPhasorTimetable;

  497. extern Model* modelPhasorToClock;

  498. extern Model* modelPhasorToLFO;

  499. extern Model* modelPhasorToWaveforms;

  500. extern Model* modelProbability;

  501. extern Model* modelRandomGates;

  502. extern Model* modelRotator;

  503. extern Model* modelRungler;

  504. extern Model* modelScanner;

  505. extern Model* modelVectorMix;

  506. extern Model* modelWaveshape;

  507. extern Model* modelXYToPolar;

  508. #undef modelASR

  509. #undef modelBlankPanel

  510. #undef modelFlipFlop

  511. #undef modelMidSide

  512. #undef modelMinMax

  513. #undef PanelBaseWidget

  514. #undef InverterWidget

  515. 

  516. // ImpromptuModular

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

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

  519. */

  520. extern Model* modelAdaptiveQuantizer;

  521. extern Model* modelBigButtonSeq;

  522. extern Model* modelBigButtonSeq2;

  523. extern Model* modelChordKey;

  524. extern Model* modelChordKeyExpander;

  525. extern Model* modelClocked;

  526. extern Model* modelClockedExpander;

  527. extern Model* modelClkd;

  528. extern Model* modelCvPad;

  529. extern Model* modelFoundry;

  530. extern Model* modelFoundryExpander;

  531. extern Model* modelFourView;

  532. extern Model* modelGateSeq64;

  533. extern Model* modelGateSeq64Expander;

  534. extern Model* modelHotkey;

  535. extern Model* modelPart;

  536. extern Model* modelPhraseSeq16;

  537. extern Model* modelPhraseSeq32;

  538. extern Model* modelPhraseSeqExpander;

  539. extern Model* modelProbKey;

  540. extern Model* modelSemiModularSynth;

  541. extern Model* modelSygen;

  542. extern Model* modelTact;

  543. extern Model* modelTact1;

  544. extern Model* modelTactG;

  545. extern Model* modelTwelveKey;

  546. extern Model* modelVariations;

  547. extern Model* modelWriteSeq32;

  548. extern Model* modelWriteSeq64;

  549. extern Model* modelBlankPanel;

  550. 

  551. // ihtsyn

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

  553. 

  554. // JW-Modules

  555. #define modelQuantizer modelJWQuantizer

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

  557. #undef modelQuantizer

  558. 

  559. // kocmoc

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

  561. 

  562. // LifeFormModular

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

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

  565. */

  566. extern Model* modelTimeDiktat;

  567. extern Model* modelSequenceModeler;

  568. extern Model* modelPitchDiktat;

  569. extern Model* modelPitchIntegrator;

  570. extern Model* modelBurstIntegrator;

  571. extern Model* modelQuadModulator;

  572. extern Model* modelImpulseControl;

  573. extern Model* modelQuadSteppedOffset;

  574. extern Model* modelPercussiveVibration;

  575. extern Model* modelQuadUtility;

  576. extern Model* modelAdditiveVibration;

  577. extern Model* modelComplexOsc;

  578. extern Model* modelDriftgen;

  579. 

  580. // LittleUtils

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

  582. 

  583. // Lilac Loop

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

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

  586. */

  587. extern Model* modelLooperOne;

  588. extern Model* modelLooperTwo;

  589. 

  590. // LomasModules

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

  592. #undef DR_WAV_IMPLEMENTATION

  593. 

  594. // LyraeModules

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

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

  597. */

  598. #define modelDelta modelLyraeDelta

  599. extern Model* modelSulafat;

  600. extern Model* modelGamma;

  601. extern Model* modelDelta;

  602. extern Model* modelVega;

  603. extern Model* modelBD383238;

  604. extern Model* modelZeta;

  605. #undef modelDelta

  606. 

  607. // Meander

  608. extern int panelTheme;

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

  610. 

  611. // MindMeldModular

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

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

  614. */

  615. extern Model *modelPatchMaster;

  616. extern Model *modelPatchMasterBlank;

  617. extern Model *modelRouteMasterMono5to1;

  618. extern Model *modelRouteMasterStereo5to1;

  619. extern Model *modelRouteMasterMono1to5;

  620. extern Model *modelRouteMasterStereo1to5;

  621. extern Model *modelMasterChannel;

  622. extern Model *modelMeld;

  623. extern Model *modelUnmeld;

  624. extern Model *modelMSMelder;

  625. extern Model *modelEqMaster;

  626. extern Model *modelEqExpander;

  627. extern Model *modelBassMaster;

  628. extern Model *modelBassMasterJr;

  629. extern Model *modelShapeMaster;

  630. extern Model *modelMixMasterJr;

  631. extern Model *modelAuxExpanderJr;

  632. extern Model *modelMixMaster;

  633. extern Model *modelAuxExpander;

  634. 

  635. // ML_modules

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

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

  638. */

  639. #define modelQuantizer modelMLQuantizer

  640. #define modelSH8 modelMLSH8

  641. extern Model* modelQuantizer;

  642. extern Model* modelQuantum;

  643. extern Model* modelTrigBuf;

  644. extern Model* modelSeqSwitch;

  645. extern Model* modelSeqSwitch2;

  646. extern Model* modelShiftRegister;

  647. extern Model* modelShiftRegister2;

  648. extern Model* modelFreeVerb;

  649. extern Model* modelSum8;

  650. extern Model* modelSum8mk2;

  651. extern Model* modelSum8mk3;

  652. extern Model* modelSH8;

  653. extern Model* modelConstants;

  654. extern Model* modelCounter;

  655. extern Model* modelTrigDelay;

  656. extern Model* modelBPMdetect;

  657. extern Model* modelVoltMeter;

  658. extern Model* modelOctaFlop;

  659. extern Model* modelOctaTrig;

  660. extern Model* modelOctaSwitch;

  661. extern Model* modelTrigSwitch;

  662. extern Model* modelTrigSwitch2;

  663. extern Model* modelTrigSwitch3;

  664. extern Model* modelTrigSwitch3_2;

  665. extern Model* modelOctaPlus;

  666. extern Model* modelOctaTimes;

  667. extern Model* modelCloner;

  668. extern Model* modelPolySplitter;

  669. extern Model* modelArpeggiator;

  670. #undef modelQuantizer

  671. #undef modelSH8

  672. 

  673. // MockbaModular

  674. #define modelBlank modelMockbaModularBlank

  675. #define modelComparator modelMockbaModularComparator

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

  677. #undef modelBlank

  678. #undef modelComparator

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

  680. #undef min

  681. #undef max

  682. #define saveBack ignoreMockbaModular1

  683. #define loadBack ignoreMockbaModular2

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

  685. #undef saveBack

  686. #undef loadBack

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

  688. 

  689. // Mog

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

  691. 

  692. // mscHack

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

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

  695. */

  696. extern Model* modelCompressor;

  697. extern Model* modelSynthDrums;

  698. extern Model* modelSEQ_6x32x16;

  699. extern Model* modelMasterClockx8;

  700. extern Model* modelMasterClockx4;

  701. extern Model* modelSEQ_Envelope_8;

  702. extern Model* modelSeq_Triad2;

  703. extern Model* modelARP700;

  704. extern Model* modelMix_24_4_4;

  705. extern Model* modelMix_16_4_4;

  706. extern Model* modelMix_9_3_4;

  707. extern Model* modelMix_4_0_4;

  708. extern Model* modelASAF8;

  709. extern Model* modelPingPong;

  710. extern Model* modelStepDelay;

  711. extern Model* modelOsc_3Ch;

  712. extern Model* modelDronez;

  713. extern Model* modelMorze;

  714. extern Model* modelWindz;

  715. extern Model* modelLorenz;

  716. extern Model* modelAlienz;

  717. extern Model* modelOSC_WaveMorph_3;

  718. extern Model* modelMaude_221;

  719. 

  720. // MSM

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

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

  723. */

  724. #define modelADSR modelMSMADSR

  725. #define modelBlankPanel modelMSMBlankPanel

  726. #define modelDelay modelMSMDelay

  727. #define modelLFO modelMSMLFO

  728. #define modelMult modelMSMMult

  729. #define modelNoise modelMSMNoise

  730. #define modelVCA modelMSMVCA

  731. #define modelVCO modelMSMVCO

  732. extern Model* modelVCO;

  733. extern Model* modelBVCO;

  734. extern Model* modelExperimentalVCO;

  735. extern Model* modelNoise;

  736. extern Model* modelLFO;

  737. extern Model* modelVCA;

  738. extern Model* modelADSR;

  739. extern Model* modelDelay;

  740. extern Model* modelWaveShaper;

  741. extern Model* modelWavefolder;

  742. extern Model* modelBitcrusher;

  743. extern Model* modelPhaserModule;

  744. extern Model* modelMorpher;

  745. extern Model* modelRingMod;

  746. extern Model* modelRandomSource;

  747. extern Model* modelMult;

  748. extern Model* modelCrazyMult;

  749. extern Model* modelFade;

  750. extern Model* modelSimpleSlider;

  751. extern Model* modelxseq;

  752. extern Model* modelBlankPanel;

  753. #undef modelADSR

  754. #undef modelBlankPanel

  755. #undef modelDelay

  756. #undef modelLFO

  757. #undef modelMult

  758. #undef modelNoise

  759. #undef modelVCA

  760. #undef modelVCO

  761. 

  762. // myth-modules

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

  764. 

  765. // Nonlinear Circuits

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

  767. 

  768. // Orbits

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

  770. 

  771. // ParableInstruments

  772. #define modelClouds modelParableClouds

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

  774. #undef modelClouds

  775. 

  776. // Path Set

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

  778. 

  779. // PdArray

  780. #define TextBox PdArrayTextBox

  781. #define CustomTrimpot PdArrayCustomTrimpot

  782. #define MsDisplayWidget PdArrayMsDisplayWidget

  783. #define MAX_POLY_CHANNELS PDARRAY_MAX_POLY_CHANNELS

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

  785. #undef Textbox

  786. #undef CustomTrimpot

  787. #undef MsDisplayWidget

  788. #undef MAX_POLY_CHANNELS

  789. 

  790. // PinkTrombone

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

  792. 

  793. // Prism

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

  795. 

  796. // rackwindows

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

  798. 

  799. // RebelTech

  800. #define BefacoInputPort BefacoInputPortRebelTech

  801. #define BefacoOutputPort BefacoOutputPortRebelTech

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

  803. #undef BefacoInputPort

  804. #undef BefacoOutputPort

  805. ModuleTheme defaultPanelTheme = DARK_THEME;

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

  807. 

  808. // repelzen

  809. #define modelBlank modelrepelzenBlank

  810. #define modelMixer modelrepelzenMixer

  811. #define modelWerner modelrepelzenWerner

  812. #define tanh_pade repelzentanh_pade

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

  814. #undef modelBlank

  815. #undef modelMixer

  816. #undef modelWerner

  817. #undef tanh_pade

  818. 

  819. // Sapphire

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

  821. 

  822. // sonusmodular

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

  824. 

  825. // Starling Via

  826. #define modelScanner modelStarlingViaScanner

  827. #define Scale starlingViaScale

  828. #define Wavetable starlingViaWavetable

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

  830. #undef modelScanner

  831. #undef Scale

  832. #undef Wavetable

  833. 

  834. // stocaudio

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

  836. 

  837. // stoermelder-packone

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

  839. Model* modelAudioInterface64;

  840. Model* modelMidiCat;

  841. Model* modelMidiCatCtx;

  842. Model* modelMidiCatMem;

  843. Model* modelMidiKey;

  844. Model* modelMidiMon;

  845. Model* modelMidiPlug;

  846. Model* modelMidiStep;

  847. StoermelderSettings pluginSettings;

  848. void StoermelderSettings::saveToJson() {}

  849. void StoermelderSettings::readFromJson() {}

  850. 

  851. // surgext

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

  853. void surgext_rack_initialize();

  854. void surgext_rack_update_theme();

  855. 

  856. // unless_modules

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

  858. 

  859. // ValleyAudio

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

  861. 

  862. // Voxglitch

  863. #define modelLooper modelVoxglitchLooper

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

  865. #undef modelLooper

  866. 

  867. // WhatTheRack

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

  869. 

  870. // ZetaCarinaeModules

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

  872. 

  873. // ZZC

  874. #define DISPLAYS_H

  875. #define ZZC_SHARED_H

  876. #define ZZC_WIDGETS_H

  877. #define modelClock modelZZCClock

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

  879. #undef modelClock

  880. 

  881. // known terminal modules

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

  883. 

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

  885. int loadConsoleType() { return 0; }

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

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

  888. int loadDirectOutMode() { return 0; }

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

  890. void saveConsoleType(int) {}

  891. void saveDarkAsDefault(bool) {}

  892. void saveDefaultTheme(ModuleTheme) {}

  893. void saveDirectOutMode(bool) {}

  894. void saveHighQualityAsDefault(bool) {}

  895. void writeDefaultTheme() {}

  896. 

  897. // plugin instances

  898. Plugin* pluginInstance__Cardinal;

  899. Plugin* pluginInstance__Fundamental;

  900. // Plugin* pluginInstance__ZamAudio;

  901. Plugin* pluginInstance__21kHz;

  902. Plugin* pluginInstance__8Mode;

  903. extern Plugin* pluginInstance__AaronStatic;

  904. Plugin* pluginInstance__alefsbits;

  905. Plugin* pluginInstance__Algoritmarte;

  906. Plugin* pluginInstance__AmalgamatedHarmonics;

  907. Plugin* pluginInstance__ArableInstruments;

  908. Plugin* pluginInstance__AnimatedCircuits;

  909. Plugin* pluginInstance__Aria;

  910. Plugin* pluginInstance__AS;

  911. Plugin* pluginInstance__AudibleInstruments;

  912. extern Plugin* pluginInstance__Autinn;

  913. Plugin* pluginInstance__Axioma;

  914. Plugin* pluginInstance__Bacon;

  915. Plugin* pluginInstance__Befaco;

  916. Plugin* pluginInstance__Bidoo;

  917. Plugin* pluginInstance__Biset;

  918. Plugin* pluginInstance__BogaudioModules;

  919. Plugin* pluginInstance__CatroModulo;

  920. Plugin* pluginInstance__cf;

  921. Plugin* pluginInstance__ChowDSP;

  922. Plugin* pluginInstance__Computerscare;

  923. Plugin* pluginInstance__CVfunk;

  924. Plugin* pluginInstance__dBiz;

  925. Plugin* pluginInstance__DHE;

  926. extern Plugin* pluginInstance__DrumKit;

  927. Plugin* pluginInstance__EnigmaCurry;

  928. Plugin* pluginInstance__ESeries;

  929. Plugin* pluginInstance__ExpertSleepersEncoders;

  930. Plugin* pluginInstance__Extratone;

  931. Plugin* pluginInstance__FehlerFabrik;

  932. Plugin* pluginInstance__forsitan;

  933. Plugin* pluginInstance__GlueTheGiant;

  934. Plugin* pluginInstance__GoodSheperd;

  935. Plugin* pluginInstance__GrandeModular;

  936. Plugin* pluginInstance__H4N4;

  937. Plugin* pluginInstance__HamptonHarmonics;

  938. Plugin* pluginInstance__HetrickCV;

  939. extern Plugin* pluginInstance__ImpromptuModular;

  940. Plugin* pluginInstance__ihtsyn;

  941. Plugin* pluginInstance__JW;

  942. Plugin* pluginInstance__kocmoc;

  943. Plugin* pluginInstance__LifeFormModular;

  944. Plugin* pluginInstance__LilacLoop;

  945. Plugin* pluginInstance__LittleUtils;

  946. Plugin* pluginInstance__Lomas;

  947. Plugin* pluginInstance__Lyrae;

  948. Plugin* pluginInstance__Meander;

  949. extern Plugin* pluginInstance__MindMeld;

  950. Plugin* pluginInstance__ML;

  951. Plugin* pluginInstance__MockbaModular;

  952. Plugin* pluginInstance__Mog;

  953. extern Plugin* pluginInstance__mscHack;

  954. Plugin* pluginInstance__MSM;

  955. Plugin* pluginInstance__myth_modules;

  956. Plugin* pluginInstance__nonlinearcircuits;

  957. Plugin* pluginInstance__Orbits;

  958. Plugin* pluginInstance__ParableInstruments;

  959. Plugin* pluginInstance__PathSet;

  960. Plugin* pluginInstance__PdArray;

  961. Plugin* pluginInstance__PinkTrombone;

  962. Plugin* pluginInstance__Prism;

  963. Plugin* pluginInstance__rackwindows;

  964. Plugin* pluginInstance__RebelTech;

  965. Plugin* pluginInstance__repelzen;

  966. Plugin* pluginInstance__sapphire;

  967. Plugin* pluginInstance__sonusmodular;

  968. Plugin* pluginInstance__StarlingVia;

  969. Plugin* pluginInstance__stocaudio;

  970. extern Plugin* pluginInstance__stoermelder_p1;

  971. Plugin* pluginInstance__surgext;

  972. Plugin* pluginInstance__unless_modules;

  973. Plugin* pluginInstance__ValleyAudio;

  974. Plugin* pluginInstance__Voxglitch;

  975. Plugin* pluginInstance__WhatTheRack;

  976. Plugin* pluginInstance__ZetaCarinaeModules;

  977. Plugin* pluginInstance__ZZC;

  978. 

  979. namespace rack {

  980. 

  981. namespace asset {

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

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

  984. }

  985. 

  986. namespace plugin {

  987. 

  988. struct StaticPluginLoader {

  989.     Plugin* const plugin;

  990.     FILE* file;

  991.     json_t* rootJ;

  992. 

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

  994.         : plugin(p),

  995.           file(nullptr),

  996.           rootJ(nullptr)

  997.     {

  998. #ifdef DEBUG

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

  1000. #endif

  1001. 

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

  1003. 

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

  1005. 

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

  1007.         {

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

  1009.             return;

  1010.         }

  1011. 

  1012.         json_error_t error;

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

  1014.         {

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

  1016.             return;

  1017.         }

  1018. 

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

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

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

  1022.         json_decref(version);

  1023. 

  1024.         // Load manifest

  1025.         p->fromJson(rootJ);

  1026. 

  1027.         // Reject plugin if slug already exists

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

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

  1030.     }

  1031. 

  1032.     ~StaticPluginLoader()

  1033.     {

  1034.         if (rootJ != nullptr)

  1035.         {

  1036.             // Load modules manifest

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

  1038.             plugin->modulesFromJson(modulesJ);

  1039. 

  1040.             json_decref(rootJ);

  1041.             plugins.push_back(plugin);

  1042.         }

  1043. 

  1044.         if (file != nullptr)

  1045.             std::fclose(file);

  1046.     }

  1047. 

  1048.     bool ok() const noexcept

  1049.     {

  1050.         return rootJ != nullptr;

  1051.     }

  1052. 

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

  1054.     {

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

  1056.         DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);

  1057. 

  1058.         size_t i;

  1059.         json_t* v;

  1060.         json_array_foreach(modules, i, v)

  1061.         {

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

  1063.             {

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

  1065.                 {

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

  1067.                     {

  1068.                         json_array_remove(modules, i);

  1069.                         break;

  1070.                     }

  1071.                 }

  1072.             }

  1073.         }

  1074.     }

  1075. };

  1076. 

  1077. static void initStatic__Cardinal()

  1078. {

  1079.     Plugin* const p = new Plugin;

  1080.     pluginInstance__Cardinal = p;

  1081. 

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

  1083.     if (spl.ok())

  1084.     {

  1085.         p->addModel(modelAidaX);

  1086.         p->addModel(modelCardinalBlank);

  1087.         p->addModel(modelExpanderInputMIDI);

  1088.         p->addModel(modelExpanderOutputMIDI);

  1089.         p->addModel(modelHostAudio2);

  1090.         p->addModel(modelHostAudio8);

  1091.         p->addModel(modelHostCV);

  1092.         p->addModel(modelHostMIDI);

  1093.         p->addModel(modelHostMIDICC);

  1094.         p->addModel(modelHostMIDIGate);

  1095.         p->addModel(modelHostMIDIMap);

  1096.         p->addModel(modelHostParameters);

  1097.         p->addModel(modelHostParametersMap);

  1098.         p->addModel(modelHostTime);

  1099.         p->addModel(modelTextEditor);

  1100.        #ifndef DGL_USE_GLES

  1101.         p->addModel(modelGlBars);

  1102.        #else

  1103.         spl.removeModule("glBars");

  1104.        #endif

  1105.        #ifndef STATIC_BUILD

  1106.         p->addModel(modelAudioFile);

  1107.        #else

  1108.         spl.removeModule("AudioFile");

  1109.        #endif

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

  1111.         p->addModel(modelCarla);

  1112.         p->addModel(modelIldaeil);

  1113.        #else

  1114.         spl.removeModule("Carla");

  1115.         spl.removeModule("Ildaeil");

  1116.        #endif

  1117.        #ifndef HEADLESS

  1118.         p->addModel(modelSassyScope);

  1119.        #else

  1120.         spl.removeModule("SassyScope");

  1121.        #endif

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

  1123.         p->addModel(modelMPV);

  1124.        #else

  1125.         spl.removeModule("MPV");

  1126.        #endif

  1127.        #ifdef HAVE_FFTW3F

  1128.         p->addModel(modelAudioToCVPitch);

  1129.        #else

  1130.         spl.removeModule("AudioToCVPitch");

  1131.        #endif

  1132. 

  1133.         hostTerminalModels = {

  1134.             modelHostAudio2,

  1135.             modelHostAudio8,

  1136.             modelHostCV,

  1137.             modelHostMIDI,

  1138.             modelHostMIDICC,

  1139.             modelHostMIDIGate,

  1140.             modelHostMIDIMap,

  1141.             modelHostParameters,

  1142.             modelHostParametersMap,

  1143.             modelHostTime,

  1144.         };

  1145.     }

  1146. }

  1147. 

  1148. static void initStatic__Fundamental()

  1149. {

  1150.     Plugin* const p = new Plugin;

  1151.     pluginInstance__Fundamental = p;

  1152. 

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

  1154.     if (spl.ok())

  1155.     {

  1156.         p->addModel(model_8vert);

  1157.         p->addModel(modelADSR);

  1158.         p->addModel(modelDelay);

  1159.         p->addModel(modelLFO);

  1160.         p->addModel(modelLFO2);

  1161.         p->addModel(modelMerge);

  1162.         p->addModel(modelMidSide);

  1163.         p->addModel(modelMixer);

  1164.         p->addModel(modelMutes);

  1165.         p->addModel(modelNoise);

  1166.         p->addModel(modelOctave);

  1167.         p->addModel(modelPulses);

  1168.         p->addModel(modelQuantizer);

  1169.         p->addModel(modelRandom);

  1170.         p->addModel(modelScope);

  1171.         p->addModel(modelSEQ3);

  1172.         p->addModel(modelSequentialSwitch1);

  1173.         p->addModel(modelSequentialSwitch2);

  1174.         p->addModel(modelSplit);

  1175.         p->addModel(modelSum);

  1176.         p->addModel(modelVCA);

  1177.         p->addModel(modelVCA_1);

  1178.         p->addModel(modelVCF);

  1179.         p->addModel(modelVCMixer);

  1180.         p->addModel(modelVCO);

  1181.         p->addModel(modelVCO2);

  1182.     }

  1183. }

  1184. 

  1185. /*

  1186. static void initStatic__ZamAudio()

  1187. {

  1188.     Plugin* const p = new Plugin;

  1189.     pluginInstance__ZamAudio = p;

  1190. 

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

  1192.     if (spl.ok())

  1193.     {

  1194.         p->addModel(modelZamComp);

  1195.     }

  1196. }

  1197. */

  1198. 

  1199. static void initStatic__21kHz()

  1200. {

  1201.     Plugin* const p = new Plugin;

  1202.     pluginInstance__21kHz = p;

  1203. 

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

  1205.     if (spl.ok())

  1206.     {

  1207.         p->addModel(modelPalmLoop);

  1208.         p->addModel(modelD_Inf);

  1209.         p->addModel(modelTachyonEntangler);

  1210.     }

  1211. }

  1212. 

  1213. static void initStatic__8Mode()

  1214. {

  1215.     Plugin* const p = new Plugin;

  1216.     pluginInstance__8Mode = p;

  1217. 

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

  1219.     if (spl.ok())

  1220.     {

  1221.         p->addModel(modelsoftSN);

  1222.     }

  1223. }

  1224. 

  1225. static void initStatic__AaronStatic()

  1226. {

  1227.     Plugin* const p = new Plugin;

  1228.     pluginInstance__AaronStatic = p;

  1229. 

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

  1231.     if (spl.ok())

  1232.     {

  1233.         p->addModel(modelChordCV);

  1234.         p->addModel(modelScaleCV);

  1235.         p->addModel(modelRandomNoteCV);

  1236.         p->addModel(modelDiatonicCV);

  1237.     }

  1238. }

  1239. 

  1240. static void initStatic__alefsbits()

  1241. {

  1242.     Plugin* const p = new Plugin;

  1243.     pluginInstance__alefsbits = p;

  1244. 

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

  1246.     if (spl.ok())

  1247.     {

  1248. #define modelSteps modelalefsbitsSteps

  1249. #define modelLogic modelalefsbitsLogic

  1250.         p->addModel(modelSimplexandhold);

  1251.         p->addModel(modelBlank6hp);

  1252.         p->addModel(modelPolyrand);

  1253.         p->addModel(modelNoize);

  1254.         p->addModel(modelSteps);

  1255.         p->addModel(modelFibb);

  1256.         p->addModel(modelOctsclr);

  1257.         p->addModel(modelShift);

  1258.         p->addModel(modelMlt);

  1259.         p->addModel(modelMath);

  1260.         p->addModel(modelLogic);

  1261.         p->addModel(modelProbablynot);

  1262. #undef modelSteps

  1263. #undef modelLogic

  1264.     }

  1265. }

  1266. 

  1267. static void initStatic__Algoritmarte()

  1268. {

  1269.     Plugin* const p = new Plugin;

  1270.     pluginInstance__Algoritmarte = p;

  1271. 

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

  1273.     if (spl.ok())

  1274.     {

  1275.         p->addModel(modelClockkky);

  1276.         p->addModel(modelPlanetz);

  1277.         p->addModel(modelMusiFrog);

  1278.         p->addModel(modelZefiro);

  1279.         p->addModel(modelHoldMeTight);

  1280.         p->addModel(modelCyclicCA);

  1281.         p->addModel(modelMusiMath);

  1282.     }

  1283. }

  1284. 

  1285. static void initStatic__AmalgamatedHarmonics()

  1286. {

  1287.     Plugin* const p = new Plugin;

  1288.     pluginInstance__AmalgamatedHarmonics = p;

  1289. 

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

  1291.     if (spl.ok())

  1292.     {

  1293.         p->addModel(modelArp31);

  1294.         p->addModel(modelArp32);

  1295.         p->addModel(modelBombe);

  1296.         p->addModel(modelChord);

  1297.         p->addModel(modelCircle);

  1298.         p->addModel(modelGalaxy);

  1299.         p->addModel(modelGenerative);

  1300.         p->addModel(modelImp);

  1301.         p->addModel(modelImperfect2);

  1302.         p->addModel(modelProgress2);

  1303.         p->addModel(modelRuckus);

  1304.         p->addModel(modelScaleQuantizer2);

  1305.         p->addModel(modelSLN);

  1306.         p->addModel(modelMuxDeMux);

  1307.         p->addModel(modelPolyProbe);

  1308.         p->addModel(modelPolyScope);

  1309.         p->addModel(modelPolyUtils);

  1310.         p->addModel(modelPolyVolt);

  1311.         p->addModel(modelScaleQuantizer);

  1312.         p->addModel(modelArpeggiator2);

  1313.         p->addModel(modelProgress);

  1314.     }

  1315. }

  1316. 

  1317. static void initStatic__AnimatedCircuits()

  1318. {

  1319.     Plugin* const p = new Plugin;

  1320.     pluginInstance__AnimatedCircuits = p;

  1321. 

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

  1323.     if (spl.ok())

  1324.     {

  1325.         p->addModel(model_AC_Folding);

  1326.         p->addModel(model_AC_LFold);

  1327.     }

  1328. }

  1329. 

  1330. static void initStatic__ArableInstruments()

  1331. {

  1332.     Plugin* const p = new Plugin;

  1333.     pluginInstance__ArableInstruments = p;

  1334. 

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

  1336.     if (spl.ok())

  1337.     {

  1338. #define modelClouds modelArableClouds

  1339.         p->addModel(modelClouds);

  1340. #undef modelClouds

  1341.     }

  1342. }

  1343. 

  1344. static void initStatic__Aria()

  1345. {

  1346.     Plugin* const p = new Plugin;

  1347.     pluginInstance__Aria = p;

  1348. 

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

  1350.     if (spl.ok())

  1351.     {

  1352. #define modelBlank modelAriaBlank

  1353.         p->addModel(modelSplort);

  1354.         p->addModel(modelSmerge);

  1355.         p->addModel(modelSpleet);

  1356.         p->addModel(modelSwerge);

  1357.         p->addModel(modelSplirge);

  1358.         p->addModel(modelQqqq);

  1359.         p->addModel(modelQuack);

  1360.         p->addModel(modelQ);

  1361.         p->addModel(modelQuale);

  1362.         p->addModel(modelDarius);

  1363.         p->addModel(modelSolomon4);

  1364.         p->addModel(modelSolomon8);

  1365.         p->addModel(modelSolomon16);

  1366.         p->addModel(modelPsychopump);

  1367.         p->addModel(modelPokies4);

  1368.         p->addModel(modelGrabby);

  1369.         p->addModel(modelRotatoes4);

  1370.         p->addModel(modelUndular);

  1371.         p->addModel(modelBlank);

  1372. #undef modelBlank

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

  1374.         spl.removeModule("Arcane");

  1375.         spl.removeModule("Atout");

  1376.         spl.removeModule("Aleister");

  1377.     }

  1378. }

  1379. 

  1380. static void initStatic__AS()

  1381. {

  1382.     Plugin* const p = new Plugin;

  1383.     pluginInstance__AS = p;

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

  1385.     if (spl.ok())

  1386.     {

  1387. #define modelADSR modelASADSR

  1388. #define modelVCA modelASVCA

  1389. #define modelWaveShaper modelASWaveShaper

  1390.         //OSCILLATORS

  1391.         p->addModel(modelSineOsc);

  1392.         p->addModel(modelSawOsc);

  1393.         //TOOLS

  1394.         p->addModel(modelADSR);

  1395.         p->addModel(modelVCA);

  1396.         p->addModel(modelQuadVCA);

  1397.         p->addModel(modelTriLFO);

  1398.         p->addModel(modelAtNuVrTr);

  1399.         p->addModel(modelBPMClock);

  1400.         p->addModel(modelSEQ16);

  1401.         p->addModel(modelMixer2ch);

  1402.         p->addModel(modelMixer4ch);

  1403.         p->addModel(modelMixer8ch);

  1404.         p->addModel(modelMonoVUmeter);

  1405.         p->addModel(modelStereoVUmeter);

  1406.         p->addModel(modelMultiple2_5);

  1407.         p->addModel(modelMerge2_5);

  1408.         p->addModel(modelSteps);

  1409.         p->addModel(modelLaunchGate);

  1410.         p->addModel(modelKillGate);

  1411.         p->addModel(modelFlow);

  1412.         p->addModel(modelSignalDelay);

  1413.         p->addModel(modelTriggersMKI);

  1414.         p->addModel(modelTriggersMKII);

  1415.         p->addModel(modelTriggersMKIII);

  1416.         p->addModel(modelBPMCalc);

  1417.         p->addModel(modelBPMCalc2);

  1418.         p->addModel(modelCv2T);

  1419.         p->addModel(modelZeroCV2T);

  1420.         p->addModel(modelReScale);

  1421.         //EFFECTS

  1422.         p->addModel(modelDelayPlusFx);

  1423.         p->addModel(modelDelayPlusStereoFx);

  1424.         p->addModel(modelPhaserFx);

  1425.         p->addModel(modelReverbFx);

  1426.         p->addModel(modelReverbStereoFx);

  1427.         p->addModel(modelSuperDriveFx);

  1428.         p->addModel(modelSuperDriveStereoFx);

  1429.         p->addModel(modelTremoloFx);

  1430.         p->addModel(modelTremoloStereoFx);

  1431.         p->addModel(modelWaveShaper);

  1432.         p->addModel(modelWaveShaperStereo);

  1433.         //BLANK PANELS

  1434.         p->addModel(modelBlankPanel4);

  1435.         p->addModel(modelBlankPanel6);

  1436.         p->addModel(modelBlankPanel8);

  1437.         p->addModel(modelBlankPanelSpecial);

  1438. #undef modelADSR

  1439. #undef modelVCA

  1440. #undef modelWaveShaper

  1441.     }

  1442. }

  1443. 

  1444. static void initStatic__AudibleInstruments()

  1445. {

  1446.     Plugin* const p = new Plugin;

  1447.     pluginInstance__AudibleInstruments = p;

  1448. 

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

  1450.     if (spl.ok())

  1451.     {

  1452.         p->addModel(modelBraids);

  1453.         p->addModel(modelPlaits);

  1454.         p->addModel(modelElements);

  1455.         p->addModel(modelTides);

  1456.         p->addModel(modelTides2);

  1457.         p->addModel(modelClouds);

  1458.         p->addModel(modelWarps);

  1459.         p->addModel(modelRings);

  1460.         p->addModel(modelLinks);

  1461.         p->addModel(modelKinks);

  1462.         p->addModel(modelShades);

  1463.         p->addModel(modelBranches);

  1464.         p->addModel(modelBlinds);

  1465.         p->addModel(modelVeils);

  1466.         p->addModel(modelFrames);

  1467.         p->addModel(modelMarbles);

  1468.         p->addModel(modelStages);

  1469.         p->addModel(modelRipples);

  1470.         p->addModel(modelShelves);

  1471.         p->addModel(modelStreams);

  1472.     }

  1473. }

  1474. 

  1475. static void initStatic__Autinn()

  1476. {

  1477.     Plugin* const p = new Plugin;

  1478.     pluginInstance__Autinn = p;

  1479. 

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

  1481.     if (spl.ok())

  1482.     {

  1483. #define modelChord modelAutinnChord

  1484. #define modelVibrato modelAutinnVibrato

  1485.         p->addModel(modelAmp);

  1486.         p->addModel(modelDeadband);

  1487.         p->addModel(modelBass);

  1488.         p->addModel(modelCVConverter);

  1489.         p->addModel(modelDC);

  1490.         p->addModel(modelDigi);

  1491.         p->addModel(modelFlopper);

  1492.         p->addModel(modelFlora);

  1493.         p->addModel(modelJette);

  1494.         p->addModel(modelBoomerang);

  1495.         p->addModel(modelOxcart);

  1496.         p->addModel(modelSaw);

  1497.         p->addModel(modelSjip);

  1498.         p->addModel(modelSquare);

  1499.         p->addModel(modelVibrato);

  1500.         p->addModel(modelVectorDriver);

  1501.         p->addModel(modelZod);

  1502.         p->addModel(modelTriBand);

  1503.         p->addModel(modelMixer6);

  1504.         p->addModel(modelNon);

  1505.         p->addModel(modelFil);

  1506.         p->addModel(modelNap);

  1507.         p->addModel(modelMelody);

  1508.         p->addModel(modelChord);

  1509. #undef modelChord

  1510. #undef modelVibrato

  1511.     }

  1512. }

  1513. 

  1514. static void initStatic__Axioma()

  1515. {

  1516.     Plugin* const p = new Plugin;

  1517.     pluginInstance__Axioma = p;

  1518. 

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

  1520.     if (spl.ok())

  1521.     {

  1522.         p->addModel(modelTheBifurcator);

  1523.         p->addModel(modelTesseract);

  1524.         p->addModel(modelIkeda);

  1525.         p->addModel(modelRhodonea);

  1526.     }

  1527. }

  1528. 

  1529. static void initStatic__Bacon()

  1530. {

  1531.     Plugin* const p = new Plugin;

  1532.     pluginInstance__Bacon = p;

  1533. 

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

  1535.     if (spl.ok())

  1536.     {

  1537.         p->addModel(modelHarMoNee);

  1538.         p->addModel(modelGlissinator);

  1539.         p->addModel(modelPolyGnome);

  1540.         p->addModel(modelQuantEyes);

  1541.         p->addModel(modelSampleDelay);

  1542.         p->addModel(modelChipNoise);

  1543.         p->addModel(modelChipWaves);

  1544.         p->addModel(modelChipYourWave);

  1545.         p->addModel(modelOpen303);

  1546.         p->addModel(modelKarplusStrongPoly);

  1547.         p->addModel(modelALingADing);

  1548.         p->addModel(modelBitulator);

  1549.         p->addModel(modelPolyGenerator);

  1550.         p->addModel(modelLintBuddy);

  1551.         p->addModel(modelLuckyHold);

  1552.     }

  1553. }

  1554. 

  1555. static void initStatic__Befaco()

  1556. {

  1557.     Plugin* const p = new Plugin;

  1558.     pluginInstance__Befaco = p;

  1559. 

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

  1561.     if (spl.ok())

  1562.     {

  1563. #define modelADSR modelBefacoADSR

  1564. #define modelMixer modelBefacoMixer

  1565. #define modelBurst modelBefacoBurst

  1566.         p->addModel(modelEvenVCO);

  1567.         p->addModel(modelRampage);

  1568.         p->addModel(modelABC);

  1569.         p->addModel(modelSpringReverb);

  1570.         p->addModel(modelMixer);

  1571.         p->addModel(modelSlewLimiter);

  1572.         p->addModel(modelDualAtenuverter);

  1573.         p->addModel(modelPercall);

  1574.         p->addModel(modelHexmixVCA);

  1575.         p->addModel(modelChoppingKinky);

  1576.         p->addModel(modelKickall);

  1577.         p->addModel(modelSamplingModulator);

  1578.         p->addModel(modelMorphader);

  1579.         p->addModel(modelADSR);

  1580.         p->addModel(modelSTMix);

  1581.         p->addModel(modelMuxlicer);

  1582.         p->addModel(modelMex);

  1583.         p->addModel(modelNoisePlethora);

  1584.         p->addModel(modelChannelStrip);

  1585.         p->addModel(modelPonyVCO);

  1586.         p->addModel(modelMotionMTR);

  1587.         p->addModel(modelBurst);

  1588.         p->addModel(modelVoltio);

  1589. #undef modelADSR

  1590. #undef modelMixer

  1591. #undef modelBurst

  1592.     }

  1593. }

  1594. 

  1595. static void initStatic__Bidoo()

  1596. {

  1597.     Plugin* const p = new Plugin;

  1598.     pluginInstance__Bidoo = p;

  1599. 

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

  1601.     if (spl.ok())

  1602.     {

  1603.         p->addModel(modelTOCANTE);

  1604.         p->addModel(modelLATE);

  1605.         p->addModel(modelDIKTAT);

  1606.         p->addModel(modelDTROY);

  1607.         p->addModel(modelBORDL);

  1608.         p->addModel(modelZOUMAI);

  1609.         p->addModel(modelZOUMAIExpander);

  1610.         p->addModel(modelENCORE);

  1611.         p->addModel(modelENCOREExpander);

  1612.         p->addModel(modelMU);

  1613.         p->addModel(modelCHUTE);

  1614.         p->addModel(modelLOURDE);

  1615.         p->addModel(modelDILEMO);

  1616.         p->addModel(modelLAMBDA);

  1617.         p->addModel(modelBANCAU);

  1618.         p->addModel(modelACNE);

  1619.         p->addModel(modelMS);

  1620.         p->addModel(modelDUKE);

  1621.         p->addModel(modelMOIRE);

  1622.         p->addModel(modelPILOT);

  1623.         p->addModel(modelHUITRE);

  1624.         p->addModel(modelOUAIVE);

  1625.         p->addModel(modelEDSAROS);

  1626.         p->addModel(modelPOUPRE);

  1627.         p->addModel(modelMAGMA);

  1628.         p->addModel(modelOAI);

  1629.         p->addModel(modelCANARD);

  1630.         p->addModel(modelEMILE);

  1631.         p->addModel(modelFORK);

  1632.         p->addModel(modelTIARE);

  1633.         p->addModel(modelLIMONADE);

  1634.         p->addModel(modelLIMBO);

  1635.         p->addModel(modelPERCO);

  1636.         p->addModel(modelBAFIS);

  1637.         p->addModel(modelBAR);

  1638.         p->addModel(modelMINIBAR);

  1639.         p->addModel(modelZINC);

  1640.         p->addModel(modelFREIN);

  1641.         p->addModel(modelHCTIP);

  1642.         p->addModel(modelSPORE);

  1643.         p->addModel(modelDFUZE);

  1644.         p->addModel(modelREI);

  1645.         p->addModel(modelRABBIT);

  1646.         p->addModel(modelBISTROT);

  1647.         p->addModel(modelSIGMA);

  1648.         p->addModel(modelFLAME);

  1649.         p->addModel(modelVOID);

  1650. 

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

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

  1653.         spl.removeModule("antN");

  1654.     }

  1655. }

  1656. 

  1657. static void initStatic__Biset()

  1658. {

  1659.     Plugin* const p = new Plugin;

  1660.     pluginInstance__Biset = p;

  1661. 

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

  1663.     if (spl.ok())

  1664.     {

  1665. #define modelBlank modelBisetBlank

  1666. #define modelTree modelBisetTree

  1667.         p->addModel(modelTracker);

  1668.         p->addModel(modelTrackerSynth);

  1669.         p->addModel(modelTrackerDrum);

  1670.         p->addModel(modelTrackerClock);

  1671.         p->addModel(modelTrackerPhase);

  1672.         p->addModel(modelTrackerQuant);

  1673.         p->addModel(modelTrackerState);

  1674.         p->addModel(modelTrackerControl);

  1675. 

  1676.         p->addModel(modelRegex);

  1677.         p->addModel(modelRegexCondensed);

  1678.         p->addModel(modelRegexExp);

  1679. 

  1680.         p->addModel(modelTree);

  1681.         p->addModel(modelTreeSeed);

  1682. 

  1683.         p->addModel(modelGbu);

  1684.         p->addModel(modelPkm);

  1685. 

  1686.         p->addModel(modelIgc);

  1687.         p->addModel(modelOmega3);

  1688.         p->addModel(modelOmega6);

  1689. 

  1690.         p->addModel(modelSegfault);

  1691.         p->addModel(modelBlank);

  1692. #undef modelBlank

  1693. #undef modelTree

  1694.     }

  1695. }

  1696. 

  1697. static void initStatic__BogaudioModules()

  1698. {

  1699.     Plugin* const p = new Plugin;

  1700.     pluginInstance__BogaudioModules = p;

  1701. 

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

  1703.     if (spl.ok())

  1704.     {

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

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

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

  1708. #define modelADSR modelBogaudioADSR

  1709. #define modelLFO modelBogaudioLFO

  1710. #define modelNoise modelBogaudioNoise

  1711. #define modelVCA modelBogaudioVCA

  1712. #define modelVCF modelBogaudioVCF

  1713. #define modelVCO modelBogaudioVCO

  1714.         p->addModel(modelVCO);

  1715.         p->addModel(modelLVCO);

  1716.         p->addModel(modelSine);

  1717.         p->addModel(modelPulse);

  1718.         p->addModel(modelXCO);

  1719.         p->addModel(modelAdditator);

  1720.         p->addModel(modelFMOp);

  1721.         p->addModel(modelChirp);

  1722.         p->addModel(modelLFO);

  1723.         p->addModel(modelLLFO);

  1724.         p->addModel(modelFourFO);

  1725.         p->addModel(modelEightFO);

  1726.         p->addModel(modelVCF);

  1727.         p->addModel(modelLVCF);

  1728.         p->addModel(modelFFB);

  1729.         p->addModel(modelEQ);

  1730.         p->addModel(modelEQS);

  1731.         p->addModel(modelLPG);

  1732.         p->addModel(modelLLPG);

  1733.         p->addModel(modelMegaGate);

  1734.         p->addModel(modelPEQ);

  1735.         p->addModel(modelPEQ6);

  1736.         p->addModel(modelPEQ6XF);

  1737.         p->addModel(modelPEQ14);

  1738.         p->addModel(modelPEQ14XF);

  1739.         p->addModel(modelDADSRH);

  1740.         p->addModel(modelDADSRHPlus);

  1741.         p->addModel(modelShaper);

  1742.         p->addModel(modelShaperPlus);

  1743.         p->addModel(modelAD);

  1744.         p->addModel(modelASR);

  1745.         p->addModel(modelADSR);

  1746.         p->addModel(modelVish);

  1747.         p->addModel(modelFollow);

  1748.         p->addModel(modelDGate);

  1749.         p->addModel(modelRGate);

  1750.         p->addModel(modelEdge);

  1751.         p->addModel(modelNoise);

  1752.         p->addModel(modelSampleHold);

  1753.         p->addModel(modelWalk2);

  1754.         p->addModel(modelWalk);

  1755.         p->addModel(modelMix8);

  1756.         p->addModel(modelMix8x);

  1757.         p->addModel(modelMix4);

  1758.         p->addModel(modelMix4x);

  1759.         p->addModel(modelMix2);

  1760.         p->addModel(modelMix1);

  1761.         p->addModel(modelVCM);

  1762.         p->addModel(modelMute8);

  1763.         p->addModel(modelPan);

  1764.         p->addModel(modelXFade);

  1765.         p->addModel(modelVCA);

  1766.         p->addModel(modelVCAmp);

  1767.         p->addModel(modelVelo);

  1768.         p->addModel(modelUMix);

  1769.         p->addModel(modelMumix);

  1770.         p->addModel(modelMatrix81);

  1771.         p->addModel(modelMatrix18);

  1772.         p->addModel(modelMatrix44);

  1773.         p->addModel(modelMatrix44Cvm);

  1774.         p->addModel(modelMatrix88);

  1775.         p->addModel(modelMatrix88Cv);

  1776.         p->addModel(modelMatrix88M);

  1777.         p->addModel(modelSwitch81);

  1778.         p->addModel(modelSwitch18);

  1779.         p->addModel(modelSwitch44);

  1780.         p->addModel(modelSwitch88);

  1781.         p->addModel(modelSwitch1616);

  1782.         p->addModel(modelAMRM);

  1783.         p->addModel(modelPressor);

  1784.         p->addModel(modelClpr);

  1785.         p->addModel(modelLmtr);

  1786.         p->addModel(modelNsgt);

  1787.         p->addModel(modelCmpDist);

  1788.         p->addModel(modelOneEight);

  1789.         p->addModel(modelEightOne);

  1790.         p->addModel(modelAddrSeq);

  1791.         p->addModel(modelAddrSeqX);

  1792.         p->addModel(modelPgmr);

  1793.         p->addModel(modelPgmrX);

  1794.         p->addModel(modelVU);

  1795.         p->addModel(modelAnalyzer);

  1796.         p->addModel(modelAnalyzerXL);

  1797.         p->addModel(modelRanalyzer);

  1798.         p->addModel(modelDetune);

  1799.         p->addModel(modelStack);

  1800.         p->addModel(modelReftone);

  1801.         p->addModel(modelMono);

  1802.         p->addModel(modelArp);

  1803.         p->addModel(modelAssign);

  1804.         p->addModel(modelUnison);

  1805.         p->addModel(modelPolyCon8);

  1806.         p->addModel(modelPolyCon16);

  1807.         p->addModel(modelPolyOff8);

  1808.         p->addModel(modelPolyOff16);

  1809.         p->addModel(modelPolyMult);

  1810.         p->addModel(modelBool);

  1811.         p->addModel(modelCmp);

  1812.         p->addModel(modelCVD);

  1813.         p->addModel(modelFlipFlop);

  1814.         p->addModel(modelInv);

  1815.         p->addModel(modelManual);

  1816.         p->addModel(modelFourMan);

  1817.         p->addModel(modelMult);

  1818.         p->addModel(modelOffset);

  1819.         p->addModel(modelSlew);

  1820.         p->addModel(modelSums);

  1821.         p->addModel(modelSwitch);

  1822.         p->addModel(modelLgsw);

  1823.         p->addModel(modelBlank3);

  1824.         p->addModel(modelBlank6);

  1825. #ifdef EXPERIMENTAL

  1826.         p->addModel(modelLag);

  1827.         p->addModel(modelPEQ14XR);

  1828.         p->addModel(modelPEQ14XV);

  1829. #endif

  1830. #ifdef TEST

  1831.         p->addModel(modelTest);

  1832.         p->addModel(modelTest2);

  1833.         p->addModel(modelTestExpanderBase);

  1834.         p->addModel(modelTestExpanderExtension);

  1835.         p->addModel(modelTestGl);

  1836.         p->addModel(modelTestVCF);

  1837. #endif

  1838. #undef modelADSR

  1839. #undef modelLFO

  1840. #undef modelNoise

  1841. #undef modelVCA

  1842. #undef modelVCF

  1843. #undef modelVCO

  1844.     }

  1845. }

  1846. 

  1847. static void initStatic__CatroModulo()

  1848. {

  1849.     Plugin* const p = new Plugin;

  1850.     pluginInstance__CatroModulo = p;

  1851. 

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

  1853.     if (spl.ok())

  1854.     {

  1855.         p->addModel(modelCM1Module);

  1856.         p->addModel(modelCM2Module);

  1857.         p->addModel(modelCM3Module);

  1858.         p->addModel(modelCM4Module);

  1859.         p->addModel(modelCM5Module);

  1860.         p->addModel(modelCM6Module);

  1861.         p->addModel(modelCM7Module);

  1862.         p->addModel(modelCM8Module);

  1863.         p->addModel(modelCM9Module);

  1864.         p->addModel(modelCM10Module);

  1865.     }

  1866. }

  1867. 

  1868. static void initStatic__cf()

  1869. {

  1870.     Plugin* const p = new Plugin;

  1871.     pluginInstance__cf = p;

  1872. 

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

  1874.     if (spl.ok())

  1875.     {

  1876.         p->addModel(modelMETRO);

  1877.         p->addModel(modelEACH);

  1878.         p->addModel(modeltrSEQ);

  1879.         p->addModel(modelLEDSEQ);

  1880.         p->addModel(modelL3DS3Q);

  1881.         p->addModel(modelSLIDERSEQ);

  1882.         p->addModel(modelPLAYER);

  1883.         p->addModel(modelPLAY);

  1884.         p->addModel(modelMONO);

  1885.         p->addModel(modelSTEREO);

  1886.         p->addModel(modelSUB);

  1887.         p->addModel(modelMASTER);

  1888.         p->addModel(modelVARIABLE);

  1889.         p->addModel(modelALGEBRA);

  1890.         p->addModel(modelFUNKTION);

  1891.         p->addModel(modelCHOKE);

  1892.         p->addModel(modelFOUR);

  1893.         p->addModel(modelSTEPS);

  1894.         p->addModel(modelPEAK);

  1895.         p->addModel(modelCUTS);

  1896.         p->addModel(modelBUFFER);

  1897.         p->addModel(modelDISTO);

  1898.         p->addModel(modelCUBE);

  1899.         p->addModel(modelPATCH);

  1900.         p->addModel(modelLABEL);

  1901.         p->addModel(modelDAVE);

  1902.     }

  1903. }

  1904. 

  1905. static void initStatic__ChowDSP()

  1906. {

  1907.     Plugin* const p = new Plugin;

  1908.     pluginInstance__ChowDSP = p;

  1909. 

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

  1911.     if (spl.ok())

  1912.     {

  1913.         p->addModel(modelChowTape);

  1914.         p->addModel(modelChowPhaserFeedback);

  1915.         p->addModel(modelChowPhaserMod);

  1916.         p->addModel(modelChowFDN);

  1917.         p->addModel(modelChowRNN);

  1918.         p->addModel(modelChowModal);

  1919.         p->addModel(modelChowDer);

  1920.         p->addModel(modelWarp);

  1921.         p->addModel(modelWerner);

  1922.         p->addModel(modelCredit);

  1923.         p->addModel(modelChowPulse);

  1924.         p->addModel(modelChowTapeCompression);

  1925.         p->addModel(modelChowTapeChew);

  1926.         p->addModel(modelChowTapeDegrade);

  1927.         p->addModel(modelChowTapeLoss);

  1928.         p->addModel(modelChowChorus);

  1929.     }

  1930. }

  1931. 

  1932. static void initStatic__Computerscare()

  1933. {

  1934.     Plugin* const p = new Plugin;

  1935.     pluginInstance__Computerscare = p;

  1936. 

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

  1938.     if (spl.ok())

  1939.     {

  1940.     	p->addModel(modelComputerscarePatchSequencer);

  1941.         p->addModel(modelComputerscareDebug);

  1942.         p->addModel(modelComputerscareLaundrySoup);

  1943.         p->addModel(modelComputerscareILoveCookies);

  1944.         p->addModel(modelComputerscareOhPeas);

  1945.         p->addModel(modelComputerscareHorseADoodleDoo);

  1946.         p->addModel(modelComputerscareKnolyPobs);

  1947.         p->addModel(modelComputerscareBolyPuttons);

  1948.         p->addModel(modelComputerscareRolyPouter);

  1949.         p->addModel(modelComputerscareSolyPequencer);

  1950.         p->addModel(modelComputerscareTolyPools);

  1951.         p->addModel(modelComputerscareMolyPatrix);

  1952.         p->addModel(modelComputerscareGolyPenerator);

  1953.         p->addModel(modelComputerscareFolyPace);

  1954.         p->addModel(modelComputerscareStolyFickPigure);

  1955.         p->addModel(modelComputerscareBlank);

  1956.         p->addModel(modelComputerscareBlankExpander);

  1957.     }

  1958. }

  1959. 

  1960. static void initStatic__CVfunk()

  1961. {

  1962.     Plugin* const p = new Plugin;

  1963.     pluginInstance__CVfunk = p;

  1964. 

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

  1966.     if (spl.ok())

  1967.     {

  1968. #define modelSteps modelCVfunkSteps

  1969. 		p->addModel(modelSteps);

  1970. 		p->addModel(modelEnvelopeArray);

  1971. 		p->addModel(modelPentaSequencer);

  1972. 		p->addModel(modelImpulseController);

  1973. 		p->addModel(modelSignals);

  1974. 		p->addModel(modelRanges);

  1975. 		p->addModel(modelHexMod);

  1976. 		p->addModel(modelCollatz);

  1977. 		p->addModel(modelStrings);

  1978. 		p->addModel(modelMagnets);

  1979. 		p->addModel(modelOuros);

  1980. 		p->addModel(modelPressedDuck);

  1981. 		p->addModel(modelFlowerPatch);

  1982. #undef modelSteps

  1983.     }

  1984. }

  1985. 

  1986. static void initStatic__dBiz()

  1987. {

  1988.     Plugin* const p = new Plugin;

  1989.     pluginInstance__dBiz = p;

  1990. 

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

  1992.     if (spl.ok())

  1993.     {

  1994. #define modelChord modeldBizChord

  1995. #define modelDivider modeldBizDivider

  1996. #define modelFourSeq modeldBizFourSeq

  1997. #define modelVCA4 modeldBizVCA4

  1998.         p->addModel(modelNavControl);

  1999.         p->addModel(modelBench);

  2000.         p->addModel(modelContorno);

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

  2002.         p->addModel(modelTranspose);

  2003.         p->addModel(modelUtility);

  2004.         p->addModel(modelChord);

  2005.         p->addModel(modelBene);

  2006.         p->addModel(modelBenePads);

  2007.         p->addModel(modelPerfMixer);

  2008.         p->addModel(modelDrMix);

  2009.         p->addModel(modelPerfMixer4);

  2010.         p->addModel(modelVCA4);

  2011.         p->addModel(modelVCA530);

  2012.         p->addModel(modelRemix);

  2013.         p->addModel(modelSmixer);

  2014.         p->addModel(modelVerbo);

  2015.         p->addModel(modelDVCO);

  2016.         p->addModel(modelDAOSC);

  2017.         p->addModel(modelTROSC);

  2018.         p->addModel(modelTROSCMK2);

  2019.         p->addModel(modelSuHa);

  2020.         p->addModel(modelSuHaMK2);

  2021.         p->addModel(modelFourSeq);

  2022.         p->addModel(modelDivider);

  2023.         p->addModel(modelUtil2);

  2024.         p->addModel(modelSmorph);

  2025.         p->addModel(modelBigSmorph);

  2026.         p->addModel(modelSPan);

  2027.         p->addModel(modelQuePasa);

  2028.         p->addModel(modelDualFilter);

  2029.         p->addModel(modelOrder);

  2030.         p->addModel(modelDualMatrix);

  2031. #undef modelChord

  2032. #undef modelDivider

  2033. #undef modelFourSeq

  2034. #undef modelVCA4

  2035.     }

  2036. }

  2037. 

  2038. static void initStatic__DHE()

  2039. {

  2040.     Plugin* const p = new Plugin;

  2041.     pluginInstance__DHE = p;

  2042. 

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

  2044.     if (spl.ok())

  2045.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  2061.     }

  2062. }

  2063. 

  2064. static void initStatic__DrumKit()

  2065. {

  2066.     Plugin* const p = new Plugin;

  2067.     pluginInstance__DrumKit = p;

  2068. 

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

  2070.     if (spl.ok())

  2071.     {

  2072.         setupSamples();

  2073.         p->addModel(modelBD9);

  2074.         p->addModel(modelSnare);

  2075.         p->addModel(modelClosedHH);

  2076.         p->addModel(modelOpenHH);

  2077.         p->addModel(modelDMX);

  2078.         p->addModel(modelCR78);

  2079.         p->addModel(modelSBD);

  2080.         p->addModel(modelGnome);

  2081.         p->addModel(modelSequencer);

  2082.         p->addModel(modelTomi);

  2083.         p->addModel(modelBaronial);

  2084.         p->addModel(modelMarionette);

  2085.     }

  2086. }

  2087. 

  2088. static void initStatic__EnigmaCurry()

  2089. {

  2090.     Plugin* const p = new Plugin;

  2091.     pluginInstance__EnigmaCurry = p;

  2092. 

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

  2094.     if (spl.ok())

  2095.     {

  2096. #define modelPulse modelEnigmaCurryPulse

  2097.       p->addModel(modelTransport);

  2098.       p->addModel(modelLatch);

  2099.       p->addModel(modelPulse);

  2100.       p->addModel(modelRange);

  2101. #undef modelPulse

  2102.     }

  2103. }

  2104. 

  2105. 

  2106. static void initStatic__ESeries()

  2107. {

  2108.     Plugin* const p = new Plugin;

  2109.     pluginInstance__ESeries = p;

  2110. 

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

  2112.     if (spl.ok())

  2113.     {

  2114.         p->addModel(modelE340);

  2115.     }

  2116. }

  2117. 

  2118. static void initStatic__ExpertSleepersEncoders()

  2119. {

  2120.     Plugin* const p = new Plugin;

  2121.     pluginInstance__ExpertSleepersEncoders = p;

  2122. 

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

  2124.     if (spl.ok())

  2125.     {

  2126.         p->addModel(model8GT);

  2127.         p->addModel(model8CV);

  2128.         p->addModel(modelES40);

  2129.         p->addModel(modelES5);

  2130.         p->addModel(modelSMUX);

  2131.         p->addModel(modelCalibrator);

  2132.     }

  2133. }

  2134. 

  2135. static void initStatic__Extratone()

  2136. {

  2137.     Plugin* const p = new Plugin;

  2138.     pluginInstance__Extratone = p;

  2139. 

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

  2141.     if (spl.ok())

  2142.     {

  2143.         p->addModel(modelModulo);

  2144.         p->addModel(modelMesoglea);

  2145.         p->addModel(modelMesoglea2);

  2146.         p->addModel(modelOpabinia);

  2147.         p->addModel(modelSplitterburst);

  2148.         p->addModel(modelPuzzlebox);

  2149.         p->addModel(modelDarwinism);

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

  2151.         p->addModel(modelIchneumonid);

  2152.         p->addModel(modelMeganeura);

  2153.         p->addModel(modelPureneura);

  2154.         p->addModel(modelMesohyl);

  2155.         p->addModel(modelXtrtnBlank);

  2156.     }

  2157. }

  2158. 

  2159. static void initStatic__FehlerFabrik()

  2160. {

  2161.     Plugin* const p = new Plugin;

  2162.     pluginInstance__FehlerFabrik = p;

  2163. 

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

  2165.     if (spl.ok())

  2166.     {

  2167.         p->addModel(modelPSIOP);

  2168.         p->addModel(modelPlanck);

  2169.         p->addModel(modelLuigi);

  2170.         p->addModel(modelAspect);

  2171.         p->addModel(modelMonte);

  2172.         p->addModel(modelArpanet);

  2173.         p->addModel(modelSigma);

  2174.         p->addModel(modelFax);

  2175.         p->addModel(modelRasoir);

  2176.         p->addModel(modelChi);

  2177.         p->addModel(modelNova);

  2178.         p->addModel(modelLilt);

  2179.         p->addModel(modelBotzinger);

  2180.     }

  2181. }

  2182. 

  2183. static void initStatic__forsitan()

  2184. {

  2185.     Plugin* const p = new Plugin;

  2186.     pluginInstance__forsitan = p;

  2187. 

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

  2189.     if (spl.ok())

  2190.     {

  2191.         p->addModel(alea);

  2192.         p->addModel(interea);

  2193.         p->addModel(cumuli);

  2194.         p->addModel(deinde);

  2195.         p->addModel(pavo);

  2196.     }

  2197. }

  2198. 

  2199. static void initStatic__GlueTheGiant()

  2200. {

  2201.     Plugin* const p = new Plugin;

  2202.     pluginInstance__GlueTheGiant = p;

  2203. 

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

  2205.     if (spl.ok())

  2206.     {

  2207.         p->addModel(modelGigBus);

  2208.         p->addModel(modelMiniBus);

  2209.         p->addModel(modelSchoolBus);

  2210.         p->addModel(modelMetroCityBus);

  2211.         p->addModel(modelBusDepot);

  2212.         p->addModel(modelBusRoute);

  2213.         p->addModel(modelRoad);

  2214.         p->addModel(modelEnterBus);

  2215.         p->addModel(modelExitBus);

  2216.     }

  2217. }

  2218. 

  2219. static void initStatic__GoodSheperd()

  2220. {

  2221.     Plugin* const p = new Plugin;

  2222.     pluginInstance__GoodSheperd = p;

  2223. 

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

  2225.     if (spl.ok())

  2226.     {

  2227.         p->addModel(modelHurdle);

  2228.         p->addModel(modelSEQ3st);

  2229.         p->addModel(modelStable16);

  2230.         p->addModel(modelStall);

  2231.         p->addModel(modelSwitch1);

  2232.         p->addModel(modelSeqtrol);

  2233.     }

  2234. }

  2235. 

  2236. static void initStatic__GrandeModular()

  2237. {

  2238.     Plugin* const p = new Plugin;

  2239.     pluginInstance__GrandeModular = p;

  2240. 

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

  2242.     if (spl.ok())

  2243.     {

  2244.         p->addModel(modelClip);

  2245.         p->addModel(modelCompare3);

  2246.         p->addModel(modelLFO3);

  2247.         p->addModel(modelLFO4);

  2248.         p->addModel(modelLogic);

  2249.         p->addModel(modelMerge8);

  2250.         p->addModel(modelMergeSplit4);

  2251.         p->addModel(modelMicrotonalChords);

  2252.         p->addModel(modelMicrotonalNotes);

  2253.         p->addModel(modelNoteMT);

  2254.         p->addModel(modelPeak);

  2255.         p->addModel(modelPolyMergeResplit);

  2256.         p->addModel(modelPolySplit);

  2257.         p->addModel(modelPush);

  2258.         p->addModel(modelQuant);

  2259.         p->addModel(modelQuantIntervals);

  2260.         p->addModel(modelQuantMT);

  2261.         p->addModel(modelSampleDelays);

  2262.         p->addModel(modelScale);

  2263.         p->addModel(modelSplit8);

  2264.         p->addModel(modelTails);

  2265.         p->addModel(modelTails4);

  2266.         p->addModel(modelVarSampleDelays);

  2267.         p->addModel(modelVCA3);

  2268.         p->addModel(modelVCA4);

  2269.     }

  2270. }

  2271. 

  2272. static void initStatic__H4N4()

  2273. {

  2274.     Plugin* const p = new Plugin;

  2275.     pluginInstance__H4N4 = p;

  2276. 

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

  2278.     if (spl.ok())

  2279.     {

  2280.         p->addModel(modelXenQnt);

  2281.     }

  2282. }

  2283. 

  2284. static void initStatic__HamptonHarmonics()

  2285. {

  2286.     Plugin* const p = new Plugin;

  2287.     pluginInstance__HamptonHarmonics = p;

  2288. 

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

  2290.     if (spl.ok())

  2291.     {

  2292. #define modelArp modelHamptonHarmonicsArp

  2293. #define modelProgress modelHamptonHarmonicsProgress

  2294.         p->addModel(modelArp);

  2295.         p->addModel(modelProgress);

  2296. #undef modelProgress

  2297. #undef modelArp

  2298.     }

  2299. }

  2300. 

  2301. static void initStatic__HetrickCV()

  2302. {

  2303.     Plugin* const p = new Plugin;

  2304.     pluginInstance__HetrickCV = p;

  2305. 

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

  2307.     if (spl.ok())

  2308.     {

  2309. #define modelASR modelHetrickCVASR

  2310. #define modelBlankPanel modelHetrickCVBlankPanel

  2311. #define modelFlipFlop modelHetrickCVFlipFlop

  2312. #define modelMidSide modelHetrickCVMidSide

  2313. #define modelMinMax modelHetrickCVMinMax

  2314. #define PanelBaseWidget HetrickCVPanelBaseWidget

  2315. #define InverterWidget HetrickCVInverterWidget

  2316.         p->addModel(modelTwoToFour);

  2317.         p->addModel(modelAnalogToDigital);

  2318.         p->addModel(modelASR);

  2319.         p->addModel(modelBinaryGate);

  2320.         p->addModel(modelBinaryNoise);

  2321.         p->addModel(modelBitshift);

  2322.         p->addModel(modelBlankPanel);

  2323.         p->addModel(modelBoolean3);

  2324.         p->addModel(modelChaos1Op);

  2325.         p->addModel(modelChaos2Op);

  2326.         p->addModel(modelChaos3Op);

  2327.         p->addModel(modelChaoticAttractors);

  2328.         p->addModel(modelClockedNoise);

  2329.         p->addModel(modelComparator);

  2330.         p->addModel(modelContrast);

  2331.         p->addModel(modelCrackle);

  2332.         p->addModel(modelDataCompander);

  2333.         p->addModel(modelDelta);

  2334.         p->addModel(modelDigitalToAnalog);

  2335.         p->addModel(modelDust);

  2336.         p->addModel(modelExponent);

  2337.         p->addModel(modelFBSineChaos);

  2338.         p->addModel(modelFlipFlop);

  2339.         p->addModel(modelFlipPan);

  2340.         p->addModel(modelGateDelay);

  2341.         p->addModel(modelGateJunction);

  2342.         p->addModel(modelGateJunctionExp);

  2343.         p->addModel(modelGingerbread);

  2344.         p->addModel(modelLogicCombine);

  2345.         p->addModel(modelMidSide);

  2346.         p->addModel(modelMinMax);

  2347.         p->addModel(modelPhaseDrivenSequencer);

  2348.         p->addModel(modelPhaseDrivenSequencer32);

  2349.         p->addModel(modelPhasorAnalyzer);

  2350.         p->addModel(modelPhasorBurstGen);

  2351.         p->addModel(modelPhasorDivMult);

  2352.         p->addModel(modelPhasorEuclidean);

  2353.         p->addModel(modelPhasorGates);

  2354.         p->addModel(modelPhasorGates32);

  2355.         p->addModel(modelPhasorGates64);

  2356.         p->addModel(modelPhasorGen);

  2357.         p->addModel(modelPhasorGeometry);

  2358.         p->addModel(modelPhasorHumanizer);

  2359.         p->addModel(modelPhasorMixer);

  2360.         p->addModel(modelPhasorOctature);

  2361.         p->addModel(modelPhasorQuadrature);

  2362.         p->addModel(modelPhasorRandom);

  2363.         p->addModel(modelPhasorRanger);

  2364.         p->addModel(modelPhasorReset);

  2365.         p->addModel(modelPhasorRhythmGroup);

  2366.         p->addModel(modelPhasorShape);

  2367.         p->addModel(modelPhasorShift);

  2368.         p->addModel(modelPhasorStutter);

  2369.         p->addModel(modelPhasorSubstepShape);

  2370.         p->addModel(modelPhasorSwing);

  2371.         p->addModel(modelPhasorTimetable);

  2372.         p->addModel(modelPhasorToClock);

  2373.         p->addModel(modelPhasorToLFO);

  2374.         p->addModel(modelPhasorToWaveforms);

  2375.         p->addModel(modelProbability);

  2376.         p->addModel(modelRandomGates);

  2377.         p->addModel(modelRotator);

  2378.         p->addModel(modelRungler);

  2379.         p->addModel(modelScanner);

  2380.         p->addModel(modelVectorMix);

  2381.         p->addModel(modelWaveshape);

  2382.         p->addModel(modelXYToPolar);

  2383. #undef modelASR

  2384. #undef modelBlankPanel

  2385. #undef modelFlipFlop

  2386. #undef modelMidSide

  2387. #undef modelMinMax

  2388. #undef PanelBaseWidget

  2389. #undef InverterWidget

  2390.     }

  2391. }

  2392. 

  2393. static void initStatic__ImpromptuModular()

  2394. {

  2395.     Plugin* const p = new Plugin;

  2396.     pluginInstance__ImpromptuModular = p;

  2397. 

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

  2399.     if (spl.ok())

  2400.     {

  2401.         p->addModel(modelAdaptiveQuantizer);

  2402.         p->addModel(modelBigButtonSeq);

  2403.         p->addModel(modelBigButtonSeq2);

  2404.         p->addModel(modelChordKey);

  2405.         p->addModel(modelChordKeyExpander);

  2406.         p->addModel(modelClocked);

  2407.         p->addModel(modelClockedExpander);

  2408.         p->addModel(modelClkd);

  2409.         p->addModel(modelCvPad);

  2410.         p->addModel(modelFoundry);

  2411.         p->addModel(modelFoundryExpander);

  2412.         p->addModel(modelFourView);

  2413.         p->addModel(modelGateSeq64);

  2414.         p->addModel(modelGateSeq64Expander);

  2415.         p->addModel(modelHotkey);

  2416.         p->addModel(modelPart);

  2417.         p->addModel(modelPhraseSeq16);

  2418.         p->addModel(modelPhraseSeq32);

  2419.         p->addModel(modelPhraseSeqExpander);

  2420.         p->addModel(modelProbKey);

  2421.         p->addModel(modelSemiModularSynth);

  2422.         p->addModel(modelSygen);

  2423.         p->addModel(modelTact);

  2424.         p->addModel(modelTact1);

  2425.         p->addModel(modelTactG);

  2426.         p->addModel(modelTwelveKey);

  2427.         p->addModel(modelVariations);

  2428.         p->addModel(modelWriteSeq32);

  2429.         p->addModel(modelWriteSeq64);

  2430.         p->addModel(modelBlankPanel);

  2431.     }

  2432. }

  2433. 

  2434. static void initStatic__ihtsyn()

  2435. {

  2436.     Plugin* const p = new Plugin;

  2437.     pluginInstance__ihtsyn = p;

  2438. 

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

  2440.     if (spl.ok())

  2441.     {

  2442.         p->addModel(modelPitchMangler);

  2443.         p->addModel(modelTwistedVerb);

  2444.         p->addModel(modelHiVerb);

  2445.         p->addModel(modelMVerb);

  2446.     }

  2447. }

  2448. 

  2449. static void initStatic__JW()

  2450. {

  2451.     Plugin* const p = new Plugin;

  2452.     pluginInstance__JW = p;

  2453. 

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

  2455.     if (spl.ok())

  2456.     {

  2457. #define modelQuantizer modelJWQuantizer

  2458.         p->addModel(modelAdd5);

  2459.         p->addModel(modelBouncyBalls);

  2460.         p->addModel(modelCat);

  2461.         p->addModel(modelTree);

  2462.         p->addModel(modelFullScope);

  2463.         p->addModel(modelGridSeq);

  2464.         p->addModel(modelEightSeq);

  2465.         p->addModel(modelDivSeq);

  2466.         p->addModel(modelMinMax);

  2467.         p->addModel(modelNoteSeq);

  2468.         p->addModel(modelNoteSeqFu);

  2469.         p->addModel(modelNoteSeq16);

  2470.         p->addModel(modelTrigs);

  2471.         p->addModel(modelOnePattern);

  2472.         p->addModel(modelPatterns);

  2473.         p->addModel(modelQuantizer);

  2474.         p->addModel(modelSimpleClock);

  2475.         p->addModel(modelD1v1de);

  2476.         p->addModel(modelPres1t);

  2477.         p->addModel(modelThingThing);

  2478.         p->addModel(modelWavHead);

  2479.         p->addModel(modelXYPad);

  2480.         p->addModel(modelBlankPanel1hp);

  2481.         p->addModel(modelBlankPanelSmall);

  2482.         p->addModel(modelBlankPanelMedium);

  2483.         p->addModel(modelBlankPanelLarge);

  2484.         p->addModel(modelCoolBreeze);

  2485.         p->addModel(modelPete);

  2486.        #ifndef STATIC_BUILD

  2487.         p->addModel(modelStr1ker);

  2488.        #else

  2489.         spl.removeModule("Str1ker");

  2490.        #endif

  2491. #undef modelQuantizer

  2492.     }

  2493. }

  2494. 

  2495. static void initStatic__kocmoc()

  2496. {

  2497.     Plugin* const p = new Plugin;

  2498.     pluginInstance__kocmoc= p;

  2499. 

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

  2501.     if (spl.ok())

  2502.     {

  2503.         p->addModel(modelSVF_1);

  2504.         p->addModel(modelTRG);

  2505.         p->addModel(modelLADR);

  2506.         p->addModel(modelOP);

  2507.         p->addModel(modelPHASR);

  2508.         p->addModel(modelMUL);

  2509.         p->addModel(modelSKF);

  2510.         p->addModel(modelDDLY);

  2511.     }

  2512. }

  2513. 

  2514. static void initStatic__LifeFormModular()

  2515. {

  2516.     Plugin* const p = new Plugin;

  2517.     pluginInstance__LifeFormModular= p;

  2518. 

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

  2520.     if (spl.ok())

  2521.     {

  2522.         p->addModel(modelTimeDiktat);

  2523.         p->addModel(modelSequenceModeler);

  2524.         p->addModel(modelPitchDiktat);

  2525.         p->addModel(modelPitchIntegrator);

  2526.         p->addModel(modelBurstIntegrator);

  2527.         p->addModel(modelQuadModulator);

  2528.         p->addModel(modelImpulseControl);

  2529.         p->addModel(modelQuadSteppedOffset);

  2530.         p->addModel(modelPercussiveVibration);

  2531.         p->addModel(modelQuadUtility);

  2532.         p->addModel(modelAdditiveVibration);

  2533.         p->addModel(modelComplexOsc);

  2534.         p->addModel(modelDriftgen);

  2535.     }

  2536. }

  2537. 

  2538. static void initStatic__LilacLoop()

  2539. {

  2540.     Plugin* const p = new Plugin;

  2541.     pluginInstance__LilacLoop = p;

  2542. 

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

  2544.     if (spl.ok())

  2545.     {

  2546.         p->addModel(modelLooperOne);

  2547.     }

  2548. }

  2549. 

  2550. static void initStatic__LittleUtils()

  2551. {

  2552.     Plugin* const p = new Plugin;

  2553.     pluginInstance__LittleUtils = p;

  2554. 

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

  2556.     if (spl.ok())

  2557.     {

  2558.         p->addModel(modelButtonModule);

  2559.         p->addModel(modelPulseGenerator);

  2560.         p->addModel(modelBias_Semitone);

  2561.         p->addModel(modelMulDiv);

  2562.         p->addModel(modelTeleportInModule);

  2563.         p->addModel(modelTeleportOutModule);

  2564.     }

  2565. }

  2566. 

  2567. static void initStatic__Lomas()

  2568. {

  2569.     Plugin* const p = new Plugin;

  2570.     pluginInstance__Lomas = p;

  2571. 

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

  2573.     if (spl.ok())

  2574.     {

  2575.         p->addModel(modelAdvancedSampler);

  2576.         p->addModel(modelGateSequencer);

  2577.     }

  2578. }

  2579. 

  2580. static void initStatic__Lyrae()

  2581. {

  2582.     Plugin* const p = new Plugin;

  2583.     pluginInstance__Lyrae = p;

  2584. 

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

  2586.     if (spl.ok())

  2587.     {

  2588. #define modelDelta modelLyraeDelta

  2589.         p->addModel(modelSulafat);

  2590.         p->addModel(modelGamma);

  2591.         p->addModel(modelDelta);

  2592.         p->addModel(modelVega);

  2593.         p->addModel(modelBD383238);

  2594.         p->addModel(modelZeta);

  2595. #undef modelDelta

  2596.     }

  2597. }

  2598. 

  2599. static void initStatic__Meander()

  2600. {

  2601.     Plugin* const p = new Plugin;

  2602.     pluginInstance__Meander = p;

  2603. 

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

  2605.     if (spl.ok())

  2606.     {

  2607.         // for dark theme

  2608.         panelTheme = 1;

  2609.         p->addModel(modelMeander);

  2610.     }

  2611. }

  2612. 

  2613. static void initStatic__MindMeld()

  2614. {

  2615.     Plugin* const p = new Plugin;

  2616.     pluginInstance__MindMeld = p;

  2617. 

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

  2619.     if (spl.ok())

  2620.     {

  2621.         p->addModel(modelPatchMaster);

  2622.         p->addModel(modelPatchMasterBlank);

  2623.         p->addModel(modelRouteMasterMono5to1);

  2624.         p->addModel(modelRouteMasterStereo5to1);

  2625.         p->addModel(modelRouteMasterMono1to5);

  2626.         p->addModel(modelRouteMasterStereo1to5);

  2627.         p->addModel(modelMasterChannel);

  2628.         p->addModel(modelMeld);

  2629.         p->addModel(modelUnmeld);

  2630.         p->addModel(modelMSMelder);

  2631.         p->addModel(modelEqMaster);

  2632.         p->addModel(modelEqExpander);

  2633.         p->addModel(modelBassMaster);

  2634.         p->addModel(modelBassMasterJr);

  2635.         p->addModel(modelShapeMaster);

  2636.         p->addModel(modelMixMasterJr);

  2637.         p->addModel(modelAuxExpanderJr);

  2638.         p->addModel(modelMixMaster);

  2639.         p->addModel(modelAuxExpander);

  2640.     }

  2641. }

  2642. 

  2643. static void initStatic__ML()

  2644. {

  2645.     Plugin* const p = new Plugin;

  2646.     pluginInstance__ML = p;

  2647. 

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

  2649.     if (spl.ok())

  2650.     {

  2651. #define modelQuantizer modelMLQuantizer

  2652. #define modelSH8 modelMLSH8

  2653.         p->addModel(modelQuantizer);

  2654.         p->addModel(modelQuantum);

  2655.         p->addModel(modelTrigBuf);

  2656.         p->addModel(modelSeqSwitch);

  2657.         p->addModel(modelSeqSwitch2);

  2658.         p->addModel(modelShiftRegister);

  2659.         p->addModel(modelShiftRegister2);

  2660.         p->addModel(modelFreeVerb);

  2661.         p->addModel(modelSum8);

  2662.         p->addModel(modelSum8mk2);

  2663.         p->addModel(modelSum8mk3);

  2664.         p->addModel(modelSH8);

  2665.         p->addModel(modelConstants);

  2666.         p->addModel(modelCounter);

  2667.         p->addModel(modelTrigDelay);

  2668.         p->addModel(modelBPMdetect);

  2669.         p->addModel(modelVoltMeter);

  2670.         p->addModel(modelOctaFlop);

  2671.         p->addModel(modelOctaTrig);

  2672.         p->addModel(modelOctaSwitch);

  2673.         p->addModel(modelTrigSwitch);

  2674.         p->addModel(modelTrigSwitch2);

  2675.         p->addModel(modelTrigSwitch3);

  2676.         p->addModel(modelTrigSwitch3_2);

  2677.         p->addModel(modelOctaPlus);

  2678.         p->addModel(modelOctaTimes);

  2679.         p->addModel(modelCloner);

  2680.         p->addModel(modelPolySplitter);

  2681.         p->addModel(modelArpeggiator);

  2682. #undef modelQuantizer

  2683. #undef modelSH8

  2684.     }

  2685. }

  2686. 

  2687. static void initStatic__MockbaModular()

  2688. {

  2689.     Plugin* const p = new Plugin;

  2690.     pluginInstance__MockbaModular = p;

  2691. 

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

  2693.     if (spl.ok())

  2694.     {

  2695. #define modelBlank modelMockbaModularBlank

  2696. #define modelComparator modelMockbaModularComparator

  2697.         p->addModel(modelBlank);

  2698.         p->addModel(modelFeidah);

  2699.         p->addModel(modelFeidahS);

  2700.         p->addModel(modelFiltah);

  2701.         p->addModel(modelMixah);

  2702.         p->addModel(modelMixah3);

  2703.         p->addModel(modelDividah);

  2704.         p->addModel(modelCountah);

  2705.         p->addModel(modelSelectah);

  2706.         p->addModel(modelShapah);

  2707.         p->addModel(modelHoldah);

  2708.         p->addModel(modelPannah);

  2709.         p->addModel(modelReVoltah);

  2710.         p->addModel(modelCZSaw);

  2711.         p->addModel(modelCZSquare);

  2712.         p->addModel(modelCZPulse);

  2713.         p->addModel(modelCZDblSine);

  2714.         p->addModel(modelCZSawPulse);

  2715.         p->addModel(modelCZReso1);

  2716.         p->addModel(modelCZReso2);

  2717.         p->addModel(modelCZReso3);

  2718.         p->addModel(modelCZOsc);

  2719.         p->addModel(modelMaugTriangle);

  2720.         p->addModel(modelMaugShark);

  2721.         p->addModel(modelMaugSaw);

  2722.         p->addModel(modelMaugSaw2);

  2723.         p->addModel(modelMaugSquare);

  2724.         p->addModel(modelMaugSquare2);

  2725.         p->addModel(modelMaugSquare3);

  2726.         p->addModel(modelMaugOsc);

  2727.         p->addModel(modelComparator);

  2728.         p->addModel(modelDualBUFFER);

  2729.         p->addModel(modelDualNOT);

  2730.         p->addModel(modelDualOR);

  2731.         p->addModel(modelDualNOR);

  2732.         p->addModel(modelDualAND);

  2733.         p->addModel(modelDualNAND);

  2734.         p->addModel(modelDualXOR);

  2735.         p->addModel(modelDualXNOR);

  2736.         p->addModel(modelPSelectah);

  2737. 

  2738.         // require input files to work

  2739.         spl.removeModule("UDPClockMaster");

  2740.         spl.removeModule("UDPClockSlave");

  2741. #undef modelBlank

  2742. #undef modelComparator

  2743.     }

  2744. }

  2745. 

  2746. static void initStatic__Mog()

  2747. {

  2748.     Plugin* const p = new Plugin;

  2749.     pluginInstance__Mog = p;

  2750. 

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

  2752.     if (spl.ok())

  2753.     {

  2754.         p->addModel(modelNetwork);

  2755.         p->addModel(modelNexus);

  2756.     }

  2757. }

  2758. 

  2759. static void initStatic__mscHack()

  2760. {

  2761.     Plugin* const p = new Plugin;

  2762.     pluginInstance__mscHack = p;

  2763. 

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

  2765.     if (spl.ok())

  2766.     {

  2767.         p->addModel(modelCompressor);

  2768.         p->addModel(modelSynthDrums);

  2769.         p->addModel(modelSEQ_6x32x16);

  2770.         p->addModel(modelMasterClockx4);

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

  2772.         p->addModel(modelSEQ_Envelope_8);

  2773.         p->addModel(modelSeq_Triad2);

  2774.         p->addModel(modelARP700);

  2775.         p->addModel(modelMix_4_0_4);

  2776.         p->addModel(modelMix_9_3_4);

  2777.         p->addModel(modelMix_16_4_4);

  2778.         p->addModel(modelMix_24_4_4);

  2779.         p->addModel(modelASAF8);

  2780.         p->addModel(modelPingPong);

  2781.         p->addModel(modelStepDelay);

  2782.         p->addModel(modelOsc_3Ch);

  2783.         p->addModel(modelDronez);

  2784.         p->addModel(modelMorze);

  2785.         p->addModel(modelWindz);

  2786.         p->addModel(modelLorenz);

  2787.         p->addModel(modelAlienz);

  2788.         p->addModel(modelOSC_WaveMorph_3);

  2789.         p->addModel(modelMaude_221);

  2790.     }

  2791. }

  2792. 

  2793. static void initStatic__MSM()

  2794. {

  2795.     Plugin* const p = new Plugin;

  2796.     pluginInstance__MSM = p;

  2797. 

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

  2799.     if (spl.ok())

  2800.     {

  2801. #define modelADSR modelMSMADSR

  2802. #define modelBlankPanel modelMSMBlankPanel

  2803. #define modelDelay modelMSMDelay

  2804. #define modelLFO modelMSMLFO

  2805. #define modelMult modelMSMMult

  2806. #define modelNoise modelMSMNoise

  2807. #define modelVCA modelMSMVCA

  2808. #define modelVCO modelMSMVCO

  2809.         p->addModel(modelVCO);

  2810.         p->addModel(modelBVCO);

  2811.         p->addModel(modelExperimentalVCO);

  2812.         p->addModel(modelNoise);

  2813.         p->addModel(modelLFO);

  2814.         p->addModel(modelVCA);

  2815.         p->addModel(modelADSR);

  2816.         p->addModel(modelDelay);

  2817.         p->addModel(modelWaveShaper);

  2818.         p->addModel(modelWavefolder);

  2819.         p->addModel(modelBitcrusher);

  2820.         p->addModel(modelPhaserModule);

  2821.         p->addModel(modelMorpher);

  2822.         p->addModel(modelRingMod);

  2823.         p->addModel(modelRandomSource);

  2824.         p->addModel(modelMult);

  2825.         p->addModel(modelCrazyMult);

  2826.         p->addModel(modelFade);

  2827.         p->addModel(modelSimpleSlider);

  2828.         p->addModel(modelxseq);

  2829.         p->addModel(modelBlankPanel);

  2830. #undef modelADSR

  2831. #undef modelBlankPanel

  2832. #undef modelDelay

  2833. #undef modelLFO

  2834. #undef modelMult

  2835. #undef modelNoise

  2836. #undef modelVCA

  2837. #undef modelVCO

  2838.     }

  2839. }

  2840. 

  2841. static void initStatic__myth_modules()

  2842. {

  2843.     Plugin* const p = new Plugin;

  2844.     pluginInstance__myth_modules = p;

  2845. 

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

  2847.     if (spl.ok())

  2848.     {

  2849.         p->addModel(modelMavka);

  2850.         p->addModel(modelMolphar);

  2851.     }

  2852. }

  2853. 

  2854. static void initStatic__nonlinearcircuits()

  2855. {

  2856.     Plugin* const p = new Plugin;

  2857.     pluginInstance__nonlinearcircuits = p;

  2858. 

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

  2860.     if (spl.ok())

  2861.     {

  2862.         p->addModel(model4Seq);

  2863.         p->addModel(modelCipher);

  2864.         p->addModel(modelBOOLs);

  2865.         p->addModel(modelDivideConquer);

  2866.         p->addModel(modelDivineCMOS);

  2867.         p->addModel(modelDoubleNeuron);

  2868.         p->addModel(modelGenie);

  2869.         p->addModel(modelLetsSplosh);

  2870.         p->addModel(modelNeuron);

  2871.         p->addModel(modelNumberwang);

  2872.         p->addModel(modelRouter);

  2873.         p->addModel(modelSegue);

  2874.         p->addModel(modelSlothApathy);

  2875.         p->addModel(modelSlothInertia);

  2876.         p->addModel(modelSlothTorpor);

  2877.         p->addModel(modelSquidAxon);

  2878.         p->addModel(modelStatues);

  2879.         p->addModel(modelTripleSloth);

  2880.     }

  2881. }

  2882. 

  2883. static void initStatic__Orbits()

  2884. {

  2885.     Plugin* const p = new Plugin;

  2886.     pluginInstance__Orbits = p;

  2887. 

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

  2889.     if (spl.ok())

  2890.     {

  2891.         p->addModel(modelRareBreeds_Orbits_Eugene);

  2892.         p->addModel(modelRareBreeds_Orbits_Polygene);

  2893.     }

  2894. }

  2895. 

  2896. static void initStatic__ParableInstruments()

  2897. {

  2898.     Plugin* const p = new Plugin;

  2899.     pluginInstance__ParableInstruments = p;

  2900. 

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

  2902.     if (spl.ok())

  2903.     {

  2904. #define modelClouds modelParableClouds

  2905.         p->addModel(modelClouds);

  2906. #undef modelClouds

  2907.     }

  2908. }

  2909. 

  2910. static void initStatic__PathSet()

  2911. {

  2912.     Plugin* const p = new Plugin;

  2913.     pluginInstance__PathSet = p;

  2914. 

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

  2916.     if (spl.ok())

  2917.     {

  2918.         p->addModel(modelShiftyMod);

  2919.         p->addModel(modelShiftyExpander);

  2920.         p->addModel(modelIceTray);

  2921.         p->addModel(modelAstroVibe);

  2922.         p->addModel(modelGlassPane);

  2923. 	    p->addModel(modelPlusPane);

  2924.         p->addModel(modelNudge);

  2925.         p->addModel(modelOneShot);

  2926.     }

  2927. }

  2928. 

  2929. static void initStatic__PdArray()

  2930. {

  2931.     Plugin* const p = new Plugin;

  2932.     pluginInstance__PdArray = p;

  2933. 

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

  2935.     if (spl.ok())

  2936.     {

  2937.         p->addModel(modelArray);

  2938.         p->addModel(modelMiniramp);

  2939.         p->addModel(modelMinistep);

  2940.     }

  2941. }

  2942. 

  2943. static void initStatic__PinkTrombone()

  2944. {

  2945.     Plugin* const p = new Plugin;

  2946.     pluginInstance__PinkTrombone = p;

  2947. 

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

  2949.     if (spl.ok())

  2950.     {

  2951.         p->addModel(modelPinkTrombone);

  2952.     }

  2953. }

  2954. 

  2955. static void initStatic__Prism()

  2956. {

  2957.     Plugin* const p = new Plugin;

  2958.     pluginInstance__Prism = p;

  2959. 

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

  2961.     if (spl.ok())

  2962.     {

  2963.         p->addModel(modelRainbow);

  2964.         p->addModel(modelRainbowScaleExpander);

  2965.         p->addModel(modelDroplet);

  2966.     }

  2967. }

  2968. 

  2969. static void initStatic__rackwindows()

  2970. {

  2971.     Plugin* const p = new Plugin;

  2972.     pluginInstance__rackwindows = p;

  2973. 

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

  2975.     if (spl.ok())

  2976.     {

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

  2978.         p->addModel(modelBitshiftgain);

  2979.         p->addModel(modelCapacitor);

  2980.         p->addModel(modelCapacitor_stereo);

  2981.         p->addModel(modelChorus);

  2982.         p->addModel(modelConsole);

  2983.         p->addModel(modelConsole_mm);

  2984.         p->addModel(modelDistance);

  2985.         p->addModel(modelGolem);

  2986.         p->addModel(modelHolt);

  2987.         p->addModel(modelHombre);

  2988.         p->addModel(modelInterstage);

  2989.         p->addModel(modelMonitoring);

  2990.         p->addModel(modelMv);

  2991.         p->addModel(modelRasp);

  2992.         p->addModel(modelReseq);

  2993.         p->addModel(modelTape);

  2994.         p->addModel(modelTremolo);

  2995.         p->addModel(modelVibrato);

  2996.     }

  2997. }

  2998. 

  2999. static void initStatic__RebelTech()

  3000. {

  3001.     Plugin* const p = new Plugin;

  3002.     pluginInstance__RebelTech = p;

  3003. 

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

  3005.     if (spl.ok())

  3006.     {

  3007.         p->addModel(modelStoicheia);

  3008.         p->addModel(modelTonic);

  3009.         p->addModel(modelKlasmata);

  3010.         p->addModel(modelCLK);

  3011.         p->addModel(modelLogoi);

  3012.         p->addModel(modelPhoreo);

  3013.     }

  3014. }

  3015. 

  3016. static void initStatic__repelzen()

  3017. {

  3018.     Plugin* const p = new Plugin;

  3019.     pluginInstance__repelzen = p;

  3020. 

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

  3022.     if (spl.ok())

  3023.     {

  3024. #define modelBlank modelrepelzenBlank

  3025. #define modelMixer modelrepelzenMixer

  3026. #define modelWerner modelrepelzenWerner

  3027.         p->addModel(modelBlank);

  3028.         p->addModel(modelBurst);

  3029.         p->addModel(modelFolder);

  3030.         p->addModel(modelErwin);

  3031.         p->addModel(modelWerner);

  3032.         p->addModel(modelMixer);

  3033. #undef modelBlank

  3034. #undef modelMixer

  3035. #undef modelWerner

  3036.     }

  3037. }

  3038. 

  3039. static void initStatic__Sapphire()

  3040. {

  3041.     Plugin* const p = new Plugin;

  3042.     pluginInstance__sapphire = p;

  3043. 

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

  3045.     if (spl.ok())

  3046.     {

  3047.         p->addModel(modelElastika);

  3048.         p->addModel(modelFrolic);

  3049.         p->addModel(modelGlee);

  3050.         p->addModel(modelHiss);

  3051.         p->addModel(modelMoots);

  3052.         p->addModel(modelNucleus);

  3053.         p->addModel(modelPolynucleus);

  3054.         p->addModel(modelTin);

  3055.         p->addModel(modelTout);

  3056.         p->addModel(modelTricorder);

  3057.         p->addModel(modelTubeUnit);

  3058.     }

  3059. }

  3060. 

  3061. static void initStatic__sonusmodular()

  3062. {

  3063.     Plugin* const p = new Plugin;

  3064.     pluginInstance__sonusmodular = p;

  3065. 

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

  3067.     if (spl.ok())

  3068.     {

  3069.         p->addModel(modelAddiction);

  3070.         p->addModel(modelBitter);

  3071.         p->addModel(modelBymidside);

  3072.         p->addModel(modelCampione);

  3073.         p->addModel(modelChainsaw);

  3074.         p->addModel(modelCtrl);

  3075.         p->addModel(modelDeathcrush);

  3076.         p->addModel(modelFraction);

  3077.         p->addModel(modelHarmony);

  3078.         p->addModel(modelLadrone);

  3079.         p->addModel(modelLuppolo);

  3080.         p->addModel(modelLuppolo3);

  3081.         p->addModel(modelMicromacro);

  3082.         p->addModel(modelMrcheb);

  3083.         p->addModel(modelMultimulti);

  3084.         p->addModel(modelNeurosc);

  3085.         p->addModel(modelOktagon);

  3086.         p->addModel(modelOsculum);

  3087.         p->addModel(modelParamath);

  3088.         p->addModel(modelPiconoise);

  3089.         p->addModel(modelPith);

  3090.         p->addModel(modelPusher);

  3091.         p->addModel(modelRingo);

  3092.         p->addModel(modelScramblase);

  3093.         p->addModel(modelTropicana);

  3094.         p->addModel(modelTwoff);

  3095.         p->addModel(modelYabp);

  3096.     }

  3097. }

  3098. 

  3099. static void initStatic__StarlingVia()

  3100. {

  3101.     Plugin* const p = new Plugin;

  3102.     pluginInstance__StarlingVia = p;

  3103. 

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

  3105.     if (spl.ok())

  3106.     {

  3107. #define modelScanner modelStarlingViaScanner

  3108.         p->addModel(modelMeta);

  3109.         p->addModel(modelGateseq);

  3110.         p->addModel(modelScanner);

  3111.         p->addModel(modelSync);

  3112.         p->addModel(modelAtsr);

  3113.         p->addModel(modelOsc3);

  3114.         p->addModel(modelSync3);

  3115.         p->addModel(modelSync3XL);

  3116.         p->addModel(modelSync3XLLevels);

  3117. #undef modelScanner

  3118.     }

  3119. }

  3120. 

  3121. static void initStatic__stocaudio()

  3122. {

  3123.     Plugin* const p = new Plugin;

  3124.     pluginInstance__stocaudio = p;

  3125. 

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

  3127.     if (spl.ok())

  3128.     {

  3129.         p->addModel(modelPolyturing);

  3130.         p->addModel(modelPolydelay);

  3131.         p->addModel(modelSpread);

  3132.     }

  3133. }

  3134. 

  3135. static void initStatic__stoermelder_p1()

  3136. {

  3137.     Plugin* const p = new Plugin;

  3138.     pluginInstance__stoermelder_p1 = p;

  3139. 

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

  3141.     if (spl.ok())

  3142.     {

  3143.         p->addModel(modelCVMap);

  3144.         p->addModel(modelCVMapCtx);

  3145.         p->addModel(modelCVMapMicro);

  3146.         p->addModel(modelCVPam);

  3147.         p->addModel(modelRotorA);

  3148.         p->addModel(modelReMoveLite);

  3149.         p->addModel(modelBolt);

  3150.         p->addModel(modelInfix);

  3151.         p->addModel(modelInfixMicro);

  3152.         p->addModel(modelEightFace);

  3153.         p->addModel(modelEightFaceX2);

  3154.         p->addModel(modelSipo);

  3155.         p->addModel(modelFourRounds);

  3156.         p->addModel(modelArena);

  3157.         p->addModel(modelMaze);

  3158.         p->addModel(modelHive);

  3159.         p->addModel(modelIntermix);

  3160.         p->addModel(modelIntermixGate);

  3161.         p->addModel(modelIntermixEnv);

  3162.         p->addModel(modelIntermixFade);

  3163.         p->addModel(modelSail);

  3164.         p->addModel(modelPile);

  3165.         p->addModel(modelPilePoly);

  3166.         p->addModel(modelMirror);

  3167.         p->addModel(modelAffix);

  3168.         p->addModel(modelAffixMicro);

  3169.         p->addModel(modelGrip);

  3170.         p->addModel(modelGlue);

  3171.         p->addModel(modelGoto);

  3172.         p->addModel(modelStroke);

  3173.         p->addModel(modelSpin);

  3174.         p->addModel(modelTransit);

  3175.         p->addModel(modelTransitEx);

  3176.         p->addModel(modelX4);

  3177.         p->addModel(modelMacro);

  3178.         p->addModel(modelOrbit);

  3179.         p->addModel(modelEightFaceMk2);

  3180.         p->addModel(modelEightFaceMk2Ex);

  3181.         p->addModel(modelDirt);

  3182.         p->addModel(modelMb);

  3183.         p->addModel(modelMe);

  3184.         p->addModel(modelRaw);

  3185.         p->addModel(modelStrip);

  3186.         p->addModel(modelStripBay4);

  3187.         p->addModel(modelStripPp);

  3188. 

  3189.         spl.removeModule("AudioInterface64");

  3190.         spl.removeModule("MidiCat");

  3191.         spl.removeModule("MidiCatEx");

  3192.         spl.removeModule("MidiCatCtx");

  3193.         spl.removeModule("MidiKey");

  3194.         spl.removeModule("MidiMon");

  3195.         spl.removeModule("MidiPlug");

  3196.         spl.removeModule("MidiStep");

  3197.     }

  3198. }

  3199. 

  3200. static void initStatic__surgext()

  3201. {

  3202.     Plugin* const p = new Plugin;

  3203.     pluginInstance__surgext = p;

  3204. 

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

  3206.     if (spl.ok())

  3207.     {

  3208.         p->addModel(modelVCOClassic);

  3209.         p->addModel(modelVCOModern);

  3210.         p->addModel(modelVCOWavetable);

  3211.         p->addModel(modelVCOWindow);

  3212.         p->addModel(modelVCOSine);

  3213.         p->addModel(modelVCOFM2);

  3214.         p->addModel(modelVCOFM3);

  3215.         p->addModel(modelVCOSHNoise);

  3216.         p->addModel(modelVCOAlias);

  3217.         p->addModel(modelVCOString);

  3218.         p->addModel(modelVCOTwist);

  3219. 

  3220.         // Add the ported ones

  3221.         p->addModel(modelSurgeVCF);

  3222.         p->addModel(modelSurgeDelay);

  3223.         p->addModel(modelSurgeDelayLineByFreq);

  3224.         p->addModel(modelSurgeDelayLineByFreqExpanded);

  3225.         p->addModel(modelSurgeDigitalRingMods);

  3226.         p->addModel(modelSurgeWaveshaper);

  3227.         p->addModel(modelSurgeLFO);

  3228.         p->addModel(modelSurgeMixer);

  3229.         p->addModel(modelSurgeMixerSlider);

  3230.         p->addModel(modelSurgeModMatrix);

  3231. 

  3232.         p->addModel(modelFXReverb);

  3233.         p->addModel(modelFXPhaser);

  3234.         p->addModel(modelFXRotarySpeaker);

  3235.         p->addModel(modelFXDistortion);

  3236.         p->addModel(modelFXFrequencyShifter);

  3237.         p->addModel(modelFXChorus);

  3238.         p->addModel(modelFXVocoder);

  3239.         p->addModel(modelFXReverb2);

  3240.         p->addModel(modelFXFlanger);

  3241.         p->addModel(modelFXRingMod);

  3242.         p->addModel(modelFXNeuron);

  3243.         p->addModel(modelFXResonator);

  3244.         p->addModel(modelFXChow);

  3245.         p->addModel(modelFXExciter);

  3246.         p->addModel(modelFXEnsemble);

  3247.         p->addModel(modelFXCombulator);

  3248.         p->addModel(modelFXNimbus);

  3249.         p->addModel(modelFXSpringReverb);

  3250.         p->addModel(modelFXTreeMonster);

  3251.         p->addModel(modelFXBonsai);

  3252. 

  3253.         p->addModel(modelEGxVCA);

  3254.         p->addModel(modelQuadAD);

  3255.         p->addModel(modelQuadLFO);

  3256.         p->addModel(modelUnisonHelper);

  3257.         p->addModel(modelUnisonHelperCVExpander);

  3258. 

  3259.         surgext_rack_initialize();

  3260.     }

  3261. }

  3262. 

  3263. static void initStatic__unless_modules()

  3264. {

  3265.     Plugin* const p = new Plugin;

  3266.     pluginInstance__unless_modules = p;

  3267. 

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

  3269.     if (spl.ok())

  3270.     {

  3271.         // unless_modules::init_theme();

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

  3273.         p->addModel(modelPiong);

  3274.         p->addModel(modelChainkov);

  3275.         p->addModel(modelAtoms);

  3276.         p->addModel(modelCantor);

  3277.         p->addModel(modelRoom);

  3278.         p->addModel(modelSnake);

  3279.         p->addModel(modelTowers);

  3280.         p->addModel(modelPianoid);

  3281.         p->addModel(modelPremuter);

  3282.         p->addModel(modelAvoider);

  3283.     }

  3284. }

  3285. 

  3286. static void initStatic__ValleyAudio()

  3287. {

  3288.     Plugin* const p = new Plugin;

  3289.     pluginInstance__ValleyAudio = p;

  3290. 

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

  3292.     if (spl.ok())

  3293.     {

  3294.         p->addModel(modelTopograph);

  3295.         p->addModel(modelUGraph);

  3296.         p->addModel(modelDexter);

  3297.         p->addModel(modelPlateau);

  3298.         p->addModel(modelInterzone);

  3299.         p->addModel(modelAmalgam);

  3300.         p->addModel(modelFeline);

  3301.         p->addModel(modelTerrorform);

  3302.     }

  3303. }

  3304. 

  3305. static void initStatic__Voxglitch()

  3306. {

  3307.     Plugin* p = new Plugin;

  3308.     pluginInstance__Voxglitch = p;

  3309. 

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

  3311.     if (spl.ok())

  3312.     {

  3313. #define modelLooper modelVoxglitchLooper

  3314.       p->addModel(modelAutobreak);

  3315.       p->addModel(modelByteBeat);

  3316.       p->addModel(modelDigitalProgrammer);

  3317.       p->addModel(modelDigitalSequencer);

  3318.       p->addModel(modelDigitalSequencerXP);

  3319.       p->addModel(modelGlitchSequencer);

  3320.       p->addModel(modelGhosts);

  3321.       p->addModel(modelGrainEngineMK2);

  3322.       p->addModel(modelGrainEngineMK2Expander);

  3323.       p->addModel(modelGrainFx);

  3324.       p->addModel(modelGrooveBox);

  3325.       p->addModel(modelGrooveBoxExpander);

  3326.       p->addModel(modelHazumi);

  3327.       p->addModel(modelLooper);

  3328.       p->addModel(modelRepeater);

  3329.       p->addModel(modelSamplerX8);

  3330.       p->addModel(modelSatanonaut);

  3331.       p->addModel(modelWavBank);

  3332.       p->addModel(modelWavBankMC);

  3333.       p->addModel(modelXY);

  3334. #undef modelLooper

  3335.     }

  3336. }

  3337. 

  3338. static void initStatic__WhatTheRack()

  3339. {

  3340.     Plugin* p = new Plugin;

  3341.     pluginInstance__WhatTheRack = p;

  3342. 

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

  3344.     if (spl.ok())

  3345.     {

  3346.       p->addModel(modelWhatTheRack);

  3347.       p->addModel(modelWhatTheMod);

  3348.       p->addModel(modelWhatTheJack);

  3349.     }

  3350. }

  3351. 

  3352. static void initStatic__ZetaCarinaeModules()

  3353. {

  3354.     Plugin* p = new Plugin;

  3355.     pluginInstance__ZetaCarinaeModules = p;

  3356. 

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

  3358.     if (spl.ok())

  3359.     {

  3360.         p->addModel(modelBrownianBridge);

  3361.         p->addModel(modelOrnsteinUhlenbeck);

  3362.         p->addModel(modelIOU);

  3363.         p->addModel(modelWarbler);

  3364.         p->addModel(modelRosenchance);

  3365.         p->addModel(modelGuildensTurn);

  3366.         p->addModel(modelRosslerRustler);

  3367.         p->addModel(modelFirefly);

  3368.     }

  3369. }

  3370. 

  3371. static void initStatic__ZZC()

  3372. {

  3373.     Plugin* p = new Plugin;

  3374.     pluginInstance__ZZC = p;

  3375. 

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

  3377.     if (spl.ok())

  3378.     {

  3379. #define modelClock modelZZCClock

  3380.         p->addModel(modelClock);

  3381.         p->addModel(modelDivider);

  3382.         p->addModel(modelFN3);

  3383.         p->addModel(modelSCVCA);

  3384.         p->addModel(modelSH8);

  3385.         p->addModel(modelSRC);

  3386.         p->addModel(modelDiv);

  3387.         p->addModel(modelDivExp);

  3388.         p->addModel(modelPolygate);

  3389. #undef modelClock

  3390.     }

  3391. }

  3392. 

  3393. void initStaticPlugins()

  3394. {

  3395.     initStatic__Cardinal();

  3396.     initStatic__Fundamental();

  3397.     // initStatic__ZamAudio();

  3398.     initStatic__21kHz();

  3399.     initStatic__8Mode();

  3400.     initStatic__AaronStatic();

  3401.     initStatic__alefsbits();

  3402.     initStatic__Algoritmarte();

  3403.     initStatic__AmalgamatedHarmonics();

  3404.     initStatic__AnimatedCircuits();

  3405.     initStatic__ArableInstruments();

  3406.     initStatic__Aria();

  3407.     initStatic__AS();

  3408.     initStatic__AudibleInstruments();

  3409.     initStatic__Autinn();

  3410.     initStatic__Axioma();

  3411.     initStatic__Bacon();

  3412.     initStatic__Befaco();

  3413.     initStatic__Bidoo();

  3414.     initStatic__Biset();

  3415.     initStatic__BogaudioModules();

  3416.     initStatic__CatroModulo();

  3417.     initStatic__cf();

  3418.     initStatic__ChowDSP();

  3419.     initStatic__Computerscare();

  3420.     initStatic__CVfunk();

  3421.     initStatic__dBiz();

  3422.     initStatic__DHE();

  3423.     initStatic__DrumKit();

  3424.     initStatic__EnigmaCurry();

  3425.     initStatic__ESeries();

  3426.     initStatic__ExpertSleepersEncoders();

  3427.     initStatic__Extratone();

  3428.     initStatic__FehlerFabrik();

  3429.     initStatic__forsitan();

  3430.     initStatic__GlueTheGiant();

  3431.     initStatic__GoodSheperd();

  3432.     initStatic__GrandeModular();

  3433.     initStatic__H4N4();

  3434.     initStatic__HamptonHarmonics();

  3435.     initStatic__HetrickCV();

  3436.     initStatic__ImpromptuModular();

  3437.     initStatic__ihtsyn();

  3438.     initStatic__JW();

  3439.     initStatic__kocmoc();

  3440.     initStatic__LifeFormModular();

  3441.     initStatic__LilacLoop();

  3442.     initStatic__LittleUtils();

  3443.     initStatic__Lomas();

  3444.     initStatic__Lyrae();

  3445.     initStatic__Meander();

  3446.     initStatic__MindMeld();

  3447.     initStatic__ML();

  3448.     initStatic__MockbaModular();

  3449.     initStatic__Mog();

  3450.     initStatic__mscHack();

  3451.     initStatic__MSM();

  3452.     initStatic__myth_modules();

  3453.     initStatic__nonlinearcircuits();

  3454.     initStatic__Orbits();

  3455.     initStatic__ParableInstruments();

  3456.     initStatic__PathSet();

  3457.     initStatic__PdArray();

  3458.     initStatic__PinkTrombone();

  3459.     initStatic__Prism();

  3460.     initStatic__rackwindows();

  3461.     initStatic__RebelTech();

  3462.     initStatic__repelzen();

  3463.     initStatic__Sapphire();

  3464.     initStatic__sonusmodular();

  3465.     initStatic__StarlingVia();

  3466.     initStatic__stocaudio();

  3467.     initStatic__stoermelder_p1();

  3468.     initStatic__surgext();

  3469.     initStatic__unless_modules();

  3470.     initStatic__ValleyAudio();

  3471.     initStatic__Voxglitch();

  3472.     initStatic__WhatTheRack();

  3473.     initStatic__ZetaCarinaeModules();

  3474.     initStatic__ZZC();

  3475. }

  3476. 

  3477. void destroyStaticPlugins()

  3478. {

  3479.     for (Plugin* p : plugins)

  3480.         delete p;

  3481.     plugins.clear();

  3482. }

  3483. 

  3484. void updateStaticPluginsDarkMode()

  3485. {

  3486.     const bool darkMode = settings::preferDarkPanels;

  3487.     // bogaudio

  3488.     {

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

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

  3491. 

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

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

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

  3495.         }

  3496.     }

  3497.     // meander

  3498.     {

  3499.         panelTheme = darkMode ? 1 : 0;

  3500.     }

  3501.     // glue the giant

  3502.     {

  3503.         gtg_default_theme = darkMode ? 1 : 0;

  3504.     }

  3505.     // surgext

  3506.     {

  3507.         surgext_rack_update_theme();

  3508.     }

  3509. }

  3510. 

  3511. }

  3512. }