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

3204 lines
86KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

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

  4.  *

  5.  * This program is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU General Public License as

  7.  * published by the Free Software Foundation; either version 3 of

  8.  * the License, or any later version.

  9.  *

  10.  * This program is distributed in the hope that it will be useful,

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  13.  * GNU General Public License for more details.

  14.  *

  15.  * For a full copy of the GNU General Public License see the LICENSE file.

  16.  */

  17. 

  18. #include "rack.hpp"

  19. #include "plugin.hpp"

  20. 

  21. #include "DistrhoUtils.hpp"

  22. 

  23. // Cardinal (built-in)

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

  25. 

  26. // Fundamental (always enabled)

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

  28. 

  29. // ZamAudio (always enabled) - TODO

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

  31. 

  32. #ifndef NOPLUGINS

  33. // 21kHz

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

  35. 

  36. // 8Mode

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

  38. 

  39. // Aaron Static

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

  41. 

  42. // Alef's Bits

  43. #define modelSteps modelalefsbitsSteps

  44. #define modelLogic modelalefsbitsLogic

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

  46. #undef modelSteps

  47. #undef modelLogic

  48. 

  49. // Algoritmarte

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

  51. 

  52. // AmalgamatedHarmonics

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

  54. 

  55. // AnimatedCircuits

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

  57. 

  58. // ArableInstruments

  59. #define modelClouds modelArableClouds

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

  61. #undef modelClouds

  62. 

  63. // Aria

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

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

  66. */

  67. #define modelBlank modelAriaBlank

  68. extern Model* modelSplort;

  69. extern Model* modelSmerge;

  70. extern Model* modelSpleet;

  71. extern Model* modelSwerge;

  72. extern Model* modelSplirge;

  73. // extern Model* modelSrot;

  74. extern Model* modelQqqq;

  75. extern Model* modelQuack;

  76. extern Model* modelQ;

  77. extern Model* modelQuale;

  78. extern Model* modelDarius;

  79. extern Model* modelSolomon4;

  80. extern Model* modelSolomon8;

  81. extern Model* modelSolomon16;

  82. extern Model* modelPsychopump;

  83. extern Model* modelPokies4;

  84. extern Model* modelGrabby;

  85. extern Model* modelRotatoes4;

  86. extern Model* modelUndular;

  87. extern Model* modelBlank;

  88. #undef modelBlank

  89. 

  90. // AS

  91. #define modelADSR modelASADSR

  92. #define modelVCA modelASVCA

  93. #define modelWaveShaper modelASWaveShaper

  94. #define LedLight ASLedLight

  95. #define YellowRedLight ASYellowRedLight

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

  97. #undef modelADSR

  98. #undef modelVCA

  99. #undef modelWaveShaper

  100. #undef LedLight

  101. #undef YellowRedLight

  102. 

  103. // AudibleInstruments

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

  105. 

  106. // Autinn

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

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

  109. */

  110. #define modelChord modelAutinnChord

  111. #define modelVibrato modelAutinnVibrato

  112. extern Model* modelJette;

  113. extern Model* modelFlora;

  114. extern Model* modelOxcart;

  115. extern Model* modelDeadband;

  116. extern Model* modelDigi;

  117. extern Model* modelFlopper;

  118. extern Model* modelAmp;

  119. extern Model* modelDC;

  120. extern Model* modelSjip;

  121. extern Model* modelBass;

  122. extern Model* modelSquare;

  123. extern Model* modelSaw;

  124. extern Model* modelBoomerang;

  125. extern Model* modelVibrato;

  126. extern Model* modelVectorDriver; //deprecated

  127. extern Model* modelCVConverter;

  128. extern Model* modelZod;

  129. extern Model* modelTriBand;

  130. extern Model* modelMixer6;

  131. extern Model* modelNon;

  132. extern Model* modelFil;

  133. extern Model* modelNap;

  134. extern Model* modelMelody;

  135. extern Model* modelChord;

  136. #undef modelChord

  137. #undef modelVibrato

  138. 

  139. // Axioma

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

  141. 

  142. // BaconPlugs

  143. #define INCLUDE_COMPONENTS_HPP

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

  145. #undef INCLUDE_COMPONENTS_HPP

  146. #undef SCREW_WIDTH

  147. #undef RACK_HEIGHT

  148. 

  149. // Befaco

  150. #define modelADSR modelBefacoADSR

  151. #define modelMixer modelBefacoMixer

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

  153. #undef modelADSR

  154. #undef modelMixer

  155. 

  156. // Bidoo

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

  158. 

  159. // BogaudioModules - integrate theme/skin support

  160. #include <mutex>

  161. #include <string>

  162. #include <unordered_map>

  163. #include <unordered_set>

  164. #include <vector>

  165. #define private public

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

  167. #undef private

  168. 

  169. // BogaudioModules

  170. #define modelADSR modelBogaudioADSR

  171. #define modelLFO modelBogaudioLFO

  172. #define modelNoise modelBogaudioNoise

  173. #define modelVCA modelBogaudioVCA

  174. #define modelVCF modelBogaudioVCF

  175. #define modelVCO modelBogaudioVCO

  176. extern Model* modelVCO;

  177. extern Model* modelLVCO;

  178. extern Model* modelSine;

  179. extern Model* modelPulse;

  180. extern Model* modelXCO;

  181. extern Model* modelAdditator;

  182. extern Model* modelFMOp;

  183. extern Model* modelChirp;

  184. extern Model* modelLFO;

  185. extern Model* modelLLFO;

  186. extern Model* modelFourFO;

  187. extern Model* modelEightFO;

  188. extern Model* modelVCF;

  189. extern Model* modelLVCF;

  190. extern Model* modelFFB;

  191. extern Model* modelEQ;

  192. extern Model* modelEQS;

  193. extern Model* modelLPG;

  194. extern Model* modelLLPG;

  195. extern Model* modelMegaGate;

  196. extern Model* modelPEQ;

  197. extern Model* modelPEQ6;

  198. extern Model* modelPEQ6XF;

  199. extern Model* modelPEQ14;

  200. extern Model* modelPEQ14XF;

  201. extern Model* modelDADSRH;

  202. extern Model* modelDADSRHPlus;

  203. extern Model* modelShaper;

  204. extern Model* modelShaperPlus;

  205. extern Model* modelAD;

  206. extern Model* modelASR;

  207. extern Model* modelADSR;

  208. extern Model* modelVish;

  209. extern Model* modelFollow;

  210. extern Model* modelDGate;

  211. extern Model* modelRGate;

  212. extern Model* modelEdge;

  213. extern Model* modelNoise;

  214. extern Model* modelSampleHold;

  215. extern Model* modelWalk2;

  216. extern Model* modelWalk;

  217. extern Model* modelMix8;

  218. extern Model* modelMix8x;

  219. extern Model* modelMix4;

  220. extern Model* modelMix4x;

  221. extern Model* modelMix2;

  222. extern Model* modelMix1;

  223. extern Model* modelVCM;

  224. extern Model* modelMute8;

  225. extern Model* modelPan;

  226. extern Model* modelXFade;

  227. extern Model* modelVCA;

  228. extern Model* modelVCAmp;

  229. extern Model* modelVelo;

  230. extern Model* modelUMix;

  231. extern Model* modelMumix;

  232. extern Model* modelMatrix81;

  233. extern Model* modelMatrix18;

  234. extern Model* modelMatrix44;

  235. extern Model* modelMatrix44Cvm;

  236. extern Model* modelMatrix88;

  237. extern Model* modelMatrix88Cv;

  238. extern Model* modelMatrix88M;

  239. extern Model* modelSwitch81;

  240. extern Model* modelSwitch18;

  241. extern Model* modelSwitch44;

  242. extern Model* modelSwitch88;

  243. extern Model* modelSwitch1616;

  244. extern Model* modelAMRM;

  245. extern Model* modelPressor;

  246. extern Model* modelClpr;

  247. extern Model* modelLmtr;

  248. extern Model* modelNsgt;

  249. extern Model* modelCmpDist;

  250. extern Model* modelOneEight;

  251. extern Model* modelEightOne;

  252. extern Model* modelAddrSeq;

  253. extern Model* modelAddrSeqX;

  254. extern Model* modelPgmr;

  255. extern Model* modelPgmrX;

  256. extern Model* modelVU;

  257. extern Model* modelAnalyzer;

  258. extern Model* modelAnalyzerXL;

  259. extern Model* modelRanalyzer;

  260. extern Model* modelDetune;

  261. extern Model* modelStack;

  262. extern Model* modelReftone;

  263. extern Model* modelMono;

  264. extern Model* modelArp;

  265. extern Model* modelAssign;

  266. extern Model* modelUnison;

  267. extern Model* modelPolyCon8;

  268. extern Model* modelPolyCon16;

  269. extern Model* modelPolyOff8;

  270. extern Model* modelPolyOff16;

  271. extern Model* modelPolyMult;

  272. extern Model* modelBool;

  273. extern Model* modelCmp;

  274. extern Model* modelCVD;

  275. extern Model* modelFlipFlop;

  276. extern Model* modelInv;

  277. extern Model* modelManual;

  278. extern Model* modelFourMan;

  279. extern Model* modelMult;

  280. extern Model* modelOffset;

  281. extern Model* modelSlew;

  282. extern Model* modelSums;

  283. extern Model* modelSwitch;

  284. extern Model* modelLgsw;

  285. extern Model* modelBlank3;

  286. extern Model* modelBlank6;

  287. #ifdef EXPERIMENTAL

  288. extern Model* modelLag;

  289. extern Model* modelPEQ14XR;

  290. extern Model* modelPEQ14XV;

  291. #endif

  292. #ifdef TEST

  293. extern Model* modelTest;

  294. extern Model* modelTest2;

  295. extern Model* modelTestExpanderBase;

  296. extern Model* modelTestExpanderExtension;

  297. extern Model* modelTestGl;

  298. extern Model* modelTestVCF;

  299. #endif

  300. #undef modelADSR

  301. #undef modelLFO

  302. #undef modelNoise

  303. #undef modelVCA

  304. #undef modelVCF

  305. #undef modelVCO

  306. 

  307. // CatroModulo

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

  309. 

  310. // cf

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

  312. 

  313. // ChowDSP

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

  315. #define init initChowDSP

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

  317. #undef init

  318. 

  319. // dBiz

  320. #define DarkDefaultItem dBizDarkDefaultItem

  321. #define OrangeLight dBizOrangeLight

  322. #define darkPanelID dBizdarkPanelID

  323. #define lightPanelID dBizlightPanelID

  324. #define modelChord modeldBizChord

  325. #define modelDivider modeldBizDivider

  326. #define modelFourSeq modeldBizFourSeq

  327. #define modelVCA4 modeldBizVCA4

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

  329. #undef DarkDefaultItem

  330. #undef OrangeLight

  331. #undef darkPanelID

  332. #undef lightPanelID

  333. #undef modelChord

  334. #undef modelDivider

  335. #undef modelFourSeq

  336. #undef modelVCA4

  337. 

  338. // DrumKit

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

  340. void setupSamples();

  341. 

  342. // EnigmaCurry

  343. #define modelPulse modelEnigmaCurryPulse

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

  345. #undef modelPulse

  346. 

  347. // ESeries

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

  349. 

  350. // ExpertSleepers-Encoders

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

  352. 

  353. // Extratone

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

  355. 

  356. // FehlerFabrik

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

  358. 

  359. // forsitan modulare

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

  361. 

  362. // GlueTheGiant

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

  364. bool audition_mixer = false;

  365. bool audition_depot = false;

  366. int gtg_default_theme = 1;

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

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

  369. 

  370. // GoodSheperd

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

  372. 

  373. // GrandeModular

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

  375. 

  376. // H4N4 Modules

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

  378. 

  379. // Hampton Harmonics

  380. #define modelArp modelHamptonHarmonicsArp

  381. #define modelProgress modelHamptonHarmonicsProgress

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

  383. #undef modelProgress

  384. #undef modelArp

  385. 

  386. // HetrickCV

  387. #define modelASR modelHetrickCVASR

  388. #define modelBlankPanel modelHetrickCVBlankPanel

  389. #define modelFlipFlop modelHetrickCVFlipFlop

  390. #define modelMidSide modelHetrickCVMidSide

  391. #define modelMinMax modelHetrickCVMinMax

  392. extern Model* modelTwoToFour;

  393. extern Model* modelAnalogToDigital;

  394. extern Model* modelASR;

  395. extern Model* modelBinaryGate;

  396. extern Model* modelBinaryNoise;

  397. extern Model* modelBitshift;

  398. extern Model* modelBlankPanel;

  399. extern Model* modelBoolean3;

  400. extern Model* modelChaos1Op;

  401. extern Model* modelChaos2Op;

  402. extern Model* modelChaos3Op;

  403. extern Model* modelChaoticAttractors;

  404. extern Model* modelClockedNoise;

  405. extern Model* modelComparator;

  406. extern Model* modelContrast;

  407. extern Model* modelCrackle;

  408. extern Model* modelDataCompander;

  409. extern Model* modelDelta;

  410. extern Model* modelDigitalToAnalog;

  411. extern Model* modelDust;

  412. extern Model* modelExponent;

  413. extern Model* modelFBSineChaos;

  414. extern Model* modelFlipFlop;

  415. extern Model* modelFlipPan;

  416. extern Model* modelGateJunction;

  417. extern Model* modelGingerbread;

  418. extern Model* modelLogicCombine;

  419. extern Model* modelMidSide;

  420. extern Model* modelMinMax;

  421. extern Model* modelRandomGates;

  422. extern Model* modelRotator;

  423. extern Model* modelRungler;

  424. extern Model* modelScanner;

  425. extern Model* modelWaveshape;

  426. extern Model* modelXYToPolar;

  427. #undef modelASR

  428. #undef modelBlankPanel

  429. #undef modelFlipFlop

  430. #undef modelMidSide

  431. #undef modelMinMax

  432. 

  433. // ImpromptuModular

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

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

  436. */

  437. extern Model* modelAdaptiveQuantizer;

  438. extern Model* modelBigButtonSeq;

  439. extern Model* modelBigButtonSeq2;

  440. extern Model* modelChordKey;

  441. extern Model* modelChordKeyExpander;

  442. extern Model* modelClocked;

  443. extern Model* modelClockedExpander;

  444. extern Model* modelClkd;

  445. extern Model* modelCvPad;

  446. extern Model* modelFoundry;

  447. extern Model* modelFoundryExpander;

  448. extern Model* modelFourView;

  449. extern Model* modelGateSeq64;

  450. extern Model* modelGateSeq64Expander;

  451. extern Model* modelHotkey;

  452. extern Model* modelPart;

  453. extern Model* modelPhraseSeq16;

  454. extern Model* modelPhraseSeq32;

  455. extern Model* modelPhraseSeqExpander;

  456. extern Model* modelProbKey;

  457. extern Model* modelSemiModularSynth;

  458. extern Model* modelSygen;

  459. extern Model* modelTact;

  460. extern Model* modelTact1;

  461. extern Model* modelTactG;

  462. extern Model* modelTwelveKey;

  463. extern Model* modelVariations;

  464. extern Model* modelWriteSeq32;

  465. extern Model* modelWriteSeq64;

  466. extern Model* modelBlankPanel;

  467. 

  468. // ihtsyn

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

  470. 

  471. // JW-Modules

  472. #define modelQuantizer modelJWQuantizer

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

  474. #undef modelQuantizer

  475. 

  476. // kocmoc

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

  478. 

  479. // LifeFormModular

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

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

  482. */

  483. extern Model* modelTimeDiktat;

  484. extern Model* modelSequenceModeler;

  485. extern Model* modelPitchDiktat;

  486. extern Model* modelPitchIntegrator;

  487. extern Model* modelBurstIntegrator;

  488. extern Model* modelQuadModulator;

  489. extern Model* modelImpulseControl;

  490. extern Model* modelQuadSteppedOffset;

  491. extern Model* modelPercussiveVibration;

  492. extern Model* modelQuadUtility;

  493. extern Model* modelAdditiveVibration;

  494. extern Model* modelComplexOsc;

  495. extern Model* modelDriftgen;

  496. 

  497. // LittleUtils

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

  499. 

  500. // Lilac Loop

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

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

  503. */

  504. extern Model* modelLooperOne;

  505. extern Model* modelLooperTwo;

  506. 

  507. // LomasModules

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

  509. #undef DR_WAV_IMPLEMENTATION

  510. 

  511. // LyraeModules

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

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

  514. */

  515. #define modelDelta modelLyraeDelta

  516. extern Model* modelSulafat;

  517. extern Model* modelGamma;

  518. extern Model* modelDelta;

  519. extern Model* modelVega;

  520. extern Model* modelBD383238;

  521. extern Model* modelZeta;

  522. #undef modelDelta

  523. 

  524. // Meander

  525. extern int panelTheme;

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

  527. 

  528. // MindMeldModular

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

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

  531. */

  532. extern Model *modelPatchMaster;

  533. extern Model *modelPatchMasterBlank;

  534. extern Model *modelRouteMasterMono5to1;

  535. extern Model *modelRouteMasterStereo5to1;

  536. extern Model *modelRouteMasterMono1to5;

  537. extern Model *modelRouteMasterStereo1to5;

  538. extern Model *modelMasterChannel;

  539. extern Model *modelMeld;

  540. extern Model *modelUnmeld;

  541. extern Model *modelMSMelder;

  542. extern Model *modelEqMaster;

  543. extern Model *modelEqExpander;

  544. extern Model *modelBassMaster;

  545. extern Model *modelBassMasterJr;

  546. extern Model *modelShapeMaster;

  547. extern Model *modelMixMasterJr;

  548. extern Model *modelAuxExpanderJr;

  549. extern Model *modelMixMaster;

  550. extern Model *modelAuxExpander;

  551. 

  552. // ML_modules

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

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

  555. */

  556. #define modelQuantizer modelMLQuantizer

  557. #define modelSH8 modelMLSH8

  558. extern Model* modelQuantizer;

  559. extern Model* modelQuantum;

  560. extern Model* modelTrigBuf;

  561. extern Model* modelSeqSwitch;

  562. extern Model* modelSeqSwitch2;

  563. extern Model* modelShiftRegister;

  564. extern Model* modelShiftRegister2;

  565. extern Model* modelFreeVerb;

  566. extern Model* modelSum8;

  567. extern Model* modelSum8mk2;

  568. extern Model* modelSum8mk3;

  569. extern Model* modelSH8;

  570. extern Model* modelConstants;

  571. extern Model* modelCounter;

  572. extern Model* modelTrigDelay;

  573. extern Model* modelBPMdetect;

  574. extern Model* modelVoltMeter;

  575. extern Model* modelOctaFlop;

  576. extern Model* modelOctaTrig;

  577. extern Model* modelOctaSwitch;

  578. extern Model* modelTrigSwitch;

  579. extern Model* modelTrigSwitch2;

  580. extern Model* modelTrigSwitch3;

  581. extern Model* modelTrigSwitch3_2;

  582. extern Model* modelOctaPlus;

  583. extern Model* modelOctaTimes;

  584. extern Model* modelCloner;

  585. extern Model* modelPolySplitter;

  586. extern Model* modelArpeggiator;

  587. #undef modelQuantizer

  588. #undef modelSH8

  589. 

  590. // MockbaModular

  591. #define modelBlank modelMockbaModularBlank

  592. #define modelComparator modelMockbaModularComparator

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

  594. #undef modelBlank

  595. #undef modelComparator

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

  597. #undef min

  598. #undef max

  599. #define saveBack ignoreMockbaModular1

  600. #define loadBack ignoreMockbaModular2

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

  602. #undef saveBack

  603. #undef loadBack

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

  605. 

  606. // Mog

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

  608. 

  609. // mscHack

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

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

  612. */

  613. extern Model* modelCompressor;

  614. extern Model* modelSynthDrums;

  615. extern Model* modelSEQ_6x32x16;

  616. extern Model* modelMasterClockx8;

  617. extern Model* modelMasterClockx4;

  618. extern Model* modelSEQ_Envelope_8;

  619. extern Model* modelSeq_Triad2;

  620. extern Model* modelARP700;

  621. extern Model* modelMix_24_4_4;

  622. extern Model* modelMix_16_4_4;

  623. extern Model* modelMix_9_3_4;

  624. extern Model* modelMix_4_0_4;

  625. extern Model* modelASAF8;

  626. extern Model* modelPingPong;

  627. extern Model* modelStepDelay;

  628. extern Model* modelOsc_3Ch;

  629. extern Model* modelDronez;

  630. extern Model* modelMorze;

  631. extern Model* modelWindz;

  632. extern Model* modelLorenz;

  633. extern Model* modelAlienz;

  634. extern Model* modelOSC_WaveMorph_3;

  635. extern Model* modelMaude_221;

  636. 

  637. // MSM

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

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

  640. */

  641. #define modelADSR modelMSMADSR

  642. #define modelBlankPanel modelMSMBlankPanel

  643. #define modelDelay modelMSMDelay

  644. #define modelLFO modelMSMLFO

  645. #define modelMult modelMSMMult

  646. #define modelNoise modelMSMNoise

  647. #define modelVCA modelMSMVCA

  648. #define modelVCO modelMSMVCO

  649. extern Model* modelVCO;

  650. extern Model* modelBVCO;

  651. extern Model* modelExperimentalVCO;

  652. extern Model* modelNoise;

  653. extern Model* modelLFO;

  654. extern Model* modelVCA;

  655. extern Model* modelADSR;

  656. extern Model* modelDelay;

  657. extern Model* modelWaveShaper;

  658. extern Model* modelWavefolder;

  659. extern Model* modelBitcrusher;

  660. extern Model* modelPhaserModule;

  661. extern Model* modelMorpher;

  662. extern Model* modelRingMod;

  663. extern Model* modelRandomSource;

  664. extern Model* modelMult;

  665. extern Model* modelCrazyMult;

  666. extern Model* modelFade;

  667. extern Model* modelSimpleSlider;

  668. extern Model* modelxseq;

  669. extern Model* modelBlankPanel;

  670. #undef modelADSR

  671. #undef modelBlankPanel

  672. #undef modelDelay

  673. #undef modelLFO

  674. #undef modelMult

  675. #undef modelNoise

  676. #undef modelVCA

  677. #undef modelVCO

  678. 

  679. // myth-modules

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

  681. 

  682. // Nonlinear Circuits

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

  684. 

  685. // Orbits

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

  687. 

  688. // ParableInstruments

  689. #define modelClouds modelParableClouds

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

  691. #undef modelClouds

  692. 

  693. // Path Set

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

  695. 

  696. // PinkTrombone

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

  698. 

  699. // Prism

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

  701. 

  702. // rackwindows

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

  704. 

  705. // RebelTech

  706. #define BefacoInputPort BefacoInputPortRebelTech

  707. #define BefacoOutputPort BefacoOutputPortRebelTech

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

  709. #undef BefacoInputPort

  710. #undef BefacoOutputPort

  711. ModuleTheme defaultPanelTheme = DARK_THEME;

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

  713. 

  714. // repelzen

  715. #define modelBlank modelrepelzenBlank

  716. #define modelMixer modelrepelzenMixer

  717. #define modelWerner modelrepelzenWerner

  718. #define tanh_pade repelzentanh_pade

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

  720. #undef modelBlank

  721. #undef modelMixer

  722. #undef modelWerner

  723. #undef tanh_pade

  724. 

  725. // Sapphire

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

  727. 

  728. // sonusmodular

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

  730. 

  731. // stocaudio

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

  733. 

  734. // stoermelder-packone

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

  736. Model* modelAudioInterface64;

  737. Model* modelMidiCat;

  738. Model* modelMidiCatCtx;

  739. Model* modelMidiCatMem;

  740. Model* modelMidiKey;

  741. Model* modelMidiMon;

  742. Model* modelMidiPlug;

  743. Model* modelMidiStep;

  744. StoermelderSettings pluginSettings;

  745. void StoermelderSettings::saveToJson() {}

  746. void StoermelderSettings::readFromJson() {}

  747. 

  748. // surgext

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

  750. void surgext_rack_initialize();

  751. void surgext_rack_update_theme();

  752. 

  753. // unless_modules

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

  755. 

  756. // ValleyAudio

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

  758. 

  759. // Voxglitch

  760. #define modelLooper modelVoxglitchLooper

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

  762. #undef modelLooper

  763. 

  764. // WhatTheRack

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

  766. 

  767. // ZetaCarinaeModules

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

  769. 

  770. // ZZC

  771. #define DISPLAYS_H

  772. #define ZZC_SHARED_H

  773. #define ZZC_WIDGETS_H

  774. #define modelClock modelZZCClock

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

  776. #undef modelClock

  777. 

  778. #endif // NOPLUGINS

  779. 

  780. // known terminal modules

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

  782. 

  783. #ifndef NOPLUGINS

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

  785. int loadConsoleType() { return 0; }

  786. bool loadDarkAsDefault() { return settings::darkMode; }

  787. ModuleTheme loadDefaultTheme() { return settings::darkMode ? DARK_THEME : LIGHT_THEME; }

  788. int loadDirectOutMode() { return 0; }

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

  790. void saveConsoleType(int) {}

  791. void saveDarkAsDefault(bool) {}

  792. void saveDefaultTheme(ModuleTheme) {}

  793. void saveDirectOutMode(bool) {}

  794. void saveHighQualityAsDefault(bool) {}

  795. void writeDefaultTheme() {}

  796. #endif

  797. 

  798. // plugin instances

  799. Plugin* pluginInstance__Cardinal;

  800. Plugin* pluginInstance__Fundamental;

  801. // Plugin* pluginInstance__ZamAudio;

  802. #ifndef NOPLUGINS

  803. Plugin* pluginInstance__21kHz;

  804. Plugin* pluginInstance__8Mode;

  805. extern Plugin* pluginInstance__AaronStatic;

  806. Plugin* pluginInstance__alefsbits;

  807. Plugin* pluginInstance__Algoritmarte;

  808. Plugin* pluginInstance__AmalgamatedHarmonics;

  809. Plugin* pluginInstance__ArableInstruments;

  810. Plugin* pluginInstance__AnimatedCircuits;

  811. Plugin* pluginInstance__Aria;

  812. Plugin* pluginInstance__AS;

  813. Plugin* pluginInstance__AudibleInstruments;

  814. extern Plugin* pluginInstance__Autinn;

  815. Plugin* pluginInstance__Axioma;

  816. Plugin* pluginInstance__Bacon;

  817. Plugin* pluginInstance__Befaco;

  818. Plugin* pluginInstance__Bidoo;

  819. Plugin* pluginInstance__BogaudioModules;

  820. Plugin* pluginInstance__CatroModulo;

  821. Plugin* pluginInstance__cf;

  822. Plugin* pluginInstance__ChowDSP;

  823. Plugin* pluginInstance__dBiz;

  824. extern Plugin* pluginInstance__DrumKit;

  825. Plugin* pluginInstance__EnigmaCurry;

  826. Plugin* pluginInstance__ESeries;

  827. Plugin* pluginInstance__ExpertSleepersEncoders;

  828. Plugin* pluginInstance__Extratone;

  829. Plugin* pluginInstance__FehlerFabrik;

  830. Plugin* pluginInstance__forsitan;

  831. Plugin* pluginInstance__GlueTheGiant;

  832. Plugin* pluginInstance__GoodSheperd;

  833. Plugin* pluginInstance__GrandeModular;

  834. Plugin* pluginInstance__H4N4;

  835. Plugin* pluginInstance__HamptonHarmonics;

  836. Plugin* pluginInstance__HetrickCV;

  837. extern Plugin* pluginInstance__ImpromptuModular;

  838. Plugin* pluginInstance__ihtsyn;

  839. Plugin* pluginInstance__JW;

  840. Plugin* pluginInstance__kocmoc;

  841. Plugin* pluginInstance__LifeFormModular;

  842. Plugin* pluginInstance__LilacLoop;

  843. Plugin* pluginInstance__LittleUtils;

  844. Plugin* pluginInstance__Lomas;

  845. Plugin* pluginInstance__Lyrae;

  846. Plugin* pluginInstance__Meander;

  847. extern Plugin* pluginInstance__MindMeld;

  848. Plugin* pluginInstance__ML;

  849. Plugin* pluginInstance__MockbaModular;

  850. Plugin* pluginInstance__Mog;

  851. extern Plugin* pluginInstance__mscHack;

  852. Plugin* pluginInstance__MSM;

  853. Plugin* pluginInstance__myth_modules;

  854. Plugin* pluginInstance__nonlinearcircuits;

  855. Plugin* pluginInstance__Orbits;

  856. Plugin* pluginInstance__ParableInstruments;

  857. Plugin* pluginInstance__PathSet;

  858. Plugin* pluginInstance__PinkTrombone;

  859. Plugin* pluginInstance__Prism;

  860. Plugin* pluginInstance__rackwindows;

  861. Plugin* pluginInstance__RebelTech;

  862. Plugin* pluginInstance__repelzen;

  863. Plugin* pluginInstance__sapphire;

  864. Plugin* pluginInstance__sonusmodular;

  865. Plugin* pluginInstance__stocaudio;

  866. extern Plugin* pluginInstance__stoermelder_p1;

  867. Plugin* pluginInstance__surgext;

  868. Plugin* pluginInstance__unless_modules;

  869. Plugin* pluginInstance__ValleyAudio;

  870. Plugin* pluginInstance__Voxglitch;

  871. Plugin* pluginInstance__WhatTheRack;

  872. Plugin* pluginInstance__ZetaCarinaeModules;

  873. Plugin* pluginInstance__ZZC;

  874. #endif // NOPLUGINS

  875. 

  876. namespace rack {

  877. 

  878. namespace asset {

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

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

  881. }

  882. 

  883. namespace plugin {

  884. 

  885. struct StaticPluginLoader {

  886.     Plugin* const plugin;

  887.     FILE* file;

  888.     json_t* rootJ;

  889. 

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

  891.         : plugin(p),

  892.           file(nullptr),

  893.           rootJ(nullptr)

  894.     {

  895. #ifdef DEBUG

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

  897. #endif

  898. 

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

  900. 

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

  902. 

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

  904.         {

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

  906.             return;

  907.         }

  908. 

  909.         json_error_t error;

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

  911.         {

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

  913.             return;

  914.         }

  915. 

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

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

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

  919.         json_decref(version);

  920. 

  921.         // Load manifest

  922.         p->fromJson(rootJ);

  923. 

  924.         // Reject plugin if slug already exists

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

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

  927.     }

  928. 

  929.     ~StaticPluginLoader()

  930.     {

  931.         if (rootJ != nullptr)

  932.         {

  933.             // Load modules manifest

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

  935.             plugin->modulesFromJson(modulesJ);

  936. 

  937.             json_decref(rootJ);

  938.             plugins.push_back(plugin);

  939.         }

  940. 

  941.         if (file != nullptr)

  942.             std::fclose(file);

  943.     }

  944. 

  945.     bool ok() const noexcept

  946.     {

  947.         return rootJ != nullptr;

  948.     }

  949. 

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

  951.     {

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

  953.         DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);

  954. 

  955.         size_t i;

  956.         json_t* v;

  957.         json_array_foreach(modules, i, v)

  958.         {

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

  960.             {

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

  962.                 {

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

  964.                     {

  965.                         json_array_remove(modules, i);

  966.                         break;

  967.                     }

  968.                 }

  969.             }

  970.         }

  971.     }

  972. };

  973. 

  974. static void initStatic__Cardinal()

  975. {

  976.     Plugin* const p = new Plugin;

  977.     pluginInstance__Cardinal = p;

  978. 

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

  980.     if (spl.ok())

  981.     {

  982.         p->addModel(modelAidaX);

  983.         p->addModel(modelCardinalBlank);

  984.         p->addModel(modelExpanderInputMIDI);

  985.         p->addModel(modelExpanderOutputMIDI);

  986.         p->addModel(modelHostAudio2);

  987.         p->addModel(modelHostAudio8);

  988.         p->addModel(modelHostCV);

  989.         p->addModel(modelHostMIDI);

  990.         p->addModel(modelHostMIDICC);

  991.         p->addModel(modelHostMIDIGate);

  992.         p->addModel(modelHostMIDIMap);

  993.         p->addModel(modelHostParameters);

  994.         p->addModel(modelHostParametersMap);

  995.         p->addModel(modelHostTime);

  996.         p->addModel(modelTextEditor);

  997.        #ifndef DGL_USE_GLES

  998.         p->addModel(modelGlBars);

  999.        #else

  1000.         spl.removeModule("glBars");

  1001.        #endif

  1002.        #ifndef STATIC_BUILD

  1003.         p->addModel(modelAudioFile);

  1004.        #else

  1005.         spl.removeModule("AudioFile");

  1006.        #endif

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

  1008.         p->addModel(modelCarla);

  1009.         p->addModel(modelIldaeil);

  1010.        #else

  1011.         spl.removeModule("Carla");

  1012.         spl.removeModule("Ildaeil");

  1013.        #endif

  1014.        #ifndef HEADLESS

  1015.         p->addModel(modelSassyScope);

  1016.        #else

  1017.         spl.removeModule("SassyScope");

  1018.        #endif

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

  1020.         p->addModel(modelMPV);

  1021.        #else

  1022.         spl.removeModule("MPV");

  1023.        #endif

  1024.        #ifdef HAVE_FFTW3F

  1025.         p->addModel(modelAudioToCVPitch);

  1026.        #else

  1027.         spl.removeModule("AudioToCVPitch");

  1028.        #endif

  1029. 

  1030.         hostTerminalModels = {

  1031.             modelHostAudio2,

  1032.             modelHostAudio8,

  1033.             modelHostCV,

  1034.             modelHostMIDI,

  1035.             modelHostMIDICC,

  1036.             modelHostMIDIGate,

  1037.             modelHostMIDIMap,

  1038.             modelHostParameters,

  1039.             modelHostParametersMap,

  1040.             modelHostTime,

  1041.         };

  1042.     }

  1043. }

  1044. 

  1045. static void initStatic__Fundamental()

  1046. {

  1047.     Plugin* const p = new Plugin;

  1048.     pluginInstance__Fundamental = p;

  1049. 

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

  1051.     if (spl.ok())

  1052.     {

  1053.         p->addModel(model_8vert);

  1054.         p->addModel(modelADSR);

  1055.         p->addModel(modelDelay);

  1056.         p->addModel(modelLFO);

  1057.         p->addModel(modelLFO2);

  1058.         p->addModel(modelMerge);

  1059.         p->addModel(modelMidSide);

  1060.         p->addModel(modelMixer);

  1061.         p->addModel(modelMutes);

  1062.         p->addModel(modelNoise);

  1063.         p->addModel(modelOctave);

  1064.         p->addModel(modelPulses);

  1065.         p->addModel(modelQuantizer);

  1066.         p->addModel(modelRandom);

  1067.         p->addModel(modelScope);

  1068.         p->addModel(modelSEQ3);

  1069.         p->addModel(modelSequentialSwitch1);

  1070.         p->addModel(modelSequentialSwitch2);

  1071.         p->addModel(modelSplit);

  1072.         p->addModel(modelSum);

  1073.         p->addModel(modelVCA);

  1074.         p->addModel(modelVCA_1);

  1075.         p->addModel(modelVCF);

  1076.         p->addModel(modelVCMixer);

  1077.         p->addModel(modelVCO);

  1078.         p->addModel(modelVCO2);

  1079.     }

  1080. }

  1081. 

  1082. /*

  1083. static void initStatic__ZamAudio()

  1084. {

  1085.     Plugin* const p = new Plugin;

  1086.     pluginInstance__ZamAudio = p;

  1087. 

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

  1089.     if (spl.ok())

  1090.     {

  1091.         p->addModel(modelZamComp);

  1092.     }

  1093. }

  1094. */

  1095. 

  1096. #ifndef NOPLUGINS

  1097. static void initStatic__21kHz()

  1098. {

  1099.     Plugin* const p = new Plugin;

  1100.     pluginInstance__21kHz = p;

  1101. 

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

  1103.     if (spl.ok())

  1104.     {

  1105.         p->addModel(modelPalmLoop);

  1106.         p->addModel(modelD_Inf);

  1107.         p->addModel(modelTachyonEntangler);

  1108.     }

  1109. }

  1110. 

  1111. static void initStatic__8Mode()

  1112. {

  1113.     Plugin* const p = new Plugin;

  1114.     pluginInstance__8Mode = p;

  1115. 

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

  1117.     if (spl.ok())

  1118.     {

  1119.         p->addModel(modelsoftSN);

  1120.     }

  1121. }

  1122. 

  1123. static void initStatic__AaronStatic()

  1124. {

  1125.     Plugin* const p = new Plugin;

  1126.     pluginInstance__AaronStatic = p;

  1127. 

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

  1129.     if (spl.ok())

  1130.     {

  1131.         p->addModel(modelChordCV);

  1132.         p->addModel(modelScaleCV);

  1133.         p->addModel(modelRandomNoteCV);

  1134.         p->addModel(modelDiatonicCV);

  1135.     }

  1136. }

  1137. 

  1138. static void initStatic__alefsbits()

  1139. {

  1140.     Plugin* const p = new Plugin;

  1141.     pluginInstance__alefsbits = p;

  1142. 

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

  1144.     if (spl.ok())

  1145.     {

  1146. #define modelSteps modelalefsbitsSteps

  1147. #define modelLogic modelalefsbitsLogic

  1148.         p->addModel(modelSimplexandhold);

  1149.         p->addModel(modelBlank6hp);

  1150.         p->addModel(modelPolyrand);

  1151.         p->addModel(modelNoize);

  1152.         p->addModel(modelSteps);

  1153.         p->addModel(modelFibb);

  1154.         p->addModel(modelOctsclr);

  1155.         p->addModel(modelShift);

  1156.         p->addModel(modelMlt);

  1157.         p->addModel(modelMath);

  1158.         p->addModel(modelLogic);

  1159.         p->addModel(modelProbablynot);

  1160. #undef modelSteps

  1161. #undef modelLogic

  1162.     }

  1163. }

  1164. 

  1165. static void initStatic__Algoritmarte()

  1166. {

  1167.     Plugin* const p = new Plugin;

  1168.     pluginInstance__Algoritmarte = p;

  1169. 

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

  1171.     if (spl.ok())

  1172.     {

  1173.         p->addModel(modelClockkky);

  1174.         p->addModel(modelPlanetz);

  1175.         p->addModel(modelMusiFrog);

  1176.         p->addModel(modelZefiro);

  1177.         p->addModel(modelHoldMeTight);

  1178.         p->addModel(modelCyclicCA);

  1179.         p->addModel(modelMusiMath);

  1180.     }

  1181. }

  1182. 

  1183. static void initStatic__AmalgamatedHarmonics()

  1184. {

  1185.     Plugin* const p = new Plugin;

  1186.     pluginInstance__AmalgamatedHarmonics = p;

  1187. 

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

  1189.     if (spl.ok())

  1190.     {

  1191.         p->addModel(modelArp31);

  1192.         p->addModel(modelArp32);

  1193.         p->addModel(modelBombe);

  1194.         p->addModel(modelChord);

  1195.         p->addModel(modelCircle);

  1196.         p->addModel(modelGalaxy);

  1197.         p->addModel(modelGenerative);

  1198.         p->addModel(modelImp);

  1199.         p->addModel(modelImperfect2);

  1200.         p->addModel(modelProgress2);

  1201.         p->addModel(modelRuckus);

  1202.         p->addModel(modelScaleQuantizer2);

  1203.         p->addModel(modelSLN);

  1204.         p->addModel(modelMuxDeMux);

  1205.         p->addModel(modelPolyProbe);

  1206.         p->addModel(modelPolyScope);

  1207.         p->addModel(modelPolyUtils);

  1208.         p->addModel(modelPolyVolt);

  1209.         p->addModel(modelScaleQuantizer);

  1210.         p->addModel(modelArpeggiator2);

  1211.         p->addModel(modelProgress);

  1212.     }

  1213. }

  1214. 

  1215. static void initStatic__AnimatedCircuits()

  1216. {

  1217.     Plugin* const p = new Plugin;

  1218.     pluginInstance__AnimatedCircuits = p;

  1219. 

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

  1221.     if (spl.ok())

  1222.     {

  1223.         p->addModel(model_AC_Folding);

  1224.         p->addModel(model_AC_LFold);

  1225.     }

  1226. }

  1227. 

  1228. static void initStatic__ArableInstruments()

  1229. {

  1230.     Plugin* const p = new Plugin;

  1231.     pluginInstance__ArableInstruments = p;

  1232. 

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

  1234.     if (spl.ok())

  1235.     {

  1236. #define modelClouds modelArableClouds

  1237.         p->addModel(modelClouds);

  1238. #undef modelClouds

  1239.     }

  1240. }

  1241. 

  1242. static void initStatic__Aria()

  1243. {

  1244.     Plugin* const p = new Plugin;

  1245.     pluginInstance__Aria = p;

  1246. 

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

  1248.     if (spl.ok())

  1249.     {

  1250. #define modelBlank modelAriaBlank

  1251.         p->addModel(modelSplort);

  1252.         p->addModel(modelSmerge);

  1253.         p->addModel(modelSpleet);

  1254.         p->addModel(modelSwerge);

  1255.         p->addModel(modelSplirge);

  1256.         p->addModel(modelQqqq);

  1257.         p->addModel(modelQuack);

  1258.         p->addModel(modelQ);

  1259.         p->addModel(modelQuale);

  1260.         p->addModel(modelDarius);

  1261.         p->addModel(modelSolomon4);

  1262.         p->addModel(modelSolomon8);

  1263.         p->addModel(modelSolomon16);

  1264.         p->addModel(modelPsychopump);

  1265.         p->addModel(modelPokies4);

  1266.         p->addModel(modelGrabby);

  1267.         p->addModel(modelRotatoes4);

  1268.         p->addModel(modelUndular);

  1269.         p->addModel(modelBlank);

  1270. #undef modelBlank

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

  1272.         spl.removeModule("Arcane");

  1273.         spl.removeModule("Atout");

  1274.         spl.removeModule("Aleister");

  1275.     }

  1276. }

  1277. 

  1278. static void initStatic__AS()

  1279. {

  1280.     Plugin* const p = new Plugin;

  1281.     pluginInstance__AS = p;

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

  1283.     if (spl.ok())

  1284.     {

  1285. #define modelADSR modelASADSR

  1286. #define modelVCA modelASVCA

  1287. #define modelWaveShaper modelASWaveShaper

  1288.         //OSCILLATORS

  1289.         p->addModel(modelSineOsc);

  1290.         p->addModel(modelSawOsc);

  1291.         //TOOLS

  1292.         p->addModel(modelADSR);

  1293.         p->addModel(modelVCA);

  1294.         p->addModel(modelQuadVCA);

  1295.         p->addModel(modelTriLFO);

  1296.         p->addModel(modelAtNuVrTr);

  1297.         p->addModel(modelBPMClock);

  1298.         p->addModel(modelSEQ16);

  1299.         p->addModel(modelMixer2ch);

  1300.         p->addModel(modelMixer4ch);

  1301.         p->addModel(modelMixer8ch);

  1302.         p->addModel(modelMonoVUmeter);

  1303.         p->addModel(modelStereoVUmeter);

  1304.         p->addModel(modelMultiple2_5);

  1305.         p->addModel(modelMerge2_5);

  1306.         p->addModel(modelSteps);

  1307.         p->addModel(modelLaunchGate);

  1308.         p->addModel(modelKillGate);

  1309.         p->addModel(modelFlow);

  1310.         p->addModel(modelSignalDelay);

  1311.         p->addModel(modelTriggersMKI);

  1312.         p->addModel(modelTriggersMKII);

  1313.         p->addModel(modelTriggersMKIII);

  1314.         p->addModel(modelBPMCalc);

  1315.         p->addModel(modelBPMCalc2);

  1316.         p->addModel(modelCv2T);

  1317.         p->addModel(modelZeroCV2T);

  1318.         p->addModel(modelReScale);

  1319.         //EFFECTS

  1320.         p->addModel(modelDelayPlusFx);

  1321.         p->addModel(modelDelayPlusStereoFx);

  1322.         p->addModel(modelPhaserFx);

  1323.         p->addModel(modelReverbFx);

  1324.         p->addModel(modelReverbStereoFx);

  1325.         p->addModel(modelSuperDriveFx);

  1326.         p->addModel(modelSuperDriveStereoFx);

  1327.         p->addModel(modelTremoloFx);

  1328.         p->addModel(modelTremoloStereoFx);

  1329.         p->addModel(modelWaveShaper);

  1330.         p->addModel(modelWaveShaperStereo);

  1331.         //BLANK PANELS

  1332.         p->addModel(modelBlankPanel4);

  1333.         p->addModel(modelBlankPanel6);

  1334.         p->addModel(modelBlankPanel8);

  1335.         p->addModel(modelBlankPanelSpecial);

  1336. #undef modelADSR

  1337. #undef modelVCA

  1338. #undef modelWaveShaper

  1339.     }

  1340. }

  1341. 

  1342. static void initStatic__AudibleInstruments()

  1343. {

  1344.     Plugin* const p = new Plugin;

  1345.     pluginInstance__AudibleInstruments = p;

  1346. 

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

  1348.     if (spl.ok())

  1349.     {

  1350.         p->addModel(modelBraids);

  1351.         p->addModel(modelPlaits);

  1352.         p->addModel(modelElements);

  1353.         p->addModel(modelTides);

  1354.         p->addModel(modelTides2);

  1355.         p->addModel(modelClouds);

  1356.         p->addModel(modelWarps);

  1357.         p->addModel(modelRings);

  1358.         p->addModel(modelLinks);

  1359.         p->addModel(modelKinks);

  1360.         p->addModel(modelShades);

  1361.         p->addModel(modelBranches);

  1362.         p->addModel(modelBlinds);

  1363.         p->addModel(modelVeils);

  1364.         p->addModel(modelFrames);

  1365.         p->addModel(modelMarbles);

  1366.         p->addModel(modelStages);

  1367.         p->addModel(modelRipples);

  1368.         p->addModel(modelShelves);

  1369.         p->addModel(modelStreams);

  1370.     }

  1371. }

  1372. 

  1373. static void initStatic__Autinn()

  1374. {

  1375.     Plugin* const p = new Plugin;

  1376.     pluginInstance__Autinn = p;

  1377. 

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

  1379.     if (spl.ok())

  1380.     {

  1381. #define modelChord modelAutinnChord

  1382. #define modelVibrato modelAutinnVibrato

  1383.         p->addModel(modelAmp);

  1384.         p->addModel(modelDeadband);

  1385.         p->addModel(modelBass);

  1386.         p->addModel(modelCVConverter);

  1387.         p->addModel(modelDC);

  1388.         p->addModel(modelDigi);

  1389.         p->addModel(modelFlopper);

  1390.         p->addModel(modelFlora);

  1391.         p->addModel(modelJette);

  1392.         p->addModel(modelBoomerang);

  1393.         p->addModel(modelOxcart);

  1394.         p->addModel(modelSaw);

  1395.         p->addModel(modelSjip);

  1396.         p->addModel(modelSquare);

  1397.         p->addModel(modelVibrato);

  1398.         p->addModel(modelVectorDriver);

  1399.         p->addModel(modelZod);

  1400.         p->addModel(modelTriBand);

  1401.         p->addModel(modelMixer6);

  1402.         p->addModel(modelNon);

  1403.         p->addModel(modelFil);

  1404.         p->addModel(modelNap);

  1405.         p->addModel(modelMelody);

  1406.         p->addModel(modelChord);

  1407. #undef modelChord

  1408. #undef modelVibrato

  1409.     }

  1410. }

  1411. 

  1412. static void initStatic__Axioma()

  1413. {

  1414.     Plugin* const p = new Plugin;

  1415.     pluginInstance__Axioma = p;

  1416. 

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

  1418.     if (spl.ok())

  1419.     {

  1420.         p->addModel(modelTheBifurcator);

  1421.         p->addModel(modelTesseract);

  1422.         p->addModel(modelIkeda);

  1423.         p->addModel(modelRhodonea);

  1424.     }

  1425. }

  1426. 

  1427. static void initStatic__Bacon()

  1428. {

  1429.     Plugin* const p = new Plugin;

  1430.     pluginInstance__Bacon = p;

  1431. 

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

  1433.     if (spl.ok())

  1434.     {

  1435.         p->addModel(modelHarMoNee);

  1436.         p->addModel(modelGlissinator);

  1437.         p->addModel(modelPolyGnome);

  1438.         p->addModel(modelQuantEyes);

  1439.         p->addModel(modelSampleDelay);

  1440.         p->addModel(modelChipNoise);

  1441.         p->addModel(modelChipWaves);

  1442.         p->addModel(modelChipYourWave);

  1443.         p->addModel(modelOpen303);

  1444.         p->addModel(modelKarplusStrongPoly);

  1445.         p->addModel(modelALingADing);

  1446.         p->addModel(modelBitulator);

  1447.         p->addModel(modelPolyGenerator);

  1448.         p->addModel(modelLintBuddy);

  1449.         p->addModel(modelLuckyHold);

  1450.     }

  1451. }

  1452. 

  1453. static void initStatic__Befaco()

  1454. {

  1455.     Plugin* const p = new Plugin;

  1456.     pluginInstance__Befaco = p;

  1457. 

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

  1459.     if (spl.ok())

  1460.     {

  1461. #define modelADSR modelBefacoADSR

  1462. #define modelMixer modelBefacoMixer

  1463.         p->addModel(modelEvenVCO);

  1464.         p->addModel(modelRampage);

  1465.         p->addModel(modelABC);

  1466.         p->addModel(modelSpringReverb);

  1467.         p->addModel(modelMixer);

  1468.         p->addModel(modelSlewLimiter);

  1469.         p->addModel(modelDualAtenuverter);

  1470.         p->addModel(modelPercall);

  1471.         p->addModel(modelHexmixVCA);

  1472.         p->addModel(modelChoppingKinky);

  1473.         p->addModel(modelKickall);

  1474.         p->addModel(modelSamplingModulator);

  1475.         p->addModel(modelMorphader);

  1476.         p->addModel(modelADSR);

  1477.         p->addModel(modelSTMix);

  1478.         p->addModel(modelMuxlicer);

  1479.         p->addModel(modelMex);

  1480.         p->addModel(modelNoisePlethora);

  1481.         p->addModel(modelChannelStrip);

  1482.         p->addModel(modelPonyVCO);

  1483.         p->addModel(modelMotionMTR);

  1484. #undef modelADSR

  1485. #undef modelMixer

  1486.     }

  1487. }

  1488. 

  1489. static void initStatic__Bidoo()

  1490. {

  1491.     Plugin* const p = new Plugin;

  1492.     pluginInstance__Bidoo = p;

  1493. 

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

  1495.     if (spl.ok())

  1496.     {

  1497.         p->addModel(modelTOCANTE);

  1498.         p->addModel(modelLATE);

  1499.         p->addModel(modelDIKTAT);

  1500.         p->addModel(modelDTROY);

  1501.         p->addModel(modelBORDL);

  1502.         p->addModel(modelZOUMAI);

  1503.         p->addModel(modelZOUMAIExpander);

  1504.         p->addModel(modelENCORE);

  1505.         p->addModel(modelENCOREExpander);

  1506.         p->addModel(modelMU);

  1507.         p->addModel(modelCHUTE);

  1508.         p->addModel(modelLOURDE);

  1509.         p->addModel(modelDILEMO);

  1510.         p->addModel(modelLAMBDA);

  1511.         p->addModel(modelBANCAU);

  1512.         p->addModel(modelACNE);

  1513.         p->addModel(modelMS);

  1514.         p->addModel(modelDUKE);

  1515.         p->addModel(modelMOIRE);

  1516.         p->addModel(modelPILOT);

  1517.         p->addModel(modelHUITRE);

  1518.         p->addModel(modelOUAIVE);

  1519.         p->addModel(modelEDSAROS);

  1520.         p->addModel(modelPOUPRE);

  1521.         p->addModel(modelMAGMA);

  1522.         p->addModel(modelOAI);

  1523.         p->addModel(modelCANARD);

  1524.         p->addModel(modelEMILE);

  1525.         p->addModel(modelFORK);

  1526.         p->addModel(modelTIARE);

  1527.         p->addModel(modelLIMONADE);

  1528.         p->addModel(modelLIMBO);

  1529.         p->addModel(modelPERCO);

  1530.         p->addModel(modelBAFIS);

  1531.         p->addModel(modelBAR);

  1532.         p->addModel(modelMINIBAR);

  1533.         p->addModel(modelZINC);

  1534.         p->addModel(modelFREIN);

  1535.         p->addModel(modelHCTIP);

  1536.         p->addModel(modelSPORE);

  1537.         p->addModel(modelDFUZE);

  1538.         p->addModel(modelREI);

  1539.         p->addModel(modelRABBIT);

  1540.         p->addModel(modelBISTROT);

  1541.         p->addModel(modelSIGMA);

  1542.         p->addModel(modelFLAME);

  1543.         p->addModel(modelVOID);

  1544. 

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

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

  1547.         spl.removeModule("antN");

  1548.     }

  1549. }

  1550. 

  1551. static void initStatic__BogaudioModules()

  1552. {

  1553.     Plugin* const p = new Plugin;

  1554.     pluginInstance__BogaudioModules = p;

  1555. 

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

  1557.     if (spl.ok())

  1558.     {

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

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

  1561.         skins._default = settings::darkMode ? "dark" : "light";

  1562. #define modelADSR modelBogaudioADSR

  1563. #define modelLFO modelBogaudioLFO

  1564. #define modelNoise modelBogaudioNoise

  1565. #define modelVCA modelBogaudioVCA

  1566. #define modelVCF modelBogaudioVCF

  1567. #define modelVCO modelBogaudioVCO

  1568.         p->addModel(modelVCO);

  1569.         p->addModel(modelLVCO);

  1570.         p->addModel(modelSine);

  1571.         p->addModel(modelPulse);

  1572.         p->addModel(modelXCO);

  1573.         p->addModel(modelAdditator);

  1574.         p->addModel(modelFMOp);

  1575.         p->addModel(modelChirp);

  1576.         p->addModel(modelLFO);

  1577.         p->addModel(modelLLFO);

  1578.         p->addModel(modelFourFO);

  1579.         p->addModel(modelEightFO);

  1580.         p->addModel(modelVCF);

  1581.         p->addModel(modelLVCF);

  1582.         p->addModel(modelFFB);

  1583.         p->addModel(modelEQ);

  1584.         p->addModel(modelEQS);

  1585.         p->addModel(modelLPG);

  1586.         p->addModel(modelLLPG);

  1587.         p->addModel(modelMegaGate);

  1588.         p->addModel(modelPEQ);

  1589.         p->addModel(modelPEQ6);

  1590.         p->addModel(modelPEQ6XF);

  1591.         p->addModel(modelPEQ14);

  1592.         p->addModel(modelPEQ14XF);

  1593.         p->addModel(modelDADSRH);

  1594.         p->addModel(modelDADSRHPlus);

  1595.         p->addModel(modelShaper);

  1596.         p->addModel(modelShaperPlus);

  1597.         p->addModel(modelAD);

  1598.         p->addModel(modelASR);

  1599.         p->addModel(modelADSR);

  1600.         p->addModel(modelVish);

  1601.         p->addModel(modelFollow);

  1602.         p->addModel(modelDGate);

  1603.         p->addModel(modelRGate);

  1604.         p->addModel(modelEdge);

  1605.         p->addModel(modelNoise);

  1606.         p->addModel(modelSampleHold);

  1607.         p->addModel(modelWalk2);

  1608.         p->addModel(modelWalk);

  1609.         p->addModel(modelMix8);

  1610.         p->addModel(modelMix8x);

  1611.         p->addModel(modelMix4);

  1612.         p->addModel(modelMix4x);

  1613.         p->addModel(modelMix2);

  1614.         p->addModel(modelMix1);

  1615.         p->addModel(modelVCM);

  1616.         p->addModel(modelMute8);

  1617.         p->addModel(modelPan);

  1618.         p->addModel(modelXFade);

  1619.         p->addModel(modelVCA);

  1620.         p->addModel(modelVCAmp);

  1621.         p->addModel(modelVelo);

  1622.         p->addModel(modelUMix);

  1623.         p->addModel(modelMumix);

  1624.         p->addModel(modelMatrix81);

  1625.         p->addModel(modelMatrix18);

  1626.         p->addModel(modelMatrix44);

  1627.         p->addModel(modelMatrix44Cvm);

  1628.         p->addModel(modelMatrix88);

  1629.         p->addModel(modelMatrix88Cv);

  1630.         p->addModel(modelMatrix88M);

  1631.         p->addModel(modelSwitch81);

  1632.         p->addModel(modelSwitch18);

  1633.         p->addModel(modelSwitch44);

  1634.         p->addModel(modelSwitch88);

  1635.         p->addModel(modelSwitch1616);

  1636.         p->addModel(modelAMRM);

  1637.         p->addModel(modelPressor);

  1638.         p->addModel(modelClpr);

  1639.         p->addModel(modelLmtr);

  1640.         p->addModel(modelNsgt);

  1641.         p->addModel(modelCmpDist);

  1642.         p->addModel(modelOneEight);

  1643.         p->addModel(modelEightOne);

  1644.         p->addModel(modelAddrSeq);

  1645.         p->addModel(modelAddrSeqX);

  1646.         p->addModel(modelPgmr);

  1647.         p->addModel(modelPgmrX);

  1648.         p->addModel(modelVU);

  1649.         p->addModel(modelAnalyzer);

  1650.         p->addModel(modelAnalyzerXL);

  1651.         p->addModel(modelRanalyzer);

  1652.         p->addModel(modelDetune);

  1653.         p->addModel(modelStack);

  1654.         p->addModel(modelReftone);

  1655.         p->addModel(modelMono);

  1656.         p->addModel(modelArp);

  1657.         p->addModel(modelAssign);

  1658.         p->addModel(modelUnison);

  1659.         p->addModel(modelPolyCon8);

  1660.         p->addModel(modelPolyCon16);

  1661.         p->addModel(modelPolyOff8);

  1662.         p->addModel(modelPolyOff16);

  1663.         p->addModel(modelPolyMult);

  1664.         p->addModel(modelBool);

  1665.         p->addModel(modelCmp);

  1666.         p->addModel(modelCVD);

  1667.         p->addModel(modelFlipFlop);

  1668.         p->addModel(modelInv);

  1669.         p->addModel(modelManual);

  1670.         p->addModel(modelFourMan);

  1671.         p->addModel(modelMult);

  1672.         p->addModel(modelOffset);

  1673.         p->addModel(modelSlew);

  1674.         p->addModel(modelSums);

  1675.         p->addModel(modelSwitch);

  1676.         p->addModel(modelLgsw);

  1677.         p->addModel(modelBlank3);

  1678.         p->addModel(modelBlank6);

  1679. #ifdef EXPERIMENTAL

  1680.         p->addModel(modelLag);

  1681.         p->addModel(modelPEQ14XR);

  1682.         p->addModel(modelPEQ14XV);

  1683. #endif

  1684. #ifdef TEST

  1685.         p->addModel(modelTest);

  1686.         p->addModel(modelTest2);

  1687.         p->addModel(modelTestExpanderBase);

  1688.         p->addModel(modelTestExpanderExtension);

  1689.         p->addModel(modelTestGl);

  1690.         p->addModel(modelTestVCF);

  1691. #endif

  1692. #undef modelADSR

  1693. #undef modelLFO

  1694. #undef modelNoise

  1695. #undef modelVCA

  1696. #undef modelVCF

  1697. #undef modelVCO

  1698.     }

  1699. }

  1700. 

  1701. static void initStatic__CatroModulo()

  1702. {

  1703.     Plugin* const p = new Plugin;

  1704.     pluginInstance__CatroModulo = p;

  1705. 

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

  1707.     if (spl.ok())

  1708.     {

  1709.         p->addModel(modelCM1Module);

  1710.         p->addModel(modelCM2Module);

  1711.         p->addModel(modelCM3Module);

  1712.         p->addModel(modelCM4Module);

  1713.         p->addModel(modelCM5Module);

  1714.         p->addModel(modelCM6Module);

  1715.         p->addModel(modelCM7Module);

  1716.         p->addModel(modelCM8Module);

  1717.         p->addModel(modelCM9Module);

  1718.         p->addModel(modelCM10Module);

  1719.     }

  1720. }

  1721. 

  1722. static void initStatic__cf()

  1723. {

  1724.     Plugin* const p = new Plugin;

  1725.     pluginInstance__cf = p;

  1726. 

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

  1728.     if (spl.ok())

  1729.     {

  1730.         p->addModel(modelMETRO);

  1731.         p->addModel(modelEACH);

  1732.         p->addModel(modeltrSEQ);

  1733.         p->addModel(modelLEDSEQ);

  1734.         p->addModel(modelL3DS3Q);

  1735.         p->addModel(modelSLIDERSEQ);

  1736.         p->addModel(modelPLAYER);

  1737.         p->addModel(modelPLAY);

  1738.         p->addModel(modelMONO);

  1739.         p->addModel(modelSTEREO);

  1740.         p->addModel(modelSUB);

  1741.         p->addModel(modelMASTER);

  1742.         p->addModel(modelVARIABLE);

  1743.         p->addModel(modelALGEBRA);

  1744.         p->addModel(modelFUNKTION);

  1745.         p->addModel(modelCHOKE);

  1746.         p->addModel(modelFOUR);

  1747.         p->addModel(modelSTEPS);

  1748.         p->addModel(modelPEAK);

  1749.         p->addModel(modelCUTS);

  1750.         p->addModel(modelBUFFER);

  1751.         p->addModel(modelDISTO);

  1752.         p->addModel(modelCUBE);

  1753.         p->addModel(modelPATCH);

  1754.         p->addModel(modelLABEL);

  1755.         p->addModel(modelDAVE);

  1756.     }

  1757. }

  1758. 

  1759. static void initStatic__ChowDSP()

  1760. {

  1761.     Plugin* const p = new Plugin;

  1762.     pluginInstance__ChowDSP = p;

  1763. 

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

  1765.     if (spl.ok())

  1766.     {

  1767.         p->addModel(modelChowTape);

  1768.         p->addModel(modelChowPhaserFeedback);

  1769.         p->addModel(modelChowPhaserMod);

  1770.         p->addModel(modelChowFDN);

  1771.         p->addModel(modelChowRNN);

  1772.         p->addModel(modelChowModal);

  1773.         p->addModel(modelChowDer);

  1774.         p->addModel(modelWarp);

  1775.         p->addModel(modelWerner);

  1776.         p->addModel(modelCredit);

  1777.         p->addModel(modelChowPulse);

  1778.         p->addModel(modelChowTapeCompression);

  1779.         p->addModel(modelChowTapeChew);

  1780.         p->addModel(modelChowTapeDegrade);

  1781.         p->addModel(modelChowTapeLoss);

  1782.         p->addModel(modelChowChorus);

  1783.     }

  1784. }

  1785. 

  1786. static void initStatic__dBiz()

  1787. {

  1788.     Plugin* const p = new Plugin;

  1789.     pluginInstance__dBiz = p;

  1790. 

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

  1792.     if (spl.ok())

  1793.     {

  1794. #define modelChord modeldBizChord

  1795. #define modelDivider modeldBizDivider

  1796. #define modelFourSeq modeldBizFourSeq

  1797. #define modelVCA4 modeldBizVCA4

  1798.         p->addModel(modelNavControl);

  1799.         p->addModel(modelBench);

  1800.         p->addModel(modelContorno);

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

  1802.         p->addModel(modelTranspose);

  1803.         p->addModel(modelUtility);

  1804.         p->addModel(modelChord);

  1805.         p->addModel(modelBene);

  1806.         p->addModel(modelBenePads);

  1807.         p->addModel(modelPerfMixer);

  1808.         p->addModel(modelDrMix);

  1809.         p->addModel(modelPerfMixer4);

  1810.         p->addModel(modelVCA4);

  1811.         p->addModel(modelVCA530);

  1812.         p->addModel(modelRemix);

  1813.         p->addModel(modelSmixer);

  1814.         p->addModel(modelVerbo);

  1815.         p->addModel(modelDVCO);

  1816.         p->addModel(modelDAOSC);

  1817.         p->addModel(modelTROSC);

  1818.         p->addModel(modelTROSCMK2);

  1819.         p->addModel(modelSuHa);

  1820.         p->addModel(modelSuHaMK2);

  1821.         p->addModel(modelFourSeq);

  1822.         p->addModel(modelDivider);

  1823.         p->addModel(modelUtil2);

  1824.         p->addModel(modelSmorph);

  1825.         p->addModel(modelBigSmorph);

  1826.         p->addModel(modelSPan);

  1827.         p->addModel(modelQuePasa);

  1828.         p->addModel(modelDualFilter);

  1829.         p->addModel(modelOrder);

  1830.         p->addModel(modelDualMatrix);

  1831. #undef modelChord

  1832. #undef modelDivider

  1833. #undef modelFourSeq

  1834. #undef modelVCA4

  1835.     }

  1836. }

  1837. 

  1838. static void initStatic__DrumKit()

  1839. {

  1840.     Plugin* const p = new Plugin;

  1841.     pluginInstance__DrumKit = p;

  1842. 

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

  1844.     if (spl.ok())

  1845.     {

  1846.         setupSamples();

  1847.         p->addModel(modelBD9);

  1848.         p->addModel(modelSnare);

  1849.         p->addModel(modelClosedHH);

  1850.         p->addModel(modelOpenHH);

  1851.         p->addModel(modelDMX);

  1852.         p->addModel(modelCR78);

  1853.         p->addModel(modelSBD);

  1854.         p->addModel(modelGnome);

  1855.         p->addModel(modelSequencer);

  1856.         p->addModel(modelTomi);

  1857.         p->addModel(modelBaronial);

  1858.         p->addModel(modelMarionette);

  1859.     }

  1860. }

  1861. 

  1862. static void initStatic__EnigmaCurry()

  1863. {

  1864.     Plugin* const p = new Plugin;

  1865.     pluginInstance__EnigmaCurry = p;

  1866. 

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

  1868.     if (spl.ok())

  1869.     {

  1870. #define modelPulse modelEnigmaCurryPulse

  1871.       p->addModel(modelTransport);

  1872.       p->addModel(modelLatch);

  1873.       p->addModel(modelPulse);

  1874.       p->addModel(modelRange);

  1875. #undef modelPulse

  1876.     }

  1877. }

  1878. 

  1879. 

  1880. static void initStatic__ESeries()

  1881. {

  1882.     Plugin* const p = new Plugin;

  1883.     pluginInstance__ESeries = p;

  1884. 

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

  1886.     if (spl.ok())

  1887.     {

  1888.         p->addModel(modelE340);

  1889.     }

  1890. }

  1891. 

  1892. static void initStatic__ExpertSleepersEncoders()

  1893. {

  1894.     Plugin* const p = new Plugin;

  1895.     pluginInstance__ExpertSleepersEncoders = p;

  1896. 

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

  1898.     if (spl.ok())

  1899.     {

  1900.         p->addModel(model8GT);

  1901.         p->addModel(model8CV);

  1902.         p->addModel(modelES40);

  1903.         p->addModel(modelES5);

  1904.         p->addModel(modelSMUX);

  1905.         p->addModel(modelCalibrator);

  1906.     }

  1907. }

  1908. 

  1909. static void initStatic__Extratone()

  1910. {

  1911.     Plugin* const p = new Plugin;

  1912.     pluginInstance__Extratone = p;

  1913. 

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

  1915.     if (spl.ok())

  1916.     {

  1917.         p->addModel(modelModulo);

  1918.         p->addModel(modelMesoglea);

  1919.         p->addModel(modelMesoglea2);

  1920.         p->addModel(modelOpabinia);

  1921.         p->addModel(modelSplitterburst);

  1922.         p->addModel(modelPuzzlebox);

  1923.         p->addModel(modelDarwinism);

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

  1925.         p->addModel(modelIchneumonid);

  1926.         p->addModel(modelMeganeura);

  1927.         p->addModel(modelPureneura);

  1928.         p->addModel(modelMesohyl);

  1929.         p->addModel(modelXtrtnBlank);

  1930.     }

  1931. }

  1932. 

  1933. static void initStatic__FehlerFabrik()

  1934. {

  1935.     Plugin* const p = new Plugin;

  1936.     pluginInstance__FehlerFabrik = p;

  1937. 

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

  1939.     if (spl.ok())

  1940.     {

  1941.         p->addModel(modelPSIOP);

  1942.         p->addModel(modelPlanck);

  1943.         p->addModel(modelLuigi);

  1944.         p->addModel(modelAspect);

  1945.         p->addModel(modelMonte);

  1946.         p->addModel(modelArpanet);

  1947.         p->addModel(modelSigma);

  1948.         p->addModel(modelFax);

  1949.         p->addModel(modelRasoir);

  1950.         p->addModel(modelChi);

  1951.         p->addModel(modelNova);

  1952.         p->addModel(modelLilt);

  1953.         p->addModel(modelBotzinger);

  1954.     }

  1955. }

  1956. 

  1957. static void initStatic__forsitan()

  1958. {

  1959.     Plugin* const p = new Plugin;

  1960.     pluginInstance__forsitan = p;

  1961. 

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

  1963.     if (spl.ok())

  1964.     {

  1965.         p->addModel(alea);

  1966.         p->addModel(interea);

  1967.         p->addModel(cumuli);

  1968.         p->addModel(deinde);

  1969.         p->addModel(pavo);

  1970.     }

  1971. }

  1972. 

  1973. static void initStatic__GlueTheGiant()

  1974. {

  1975.     Plugin* const p = new Plugin;

  1976.     pluginInstance__GlueTheGiant = p;

  1977. 

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

  1979.     if (spl.ok())

  1980.     {

  1981.         p->addModel(modelGigBus);

  1982.         p->addModel(modelMiniBus);

  1983.         p->addModel(modelSchoolBus);

  1984.         p->addModel(modelMetroCityBus);

  1985.         p->addModel(modelBusDepot);

  1986.         p->addModel(modelBusRoute);

  1987.         p->addModel(modelRoad);

  1988.         p->addModel(modelEnterBus);

  1989.         p->addModel(modelExitBus);

  1990.     }

  1991. }

  1992. 

  1993. static void initStatic__GoodSheperd()

  1994. {

  1995.     Plugin* const p = new Plugin;

  1996.     pluginInstance__GoodSheperd = p;

  1997. 

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

  1999.     if (spl.ok())

  2000.     {

  2001.         p->addModel(modelHurdle);

  2002.         p->addModel(modelSEQ3st);

  2003.         p->addModel(modelStable16);

  2004.         p->addModel(modelStall);

  2005.         p->addModel(modelSwitch1);

  2006.         p->addModel(modelSeqtrol);

  2007.     }

  2008. }

  2009. 

  2010. static void initStatic__GrandeModular()

  2011. {

  2012.     Plugin* const p = new Plugin;

  2013.     pluginInstance__GrandeModular = p;

  2014. 

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

  2016.     if (spl.ok())

  2017.     {

  2018.         p->addModel(modelClip);

  2019.         p->addModel(modelCompare3);

  2020.         p->addModel(modelLFO3);

  2021.         p->addModel(modelLFO4);

  2022.         p->addModel(modelLogic);

  2023.         p->addModel(modelMerge8);

  2024.         p->addModel(modelMergeSplit4);

  2025.         p->addModel(modelMicrotonalChords);

  2026.         p->addModel(modelMicrotonalNotes);

  2027.         p->addModel(modelNoteMT);

  2028.         p->addModel(modelPeak);

  2029.         p->addModel(modelPolyMergeResplit);

  2030.         p->addModel(modelPolySplit);

  2031.         p->addModel(modelPush);

  2032.         p->addModel(modelQuant);

  2033.         p->addModel(modelQuantIntervals);

  2034.         p->addModel(modelQuantMT);

  2035.         p->addModel(modelSampleDelays);

  2036.         p->addModel(modelScale);

  2037.         p->addModel(modelSplit8);

  2038.         p->addModel(modelTails);

  2039.         p->addModel(modelTails4);

  2040.         p->addModel(modelVarSampleDelays);

  2041.         p->addModel(modelVCA3);

  2042.         p->addModel(modelVCA4);

  2043.     }

  2044. }

  2045. 

  2046. static void initStatic__H4N4()

  2047. {

  2048.     Plugin* const p = new Plugin;

  2049.     pluginInstance__H4N4 = p;

  2050. 

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

  2052.     if (spl.ok())

  2053.     {

  2054.         p->addModel(modelXenQnt);

  2055.     }

  2056. }

  2057. 

  2058. static void initStatic__HamptonHarmonics()

  2059. {

  2060.     Plugin* const p = new Plugin;

  2061.     pluginInstance__HamptonHarmonics = p;

  2062. 

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

  2064.     if (spl.ok())

  2065.     {

  2066. #define modelArp modelHamptonHarmonicsArp

  2067. #define modelProgress modelHamptonHarmonicsProgress

  2068.         p->addModel(modelArp);

  2069.         p->addModel(modelProgress);

  2070. #undef modelProgress

  2071. #undef modelArp

  2072.     }

  2073. }

  2074. 

  2075. static void initStatic__HetrickCV()

  2076. {

  2077.     Plugin* const p = new Plugin;

  2078.     pluginInstance__HetrickCV = p;

  2079. 

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

  2081.     if (spl.ok())

  2082.     {

  2083. #define modelASR modelHetrickCVASR

  2084. #define modelBlankPanel modelHetrickCVBlankPanel

  2085. #define modelFlipFlop modelHetrickCVFlipFlop

  2086. #define modelMidSide modelHetrickCVMidSide

  2087. #define modelMinMax modelHetrickCVMinMax

  2088.         p->addModel(modelTwoToFour);

  2089.         p->addModel(modelAnalogToDigital);

  2090.         p->addModel(modelASR);

  2091.         p->addModel(modelBinaryGate);

  2092.         p->addModel(modelBinaryNoise);

  2093.         p->addModel(modelBitshift);

  2094.         p->addModel(modelBlankPanel);

  2095.         p->addModel(modelBoolean3);

  2096.         p->addModel(modelChaos1Op);

  2097.         p->addModel(modelChaos2Op);

  2098.         p->addModel(modelChaos3Op);

  2099.         p->addModel(modelChaoticAttractors);

  2100.         p->addModel(modelClockedNoise);

  2101.         p->addModel(modelComparator);

  2102.         p->addModel(modelContrast);

  2103.         p->addModel(modelCrackle);

  2104.         p->addModel(modelDataCompander);

  2105.         p->addModel(modelDelta);

  2106.         p->addModel(modelDigitalToAnalog);

  2107.         p->addModel(modelDust);

  2108.         p->addModel(modelExponent);

  2109.         p->addModel(modelFBSineChaos);

  2110.         p->addModel(modelFlipFlop);

  2111.         p->addModel(modelFlipPan);

  2112.         p->addModel(modelGateJunction);

  2113.         p->addModel(modelGingerbread);

  2114.         p->addModel(modelLogicCombine);

  2115.         p->addModel(modelMidSide);

  2116.         p->addModel(modelMinMax);

  2117.         p->addModel(modelRandomGates);

  2118.         p->addModel(modelRotator);

  2119.         p->addModel(modelRungler);

  2120.         p->addModel(modelScanner);

  2121.         p->addModel(modelWaveshape);

  2122.         p->addModel(modelXYToPolar);

  2123. #undef modelASR

  2124. #undef modelBlankPanel

  2125. #undef modelFlipFlop

  2126. #undef modelMidSide

  2127. #undef modelMinMax

  2128.     }

  2129. }

  2130. 

  2131. static void initStatic__ImpromptuModular()

  2132. {

  2133.     Plugin* const p = new Plugin;

  2134.     pluginInstance__ImpromptuModular = p;

  2135. 

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

  2137.     if (spl.ok())

  2138.     {

  2139.         p->addModel(modelAdaptiveQuantizer);

  2140.         p->addModel(modelBigButtonSeq);

  2141.         p->addModel(modelBigButtonSeq2);

  2142.         p->addModel(modelChordKey);

  2143.         p->addModel(modelChordKeyExpander);

  2144.         p->addModel(modelClocked);

  2145.         p->addModel(modelClockedExpander);

  2146.         p->addModel(modelClkd);

  2147.         p->addModel(modelCvPad);

  2148.         p->addModel(modelFoundry);

  2149.         p->addModel(modelFoundryExpander);

  2150.         p->addModel(modelFourView);

  2151.         p->addModel(modelGateSeq64);

  2152.         p->addModel(modelGateSeq64Expander);

  2153.         p->addModel(modelHotkey);

  2154.         p->addModel(modelPart);

  2155.         p->addModel(modelPhraseSeq16);

  2156.         p->addModel(modelPhraseSeq32);

  2157.         p->addModel(modelPhraseSeqExpander);

  2158.         p->addModel(modelProbKey);

  2159.         p->addModel(modelSemiModularSynth);

  2160.         p->addModel(modelSygen);

  2161.         p->addModel(modelTact);

  2162.         p->addModel(modelTact1);

  2163.         p->addModel(modelTactG);

  2164.         p->addModel(modelTwelveKey);

  2165.         p->addModel(modelVariations);

  2166.         p->addModel(modelWriteSeq32);

  2167.         p->addModel(modelWriteSeq64);

  2168.         p->addModel(modelBlankPanel);

  2169.     }

  2170. }

  2171. 

  2172. static void initStatic__ihtsyn()

  2173. {

  2174.     Plugin* const p = new Plugin;

  2175.     pluginInstance__ihtsyn = p;

  2176. 

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

  2178.     if (spl.ok())

  2179.     {

  2180.         p->addModel(modelPitchMangler);

  2181.         p->addModel(modelTwistedVerb);

  2182.         p->addModel(modelHiVerb);

  2183.         p->addModel(modelMVerb);

  2184.     }

  2185. }

  2186. 

  2187. static void initStatic__JW()

  2188. {

  2189.     Plugin* const p = new Plugin;

  2190.     pluginInstance__JW = p;

  2191. 

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

  2193.     if (spl.ok())

  2194.     {

  2195. #define modelQuantizer modelJWQuantizer

  2196.         p->addModel(modelAdd5);

  2197.         p->addModel(modelBouncyBalls);

  2198.         p->addModel(modelCat);

  2199.         p->addModel(modelTree);

  2200.         p->addModel(modelFullScope);

  2201.         p->addModel(modelGridSeq);

  2202.         p->addModel(modelEightSeq);

  2203.         p->addModel(modelDivSeq);

  2204.         p->addModel(modelMinMax);

  2205.         p->addModel(modelNoteSeq);

  2206.         p->addModel(modelNoteSeqFu);

  2207.         p->addModel(modelNoteSeq16);

  2208.         p->addModel(modelTrigs);

  2209.         p->addModel(modelOnePattern);

  2210.         p->addModel(modelPatterns);

  2211.         p->addModel(modelQuantizer);

  2212.         p->addModel(modelSimpleClock);

  2213.         p->addModel(modelD1v1de);

  2214.         p->addModel(modelPres1t);

  2215.         p->addModel(modelThingThing);

  2216.         p->addModel(modelWavHead);

  2217.         p->addModel(modelXYPad);

  2218.         p->addModel(modelBlankPanel1hp);

  2219.         p->addModel(modelBlankPanelSmall);

  2220.         p->addModel(modelBlankPanelMedium);

  2221.         p->addModel(modelBlankPanelLarge);

  2222.         p->addModel(modelCoolBreeze);

  2223.         p->addModel(modelPete);

  2224.        #ifndef STATIC_BUILD

  2225.         p->addModel(modelStr1ker);

  2226.        #else

  2227.         spl.removeModule("Str1ker");

  2228.        #endif

  2229. #undef modelQuantizer

  2230.     }

  2231. }

  2232. 

  2233. static void initStatic__kocmoc()

  2234. {

  2235.     Plugin* const p = new Plugin;

  2236.     pluginInstance__kocmoc= p;

  2237. 

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

  2239.     if (spl.ok())

  2240.     {

  2241.         p->addModel(modelSVF_1);

  2242.         p->addModel(modelTRG);

  2243.         p->addModel(modelLADR);

  2244.         p->addModel(modelOP);

  2245.         p->addModel(modelPHASR);

  2246.         p->addModel(modelMUL);

  2247.         p->addModel(modelSKF);

  2248.         p->addModel(modelDDLY);

  2249.     }

  2250. }

  2251. 

  2252. static void initStatic__LifeFormModular()

  2253. {

  2254.     Plugin* const p = new Plugin;

  2255.     pluginInstance__LifeFormModular= p;

  2256. 

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

  2258.     if (spl.ok())

  2259.     {

  2260.         p->addModel(modelTimeDiktat);

  2261.         p->addModel(modelSequenceModeler);

  2262.         p->addModel(modelPitchDiktat);

  2263.         p->addModel(modelPitchIntegrator);

  2264.         p->addModel(modelBurstIntegrator);

  2265.         p->addModel(modelQuadModulator);

  2266.         p->addModel(modelImpulseControl);

  2267.         p->addModel(modelQuadSteppedOffset);

  2268.         p->addModel(modelPercussiveVibration);

  2269.         p->addModel(modelQuadUtility);

  2270.         p->addModel(modelAdditiveVibration);

  2271.         p->addModel(modelComplexOsc);

  2272.         p->addModel(modelDriftgen);

  2273.     }

  2274. }

  2275. 

  2276. static void initStatic__LilacLoop()

  2277. {

  2278.     Plugin* const p = new Plugin;

  2279.     pluginInstance__LilacLoop = p;

  2280. 

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

  2282.     if (spl.ok())

  2283.     {

  2284.         p->addModel(modelLooperOne);

  2285.     }

  2286. }

  2287. 

  2288. static void initStatic__LittleUtils()

  2289. {

  2290.     Plugin* const p = new Plugin;

  2291.     pluginInstance__LittleUtils = p;

  2292. 

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

  2294.     if (spl.ok())

  2295.     {

  2296.         p->addModel(modelButtonModule);

  2297.         p->addModel(modelPulseGenerator);

  2298.         p->addModel(modelBias_Semitone);

  2299.         p->addModel(modelMulDiv);

  2300.         p->addModel(modelTeleportInModule);

  2301.         p->addModel(modelTeleportOutModule);

  2302.     }

  2303. }

  2304. 

  2305. static void initStatic__Lomas()

  2306. {

  2307.     Plugin* const p = new Plugin;

  2308.     pluginInstance__Lomas = p;

  2309. 

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

  2311.     if (spl.ok())

  2312.     {

  2313.         p->addModel(modelAdvancedSampler);

  2314.         p->addModel(modelGateSequencer);

  2315.     }

  2316. }

  2317. 

  2318. static void initStatic__Lyrae()

  2319. {

  2320.     Plugin* const p = new Plugin;

  2321.     pluginInstance__Lyrae = p;

  2322. 

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

  2324.     if (spl.ok())

  2325.     {

  2326. #define modelDelta modelLyraeDelta

  2327.         p->addModel(modelSulafat);

  2328.         p->addModel(modelGamma);

  2329.         p->addModel(modelDelta);

  2330.         p->addModel(modelVega);

  2331.         p->addModel(modelBD383238);

  2332.         p->addModel(modelZeta);

  2333. #undef modelDelta

  2334.     }

  2335. }

  2336. 

  2337. static void initStatic__Meander()

  2338. {

  2339.     Plugin* const p = new Plugin;

  2340.     pluginInstance__Meander = p;

  2341. 

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

  2343.     if (spl.ok())

  2344.     {

  2345.         // for dark theme

  2346.         panelTheme = 1;

  2347.         p->addModel(modelMeander);

  2348.     }

  2349. }

  2350. 

  2351. static void initStatic__MindMeld()

  2352. {

  2353.     Plugin* const p = new Plugin;

  2354.     pluginInstance__MindMeld = p;

  2355. 

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

  2357.     if (spl.ok())

  2358.     {

  2359.         p->addModel(modelPatchMaster);

  2360.         p->addModel(modelPatchMasterBlank);

  2361.         p->addModel(modelRouteMasterMono5to1);

  2362.         p->addModel(modelRouteMasterStereo5to1);

  2363.         p->addModel(modelRouteMasterMono1to5);

  2364.         p->addModel(modelRouteMasterStereo1to5);

  2365.         p->addModel(modelMasterChannel);

  2366.         p->addModel(modelMeld);

  2367.         p->addModel(modelUnmeld);

  2368.         p->addModel(modelMSMelder);

  2369.         p->addModel(modelEqMaster);

  2370.         p->addModel(modelEqExpander);

  2371.         p->addModel(modelBassMaster);

  2372.         p->addModel(modelBassMasterJr);

  2373.         p->addModel(modelShapeMaster);

  2374.         p->addModel(modelMixMasterJr);

  2375.         p->addModel(modelAuxExpanderJr);

  2376.         p->addModel(modelMixMaster);

  2377.         p->addModel(modelAuxExpander);

  2378.     }

  2379. }

  2380. 

  2381. static void initStatic__ML()

  2382. {

  2383.     Plugin* const p = new Plugin;

  2384.     pluginInstance__ML = p;

  2385. 

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

  2387.     if (spl.ok())

  2388.     {

  2389. #define modelQuantizer modelMLQuantizer

  2390. #define modelSH8 modelMLSH8

  2391.         p->addModel(modelQuantizer);

  2392.         p->addModel(modelQuantum);

  2393.         p->addModel(modelTrigBuf);

  2394.         p->addModel(modelSeqSwitch);

  2395.         p->addModel(modelSeqSwitch2);

  2396.         p->addModel(modelShiftRegister);

  2397.         p->addModel(modelShiftRegister2);

  2398.         p->addModel(modelFreeVerb);

  2399.         p->addModel(modelSum8);

  2400.         p->addModel(modelSum8mk2);

  2401.         p->addModel(modelSum8mk3);

  2402.         p->addModel(modelSH8);

  2403.         p->addModel(modelConstants);

  2404.         p->addModel(modelCounter);

  2405.         p->addModel(modelTrigDelay);

  2406.         p->addModel(modelBPMdetect);

  2407.         p->addModel(modelVoltMeter);

  2408.         p->addModel(modelOctaFlop);

  2409.         p->addModel(modelOctaTrig);

  2410.         p->addModel(modelOctaSwitch);

  2411.         p->addModel(modelTrigSwitch);

  2412.         p->addModel(modelTrigSwitch2);

  2413.         p->addModel(modelTrigSwitch3);

  2414.         p->addModel(modelTrigSwitch3_2);

  2415.         p->addModel(modelOctaPlus);

  2416.         p->addModel(modelOctaTimes);

  2417.         p->addModel(modelCloner);

  2418.         p->addModel(modelPolySplitter);

  2419.         p->addModel(modelArpeggiator);

  2420. #undef modelQuantizer

  2421. #undef modelSH8

  2422.     }

  2423. }

  2424. 

  2425. static void initStatic__MockbaModular()

  2426. {

  2427.     Plugin* const p = new Plugin;

  2428.     pluginInstance__MockbaModular = p;

  2429. 

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

  2431.     if (spl.ok())

  2432.     {

  2433. #define modelBlank modelMockbaModularBlank

  2434. #define modelComparator modelMockbaModularComparator

  2435.         p->addModel(modelBlank);

  2436.         p->addModel(modelFeidah);

  2437.         p->addModel(modelFeidahS);

  2438.         p->addModel(modelFiltah);

  2439.         p->addModel(modelMixah);

  2440.         p->addModel(modelMixah3);

  2441.         p->addModel(modelDividah);

  2442.         p->addModel(modelCountah);

  2443.         p->addModel(modelSelectah);

  2444.         p->addModel(modelShapah);

  2445.         p->addModel(modelHoldah);

  2446.         p->addModel(modelPannah);

  2447.         p->addModel(modelReVoltah);

  2448.         p->addModel(modelCZSaw);

  2449.         p->addModel(modelCZSquare);

  2450.         p->addModel(modelCZPulse);

  2451.         p->addModel(modelCZDblSine);

  2452.         p->addModel(modelCZSawPulse);

  2453.         p->addModel(modelCZReso1);

  2454.         p->addModel(modelCZReso2);

  2455.         p->addModel(modelCZReso3);

  2456.         p->addModel(modelCZOsc);

  2457.         p->addModel(modelMaugTriangle);

  2458.         p->addModel(modelMaugShark);

  2459.         p->addModel(modelMaugSaw);

  2460.         p->addModel(modelMaugSaw2);

  2461.         p->addModel(modelMaugSquare);

  2462.         p->addModel(modelMaugSquare2);

  2463.         p->addModel(modelMaugSquare3);

  2464.         p->addModel(modelMaugOsc);

  2465.         p->addModel(modelComparator);

  2466.         p->addModel(modelDualBUFFER);

  2467.         p->addModel(modelDualNOT);

  2468.         p->addModel(modelDualOR);

  2469.         p->addModel(modelDualNOR);

  2470.         p->addModel(modelDualAND);

  2471.         p->addModel(modelDualNAND);

  2472.         p->addModel(modelDualXOR);

  2473.         p->addModel(modelDualXNOR);

  2474.         p->addModel(modelPSelectah);

  2475. 

  2476.         // require input files to work

  2477.         spl.removeModule("UDPClockMaster");

  2478.         spl.removeModule("UDPClockSlave");

  2479. #undef modelBlank

  2480. #undef modelComparator

  2481.     }

  2482. }

  2483. 

  2484. static void initStatic__Mog()

  2485. {

  2486.     Plugin* const p = new Plugin;

  2487.     pluginInstance__Mog = p;

  2488. 

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

  2490.     if (spl.ok())

  2491.     {

  2492.         p->addModel(modelNetwork);

  2493.         p->addModel(modelNexus);

  2494.     }

  2495. }

  2496. 

  2497. static void initStatic__mscHack()

  2498. {

  2499.     Plugin* const p = new Plugin;

  2500.     pluginInstance__mscHack = p;

  2501. 

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

  2503.     if (spl.ok())

  2504.     {

  2505.         p->addModel(modelCompressor);

  2506.         p->addModel(modelSynthDrums);

  2507.         p->addModel(modelSEQ_6x32x16);

  2508.         p->addModel(modelMasterClockx4);

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

  2510.         p->addModel(modelSEQ_Envelope_8);

  2511.         p->addModel(modelSeq_Triad2);

  2512.         p->addModel(modelARP700);

  2513.         p->addModel(modelMix_4_0_4);

  2514.         p->addModel(modelMix_9_3_4);

  2515.         p->addModel(modelMix_16_4_4);

  2516.         p->addModel(modelMix_24_4_4);

  2517.         p->addModel(modelASAF8);

  2518.         p->addModel(modelPingPong);

  2519.         p->addModel(modelStepDelay);

  2520.         p->addModel(modelOsc_3Ch);

  2521.         p->addModel(modelDronez);

  2522.         p->addModel(modelMorze);

  2523.         p->addModel(modelWindz);

  2524.         p->addModel(modelLorenz);

  2525.         p->addModel(modelAlienz);

  2526.         p->addModel(modelOSC_WaveMorph_3);

  2527.         p->addModel(modelMaude_221);

  2528.     }

  2529. }

  2530. 

  2531. static void initStatic__MSM()

  2532. {

  2533.     Plugin* const p = new Plugin;

  2534.     pluginInstance__MSM = p;

  2535. 

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

  2537.     if (spl.ok())

  2538.     {

  2539. #define modelADSR modelMSMADSR

  2540. #define modelBlankPanel modelMSMBlankPanel

  2541. #define modelDelay modelMSMDelay

  2542. #define modelLFO modelMSMLFO

  2543. #define modelMult modelMSMMult

  2544. #define modelNoise modelMSMNoise

  2545. #define modelVCA modelMSMVCA

  2546. #define modelVCO modelMSMVCO

  2547.         p->addModel(modelVCO);

  2548.         p->addModel(modelBVCO);

  2549.         p->addModel(modelExperimentalVCO);

  2550.         p->addModel(modelNoise);

  2551.         p->addModel(modelLFO);

  2552.         p->addModel(modelVCA);

  2553.         p->addModel(modelADSR);

  2554.         p->addModel(modelDelay);

  2555.         p->addModel(modelWaveShaper);

  2556.         p->addModel(modelWavefolder);

  2557.         p->addModel(modelBitcrusher);

  2558.         p->addModel(modelPhaserModule);

  2559.         p->addModel(modelMorpher);

  2560.         p->addModel(modelRingMod);

  2561.         p->addModel(modelRandomSource);

  2562.         p->addModel(modelMult);

  2563.         p->addModel(modelCrazyMult);

  2564.         p->addModel(modelFade);

  2565.         p->addModel(modelSimpleSlider);

  2566.         p->addModel(modelxseq);

  2567.         p->addModel(modelBlankPanel);

  2568. #undef modelADSR

  2569. #undef modelBlankPanel

  2570. #undef modelDelay

  2571. #undef modelLFO

  2572. #undef modelMult

  2573. #undef modelNoise

  2574. #undef modelVCA

  2575. #undef modelVCO

  2576.     }

  2577. }

  2578. 

  2579. static void initStatic__myth_modules()

  2580. {

  2581.     Plugin* const p = new Plugin;

  2582.     pluginInstance__myth_modules = p;

  2583. 

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

  2585.     if (spl.ok())

  2586.     {

  2587.         p->addModel(modelMavka);

  2588.         p->addModel(modelMolphar);

  2589.     }

  2590. }

  2591. 

  2592. static void initStatic__nonlinearcircuits()

  2593. {

  2594.     Plugin* const p = new Plugin;

  2595.     pluginInstance__nonlinearcircuits = p;

  2596. 

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

  2598.     if (spl.ok())

  2599.     {

  2600.         p->addModel(model4Seq);

  2601.         p->addModel(modelCipher);

  2602.         p->addModel(modelBOOLs);

  2603.         p->addModel(modelDivideConquer);

  2604.         p->addModel(modelDivineCMOS);

  2605.         p->addModel(modelDoubleNeuron);

  2606.         p->addModel(modelGenie);

  2607.         p->addModel(modelLetsSplosh);

  2608.         p->addModel(modelNeuron);

  2609.         p->addModel(modelNumberwang);

  2610.         p->addModel(modelRouter);

  2611.         p->addModel(modelSegue);

  2612.         p->addModel(modelSlothApathy);

  2613.         p->addModel(modelSlothInertia);

  2614.         p->addModel(modelSlothTorpor);

  2615.         p->addModel(modelSquidAxon);

  2616.         p->addModel(modelStatues);

  2617.         p->addModel(modelTripleSloth);

  2618.     }

  2619. }

  2620. 

  2621. static void initStatic__Orbits()

  2622. {

  2623.     Plugin* const p = new Plugin;

  2624.     pluginInstance__Orbits = p;

  2625. 

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

  2627.     if (spl.ok())

  2628.     {

  2629.         p->addModel(modelRareBreeds_Orbits_Eugene);

  2630.         p->addModel(modelRareBreeds_Orbits_Polygene);

  2631.     }

  2632. }

  2633. 

  2634. static void initStatic__ParableInstruments()

  2635. {

  2636.     Plugin* const p = new Plugin;

  2637.     pluginInstance__ParableInstruments = p;

  2638. 

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

  2640.     if (spl.ok())

  2641.     {

  2642. #define modelClouds modelParableClouds

  2643.         p->addModel(modelClouds);

  2644. #undef modelClouds

  2645.     }

  2646. }

  2647. 

  2648. static void initStatic__PathSet()

  2649. {

  2650.     Plugin* const p = new Plugin;

  2651.     pluginInstance__PathSet = p;

  2652. 

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

  2654.     if (spl.ok())

  2655.     {

  2656.         p->addModel(modelShiftyMod);

  2657.         p->addModel(modelShiftyExpander);

  2658.         p->addModel(modelIceTray);

  2659.         p->addModel(modelAstroVibe);

  2660.         p->addModel(modelGlassPane);

  2661. 	    p->addModel(modelPlusPane);

  2662.         p->addModel(modelNudge);

  2663.         p->addModel(modelOneShot);

  2664.     }

  2665. }

  2666. 

  2667. static void initStatic__PinkTrombone()

  2668. {

  2669.     Plugin* const p = new Plugin;

  2670.     pluginInstance__PinkTrombone = p;

  2671. 

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

  2673.     if (spl.ok())

  2674.     {

  2675.         p->addModel(modelPinkTrombone);

  2676.     }

  2677. }

  2678. 

  2679. static void initStatic__Prism()

  2680. {

  2681.     Plugin* const p = new Plugin;

  2682.     pluginInstance__Prism = p;

  2683. 

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

  2685.     if (spl.ok())

  2686.     {

  2687.         p->addModel(modelRainbow);

  2688.         p->addModel(modelRainbowScaleExpander);

  2689.         p->addModel(modelDroplet);

  2690.     }

  2691. }

  2692. 

  2693. static void initStatic__rackwindows()

  2694. {

  2695.     Plugin* const p = new Plugin;

  2696.     pluginInstance__rackwindows = p;

  2697. 

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

  2699.     if (spl.ok())

  2700.     {

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

  2702.         p->addModel(modelBitshiftgain);

  2703.         p->addModel(modelCapacitor);

  2704.         p->addModel(modelCapacitor_stereo);

  2705.         p->addModel(modelChorus);

  2706.         p->addModel(modelConsole);

  2707.         p->addModel(modelConsole_mm);

  2708.         p->addModel(modelDistance);

  2709.         p->addModel(modelGolem);

  2710.         p->addModel(modelHolt);

  2711.         p->addModel(modelHombre);

  2712.         p->addModel(modelInterstage);

  2713.         p->addModel(modelMonitoring);

  2714.         p->addModel(modelMv);

  2715.         p->addModel(modelRasp);

  2716.         p->addModel(modelReseq);

  2717.         p->addModel(modelTape);

  2718.         p->addModel(modelTremolo);

  2719.         p->addModel(modelVibrato);

  2720.     }

  2721. }

  2722. 

  2723. static void initStatic__RebelTech()

  2724. {

  2725.     Plugin* const p = new Plugin;

  2726.     pluginInstance__RebelTech = p;

  2727. 

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

  2729.     if (spl.ok())

  2730.     {

  2731.         p->addModel(modelStoicheia);

  2732.         p->addModel(modelTonic);

  2733.         p->addModel(modelKlasmata);

  2734.         p->addModel(modelCLK);

  2735.         p->addModel(modelLogoi);

  2736.         p->addModel(modelPhoreo);

  2737.     }

  2738. }

  2739. 

  2740. static void initStatic__repelzen()

  2741. {

  2742.     Plugin* const p = new Plugin;

  2743.     pluginInstance__repelzen = p;

  2744. 

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

  2746.     if (spl.ok())

  2747.     {

  2748. #define modelBlank modelrepelzenBlank

  2749. #define modelMixer modelrepelzenMixer

  2750. #define modelWerner modelrepelzenWerner

  2751.         p->addModel(modelBlank);

  2752.         p->addModel(modelBurst);

  2753.         p->addModel(modelFolder);

  2754.         p->addModel(modelErwin);

  2755.         p->addModel(modelWerner);

  2756.         p->addModel(modelMixer);

  2757. #undef modelBlank

  2758. #undef modelMixer

  2759. #undef modelWerner

  2760.     }

  2761. }

  2762. 

  2763. static void initStatic__Sapphire()

  2764. {

  2765.     Plugin* const p = new Plugin;

  2766.     pluginInstance__sapphire = p;

  2767. 

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

  2769.     if (spl.ok())

  2770.     {

  2771.         p->addModel(modelElastika);

  2772.         p->addModel(modelFrolic);

  2773.         p->addModel(modelGlee);

  2774.         p->addModel(modelMoots);

  2775.         p->addModel(modelTin);

  2776.         p->addModel(modelTricorder);

  2777.         p->addModel(modelTubeUnit);

  2778.     }

  2779. }

  2780. 

  2781. static void initStatic__sonusmodular()

  2782. {

  2783.     Plugin* const p = new Plugin;

  2784.     pluginInstance__sonusmodular = p;

  2785. 

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

  2787.     if (spl.ok())

  2788.     {

  2789.         p->addModel(modelAddiction);

  2790.         p->addModel(modelBitter);

  2791.         p->addModel(modelBymidside);

  2792.         p->addModel(modelCampione);

  2793.         p->addModel(modelChainsaw);

  2794.         p->addModel(modelCtrl);

  2795.         p->addModel(modelDeathcrush);

  2796.         p->addModel(modelFraction);

  2797.         p->addModel(modelHarmony);

  2798.         p->addModel(modelLadrone);

  2799.         p->addModel(modelLuppolo);

  2800.         p->addModel(modelLuppolo3);

  2801.         p->addModel(modelMicromacro);

  2802.         p->addModel(modelMrcheb);

  2803.         p->addModel(modelMultimulti);

  2804.         p->addModel(modelNeurosc);

  2805.         p->addModel(modelOktagon);

  2806.         p->addModel(modelOsculum);

  2807.         p->addModel(modelParamath);

  2808.         p->addModel(modelPiconoise);

  2809.         p->addModel(modelPith);

  2810.         p->addModel(modelPusher);

  2811.         p->addModel(modelRingo);

  2812.         p->addModel(modelScramblase);

  2813.         p->addModel(modelTropicana);

  2814.         p->addModel(modelTwoff);

  2815.         p->addModel(modelYabp);

  2816.     }

  2817. }

  2818. 

  2819. static void initStatic__stocaudio()

  2820. {

  2821.     Plugin* const p = new Plugin;

  2822.     pluginInstance__stocaudio = p;

  2823. 

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

  2825.     if (spl.ok())

  2826.     {

  2827.         p->addModel(modelPolyturing);

  2828.         p->addModel(modelPolydelay);

  2829.         p->addModel(modelSpread);

  2830.     }

  2831. }

  2832. 

  2833. static void initStatic__stoermelder_p1()

  2834. {

  2835.     Plugin* const p = new Plugin;

  2836.     pluginInstance__stoermelder_p1 = p;

  2837. 

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

  2839.     if (spl.ok())

  2840.     {

  2841.         p->addModel(modelCVMap);

  2842.         p->addModel(modelCVMapCtx);

  2843.         p->addModel(modelCVMapMicro);

  2844.         p->addModel(modelCVPam);

  2845.         p->addModel(modelRotorA);

  2846.         p->addModel(modelReMoveLite);

  2847.         p->addModel(modelBolt);

  2848.         p->addModel(modelInfix);

  2849.         p->addModel(modelInfixMicro);

  2850.         p->addModel(modelEightFace);

  2851.         p->addModel(modelEightFaceX2);

  2852.         p->addModel(modelSipo);

  2853.         p->addModel(modelFourRounds);

  2854.         p->addModel(modelArena);

  2855.         p->addModel(modelMaze);

  2856.         p->addModel(modelHive);

  2857.         p->addModel(modelIntermix);

  2858.         p->addModel(modelIntermixGate);

  2859.         p->addModel(modelIntermixEnv);

  2860.         p->addModel(modelIntermixFade);

  2861.         p->addModel(modelSail);

  2862.         p->addModel(modelPile);

  2863.         p->addModel(modelPilePoly);

  2864.         p->addModel(modelMirror);

  2865.         p->addModel(modelAffix);

  2866.         p->addModel(modelAffixMicro);

  2867.         p->addModel(modelGrip);

  2868.         p->addModel(modelGlue);

  2869.         p->addModel(modelGoto);

  2870.         p->addModel(modelStroke);

  2871.         p->addModel(modelSpin);

  2872.         p->addModel(modelTransit);

  2873.         p->addModel(modelTransitEx);

  2874.         p->addModel(modelX4);

  2875.         p->addModel(modelMacro);

  2876.         p->addModel(modelOrbit);

  2877.         p->addModel(modelEightFaceMk2);

  2878.         p->addModel(modelEightFaceMk2Ex);

  2879.         p->addModel(modelDirt);

  2880.         p->addModel(modelMb);

  2881.         p->addModel(modelMe);

  2882.         p->addModel(modelRaw);

  2883.         p->addModel(modelStrip);

  2884.         p->addModel(modelStripBay4);

  2885.         p->addModel(modelStripPp);

  2886. 

  2887.         spl.removeModule("AudioInterface64");

  2888.         spl.removeModule("MidiCat");

  2889.         spl.removeModule("MidiCatEx");

  2890.         spl.removeModule("MidiCatCtx");

  2891.         spl.removeModule("MidiKey");

  2892.         spl.removeModule("MidiMon");

  2893.         spl.removeModule("MidiPlug");

  2894.         spl.removeModule("MidiStep");

  2895.     }

  2896. }

  2897. 

  2898. static void initStatic__surgext()

  2899. {

  2900.     Plugin* const p = new Plugin;

  2901.     pluginInstance__surgext = p;

  2902. 

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

  2904.     if (spl.ok())

  2905.     {

  2906.         p->addModel(modelVCOClassic);

  2907.         p->addModel(modelVCOModern);

  2908.         p->addModel(modelVCOWavetable);

  2909.         p->addModel(modelVCOWindow);

  2910.         p->addModel(modelVCOSine);

  2911.         p->addModel(modelVCOFM2);

  2912.         p->addModel(modelVCOFM3);

  2913.         p->addModel(modelVCOSHNoise);

  2914.         p->addModel(modelVCOAlias);

  2915.         p->addModel(modelVCOString);

  2916.         p->addModel(modelVCOTwist);

  2917. 

  2918.         // Add the ported ones

  2919.         p->addModel(modelSurgeVCF);

  2920.         p->addModel(modelSurgeDelay);

  2921.         p->addModel(modelSurgeDelayLineByFreq);

  2922.         p->addModel(modelSurgeDelayLineByFreqExpanded);

  2923.         p->addModel(modelSurgeWaveshaper);

  2924.         p->addModel(modelSurgeLFO);

  2925.         p->addModel(modelSurgeMixer);

  2926.         p->addModel(modelSurgeModMatrix);

  2927. 

  2928.         p->addModel(modelFXReverb);

  2929.         p->addModel(modelFXPhaser);

  2930.         p->addModel(modelFXRotarySpeaker);

  2931.         p->addModel(modelFXDistortion);

  2932.         p->addModel(modelFXFrequencyShifter);

  2933.         p->addModel(modelFXChorus);

  2934.         p->addModel(modelFXVocoder);

  2935.         p->addModel(modelFXReverb2);

  2936.         p->addModel(modelFXFlanger);

  2937.         p->addModel(modelFXRingMod);

  2938.         p->addModel(modelFXNeuron);

  2939.         p->addModel(modelFXResonator);

  2940.         p->addModel(modelFXChow);

  2941.         p->addModel(modelFXExciter);

  2942.         p->addModel(modelFXEnsemble);

  2943.         p->addModel(modelFXCombulator);

  2944.         p->addModel(modelFXSpringReverb);

  2945.         p->addModel(modelFXTreeMonster);

  2946. 

  2947.         p->addModel(modelEGxVCA);

  2948.         p->addModel(modelQuadAD);

  2949.         p->addModel(modelQuadLFO);

  2950. 

  2951.         surgext_rack_initialize();

  2952.     }

  2953. }

  2954. 

  2955. static void initStatic__unless_modules()

  2956. {

  2957.     Plugin* const p = new Plugin;

  2958.     pluginInstance__unless_modules = p;

  2959. 

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

  2961.     if (spl.ok())

  2962.     {

  2963.         // unless_modules::init_theme();

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

  2965.         p->addModel(modelPiong);

  2966.         p->addModel(modelChainkov);

  2967.         p->addModel(modelAtoms);

  2968.         p->addModel(modelCantor);

  2969.         p->addModel(modelRoom);

  2970.         p->addModel(modelSnake);

  2971.         p->addModel(modelTowers);

  2972.         p->addModel(modelPianoid);

  2973.         p->addModel(modelPremuter);

  2974.         p->addModel(modelAvoider);

  2975.     }

  2976. }

  2977. 

  2978. static void initStatic__ValleyAudio()

  2979. {

  2980.     Plugin* const p = new Plugin;

  2981.     pluginInstance__ValleyAudio = p;

  2982. 

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

  2984.     if (spl.ok())

  2985.     {

  2986.         p->addModel(modelTopograph);

  2987.         p->addModel(modelUGraph);

  2988.         p->addModel(modelDexter);

  2989.         p->addModel(modelPlateau);

  2990.         p->addModel(modelInterzone);

  2991.         p->addModel(modelAmalgam);

  2992.         p->addModel(modelFeline);

  2993.         p->addModel(modelTerrorform);

  2994.     }

  2995. }

  2996. 

  2997. static void initStatic__Voxglitch()

  2998. {

  2999.     Plugin* p = new Plugin;

  3000.     pluginInstance__Voxglitch = p;

  3001. 

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

  3003.     if (spl.ok())

  3004.     {

  3005. #define modelLooper modelVoxglitchLooper

  3006.       p->addModel(modelAutobreak);

  3007.       p->addModel(modelByteBeat);

  3008.       p->addModel(modelDigitalProgrammer);

  3009.       p->addModel(modelDigitalSequencer);

  3010.       p->addModel(modelDigitalSequencerXP);

  3011.       p->addModel(modelGlitchSequencer);

  3012.       p->addModel(modelGhosts);

  3013.       p->addModel(modelGrainEngineMK2);

  3014.       p->addModel(modelGrainEngineMK2Expander);

  3015.       p->addModel(modelGrainFx);

  3016.       p->addModel(modelGrooveBox);

  3017.       p->addModel(modelGrooveBoxExpander);

  3018.       p->addModel(modelHazumi);

  3019.       p->addModel(modelLooper);

  3020.       p->addModel(modelRepeater);

  3021.       p->addModel(modelSamplerX8);

  3022.       p->addModel(modelSatanonaut);

  3023.       p->addModel(modelWavBank);

  3024.       p->addModel(modelWavBankMC);

  3025.       p->addModel(modelXY);

  3026. #undef modelLooper

  3027.     }

  3028. }

  3029. 

  3030. static void initStatic__WhatTheRack()

  3031. {

  3032.     Plugin* p = new Plugin;

  3033.     pluginInstance__WhatTheRack = p;

  3034. 

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

  3036.     if (spl.ok())

  3037.     {

  3038.       p->addModel(modelWhatTheRack);

  3039.       p->addModel(modelWhatTheMod);

  3040.       p->addModel(modelWhatTheJack);

  3041.     }

  3042. }

  3043. 

  3044. static void initStatic__ZetaCarinaeModules()

  3045. {

  3046.     Plugin* p = new Plugin;

  3047.     pluginInstance__ZetaCarinaeModules = p;

  3048. 

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

  3050.     if (spl.ok())

  3051.     {

  3052.         p->addModel(modelBrownianBridge);

  3053.         p->addModel(modelOrnsteinUhlenbeck);

  3054.         p->addModel(modelIOU);

  3055.         p->addModel(modelWarbler);

  3056.         p->addModel(modelRosenchance);

  3057.         p->addModel(modelGuildensTurn);

  3058.         p->addModel(modelRosslerRustler);

  3059.         p->addModel(modelFirefly);

  3060.     }

  3061. }

  3062. 

  3063. static void initStatic__ZZC()

  3064. {

  3065.     Plugin* p = new Plugin;

  3066.     pluginInstance__ZZC = p;

  3067. 

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

  3069.     if (spl.ok())

  3070.     {

  3071. #define modelClock modelZZCClock

  3072.         p->addModel(modelClock);

  3073.         p->addModel(modelDivider);

  3074.         p->addModel(modelFN3);

  3075.         p->addModel(modelSCVCA);

  3076.         p->addModel(modelSH8);

  3077.         p->addModel(modelSRC);

  3078.         p->addModel(modelDiv);

  3079.         p->addModel(modelDivExp);

  3080.         p->addModel(modelPolygate);

  3081. #undef modelClock

  3082.     }

  3083. }

  3084. #endif // NOPLUGINS

  3085. 

  3086. void initStaticPlugins()

  3087. {

  3088.     initStatic__Cardinal();

  3089.     initStatic__Fundamental();

  3090.     // initStatic__ZamAudio();

  3091. #ifndef NOPLUGINS

  3092.     initStatic__21kHz();

  3093.     initStatic__8Mode();

  3094.     initStatic__AaronStatic();

  3095.     initStatic__alefsbits();

  3096.     initStatic__Algoritmarte();

  3097.     initStatic__AmalgamatedHarmonics();

  3098.     initStatic__AnimatedCircuits();

  3099.     initStatic__ArableInstruments();

  3100.     initStatic__Aria();

  3101.     initStatic__AS();

  3102.     initStatic__AudibleInstruments();

  3103.     initStatic__Autinn();

  3104.     initStatic__Axioma();

  3105.     initStatic__Bacon();

  3106.     initStatic__Befaco();

  3107.     initStatic__Bidoo();

  3108.     initStatic__BogaudioModules();

  3109.     initStatic__CatroModulo();

  3110.     initStatic__cf();

  3111.     initStatic__ChowDSP();

  3112.     initStatic__dBiz();

  3113.     initStatic__DrumKit();

  3114.     initStatic__EnigmaCurry();

  3115.     initStatic__ESeries();

  3116.     initStatic__ExpertSleepersEncoders();

  3117.     initStatic__Extratone();

  3118.     initStatic__FehlerFabrik();

  3119.     initStatic__forsitan();

  3120.     initStatic__GlueTheGiant();

  3121.     initStatic__GoodSheperd();

  3122.     initStatic__GrandeModular();

  3123.     initStatic__H4N4();

  3124.     initStatic__HamptonHarmonics();

  3125.     initStatic__HetrickCV();

  3126.     initStatic__ImpromptuModular();

  3127.     initStatic__ihtsyn();

  3128.     initStatic__JW();

  3129.     initStatic__kocmoc();

  3130.     initStatic__LifeFormModular();

  3131.     initStatic__LilacLoop();

  3132.     initStatic__LittleUtils();

  3133.     initStatic__Lomas();

  3134.     initStatic__Lyrae();

  3135.     initStatic__Meander();

  3136.     initStatic__MindMeld();

  3137.     initStatic__ML();

  3138.     initStatic__MockbaModular();

  3139.     initStatic__Mog();

  3140.     initStatic__mscHack();

  3141.     initStatic__MSM();

  3142.     initStatic__myth_modules();

  3143.     initStatic__nonlinearcircuits();

  3144.     initStatic__Orbits();

  3145.     initStatic__ParableInstruments();

  3146.     initStatic__PathSet();

  3147.     initStatic__PinkTrombone();

  3148.     initStatic__Prism();

  3149.     initStatic__rackwindows();

  3150.     initStatic__RebelTech();

  3151.     initStatic__repelzen();

  3152.     initStatic__Sapphire();

  3153.     initStatic__sonusmodular();

  3154.     initStatic__stocaudio();

  3155.     initStatic__stoermelder_p1();

  3156.     initStatic__surgext();

  3157.     initStatic__unless_modules();

  3158.     initStatic__ValleyAudio();

  3159.     initStatic__Voxglitch();

  3160.     initStatic__WhatTheRack();

  3161.     initStatic__ZetaCarinaeModules();

  3162.     initStatic__ZZC();

  3163. #endif // NOPLUGINS

  3164. }

  3165. 

  3166. void destroyStaticPlugins()

  3167. {

  3168.     for (Plugin* p : plugins)

  3169.         delete p;

  3170.     plugins.clear();

  3171. }

  3172. 

  3173. void updateStaticPluginsDarkMode()

  3174. {

  3175. #ifndef NOPLUGINS

  3176.     const bool darkMode = settings::darkMode;

  3177.     // bogaudio

  3178.     {

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

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

  3181. 

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

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

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

  3185.         }

  3186.     }

  3187.     // meander

  3188.     {

  3189.         panelTheme = darkMode ? 1 : 0;

  3190.     }

  3191.     // glue the giant

  3192.     {

  3193.         gtg_default_theme = darkMode ? 1 : 0;

  3194.     }

  3195.     // surgext

  3196.     {

  3197.         surgext_rack_update_theme();

  3198.     }

  3199. #endif

  3200. }

  3201. 

  3202. }

  3203. }