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.

3460 lines
94KB

  1. /*
  2. * DISTRHO Cardinal Plugin
  3. * Copyright (C) 2021-2024 Filipe Coelho <falktx@falktx.com>
  4. * SPDX-License-Identifier: GPL-3.0-or-later
  5. */
  6. #include "rack.hpp"
  7. #include "plugin.hpp"
  8. #include "DistrhoUtils.hpp"
  9. // Cardinal (built-in)
  10. #include "Cardinal/src/plugin.hpp"
  11. // Fundamental (always enabled)
  12. #include "Fundamental/src/plugin.hpp"
  13. // ZamAudio (always enabled) - TODO
  14. // #include "ZamAudio/src/plugin.hpp"
  15. // 21kHz
  16. #include "21kHz/src/21kHz.hpp"
  17. // 8Mode
  18. #include "8Mode/src/8mode.hpp"
  19. // Aaron Static
  20. #include "AaronStatic/src/plugin.hpp"
  21. // Alef's Bits
  22. #define modelSteps modelalefsbitsSteps
  23. #define modelLogic modelalefsbitsLogic
  24. #include "alefsbits/src/plugin.hpp"
  25. #undef modelSteps
  26. #undef modelLogic
  27. // Algoritmarte
  28. #include "Algoritmarte/src/plugin.hpp"
  29. // AmalgamatedHarmonics
  30. #include "AmalgamatedHarmonics/src/AH.hpp"
  31. // AnimatedCircuits
  32. #include "AnimatedCircuits/src/plugin.hpp"
  33. // ArableInstruments
  34. #define modelClouds modelArableClouds
  35. #include "ArableInstruments/src/ArableInstruments.hpp"
  36. #undef modelClouds
  37. // Aria
  38. /* NOTE too much noise in original include, do this a different way
  39. // #include "AriaModules/src/plugin.hpp"
  40. */
  41. #define modelBlank modelAriaBlank
  42. extern Model* modelSplort;
  43. extern Model* modelSmerge;
  44. extern Model* modelSpleet;
  45. extern Model* modelSwerge;
  46. extern Model* modelSplirge;
  47. // extern Model* modelSrot;
  48. extern Model* modelQqqq;
  49. extern Model* modelQuack;
  50. extern Model* modelQ;
  51. extern Model* modelQuale;
  52. extern Model* modelDarius;
  53. extern Model* modelSolomon4;
  54. extern Model* modelSolomon8;
  55. extern Model* modelSolomon16;
  56. extern Model* modelPsychopump;
  57. extern Model* modelPokies4;
  58. extern Model* modelGrabby;
  59. extern Model* modelRotatoes4;
  60. extern Model* modelUndular;
  61. extern Model* modelBlank;
  62. #undef modelBlank
  63. // AS
  64. #define modelADSR modelASADSR
  65. #define modelVCA modelASVCA
  66. #define modelWaveShaper modelASWaveShaper
  67. #define LedLight ASLedLight
  68. #define YellowRedLight ASYellowRedLight
  69. #include "AS/src/AS.hpp"
  70. #undef modelADSR
  71. #undef modelVCA
  72. #undef modelWaveShaper
  73. #undef LedLight
  74. #undef YellowRedLight
  75. // AudibleInstruments
  76. #include "AudibleInstruments/src/plugin.hpp"
  77. // Autinn
  78. /* NOTE too much noise in original include, do this a different way
  79. // #include "Autinn/src/Autinn.hpp"
  80. */
  81. #define modelChord modelAutinnChord
  82. #define modelVibrato modelAutinnVibrato
  83. extern Model* modelJette;
  84. extern Model* modelFlora;
  85. extern Model* modelOxcart;
  86. extern Model* modelDeadband;
  87. extern Model* modelDigi;
  88. extern Model* modelFlopper;
  89. extern Model* modelAmp;
  90. extern Model* modelDC;
  91. extern Model* modelSjip;
  92. extern Model* modelBass;
  93. extern Model* modelSquare;
  94. extern Model* modelSaw;
  95. extern Model* modelBoomerang;
  96. extern Model* modelVibrato;
  97. extern Model* modelVectorDriver; //deprecated
  98. extern Model* modelCVConverter;
  99. extern Model* modelZod;
  100. extern Model* modelTriBand;
  101. extern Model* modelMixer6;
  102. extern Model* modelNon;
  103. extern Model* modelFil;
  104. extern Model* modelNap;
  105. extern Model* modelMelody;
  106. extern Model* modelChord;
  107. #undef modelChord
  108. #undef modelVibrato
  109. // Axioma
  110. #include "Axioma/src/plugin.hpp"
  111. // BaconPlugs
  112. #define INCLUDE_COMPONENTS_HPP
  113. #include "BaconPlugs/src/BaconPlugs.hpp"
  114. #undef INCLUDE_COMPONENTS_HPP
  115. #undef SCREW_WIDTH
  116. #undef RACK_HEIGHT
  117. // Befaco
  118. #define modelADSR modelBefacoADSR
  119. #define modelMixer modelBefacoMixer
  120. #define modelBurst modelBefacoBurst
  121. #include "Befaco/src/plugin.hpp"
  122. #undef modelADSR
  123. #undef modelMixer
  124. #undef modelBurst
  125. // Bidoo
  126. #include "Bidoo/src/plugin.hpp"
  127. // Biset
  128. #define Clock BisetClock
  129. #define ButtonTrigger BisetButtonTrigger
  130. #include "Biset/src/plugin.hpp"
  131. #undef ButtonTrigger
  132. #undef Clock
  133. // BogaudioModules - integrate theme/skin support
  134. #include <mutex>
  135. #include <string>
  136. #include <unordered_map>
  137. #include <unordered_set>
  138. #include <vector>
  139. #define private public
  140. #include "BogaudioModules/src/skins.hpp"
  141. #undef private
  142. // BogaudioModules
  143. #define modelADSR modelBogaudioADSR
  144. #define modelLFO modelBogaudioLFO
  145. #define modelNoise modelBogaudioNoise
  146. #define modelVCA modelBogaudioVCA
  147. #define modelVCF modelBogaudioVCF
  148. #define modelVCO modelBogaudioVCO
  149. extern Model* modelVCO;
  150. extern Model* modelLVCO;
  151. extern Model* modelSine;
  152. extern Model* modelPulse;
  153. extern Model* modelXCO;
  154. extern Model* modelAdditator;
  155. extern Model* modelFMOp;
  156. extern Model* modelChirp;
  157. extern Model* modelLFO;
  158. extern Model* modelLLFO;
  159. extern Model* modelFourFO;
  160. extern Model* modelEightFO;
  161. extern Model* modelVCF;
  162. extern Model* modelLVCF;
  163. extern Model* modelFFB;
  164. extern Model* modelEQ;
  165. extern Model* modelEQS;
  166. extern Model* modelLPG;
  167. extern Model* modelLLPG;
  168. extern Model* modelMegaGate;
  169. extern Model* modelPEQ;
  170. extern Model* modelPEQ6;
  171. extern Model* modelPEQ6XF;
  172. extern Model* modelPEQ14;
  173. extern Model* modelPEQ14XF;
  174. extern Model* modelDADSRH;
  175. extern Model* modelDADSRHPlus;
  176. extern Model* modelShaper;
  177. extern Model* modelShaperPlus;
  178. extern Model* modelAD;
  179. extern Model* modelASR;
  180. extern Model* modelADSR;
  181. extern Model* modelVish;
  182. extern Model* modelFollow;
  183. extern Model* modelDGate;
  184. extern Model* modelRGate;
  185. extern Model* modelEdge;
  186. extern Model* modelNoise;
  187. extern Model* modelSampleHold;
  188. extern Model* modelWalk2;
  189. extern Model* modelWalk;
  190. extern Model* modelMix8;
  191. extern Model* modelMix8x;
  192. extern Model* modelMix4;
  193. extern Model* modelMix4x;
  194. extern Model* modelMix2;
  195. extern Model* modelMix1;
  196. extern Model* modelVCM;
  197. extern Model* modelMute8;
  198. extern Model* modelPan;
  199. extern Model* modelXFade;
  200. extern Model* modelVCA;
  201. extern Model* modelVCAmp;
  202. extern Model* modelVelo;
  203. extern Model* modelUMix;
  204. extern Model* modelMumix;
  205. extern Model* modelMatrix81;
  206. extern Model* modelMatrix18;
  207. extern Model* modelMatrix44;
  208. extern Model* modelMatrix44Cvm;
  209. extern Model* modelMatrix88;
  210. extern Model* modelMatrix88Cv;
  211. extern Model* modelMatrix88M;
  212. extern Model* modelSwitch81;
  213. extern Model* modelSwitch18;
  214. extern Model* modelSwitch44;
  215. extern Model* modelSwitch88;
  216. extern Model* modelSwitch1616;
  217. extern Model* modelAMRM;
  218. extern Model* modelPressor;
  219. extern Model* modelClpr;
  220. extern Model* modelLmtr;
  221. extern Model* modelNsgt;
  222. extern Model* modelCmpDist;
  223. extern Model* modelOneEight;
  224. extern Model* modelEightOne;
  225. extern Model* modelAddrSeq;
  226. extern Model* modelAddrSeqX;
  227. extern Model* modelPgmr;
  228. extern Model* modelPgmrX;
  229. extern Model* modelVU;
  230. extern Model* modelAnalyzer;
  231. extern Model* modelAnalyzerXL;
  232. extern Model* modelRanalyzer;
  233. extern Model* modelDetune;
  234. extern Model* modelStack;
  235. extern Model* modelReftone;
  236. extern Model* modelMono;
  237. extern Model* modelArp;
  238. extern Model* modelAssign;
  239. extern Model* modelUnison;
  240. extern Model* modelPolyCon8;
  241. extern Model* modelPolyCon16;
  242. extern Model* modelPolyOff8;
  243. extern Model* modelPolyOff16;
  244. extern Model* modelPolyMult;
  245. extern Model* modelBool;
  246. extern Model* modelCmp;
  247. extern Model* modelCVD;
  248. extern Model* modelFlipFlop;
  249. extern Model* modelInv;
  250. extern Model* modelManual;
  251. extern Model* modelFourMan;
  252. extern Model* modelMult;
  253. extern Model* modelOffset;
  254. extern Model* modelSlew;
  255. extern Model* modelSums;
  256. extern Model* modelSwitch;
  257. extern Model* modelLgsw;
  258. extern Model* modelBlank3;
  259. extern Model* modelBlank6;
  260. #ifdef EXPERIMENTAL
  261. extern Model* modelLag;
  262. extern Model* modelPEQ14XR;
  263. extern Model* modelPEQ14XV;
  264. #endif
  265. #ifdef TEST
  266. extern Model* modelTest;
  267. extern Model* modelTest2;
  268. extern Model* modelTestExpanderBase;
  269. extern Model* modelTestExpanderExtension;
  270. extern Model* modelTestGl;
  271. extern Model* modelTestVCF;
  272. #endif
  273. #undef modelADSR
  274. #undef modelLFO
  275. #undef modelNoise
  276. #undef modelVCA
  277. #undef modelVCF
  278. #undef modelVCO
  279. // CatroModulo
  280. #include "CatroModulo/src/CatroModulo.hpp"
  281. // cf
  282. #include "cf/src/plugin.hpp"
  283. // CVfunk
  284. #define modelSteps modelCVfunkSteps
  285. #include "CVfunk/src/plugin.hpp"
  286. #undef modelSteps
  287. // ChowDSP
  288. #include "ChowDSP/src/plugin.hpp"
  289. #define init initChowDSP
  290. #include "ChowDSP/src/plugin.cpp"
  291. #undef init
  292. // Computerscare
  293. #include "Computerscare/src/Computerscare.hpp"
  294. // dBiz
  295. #define DarkDefaultItem dBizDarkDefaultItem
  296. #define OrangeLight dBizOrangeLight
  297. #define darkPanelID dBizdarkPanelID
  298. #define lightPanelID dBizlightPanelID
  299. #define modelChord modeldBizChord
  300. #define modelDivider modeldBizDivider
  301. #define modelFourSeq modeldBizFourSeq
  302. #define modelVCA4 modeldBizVCA4
  303. #include "dBiz/src/plugin.hpp"
  304. #undef DarkDefaultItem
  305. #undef OrangeLight
  306. #undef darkPanelID
  307. #undef lightPanelID
  308. #undef modelChord
  309. #undef modelDivider
  310. #undef modelFourSeq
  311. #undef modelVCA4
  312. // DHEModules
  313. // NOTE very unique way of handling init, needs special handling
  314. namespace dhe {
  315. namespace blossom { void init(Plugin*); }
  316. namespace buttons { void init(Plugin*); }
  317. namespace cubic { void init(Plugin*); }
  318. namespace curve_sequencer { void init(Plugin*); }
  319. namespace envelope { void init(Plugin*); }
  320. namespace func { void init(Plugin*); }
  321. namespace fuzzy_logic { void init(Plugin*); }
  322. namespace gator { void init(Plugin*); }
  323. namespace ranger { void init(Plugin*); }
  324. namespace scannibal { void init(Plugin*); }
  325. namespace sequencizer { void init(Plugin*); }
  326. namespace swave { void init(Plugin*); }
  327. namespace tapers { void init(Plugin*); }
  328. namespace truth { void init(Plugin*); }
  329. namespace xycloid { void init(Plugin*); }
  330. }
  331. // DrumKit
  332. #include "DrumKit/src/DrumKit.hpp"
  333. void setupSamples();
  334. // EnigmaCurry
  335. #define modelPulse modelEnigmaCurryPulse
  336. #include "EnigmaCurry/src/plugin.hpp"
  337. #undef modelPulse
  338. // ESeries
  339. #include "ESeries/src/plugin.hpp"
  340. // ExpertSleepers-Encoders
  341. #include "ExpertSleepers-Encoders/src/Encoders.hpp"
  342. // Extratone
  343. #include "Extratone/src/plugin.hpp"
  344. // FehlerFabrik
  345. #include "FehlerFabrik/src/plugin.hpp"
  346. // forsitan modulare
  347. #include "forsitan-modulare/src/forsitan.hpp"
  348. // GlueTheGiant
  349. #include "GlueTheGiant/src/plugin.hpp"
  350. bool audition_mixer = false;
  351. bool audition_depot = false;
  352. int gtg_default_theme = 1;
  353. int loadGtgPluginDefault(const char*, int) { return 1; }
  354. void saveGtgPluginDefault(const char*, int) {}
  355. // GoodSheperd
  356. #include "GoodSheperd/src/plugin.hpp"
  357. // GrandeModular
  358. #include "GrandeModular/src/plugin.hpp"
  359. // H4N4 Modules
  360. #include "h4n4-modules/src/plugin.hpp"
  361. // Hampton Harmonics
  362. #define modelArp modelHamptonHarmonicsArp
  363. #define modelProgress modelHamptonHarmonicsProgress
  364. #include "HamptonHarmonics/src/plugin.hpp"
  365. #undef modelProgress
  366. #undef modelArp
  367. // HetrickCV
  368. #define modelASR modelHetrickCVASR
  369. #define modelBlankPanel modelHetrickCVBlankPanel
  370. #define modelFlipFlop modelHetrickCVFlipFlop
  371. #define modelMidSide modelHetrickCVMidSide
  372. #define modelMinMax modelHetrickCVMinMax
  373. #define PanelBaseWidget HetrickCVPanelBaseWidget
  374. #define InverterWidget HetrickCVInverterWidget
  375. extern Model* modelTwoToFour;
  376. extern Model* modelAnalogToDigital;
  377. extern Model* modelASR;
  378. extern Model* modelBinaryGate;
  379. extern Model* modelBinaryNoise;
  380. extern Model* modelBitshift;
  381. extern Model* modelBlankPanel;
  382. extern Model* modelBoolean3;
  383. extern Model* modelChaos1Op;
  384. extern Model* modelChaos2Op;
  385. extern Model* modelChaos3Op;
  386. extern Model* modelChaoticAttractors;
  387. extern Model* modelClockedNoise;
  388. extern Model* modelComparator;
  389. extern Model* modelContrast;
  390. extern Model* modelCrackle;
  391. extern Model* modelDataCompander;
  392. extern Model* modelDelta;
  393. extern Model* modelDigitalToAnalog;
  394. extern Model* modelDust;
  395. extern Model* modelExponent;
  396. extern Model* modelFBSineChaos;
  397. extern Model* modelFlipFlop;
  398. extern Model* modelFlipPan;
  399. extern Model* modelGateDelay;
  400. extern Model* modelGateJunction;
  401. extern Model* modelGateJunctionExp;
  402. extern Model* modelGingerbread;
  403. extern Model* modelLogicCombine;
  404. extern Model* modelMidSide;
  405. extern Model* modelMinMax;
  406. extern Model* modelPhaseDrivenSequencer;
  407. extern Model* modelPhaseDrivenSequencer32;
  408. extern Model* modelPhasorAnalyzer;
  409. extern Model* modelPhasorBurstGen;
  410. extern Model* modelPhasorDivMult;
  411. extern Model* modelPhasorEuclidean;
  412. extern Model* modelPhasorGates;
  413. extern Model* modelPhasorGates32;
  414. extern Model* modelPhasorGates64;
  415. extern Model* modelPhasorGen;
  416. extern Model* modelPhasorGeometry;
  417. extern Model* modelPhasorHumanizer;
  418. extern Model* modelPhasorMixer;
  419. extern Model* modelPhasorOctature;
  420. extern Model* modelPhasorQuadrature;
  421. extern Model* modelPhasorRandom;
  422. extern Model* modelPhasorRanger;
  423. extern Model* modelPhasorReset;
  424. extern Model* modelPhasorRhythmGroup;
  425. extern Model* modelPhasorShape;
  426. extern Model* modelPhasorShift;
  427. extern Model* modelPhasorStutter;
  428. extern Model* modelPhasorSubstepShape;
  429. extern Model* modelPhasorSwing;
  430. extern Model* modelPhasorTimetable;
  431. extern Model* modelPhasorToClock;
  432. extern Model* modelPhasorToLFO;
  433. extern Model* modelPhasorToWaveforms;
  434. extern Model* modelProbability;
  435. extern Model* modelRandomGates;
  436. extern Model* modelRotator;
  437. extern Model* modelRungler;
  438. extern Model* modelScanner;
  439. extern Model* modelVectorMix;
  440. extern Model* modelWaveshape;
  441. extern Model* modelXYToPolar;
  442. #undef modelASR
  443. #undef modelBlankPanel
  444. #undef modelFlipFlop
  445. #undef modelMidSide
  446. #undef modelMinMax
  447. #undef PanelBaseWidget
  448. #undef InverterWidget
  449. // ImpromptuModular
  450. /* NOTE too much noise in original include, do this a different way
  451. // #include "ImpromptuModular/src/ImpromptuModular.hpp"
  452. */
  453. extern Model* modelAdaptiveQuantizer;
  454. extern Model* modelBigButtonSeq;
  455. extern Model* modelBigButtonSeq2;
  456. extern Model* modelChordKey;
  457. extern Model* modelChordKeyExpander;
  458. extern Model* modelClocked;
  459. extern Model* modelClockedExpander;
  460. extern Model* modelClkd;
  461. extern Model* modelCvPad;
  462. extern Model* modelFoundry;
  463. extern Model* modelFoundryExpander;
  464. extern Model* modelFourView;
  465. extern Model* modelGateSeq64;
  466. extern Model* modelGateSeq64Expander;
  467. extern Model* modelHotkey;
  468. extern Model* modelPart;
  469. extern Model* modelPhraseSeq16;
  470. extern Model* modelPhraseSeq32;
  471. extern Model* modelPhraseSeqExpander;
  472. extern Model* modelProbKey;
  473. extern Model* modelSemiModularSynth;
  474. extern Model* modelSygen;
  475. extern Model* modelTact;
  476. extern Model* modelTact1;
  477. extern Model* modelTactG;
  478. extern Model* modelTwelveKey;
  479. extern Model* modelVariations;
  480. extern Model* modelWriteSeq32;
  481. extern Model* modelWriteSeq64;
  482. extern Model* modelBlankPanel;
  483. // ihtsyn
  484. #include "ihtsyn/src/plugin.hpp"
  485. // JW-Modules
  486. #define modelQuantizer modelJWQuantizer
  487. #include "JW-Modules/src/JWModules.hpp"
  488. #undef modelQuantizer
  489. // kocmoc
  490. #include "kocmoc/src/plugin.hpp"
  491. // LifeFormModular
  492. /* NOTE too much noise in original include, do this a different way
  493. // #include "LifeFormModular/src/plugin.hpp"
  494. */
  495. extern Model* modelTimeDiktat;
  496. extern Model* modelSequenceModeler;
  497. extern Model* modelPitchDiktat;
  498. extern Model* modelPitchIntegrator;
  499. extern Model* modelBurstIntegrator;
  500. extern Model* modelQuadModulator;
  501. extern Model* modelImpulseControl;
  502. extern Model* modelQuadSteppedOffset;
  503. extern Model* modelPercussiveVibration;
  504. extern Model* modelQuadUtility;
  505. extern Model* modelAdditiveVibration;
  506. extern Model* modelComplexOsc;
  507. extern Model* modelDriftgen;
  508. // LittleUtils
  509. #include "LittleUtils/src/plugin.hpp"
  510. // Lilac Loop
  511. /* NOTE too much noise in original include, do this a different way
  512. // #include "LilacLoop/src/plugin.hpp"
  513. */
  514. extern Model* modelLooperOne;
  515. extern Model* modelLooperTwo;
  516. // LomasModules
  517. #include "LomasModules/src/plugin.hpp"
  518. #undef DR_WAV_IMPLEMENTATION
  519. // LyraeModules
  520. /* NOTE too much noise in original include, do this a different way
  521. // #include "LyraeModules/src/plugin.hpp"
  522. */
  523. #define modelDelta modelLyraeDelta
  524. extern Model* modelSulafat;
  525. extern Model* modelGamma;
  526. extern Model* modelDelta;
  527. extern Model* modelVega;
  528. extern Model* modelBD383238;
  529. extern Model* modelZeta;
  530. #undef modelDelta
  531. // Meander
  532. extern int panelTheme;
  533. #include "Meander/src/plugin.hpp"
  534. // MindMeldModular
  535. /* NOTE too much noise in original include, do this a different way
  536. // #include "MindMeldModular/src/MindMeldModular.hpp"
  537. */
  538. extern Model *modelPatchMaster;
  539. extern Model *modelPatchMasterBlank;
  540. extern Model *modelRouteMasterMono5to1;
  541. extern Model *modelRouteMasterStereo5to1;
  542. extern Model *modelRouteMasterMono1to5;
  543. extern Model *modelRouteMasterStereo1to5;
  544. extern Model *modelMasterChannel;
  545. extern Model *modelMeld;
  546. extern Model *modelUnmeld;
  547. extern Model *modelMSMelder;
  548. extern Model *modelEqMaster;
  549. extern Model *modelEqExpander;
  550. extern Model *modelBassMaster;
  551. extern Model *modelBassMasterJr;
  552. extern Model *modelShapeMaster;
  553. extern Model *modelMixMasterJr;
  554. extern Model *modelAuxExpanderJr;
  555. extern Model *modelMixMaster;
  556. extern Model *modelAuxExpander;
  557. // ML_modules
  558. /* NOTE too much noise in original include, do this a different way
  559. // #include "ML_modules/src/ML_modules.hpp"
  560. */
  561. #define modelQuantizer modelMLQuantizer
  562. #define modelSH8 modelMLSH8
  563. extern Model* modelQuantizer;
  564. extern Model* modelQuantum;
  565. extern Model* modelTrigBuf;
  566. extern Model* modelSeqSwitch;
  567. extern Model* modelSeqSwitch2;
  568. extern Model* modelShiftRegister;
  569. extern Model* modelShiftRegister2;
  570. extern Model* modelFreeVerb;
  571. extern Model* modelSum8;
  572. extern Model* modelSum8mk2;
  573. extern Model* modelSum8mk3;
  574. extern Model* modelSH8;
  575. extern Model* modelConstants;
  576. extern Model* modelCounter;
  577. extern Model* modelTrigDelay;
  578. extern Model* modelBPMdetect;
  579. extern Model* modelVoltMeter;
  580. extern Model* modelOctaFlop;
  581. extern Model* modelOctaTrig;
  582. extern Model* modelOctaSwitch;
  583. extern Model* modelTrigSwitch;
  584. extern Model* modelTrigSwitch2;
  585. extern Model* modelTrigSwitch3;
  586. extern Model* modelTrigSwitch3_2;
  587. extern Model* modelOctaPlus;
  588. extern Model* modelOctaTimes;
  589. extern Model* modelCloner;
  590. extern Model* modelPolySplitter;
  591. extern Model* modelArpeggiator;
  592. #undef modelQuantizer
  593. #undef modelSH8
  594. // MockbaModular
  595. #define modelBlank modelMockbaModularBlank
  596. #define modelComparator modelMockbaModularComparator
  597. #include "MockbaModular/src/plugin.hpp"
  598. #undef modelBlank
  599. #undef modelComparator
  600. #include "MockbaModular/src/MockbaModular.hpp"
  601. #undef min
  602. #undef max
  603. #define saveBack ignoreMockbaModular1
  604. #define loadBack ignoreMockbaModular2
  605. #include "MockbaModular/src/MockbaModular.cpp"
  606. #undef saveBack
  607. #undef loadBack
  608. std::string loadBack(int) { return "res/Empty_gray.svg"; }
  609. // Mog
  610. #include "Mog/src/plugin.hpp"
  611. // mscHack
  612. /* NOTE too much noise in original include, do this a different way
  613. // #include "mscHack/src/mscHack.hpp"
  614. */
  615. extern Model* modelCompressor;
  616. extern Model* modelSynthDrums;
  617. extern Model* modelSEQ_6x32x16;
  618. extern Model* modelMasterClockx8;
  619. extern Model* modelMasterClockx4;
  620. extern Model* modelSEQ_Envelope_8;
  621. extern Model* modelSeq_Triad2;
  622. extern Model* modelARP700;
  623. extern Model* modelMix_24_4_4;
  624. extern Model* modelMix_16_4_4;
  625. extern Model* modelMix_9_3_4;
  626. extern Model* modelMix_4_0_4;
  627. extern Model* modelASAF8;
  628. extern Model* modelPingPong;
  629. extern Model* modelStepDelay;
  630. extern Model* modelOsc_3Ch;
  631. extern Model* modelDronez;
  632. extern Model* modelMorze;
  633. extern Model* modelWindz;
  634. extern Model* modelLorenz;
  635. extern Model* modelAlienz;
  636. extern Model* modelOSC_WaveMorph_3;
  637. extern Model* modelMaude_221;
  638. // MSM
  639. /* NOTE too much noise in original include, do this a different way
  640. // #include "MSM/src/MSM.hpp"
  641. */
  642. #define modelADSR modelMSMADSR
  643. #define modelBlankPanel modelMSMBlankPanel
  644. #define modelDelay modelMSMDelay
  645. #define modelLFO modelMSMLFO
  646. #define modelMult modelMSMMult
  647. #define modelNoise modelMSMNoise
  648. #define modelVCA modelMSMVCA
  649. #define modelVCO modelMSMVCO
  650. extern Model* modelVCO;
  651. extern Model* modelBVCO;
  652. extern Model* modelExperimentalVCO;
  653. extern Model* modelNoise;
  654. extern Model* modelLFO;
  655. extern Model* modelVCA;
  656. extern Model* modelADSR;
  657. extern Model* modelDelay;
  658. extern Model* modelWaveShaper;
  659. extern Model* modelWavefolder;
  660. extern Model* modelBitcrusher;
  661. extern Model* modelPhaserModule;
  662. extern Model* modelMorpher;
  663. extern Model* modelRingMod;
  664. extern Model* modelRandomSource;
  665. extern Model* modelMult;
  666. extern Model* modelCrazyMult;
  667. extern Model* modelFade;
  668. extern Model* modelSimpleSlider;
  669. extern Model* modelxseq;
  670. extern Model* modelBlankPanel;
  671. #undef modelADSR
  672. #undef modelBlankPanel
  673. #undef modelDelay
  674. #undef modelLFO
  675. #undef modelMult
  676. #undef modelNoise
  677. #undef modelVCA
  678. #undef modelVCO
  679. // myth-modules
  680. #include "myth-modules/src/plugin.hpp"
  681. // Nonlinear Circuits
  682. #include "nonlinearcircuits/src/NLC.hpp"
  683. // Orbits
  684. #include "Orbits/src/plugin.hpp"
  685. // ParableInstruments
  686. #define modelClouds modelParableClouds
  687. #include "ParableInstruments/src/ArableInstruments.hpp"
  688. #undef modelClouds
  689. // Path Set
  690. #include "PathSet/src/plugin.hpp"
  691. // PinkTrombone
  692. #include "PinkTrombone/src/plugin.hpp"
  693. // Prism
  694. #include "Prism/src/plugin.hpp"
  695. // rackwindows
  696. #include "rackwindows/src/plugin.hpp"
  697. // RebelTech
  698. #define BefacoInputPort BefacoInputPortRebelTech
  699. #define BefacoOutputPort BefacoOutputPortRebelTech
  700. #include "RebelTech/src/plugin.hpp"
  701. #undef BefacoInputPort
  702. #undef BefacoOutputPort
  703. ModuleTheme defaultPanelTheme = DARK_THEME;
  704. void addThemeMenuItems(Menu*, ModuleTheme*) {}
  705. // repelzen
  706. #define modelBlank modelrepelzenBlank
  707. #define modelMixer modelrepelzenMixer
  708. #define modelWerner modelrepelzenWerner
  709. #define tanh_pade repelzentanh_pade
  710. #include "repelzen/src/repelzen.hpp"
  711. #undef modelBlank
  712. #undef modelMixer
  713. #undef modelWerner
  714. #undef tanh_pade
  715. // Sapphire
  716. #include "Sapphire/src/plugin.hpp"
  717. // sonusmodular
  718. #include "sonusmodular/src/sonusmodular.hpp"
  719. // Starling Via
  720. #define modelScanner modelStarlingViaScanner
  721. #define Scale starlingViaScale
  722. #define Wavetable starlingViaWavetable
  723. #include "StarlingVia/src/starling.hpp"
  724. #undef modelScanner
  725. #undef Scale
  726. #undef Wavetable
  727. // stocaudio
  728. #include "stocaudio/src/plugin.hpp"
  729. // stoermelder-packone
  730. #include "stoermelder-packone/src/plugin.hpp"
  731. Model* modelAudioInterface64;
  732. Model* modelMidiCat;
  733. Model* modelMidiCatCtx;
  734. Model* modelMidiCatMem;
  735. Model* modelMidiKey;
  736. Model* modelMidiMon;
  737. Model* modelMidiPlug;
  738. Model* modelMidiStep;
  739. StoermelderSettings pluginSettings;
  740. void StoermelderSettings::saveToJson() {}
  741. void StoermelderSettings::readFromJson() {}
  742. // surgext
  743. #include "surgext/src/SurgeXT.h"
  744. void surgext_rack_initialize();
  745. void surgext_rack_update_theme();
  746. // unless_modules
  747. #include "unless_modules/src/unless.hpp"
  748. // ValleyAudio
  749. #include "ValleyAudio/src/Valley.hpp"
  750. // Voxglitch
  751. #define modelLooper modelVoxglitchLooper
  752. #include "voxglitch/src/plugin.hpp"
  753. #undef modelLooper
  754. // WhatTheRack
  755. #include "WhatTheRack/src/WhatTheRack.hpp"
  756. // ZetaCarinaeModules
  757. #include "ZetaCarinaeModules/src/plugin.hpp"
  758. // ZZC
  759. #define DISPLAYS_H
  760. #define ZZC_SHARED_H
  761. #define ZZC_WIDGETS_H
  762. #define modelClock modelZZCClock
  763. #include "ZZC/src/ZZC.hpp"
  764. #undef modelClock
  765. // known terminal modules
  766. std::vector<Model*> hostTerminalModels;
  767. // stuff that reads config files, we don't want that
  768. int loadConsoleType() { return 0; }
  769. bool loadDarkAsDefault() { return settings::preferDarkPanels; }
  770. ModuleTheme loadDefaultTheme() { return settings::preferDarkPanels ? DARK_THEME : LIGHT_THEME; }
  771. int loadDirectOutMode() { return 0; }
  772. void readDefaultTheme() { defaultPanelTheme = loadDefaultTheme(); }
  773. void saveConsoleType(int) {}
  774. void saveDarkAsDefault(bool) {}
  775. void saveDefaultTheme(ModuleTheme) {}
  776. void saveDirectOutMode(bool) {}
  777. void saveHighQualityAsDefault(bool) {}
  778. void writeDefaultTheme() {}
  779. // plugin instances
  780. Plugin* pluginInstance__Cardinal;
  781. Plugin* pluginInstance__Fundamental;
  782. // Plugin* pluginInstance__ZamAudio;
  783. Plugin* pluginInstance__21kHz;
  784. Plugin* pluginInstance__8Mode;
  785. extern Plugin* pluginInstance__AaronStatic;
  786. Plugin* pluginInstance__alefsbits;
  787. Plugin* pluginInstance__Algoritmarte;
  788. Plugin* pluginInstance__AmalgamatedHarmonics;
  789. Plugin* pluginInstance__ArableInstruments;
  790. Plugin* pluginInstance__AnimatedCircuits;
  791. Plugin* pluginInstance__Aria;
  792. Plugin* pluginInstance__AS;
  793. Plugin* pluginInstance__AudibleInstruments;
  794. extern Plugin* pluginInstance__Autinn;
  795. Plugin* pluginInstance__Axioma;
  796. Plugin* pluginInstance__Bacon;
  797. Plugin* pluginInstance__Befaco;
  798. Plugin* pluginInstance__Bidoo;
  799. Plugin* pluginInstance__Biset;
  800. Plugin* pluginInstance__BogaudioModules;
  801. Plugin* pluginInstance__CatroModulo;
  802. Plugin* pluginInstance__cf;
  803. Plugin* pluginInstance__ChowDSP;
  804. Plugin* pluginInstance__Computerscare;
  805. Plugin* pluginInstance__CVfunk;
  806. Plugin* pluginInstance__dBiz;
  807. Plugin* pluginInstance__DHE;
  808. extern Plugin* pluginInstance__DrumKit;
  809. Plugin* pluginInstance__EnigmaCurry;
  810. Plugin* pluginInstance__ESeries;
  811. Plugin* pluginInstance__ExpertSleepersEncoders;
  812. Plugin* pluginInstance__Extratone;
  813. Plugin* pluginInstance__FehlerFabrik;
  814. Plugin* pluginInstance__forsitan;
  815. Plugin* pluginInstance__GlueTheGiant;
  816. Plugin* pluginInstance__GoodSheperd;
  817. Plugin* pluginInstance__GrandeModular;
  818. Plugin* pluginInstance__H4N4;
  819. Plugin* pluginInstance__HamptonHarmonics;
  820. Plugin* pluginInstance__HetrickCV;
  821. extern Plugin* pluginInstance__ImpromptuModular;
  822. Plugin* pluginInstance__ihtsyn;
  823. Plugin* pluginInstance__JW;
  824. Plugin* pluginInstance__kocmoc;
  825. Plugin* pluginInstance__LifeFormModular;
  826. Plugin* pluginInstance__LilacLoop;
  827. Plugin* pluginInstance__LittleUtils;
  828. Plugin* pluginInstance__Lomas;
  829. Plugin* pluginInstance__Lyrae;
  830. Plugin* pluginInstance__Meander;
  831. extern Plugin* pluginInstance__MindMeld;
  832. Plugin* pluginInstance__ML;
  833. Plugin* pluginInstance__MockbaModular;
  834. Plugin* pluginInstance__Mog;
  835. extern Plugin* pluginInstance__mscHack;
  836. Plugin* pluginInstance__MSM;
  837. Plugin* pluginInstance__myth_modules;
  838. Plugin* pluginInstance__nonlinearcircuits;
  839. Plugin* pluginInstance__Orbits;
  840. Plugin* pluginInstance__ParableInstruments;
  841. Plugin* pluginInstance__PathSet;
  842. Plugin* pluginInstance__PinkTrombone;
  843. Plugin* pluginInstance__Prism;
  844. Plugin* pluginInstance__rackwindows;
  845. Plugin* pluginInstance__RebelTech;
  846. Plugin* pluginInstance__repelzen;
  847. Plugin* pluginInstance__sapphire;
  848. Plugin* pluginInstance__sonusmodular;
  849. extern Plugin* pluginInstance__StarlingVia;
  850. Plugin* pluginInstance__stocaudio;
  851. extern Plugin* pluginInstance__stoermelder_p1;
  852. Plugin* pluginInstance__surgext;
  853. Plugin* pluginInstance__unless_modules;
  854. Plugin* pluginInstance__ValleyAudio;
  855. Plugin* pluginInstance__Voxglitch;
  856. Plugin* pluginInstance__WhatTheRack;
  857. Plugin* pluginInstance__ZetaCarinaeModules;
  858. Plugin* pluginInstance__ZZC;
  859. namespace rack {
  860. namespace asset {
  861. std::string pluginManifest(const std::string& dirname);
  862. std::string pluginPath(const std::string& dirname);
  863. }
  864. namespace plugin {
  865. struct StaticPluginLoader {
  866. Plugin* const plugin;
  867. FILE* file;
  868. json_t* rootJ;
  869. StaticPluginLoader(Plugin* const p, const char* const name)
  870. : plugin(p),
  871. file(nullptr),
  872. rootJ(nullptr)
  873. {
  874. #ifdef DEBUG
  875. DEBUG("Loading plugin module %s", name);
  876. #endif
  877. p->path = asset::pluginPath(name);
  878. const std::string manifestFilename = asset::pluginManifest(name);
  879. if ((file = std::fopen(manifestFilename.c_str(), "r")) == nullptr)
  880. {
  881. d_stderr2("Manifest file %s does not exist", manifestFilename.c_str());
  882. return;
  883. }
  884. json_error_t error;
  885. if ((rootJ = json_loadf(file, 0, &error)) == nullptr)
  886. {
  887. d_stderr2("JSON parsing error at %s %d:%d %s", manifestFilename.c_str(), error.line, error.column, error.text);
  888. return;
  889. }
  890. // force ABI, we use static plugins so this doesnt matter as long as it builds
  891. json_t* const version = json_string((APP_VERSION_MAJOR + ".0").c_str());
  892. json_object_set(rootJ, "version", version);
  893. json_decref(version);
  894. // Load manifest
  895. p->fromJson(rootJ);
  896. // Reject plugin if slug already exists
  897. if (Plugin* const existingPlugin = getPlugin(p->slug))
  898. throw Exception("Plugin %s is already loaded, not attempting to load it again", p->slug.c_str());
  899. }
  900. ~StaticPluginLoader()
  901. {
  902. if (rootJ != nullptr)
  903. {
  904. // Load modules manifest
  905. json_t* const modulesJ = json_object_get(rootJ, "modules");
  906. plugin->modulesFromJson(modulesJ);
  907. json_decref(rootJ);
  908. plugins.push_back(plugin);
  909. }
  910. if (file != nullptr)
  911. std::fclose(file);
  912. }
  913. bool ok() const noexcept
  914. {
  915. return rootJ != nullptr;
  916. }
  917. void removeModule(const char* const slugToRemove) const noexcept
  918. {
  919. json_t* const modules = json_object_get(rootJ, "modules");
  920. DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);
  921. size_t i;
  922. json_t* v;
  923. json_array_foreach(modules, i, v)
  924. {
  925. if (json_t* const slug = json_object_get(v, "slug"))
  926. {
  927. if (const char* const value = json_string_value(slug))
  928. {
  929. if (std::strcmp(value, slugToRemove) == 0)
  930. {
  931. json_array_remove(modules, i);
  932. break;
  933. }
  934. }
  935. }
  936. }
  937. }
  938. };
  939. static void initStatic__Cardinal()
  940. {
  941. Plugin* const p = new Plugin;
  942. pluginInstance__Cardinal = p;
  943. const StaticPluginLoader spl(p, "Cardinal");
  944. if (spl.ok())
  945. {
  946. p->addModel(modelAidaX);
  947. p->addModel(modelCardinalBlank);
  948. p->addModel(modelExpanderInputMIDI);
  949. p->addModel(modelExpanderOutputMIDI);
  950. p->addModel(modelHostAudio2);
  951. p->addModel(modelHostAudio8);
  952. p->addModel(modelHostCV);
  953. p->addModel(modelHostMIDI);
  954. p->addModel(modelHostMIDICC);
  955. p->addModel(modelHostMIDIGate);
  956. p->addModel(modelHostMIDIMap);
  957. p->addModel(modelHostParameters);
  958. p->addModel(modelHostParametersMap);
  959. p->addModel(modelHostTime);
  960. p->addModel(modelTextEditor);
  961. #ifndef DGL_USE_GLES
  962. p->addModel(modelGlBars);
  963. #else
  964. spl.removeModule("glBars");
  965. #endif
  966. #ifndef STATIC_BUILD
  967. p->addModel(modelAudioFile);
  968. #else
  969. spl.removeModule("AudioFile");
  970. #endif
  971. #if !(defined(DISTRHO_OS_WASM) || defined(STATIC_BUILD))
  972. p->addModel(modelCarla);
  973. p->addModel(modelIldaeil);
  974. #else
  975. spl.removeModule("Carla");
  976. spl.removeModule("Ildaeil");
  977. #endif
  978. #ifndef HEADLESS
  979. p->addModel(modelSassyScope);
  980. #else
  981. spl.removeModule("SassyScope");
  982. #endif
  983. #if defined(HAVE_X11) && !defined(HEADLESS) && !defined(STATIC_BUILD)
  984. p->addModel(modelMPV);
  985. #else
  986. spl.removeModule("MPV");
  987. #endif
  988. #ifdef HAVE_FFTW3F
  989. p->addModel(modelAudioToCVPitch);
  990. #else
  991. spl.removeModule("AudioToCVPitch");
  992. #endif
  993. hostTerminalModels = {
  994. modelHostAudio2,
  995. modelHostAudio8,
  996. modelHostCV,
  997. modelHostMIDI,
  998. modelHostMIDICC,
  999. modelHostMIDIGate,
  1000. modelHostMIDIMap,
  1001. modelHostParameters,
  1002. modelHostParametersMap,
  1003. modelHostTime,
  1004. };
  1005. }
  1006. }
  1007. static void initStatic__Fundamental()
  1008. {
  1009. Plugin* const p = new Plugin;
  1010. pluginInstance__Fundamental = p;
  1011. const StaticPluginLoader spl(p, "Fundamental");
  1012. if (spl.ok())
  1013. {
  1014. p->addModel(model_8vert);
  1015. p->addModel(modelADSR);
  1016. p->addModel(modelDelay);
  1017. p->addModel(modelLFO);
  1018. p->addModel(modelLFO2);
  1019. p->addModel(modelMerge);
  1020. p->addModel(modelMidSide);
  1021. p->addModel(modelMixer);
  1022. p->addModel(modelMutes);
  1023. p->addModel(modelNoise);
  1024. p->addModel(modelOctave);
  1025. p->addModel(modelPulses);
  1026. p->addModel(modelQuantizer);
  1027. p->addModel(modelRandom);
  1028. p->addModel(modelScope);
  1029. p->addModel(modelSEQ3);
  1030. p->addModel(modelSequentialSwitch1);
  1031. p->addModel(modelSequentialSwitch2);
  1032. p->addModel(modelSplit);
  1033. p->addModel(modelSum);
  1034. p->addModel(modelVCA);
  1035. p->addModel(modelVCA_1);
  1036. p->addModel(modelVCF);
  1037. p->addModel(modelVCMixer);
  1038. p->addModel(modelVCO);
  1039. p->addModel(modelVCO2);
  1040. }
  1041. }
  1042. /*
  1043. static void initStatic__ZamAudio()
  1044. {
  1045. Plugin* const p = new Plugin;
  1046. pluginInstance__ZamAudio = p;
  1047. const StaticPluginLoader spl(p, "ZamAudio");
  1048. if (spl.ok())
  1049. {
  1050. p->addModel(modelZamComp);
  1051. }
  1052. }
  1053. */
  1054. static void initStatic__21kHz()
  1055. {
  1056. Plugin* const p = new Plugin;
  1057. pluginInstance__21kHz = p;
  1058. const StaticPluginLoader spl(p, "21kHz");
  1059. if (spl.ok())
  1060. {
  1061. p->addModel(modelPalmLoop);
  1062. p->addModel(modelD_Inf);
  1063. p->addModel(modelTachyonEntangler);
  1064. }
  1065. }
  1066. static void initStatic__8Mode()
  1067. {
  1068. Plugin* const p = new Plugin;
  1069. pluginInstance__8Mode = p;
  1070. const StaticPluginLoader spl(p, "8Mode");
  1071. if (spl.ok())
  1072. {
  1073. p->addModel(modelsoftSN);
  1074. }
  1075. }
  1076. static void initStatic__AaronStatic()
  1077. {
  1078. Plugin* const p = new Plugin;
  1079. pluginInstance__AaronStatic = p;
  1080. const StaticPluginLoader spl(p, "AaronStatic");
  1081. if (spl.ok())
  1082. {
  1083. p->addModel(modelChordCV);
  1084. p->addModel(modelScaleCV);
  1085. p->addModel(modelRandomNoteCV);
  1086. p->addModel(modelDiatonicCV);
  1087. }
  1088. }
  1089. static void initStatic__alefsbits()
  1090. {
  1091. Plugin* const p = new Plugin;
  1092. pluginInstance__alefsbits = p;
  1093. const StaticPluginLoader spl(p, "alefsbits");
  1094. if (spl.ok())
  1095. {
  1096. #define modelSteps modelalefsbitsSteps
  1097. #define modelLogic modelalefsbitsLogic
  1098. p->addModel(modelSimplexandhold);
  1099. p->addModel(modelBlank6hp);
  1100. p->addModel(modelPolyrand);
  1101. p->addModel(modelNoize);
  1102. p->addModel(modelSteps);
  1103. p->addModel(modelFibb);
  1104. p->addModel(modelOctsclr);
  1105. p->addModel(modelShift);
  1106. p->addModel(modelMlt);
  1107. p->addModel(modelMath);
  1108. p->addModel(modelLogic);
  1109. p->addModel(modelProbablynot);
  1110. #undef modelSteps
  1111. #undef modelLogic
  1112. }
  1113. }
  1114. static void initStatic__Algoritmarte()
  1115. {
  1116. Plugin* const p = new Plugin;
  1117. pluginInstance__Algoritmarte = p;
  1118. const StaticPluginLoader spl(p, "Algoritmarte");
  1119. if (spl.ok())
  1120. {
  1121. p->addModel(modelClockkky);
  1122. p->addModel(modelPlanetz);
  1123. p->addModel(modelMusiFrog);
  1124. p->addModel(modelZefiro);
  1125. p->addModel(modelHoldMeTight);
  1126. p->addModel(modelCyclicCA);
  1127. p->addModel(modelMusiMath);
  1128. }
  1129. }
  1130. static void initStatic__AmalgamatedHarmonics()
  1131. {
  1132. Plugin* const p = new Plugin;
  1133. pluginInstance__AmalgamatedHarmonics = p;
  1134. const StaticPluginLoader spl(p, "AmalgamatedHarmonics");
  1135. if (spl.ok())
  1136. {
  1137. p->addModel(modelArp31);
  1138. p->addModel(modelArp32);
  1139. p->addModel(modelBombe);
  1140. p->addModel(modelChord);
  1141. p->addModel(modelCircle);
  1142. p->addModel(modelGalaxy);
  1143. p->addModel(modelGenerative);
  1144. p->addModel(modelImp);
  1145. p->addModel(modelImperfect2);
  1146. p->addModel(modelProgress2);
  1147. p->addModel(modelRuckus);
  1148. p->addModel(modelScaleQuantizer2);
  1149. p->addModel(modelSLN);
  1150. p->addModel(modelMuxDeMux);
  1151. p->addModel(modelPolyProbe);
  1152. p->addModel(modelPolyScope);
  1153. p->addModel(modelPolyUtils);
  1154. p->addModel(modelPolyVolt);
  1155. p->addModel(modelScaleQuantizer);
  1156. p->addModel(modelArpeggiator2);
  1157. p->addModel(modelProgress);
  1158. }
  1159. }
  1160. static void initStatic__AnimatedCircuits()
  1161. {
  1162. Plugin* const p = new Plugin;
  1163. pluginInstance__AnimatedCircuits = p;
  1164. const StaticPluginLoader spl(p, "AnimatedCircuits");
  1165. if (spl.ok())
  1166. {
  1167. p->addModel(model_AC_Folding);
  1168. p->addModel(model_AC_LFold);
  1169. }
  1170. }
  1171. static void initStatic__ArableInstruments()
  1172. {
  1173. Plugin* const p = new Plugin;
  1174. pluginInstance__ArableInstruments = p;
  1175. const StaticPluginLoader spl(p, "ArableInstruments");
  1176. if (spl.ok())
  1177. {
  1178. #define modelClouds modelArableClouds
  1179. p->addModel(modelClouds);
  1180. #undef modelClouds
  1181. }
  1182. }
  1183. static void initStatic__Aria()
  1184. {
  1185. Plugin* const p = new Plugin;
  1186. pluginInstance__Aria = p;
  1187. const StaticPluginLoader spl(p, "AriaModules");
  1188. if (spl.ok())
  1189. {
  1190. #define modelBlank modelAriaBlank
  1191. p->addModel(modelSplort);
  1192. p->addModel(modelSmerge);
  1193. p->addModel(modelSpleet);
  1194. p->addModel(modelSwerge);
  1195. p->addModel(modelSplirge);
  1196. p->addModel(modelQqqq);
  1197. p->addModel(modelQuack);
  1198. p->addModel(modelQ);
  1199. p->addModel(modelQuale);
  1200. p->addModel(modelDarius);
  1201. p->addModel(modelSolomon4);
  1202. p->addModel(modelSolomon8);
  1203. p->addModel(modelSolomon16);
  1204. p->addModel(modelPsychopump);
  1205. p->addModel(modelPokies4);
  1206. p->addModel(modelGrabby);
  1207. p->addModel(modelRotatoes4);
  1208. p->addModel(modelUndular);
  1209. p->addModel(modelBlank);
  1210. #undef modelBlank
  1211. // NOTE disabled in Cardinal due to online requirement
  1212. spl.removeModule("Arcane");
  1213. spl.removeModule("Atout");
  1214. spl.removeModule("Aleister");
  1215. }
  1216. }
  1217. static void initStatic__AS()
  1218. {
  1219. Plugin* const p = new Plugin;
  1220. pluginInstance__AS = p;
  1221. const StaticPluginLoader spl(p, "AS");
  1222. if (spl.ok())
  1223. {
  1224. #define modelADSR modelASADSR
  1225. #define modelVCA modelASVCA
  1226. #define modelWaveShaper modelASWaveShaper
  1227. //OSCILLATORS
  1228. p->addModel(modelSineOsc);
  1229. p->addModel(modelSawOsc);
  1230. //TOOLS
  1231. p->addModel(modelADSR);
  1232. p->addModel(modelVCA);
  1233. p->addModel(modelQuadVCA);
  1234. p->addModel(modelTriLFO);
  1235. p->addModel(modelAtNuVrTr);
  1236. p->addModel(modelBPMClock);
  1237. p->addModel(modelSEQ16);
  1238. p->addModel(modelMixer2ch);
  1239. p->addModel(modelMixer4ch);
  1240. p->addModel(modelMixer8ch);
  1241. p->addModel(modelMonoVUmeter);
  1242. p->addModel(modelStereoVUmeter);
  1243. p->addModel(modelMultiple2_5);
  1244. p->addModel(modelMerge2_5);
  1245. p->addModel(modelSteps);
  1246. p->addModel(modelLaunchGate);
  1247. p->addModel(modelKillGate);
  1248. p->addModel(modelFlow);
  1249. p->addModel(modelSignalDelay);
  1250. p->addModel(modelTriggersMKI);
  1251. p->addModel(modelTriggersMKII);
  1252. p->addModel(modelTriggersMKIII);
  1253. p->addModel(modelBPMCalc);
  1254. p->addModel(modelBPMCalc2);
  1255. p->addModel(modelCv2T);
  1256. p->addModel(modelZeroCV2T);
  1257. p->addModel(modelReScale);
  1258. //EFFECTS
  1259. p->addModel(modelDelayPlusFx);
  1260. p->addModel(modelDelayPlusStereoFx);
  1261. p->addModel(modelPhaserFx);
  1262. p->addModel(modelReverbFx);
  1263. p->addModel(modelReverbStereoFx);
  1264. p->addModel(modelSuperDriveFx);
  1265. p->addModel(modelSuperDriveStereoFx);
  1266. p->addModel(modelTremoloFx);
  1267. p->addModel(modelTremoloStereoFx);
  1268. p->addModel(modelWaveShaper);
  1269. p->addModel(modelWaveShaperStereo);
  1270. //BLANK PANELS
  1271. p->addModel(modelBlankPanel4);
  1272. p->addModel(modelBlankPanel6);
  1273. p->addModel(modelBlankPanel8);
  1274. p->addModel(modelBlankPanelSpecial);
  1275. #undef modelADSR
  1276. #undef modelVCA
  1277. #undef modelWaveShaper
  1278. }
  1279. }
  1280. static void initStatic__AudibleInstruments()
  1281. {
  1282. Plugin* const p = new Plugin;
  1283. pluginInstance__AudibleInstruments = p;
  1284. const StaticPluginLoader spl(p, "AudibleInstruments");
  1285. if (spl.ok())
  1286. {
  1287. p->addModel(modelBraids);
  1288. p->addModel(modelPlaits);
  1289. p->addModel(modelElements);
  1290. p->addModel(modelTides);
  1291. p->addModel(modelTides2);
  1292. p->addModel(modelClouds);
  1293. p->addModel(modelWarps);
  1294. p->addModel(modelRings);
  1295. p->addModel(modelLinks);
  1296. p->addModel(modelKinks);
  1297. p->addModel(modelShades);
  1298. p->addModel(modelBranches);
  1299. p->addModel(modelBlinds);
  1300. p->addModel(modelVeils);
  1301. p->addModel(modelFrames);
  1302. p->addModel(modelMarbles);
  1303. p->addModel(modelStages);
  1304. p->addModel(modelRipples);
  1305. p->addModel(modelShelves);
  1306. p->addModel(modelStreams);
  1307. }
  1308. }
  1309. static void initStatic__Autinn()
  1310. {
  1311. Plugin* const p = new Plugin;
  1312. pluginInstance__Autinn = p;
  1313. const StaticPluginLoader spl(p, "Autinn");
  1314. if (spl.ok())
  1315. {
  1316. #define modelChord modelAutinnChord
  1317. #define modelVibrato modelAutinnVibrato
  1318. p->addModel(modelAmp);
  1319. p->addModel(modelDeadband);
  1320. p->addModel(modelBass);
  1321. p->addModel(modelCVConverter);
  1322. p->addModel(modelDC);
  1323. p->addModel(modelDigi);
  1324. p->addModel(modelFlopper);
  1325. p->addModel(modelFlora);
  1326. p->addModel(modelJette);
  1327. p->addModel(modelBoomerang);
  1328. p->addModel(modelOxcart);
  1329. p->addModel(modelSaw);
  1330. p->addModel(modelSjip);
  1331. p->addModel(modelSquare);
  1332. p->addModel(modelVibrato);
  1333. p->addModel(modelVectorDriver);
  1334. p->addModel(modelZod);
  1335. p->addModel(modelTriBand);
  1336. p->addModel(modelMixer6);
  1337. p->addModel(modelNon);
  1338. p->addModel(modelFil);
  1339. p->addModel(modelNap);
  1340. p->addModel(modelMelody);
  1341. p->addModel(modelChord);
  1342. #undef modelChord
  1343. #undef modelVibrato
  1344. }
  1345. }
  1346. static void initStatic__Axioma()
  1347. {
  1348. Plugin* const p = new Plugin;
  1349. pluginInstance__Axioma = p;
  1350. const StaticPluginLoader spl(p, "Axioma");
  1351. if (spl.ok())
  1352. {
  1353. p->addModel(modelTheBifurcator);
  1354. p->addModel(modelTesseract);
  1355. p->addModel(modelIkeda);
  1356. p->addModel(modelRhodonea);
  1357. }
  1358. }
  1359. static void initStatic__Bacon()
  1360. {
  1361. Plugin* const p = new Plugin;
  1362. pluginInstance__Bacon = p;
  1363. const StaticPluginLoader spl(p, "BaconPlugs");
  1364. if (spl.ok())
  1365. {
  1366. p->addModel(modelHarMoNee);
  1367. p->addModel(modelGlissinator);
  1368. p->addModel(modelPolyGnome);
  1369. p->addModel(modelQuantEyes);
  1370. p->addModel(modelSampleDelay);
  1371. p->addModel(modelChipNoise);
  1372. p->addModel(modelChipWaves);
  1373. p->addModel(modelChipYourWave);
  1374. p->addModel(modelOpen303);
  1375. p->addModel(modelKarplusStrongPoly);
  1376. p->addModel(modelALingADing);
  1377. p->addModel(modelBitulator);
  1378. p->addModel(modelPolyGenerator);
  1379. p->addModel(modelLintBuddy);
  1380. p->addModel(modelLuckyHold);
  1381. }
  1382. }
  1383. static void initStatic__Befaco()
  1384. {
  1385. Plugin* const p = new Plugin;
  1386. pluginInstance__Befaco = p;
  1387. const StaticPluginLoader spl(p, "Befaco");
  1388. if (spl.ok())
  1389. {
  1390. #define modelADSR modelBefacoADSR
  1391. #define modelMixer modelBefacoMixer
  1392. #define modelBurst modelBefacoBurst
  1393. p->addModel(modelEvenVCO);
  1394. p->addModel(modelRampage);
  1395. p->addModel(modelABC);
  1396. p->addModel(modelSpringReverb);
  1397. p->addModel(modelMixer);
  1398. p->addModel(modelSlewLimiter);
  1399. p->addModel(modelDualAtenuverter);
  1400. p->addModel(modelPercall);
  1401. p->addModel(modelHexmixVCA);
  1402. p->addModel(modelChoppingKinky);
  1403. p->addModel(modelKickall);
  1404. p->addModel(modelSamplingModulator);
  1405. p->addModel(modelMorphader);
  1406. p->addModel(modelADSR);
  1407. p->addModel(modelSTMix);
  1408. p->addModel(modelMuxlicer);
  1409. p->addModel(modelMex);
  1410. p->addModel(modelNoisePlethora);
  1411. p->addModel(modelChannelStrip);
  1412. p->addModel(modelPonyVCO);
  1413. p->addModel(modelMotionMTR);
  1414. p->addModel(modelBurst);
  1415. p->addModel(modelVoltio);
  1416. #undef modelADSR
  1417. #undef modelMixer
  1418. #undef modelBurst
  1419. }
  1420. }
  1421. static void initStatic__Bidoo()
  1422. {
  1423. Plugin* const p = new Plugin;
  1424. pluginInstance__Bidoo = p;
  1425. const StaticPluginLoader spl(p, "Bidoo");
  1426. if (spl.ok())
  1427. {
  1428. p->addModel(modelTOCANTE);
  1429. p->addModel(modelLATE);
  1430. p->addModel(modelDIKTAT);
  1431. p->addModel(modelDTROY);
  1432. p->addModel(modelBORDL);
  1433. p->addModel(modelZOUMAI);
  1434. p->addModel(modelZOUMAIExpander);
  1435. p->addModel(modelENCORE);
  1436. p->addModel(modelENCOREExpander);
  1437. p->addModel(modelMU);
  1438. p->addModel(modelCHUTE);
  1439. p->addModel(modelLOURDE);
  1440. p->addModel(modelDILEMO);
  1441. p->addModel(modelLAMBDA);
  1442. p->addModel(modelBANCAU);
  1443. p->addModel(modelACNE);
  1444. p->addModel(modelMS);
  1445. p->addModel(modelDUKE);
  1446. p->addModel(modelMOIRE);
  1447. p->addModel(modelPILOT);
  1448. p->addModel(modelHUITRE);
  1449. p->addModel(modelOUAIVE);
  1450. p->addModel(modelEDSAROS);
  1451. p->addModel(modelPOUPRE);
  1452. p->addModel(modelMAGMA);
  1453. p->addModel(modelOAI);
  1454. p->addModel(modelCANARD);
  1455. p->addModel(modelEMILE);
  1456. p->addModel(modelFORK);
  1457. p->addModel(modelTIARE);
  1458. p->addModel(modelLIMONADE);
  1459. p->addModel(modelLIMBO);
  1460. p->addModel(modelPERCO);
  1461. p->addModel(modelBAFIS);
  1462. p->addModel(modelBAR);
  1463. p->addModel(modelMINIBAR);
  1464. p->addModel(modelZINC);
  1465. p->addModel(modelFREIN);
  1466. p->addModel(modelHCTIP);
  1467. p->addModel(modelSPORE);
  1468. p->addModel(modelDFUZE);
  1469. p->addModel(modelREI);
  1470. p->addModel(modelRABBIT);
  1471. p->addModel(modelBISTROT);
  1472. p->addModel(modelSIGMA);
  1473. p->addModel(modelFLAME);
  1474. p->addModel(modelVOID);
  1475. // NOTE disabled in Cardinal due to curl usage
  1476. // p->addModel(modelANTN);
  1477. spl.removeModule("antN");
  1478. }
  1479. }
  1480. static void initStatic__Biset()
  1481. {
  1482. Plugin* const p = new Plugin;
  1483. pluginInstance__Biset = p;
  1484. const StaticPluginLoader spl(p, "Biset");
  1485. if (spl.ok())
  1486. {
  1487. p->addModel(modelTracker);
  1488. p->addModel(modelTrackerSynth);
  1489. p->addModel(modelTrackerDrum);
  1490. p->addModel(modelTrackerClock);
  1491. p->addModel(modelTrackerPhase);
  1492. p->addModel(modelTrackerQuant);
  1493. p->addModel(modelTrackerState);
  1494. p->addModel(modelTrackerControl);
  1495. p->addModel(modelRegex);
  1496. p->addModel(modelRegexCondensed);
  1497. p->addModel(modelRegexExp);
  1498. p->addModel(modelTree);
  1499. p->addModel(modelTreeSeed);
  1500. p->addModel(modelGbu);
  1501. p->addModel(modelPkm);
  1502. p->addModel(modelIgc);
  1503. p->addModel(modelOmega3);
  1504. p->addModel(modelOmega6);
  1505. p->addModel(modelSegfault);
  1506. p->addModel(modelBlank);
  1507. }
  1508. }
  1509. static void initStatic__BogaudioModules()
  1510. {
  1511. Plugin* const p = new Plugin;
  1512. pluginInstance__BogaudioModules = p;
  1513. const StaticPluginLoader spl(p, "BogaudioModules");
  1514. if (spl.ok())
  1515. {
  1516. // Make sure to use dark theme as default
  1517. Skins& skins(Skins::skins());
  1518. skins._default = settings::preferDarkPanels ? "dark" : "light";
  1519. #define modelADSR modelBogaudioADSR
  1520. #define modelLFO modelBogaudioLFO
  1521. #define modelNoise modelBogaudioNoise
  1522. #define modelVCA modelBogaudioVCA
  1523. #define modelVCF modelBogaudioVCF
  1524. #define modelVCO modelBogaudioVCO
  1525. p->addModel(modelVCO);
  1526. p->addModel(modelLVCO);
  1527. p->addModel(modelSine);
  1528. p->addModel(modelPulse);
  1529. p->addModel(modelXCO);
  1530. p->addModel(modelAdditator);
  1531. p->addModel(modelFMOp);
  1532. p->addModel(modelChirp);
  1533. p->addModel(modelLFO);
  1534. p->addModel(modelLLFO);
  1535. p->addModel(modelFourFO);
  1536. p->addModel(modelEightFO);
  1537. p->addModel(modelVCF);
  1538. p->addModel(modelLVCF);
  1539. p->addModel(modelFFB);
  1540. p->addModel(modelEQ);
  1541. p->addModel(modelEQS);
  1542. p->addModel(modelLPG);
  1543. p->addModel(modelLLPG);
  1544. p->addModel(modelMegaGate);
  1545. p->addModel(modelPEQ);
  1546. p->addModel(modelPEQ6);
  1547. p->addModel(modelPEQ6XF);
  1548. p->addModel(modelPEQ14);
  1549. p->addModel(modelPEQ14XF);
  1550. p->addModel(modelDADSRH);
  1551. p->addModel(modelDADSRHPlus);
  1552. p->addModel(modelShaper);
  1553. p->addModel(modelShaperPlus);
  1554. p->addModel(modelAD);
  1555. p->addModel(modelASR);
  1556. p->addModel(modelADSR);
  1557. p->addModel(modelVish);
  1558. p->addModel(modelFollow);
  1559. p->addModel(modelDGate);
  1560. p->addModel(modelRGate);
  1561. p->addModel(modelEdge);
  1562. p->addModel(modelNoise);
  1563. p->addModel(modelSampleHold);
  1564. p->addModel(modelWalk2);
  1565. p->addModel(modelWalk);
  1566. p->addModel(modelMix8);
  1567. p->addModel(modelMix8x);
  1568. p->addModel(modelMix4);
  1569. p->addModel(modelMix4x);
  1570. p->addModel(modelMix2);
  1571. p->addModel(modelMix1);
  1572. p->addModel(modelVCM);
  1573. p->addModel(modelMute8);
  1574. p->addModel(modelPan);
  1575. p->addModel(modelXFade);
  1576. p->addModel(modelVCA);
  1577. p->addModel(modelVCAmp);
  1578. p->addModel(modelVelo);
  1579. p->addModel(modelUMix);
  1580. p->addModel(modelMumix);
  1581. p->addModel(modelMatrix81);
  1582. p->addModel(modelMatrix18);
  1583. p->addModel(modelMatrix44);
  1584. p->addModel(modelMatrix44Cvm);
  1585. p->addModel(modelMatrix88);
  1586. p->addModel(modelMatrix88Cv);
  1587. p->addModel(modelMatrix88M);
  1588. p->addModel(modelSwitch81);
  1589. p->addModel(modelSwitch18);
  1590. p->addModel(modelSwitch44);
  1591. p->addModel(modelSwitch88);
  1592. p->addModel(modelSwitch1616);
  1593. p->addModel(modelAMRM);
  1594. p->addModel(modelPressor);
  1595. p->addModel(modelClpr);
  1596. p->addModel(modelLmtr);
  1597. p->addModel(modelNsgt);
  1598. p->addModel(modelCmpDist);
  1599. p->addModel(modelOneEight);
  1600. p->addModel(modelEightOne);
  1601. p->addModel(modelAddrSeq);
  1602. p->addModel(modelAddrSeqX);
  1603. p->addModel(modelPgmr);
  1604. p->addModel(modelPgmrX);
  1605. p->addModel(modelVU);
  1606. p->addModel(modelAnalyzer);
  1607. p->addModel(modelAnalyzerXL);
  1608. p->addModel(modelRanalyzer);
  1609. p->addModel(modelDetune);
  1610. p->addModel(modelStack);
  1611. p->addModel(modelReftone);
  1612. p->addModel(modelMono);
  1613. p->addModel(modelArp);
  1614. p->addModel(modelAssign);
  1615. p->addModel(modelUnison);
  1616. p->addModel(modelPolyCon8);
  1617. p->addModel(modelPolyCon16);
  1618. p->addModel(modelPolyOff8);
  1619. p->addModel(modelPolyOff16);
  1620. p->addModel(modelPolyMult);
  1621. p->addModel(modelBool);
  1622. p->addModel(modelCmp);
  1623. p->addModel(modelCVD);
  1624. p->addModel(modelFlipFlop);
  1625. p->addModel(modelInv);
  1626. p->addModel(modelManual);
  1627. p->addModel(modelFourMan);
  1628. p->addModel(modelMult);
  1629. p->addModel(modelOffset);
  1630. p->addModel(modelSlew);
  1631. p->addModel(modelSums);
  1632. p->addModel(modelSwitch);
  1633. p->addModel(modelLgsw);
  1634. p->addModel(modelBlank3);
  1635. p->addModel(modelBlank6);
  1636. #ifdef EXPERIMENTAL
  1637. p->addModel(modelLag);
  1638. p->addModel(modelPEQ14XR);
  1639. p->addModel(modelPEQ14XV);
  1640. #endif
  1641. #ifdef TEST
  1642. p->addModel(modelTest);
  1643. p->addModel(modelTest2);
  1644. p->addModel(modelTestExpanderBase);
  1645. p->addModel(modelTestExpanderExtension);
  1646. p->addModel(modelTestGl);
  1647. p->addModel(modelTestVCF);
  1648. #endif
  1649. #undef modelADSR
  1650. #undef modelLFO
  1651. #undef modelNoise
  1652. #undef modelVCA
  1653. #undef modelVCF
  1654. #undef modelVCO
  1655. }
  1656. }
  1657. static void initStatic__CatroModulo()
  1658. {
  1659. Plugin* const p = new Plugin;
  1660. pluginInstance__CatroModulo = p;
  1661. const StaticPluginLoader spl(p, "CatroModulo");
  1662. if (spl.ok())
  1663. {
  1664. p->addModel(modelCM1Module);
  1665. p->addModel(modelCM2Module);
  1666. p->addModel(modelCM3Module);
  1667. p->addModel(modelCM4Module);
  1668. p->addModel(modelCM5Module);
  1669. p->addModel(modelCM6Module);
  1670. p->addModel(modelCM7Module);
  1671. p->addModel(modelCM8Module);
  1672. p->addModel(modelCM9Module);
  1673. p->addModel(modelCM10Module);
  1674. }
  1675. }
  1676. static void initStatic__cf()
  1677. {
  1678. Plugin* const p = new Plugin;
  1679. pluginInstance__cf = p;
  1680. const StaticPluginLoader spl(p, "cf");
  1681. if (spl.ok())
  1682. {
  1683. p->addModel(modelMETRO);
  1684. p->addModel(modelEACH);
  1685. p->addModel(modeltrSEQ);
  1686. p->addModel(modelLEDSEQ);
  1687. p->addModel(modelL3DS3Q);
  1688. p->addModel(modelSLIDERSEQ);
  1689. p->addModel(modelPLAYER);
  1690. p->addModel(modelPLAY);
  1691. p->addModel(modelMONO);
  1692. p->addModel(modelSTEREO);
  1693. p->addModel(modelSUB);
  1694. p->addModel(modelMASTER);
  1695. p->addModel(modelVARIABLE);
  1696. p->addModel(modelALGEBRA);
  1697. p->addModel(modelFUNKTION);
  1698. p->addModel(modelCHOKE);
  1699. p->addModel(modelFOUR);
  1700. p->addModel(modelSTEPS);
  1701. p->addModel(modelPEAK);
  1702. p->addModel(modelCUTS);
  1703. p->addModel(modelBUFFER);
  1704. p->addModel(modelDISTO);
  1705. p->addModel(modelCUBE);
  1706. p->addModel(modelPATCH);
  1707. p->addModel(modelLABEL);
  1708. p->addModel(modelDAVE);
  1709. }
  1710. }
  1711. static void initStatic__ChowDSP()
  1712. {
  1713. Plugin* const p = new Plugin;
  1714. pluginInstance__ChowDSP = p;
  1715. const StaticPluginLoader spl(p, "ChowDSP");
  1716. if (spl.ok())
  1717. {
  1718. p->addModel(modelChowTape);
  1719. p->addModel(modelChowPhaserFeedback);
  1720. p->addModel(modelChowPhaserMod);
  1721. p->addModel(modelChowFDN);
  1722. p->addModel(modelChowRNN);
  1723. p->addModel(modelChowModal);
  1724. p->addModel(modelChowDer);
  1725. p->addModel(modelWarp);
  1726. p->addModel(modelWerner);
  1727. p->addModel(modelCredit);
  1728. p->addModel(modelChowPulse);
  1729. p->addModel(modelChowTapeCompression);
  1730. p->addModel(modelChowTapeChew);
  1731. p->addModel(modelChowTapeDegrade);
  1732. p->addModel(modelChowTapeLoss);
  1733. p->addModel(modelChowChorus);
  1734. }
  1735. }
  1736. static void initStatic__Computerscare()
  1737. {
  1738. Plugin* const p = new Plugin;
  1739. pluginInstance__Computerscare = p;
  1740. const StaticPluginLoader spl(p, "Computerscare");
  1741. if (spl.ok())
  1742. {
  1743. p->addModel(modelComputerscarePatchSequencer);
  1744. p->addModel(modelComputerscareDebug);
  1745. p->addModel(modelComputerscareLaundrySoup);
  1746. p->addModel(modelComputerscareILoveCookies);
  1747. p->addModel(modelComputerscareOhPeas);
  1748. p->addModel(modelComputerscareHorseADoodleDoo);
  1749. p->addModel(modelComputerscareKnolyPobs);
  1750. p->addModel(modelComputerscareBolyPuttons);
  1751. p->addModel(modelComputerscareRolyPouter);
  1752. p->addModel(modelComputerscareSolyPequencer);
  1753. p->addModel(modelComputerscareTolyPools);
  1754. p->addModel(modelComputerscareMolyPatrix);
  1755. p->addModel(modelComputerscareGolyPenerator);
  1756. p->addModel(modelComputerscareFolyPace);
  1757. p->addModel(modelComputerscareStolyFickPigure);
  1758. p->addModel(modelComputerscareBlank);
  1759. p->addModel(modelComputerscareBlankExpander);
  1760. }
  1761. }
  1762. static void initStatic__CVfunk()
  1763. {
  1764. Plugin* const p = new Plugin;
  1765. pluginInstance__CVfunk = p;
  1766. const StaticPluginLoader spl(p, "CVfunk");
  1767. if (spl.ok())
  1768. {
  1769. #define modelSteps modelCVfunkSteps
  1770. p->addModel(modelSteps);
  1771. p->addModel(modelEnvelopeArray);
  1772. p->addModel(modelPentaSequencer);
  1773. p->addModel(modelImpulseController);
  1774. p->addModel(modelSignals);
  1775. p->addModel(modelRanges);
  1776. p->addModel(modelHexMod);
  1777. p->addModel(modelCollatz);
  1778. p->addModel(modelStrings);
  1779. p->addModel(modelMagnets);
  1780. p->addModel(modelOuros);
  1781. #undef modelSteps
  1782. }
  1783. }
  1784. static void initStatic__dBiz()
  1785. {
  1786. Plugin* const p = new Plugin;
  1787. pluginInstance__dBiz = p;
  1788. const StaticPluginLoader spl(p, "dBiz");
  1789. if (spl.ok())
  1790. {
  1791. #define modelChord modeldBizChord
  1792. #define modelDivider modeldBizDivider
  1793. #define modelFourSeq modeldBizFourSeq
  1794. #define modelVCA4 modeldBizVCA4
  1795. p->addModel(modelNavControl);
  1796. p->addModel(modelBench);
  1797. p->addModel(modelContorno);
  1798. //p->addModel(modelContornoMK2);
  1799. p->addModel(modelTranspose);
  1800. p->addModel(modelUtility);
  1801. p->addModel(modelChord);
  1802. p->addModel(modelBene);
  1803. p->addModel(modelBenePads);
  1804. p->addModel(modelPerfMixer);
  1805. p->addModel(modelDrMix);
  1806. p->addModel(modelPerfMixer4);
  1807. p->addModel(modelVCA4);
  1808. p->addModel(modelVCA530);
  1809. p->addModel(modelRemix);
  1810. p->addModel(modelSmixer);
  1811. p->addModel(modelVerbo);
  1812. p->addModel(modelDVCO);
  1813. p->addModel(modelDAOSC);
  1814. p->addModel(modelTROSC);
  1815. p->addModel(modelTROSCMK2);
  1816. p->addModel(modelSuHa);
  1817. p->addModel(modelSuHaMK2);
  1818. p->addModel(modelFourSeq);
  1819. p->addModel(modelDivider);
  1820. p->addModel(modelUtil2);
  1821. p->addModel(modelSmorph);
  1822. p->addModel(modelBigSmorph);
  1823. p->addModel(modelSPan);
  1824. p->addModel(modelQuePasa);
  1825. p->addModel(modelDualFilter);
  1826. p->addModel(modelOrder);
  1827. p->addModel(modelDualMatrix);
  1828. #undef modelChord
  1829. #undef modelDivider
  1830. #undef modelFourSeq
  1831. #undef modelVCA4
  1832. }
  1833. }
  1834. static void initStatic__DHE()
  1835. {
  1836. Plugin* const p = new Plugin;
  1837. pluginInstance__DHE = p;
  1838. const StaticPluginLoader spl(p, "DHE-Modules");
  1839. if (spl.ok())
  1840. {
  1841. dhe::blossom::init(p);
  1842. dhe::buttons::init(p);
  1843. dhe::cubic::init(p);
  1844. dhe::curve_sequencer::init(p);
  1845. dhe::envelope::init(p);
  1846. dhe::func::init(p);
  1847. dhe::fuzzy_logic::init(p);
  1848. dhe::gator::init(p);
  1849. dhe::ranger::init(p);
  1850. dhe::scannibal::init(p);
  1851. dhe::sequencizer::init(p);
  1852. dhe::swave::init(p);
  1853. dhe::tapers::init(p);
  1854. dhe::truth::init(p);
  1855. dhe::xycloid::init(p);
  1856. }
  1857. }
  1858. static void initStatic__DrumKit()
  1859. {
  1860. Plugin* const p = new Plugin;
  1861. pluginInstance__DrumKit = p;
  1862. const StaticPluginLoader spl(p, "DrumKit");
  1863. if (spl.ok())
  1864. {
  1865. setupSamples();
  1866. p->addModel(modelBD9);
  1867. p->addModel(modelSnare);
  1868. p->addModel(modelClosedHH);
  1869. p->addModel(modelOpenHH);
  1870. p->addModel(modelDMX);
  1871. p->addModel(modelCR78);
  1872. p->addModel(modelSBD);
  1873. p->addModel(modelGnome);
  1874. p->addModel(modelSequencer);
  1875. p->addModel(modelTomi);
  1876. p->addModel(modelBaronial);
  1877. p->addModel(modelMarionette);
  1878. }
  1879. }
  1880. static void initStatic__EnigmaCurry()
  1881. {
  1882. Plugin* const p = new Plugin;
  1883. pluginInstance__EnigmaCurry = p;
  1884. const StaticPluginLoader spl(p, "EnigmaCurry");
  1885. if (spl.ok())
  1886. {
  1887. #define modelPulse modelEnigmaCurryPulse
  1888. p->addModel(modelTransport);
  1889. p->addModel(modelLatch);
  1890. p->addModel(modelPulse);
  1891. p->addModel(modelRange);
  1892. #undef modelPulse
  1893. }
  1894. }
  1895. static void initStatic__ESeries()
  1896. {
  1897. Plugin* const p = new Plugin;
  1898. pluginInstance__ESeries = p;
  1899. const StaticPluginLoader spl(p, "ESeries");
  1900. if (spl.ok())
  1901. {
  1902. p->addModel(modelE340);
  1903. }
  1904. }
  1905. static void initStatic__ExpertSleepersEncoders()
  1906. {
  1907. Plugin* const p = new Plugin;
  1908. pluginInstance__ExpertSleepersEncoders = p;
  1909. const StaticPluginLoader spl(p, "ExpertSleepers-Encoders");
  1910. if (spl.ok())
  1911. {
  1912. p->addModel(model8GT);
  1913. p->addModel(model8CV);
  1914. p->addModel(modelES40);
  1915. p->addModel(modelES5);
  1916. p->addModel(modelSMUX);
  1917. p->addModel(modelCalibrator);
  1918. }
  1919. }
  1920. static void initStatic__Extratone()
  1921. {
  1922. Plugin* const p = new Plugin;
  1923. pluginInstance__Extratone = p;
  1924. const StaticPluginLoader spl(p, "Extratone");
  1925. if (spl.ok())
  1926. {
  1927. p->addModel(modelModulo);
  1928. p->addModel(modelMesoglea);
  1929. p->addModel(modelMesoglea2);
  1930. p->addModel(modelOpabinia);
  1931. p->addModel(modelSplitterburst);
  1932. p->addModel(modelPuzzlebox);
  1933. p->addModel(modelDarwinism);
  1934. // p->addModel(modelHalluciMemory);
  1935. p->addModel(modelIchneumonid);
  1936. p->addModel(modelMeganeura);
  1937. p->addModel(modelPureneura);
  1938. p->addModel(modelMesohyl);
  1939. p->addModel(modelXtrtnBlank);
  1940. }
  1941. }
  1942. static void initStatic__FehlerFabrik()
  1943. {
  1944. Plugin* const p = new Plugin;
  1945. pluginInstance__FehlerFabrik = p;
  1946. const StaticPluginLoader spl(p, "FehlerFabrik");
  1947. if (spl.ok())
  1948. {
  1949. p->addModel(modelPSIOP);
  1950. p->addModel(modelPlanck);
  1951. p->addModel(modelLuigi);
  1952. p->addModel(modelAspect);
  1953. p->addModel(modelMonte);
  1954. p->addModel(modelArpanet);
  1955. p->addModel(modelSigma);
  1956. p->addModel(modelFax);
  1957. p->addModel(modelRasoir);
  1958. p->addModel(modelChi);
  1959. p->addModel(modelNova);
  1960. p->addModel(modelLilt);
  1961. p->addModel(modelBotzinger);
  1962. }
  1963. }
  1964. static void initStatic__forsitan()
  1965. {
  1966. Plugin* const p = new Plugin;
  1967. pluginInstance__forsitan = p;
  1968. const StaticPluginLoader spl(p, "forsitan-modulare");
  1969. if (spl.ok())
  1970. {
  1971. p->addModel(alea);
  1972. p->addModel(interea);
  1973. p->addModel(cumuli);
  1974. p->addModel(deinde);
  1975. p->addModel(pavo);
  1976. }
  1977. }
  1978. static void initStatic__GlueTheGiant()
  1979. {
  1980. Plugin* const p = new Plugin;
  1981. pluginInstance__GlueTheGiant = p;
  1982. const StaticPluginLoader spl(p, "GlueTheGiant");
  1983. if (spl.ok())
  1984. {
  1985. p->addModel(modelGigBus);
  1986. p->addModel(modelMiniBus);
  1987. p->addModel(modelSchoolBus);
  1988. p->addModel(modelMetroCityBus);
  1989. p->addModel(modelBusDepot);
  1990. p->addModel(modelBusRoute);
  1991. p->addModel(modelRoad);
  1992. p->addModel(modelEnterBus);
  1993. p->addModel(modelExitBus);
  1994. }
  1995. }
  1996. static void initStatic__GoodSheperd()
  1997. {
  1998. Plugin* const p = new Plugin;
  1999. pluginInstance__GoodSheperd = p;
  2000. const StaticPluginLoader spl(p, "GoodSheperd");
  2001. if (spl.ok())
  2002. {
  2003. p->addModel(modelHurdle);
  2004. p->addModel(modelSEQ3st);
  2005. p->addModel(modelStable16);
  2006. p->addModel(modelStall);
  2007. p->addModel(modelSwitch1);
  2008. p->addModel(modelSeqtrol);
  2009. }
  2010. }
  2011. static void initStatic__GrandeModular()
  2012. {
  2013. Plugin* const p = new Plugin;
  2014. pluginInstance__GrandeModular = p;
  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. static void initStatic__H4N4()
  2046. {
  2047. Plugin* const p = new Plugin;
  2048. pluginInstance__H4N4 = p;
  2049. const StaticPluginLoader spl(p, "h4n4-modules");
  2050. if (spl.ok())
  2051. {
  2052. p->addModel(modelXenQnt);
  2053. }
  2054. }
  2055. static void initStatic__HamptonHarmonics()
  2056. {
  2057. Plugin* const p = new Plugin;
  2058. pluginInstance__HamptonHarmonics = p;
  2059. const StaticPluginLoader spl(p, "HamptonHarmonics");
  2060. if (spl.ok())
  2061. {
  2062. #define modelArp modelHamptonHarmonicsArp
  2063. #define modelProgress modelHamptonHarmonicsProgress
  2064. p->addModel(modelArp);
  2065. p->addModel(modelProgress);
  2066. #undef modelProgress
  2067. #undef modelArp
  2068. }
  2069. }
  2070. static void initStatic__HetrickCV()
  2071. {
  2072. Plugin* const p = new Plugin;
  2073. pluginInstance__HetrickCV = p;
  2074. const StaticPluginLoader spl(p, "HetrickCV");
  2075. if (spl.ok())
  2076. {
  2077. #define modelASR modelHetrickCVASR
  2078. #define modelBlankPanel modelHetrickCVBlankPanel
  2079. #define modelFlipFlop modelHetrickCVFlipFlop
  2080. #define modelMidSide modelHetrickCVMidSide
  2081. #define modelMinMax modelHetrickCVMinMax
  2082. #define PanelBaseWidget HetrickCVPanelBaseWidget
  2083. #define InverterWidget HetrickCVInverterWidget
  2084. p->addModel(modelTwoToFour);
  2085. p->addModel(modelAnalogToDigital);
  2086. p->addModel(modelASR);
  2087. p->addModel(modelBinaryGate);
  2088. p->addModel(modelBinaryNoise);
  2089. p->addModel(modelBitshift);
  2090. p->addModel(modelBlankPanel);
  2091. p->addModel(modelBoolean3);
  2092. p->addModel(modelChaos1Op);
  2093. p->addModel(modelChaos2Op);
  2094. p->addModel(modelChaos3Op);
  2095. p->addModel(modelChaoticAttractors);
  2096. p->addModel(modelClockedNoise);
  2097. p->addModel(modelComparator);
  2098. p->addModel(modelContrast);
  2099. p->addModel(modelCrackle);
  2100. p->addModel(modelDataCompander);
  2101. p->addModel(modelDelta);
  2102. p->addModel(modelDigitalToAnalog);
  2103. p->addModel(modelDust);
  2104. p->addModel(modelExponent);
  2105. p->addModel(modelFBSineChaos);
  2106. p->addModel(modelFlipFlop);
  2107. p->addModel(modelFlipPan);
  2108. p->addModel(modelGateDelay);
  2109. p->addModel(modelGateJunction);
  2110. p->addModel(modelGateJunctionExp);
  2111. p->addModel(modelGingerbread);
  2112. p->addModel(modelLogicCombine);
  2113. p->addModel(modelMidSide);
  2114. p->addModel(modelMinMax);
  2115. p->addModel(modelPhaseDrivenSequencer);
  2116. p->addModel(modelPhaseDrivenSequencer32);
  2117. p->addModel(modelPhasorAnalyzer);
  2118. p->addModel(modelPhasorBurstGen);
  2119. p->addModel(modelPhasorDivMult);
  2120. p->addModel(modelPhasorEuclidean);
  2121. p->addModel(modelPhasorGates);
  2122. p->addModel(modelPhasorGates32);
  2123. p->addModel(modelPhasorGates64);
  2124. p->addModel(modelPhasorGen);
  2125. p->addModel(modelPhasorGeometry);
  2126. p->addModel(modelPhasorHumanizer);
  2127. p->addModel(modelPhasorMixer);
  2128. p->addModel(modelPhasorOctature);
  2129. p->addModel(modelPhasorQuadrature);
  2130. p->addModel(modelPhasorRandom);
  2131. p->addModel(modelPhasorRanger);
  2132. p->addModel(modelPhasorReset);
  2133. p->addModel(modelPhasorRhythmGroup);
  2134. p->addModel(modelPhasorShape);
  2135. p->addModel(modelPhasorShift);
  2136. p->addModel(modelPhasorStutter);
  2137. p->addModel(modelPhasorSubstepShape);
  2138. p->addModel(modelPhasorSwing);
  2139. p->addModel(modelPhasorTimetable);
  2140. p->addModel(modelPhasorToClock);
  2141. p->addModel(modelPhasorToLFO);
  2142. p->addModel(modelPhasorToWaveforms);
  2143. p->addModel(modelProbability);
  2144. p->addModel(modelRandomGates);
  2145. p->addModel(modelRotator);
  2146. p->addModel(modelRungler);
  2147. p->addModel(modelScanner);
  2148. p->addModel(modelVectorMix);
  2149. p->addModel(modelWaveshape);
  2150. p->addModel(modelXYToPolar);
  2151. #undef modelASR
  2152. #undef modelBlankPanel
  2153. #undef modelFlipFlop
  2154. #undef modelMidSide
  2155. #undef modelMinMax
  2156. #undef PanelBaseWidget
  2157. #undef InverterWidget
  2158. }
  2159. }
  2160. static void initStatic__ImpromptuModular()
  2161. {
  2162. Plugin* const p = new Plugin;
  2163. pluginInstance__ImpromptuModular = p;
  2164. const StaticPluginLoader spl(p, "ImpromptuModular");
  2165. if (spl.ok())
  2166. {
  2167. p->addModel(modelAdaptiveQuantizer);
  2168. p->addModel(modelBigButtonSeq);
  2169. p->addModel(modelBigButtonSeq2);
  2170. p->addModel(modelChordKey);
  2171. p->addModel(modelChordKeyExpander);
  2172. p->addModel(modelClocked);
  2173. p->addModel(modelClockedExpander);
  2174. p->addModel(modelClkd);
  2175. p->addModel(modelCvPad);
  2176. p->addModel(modelFoundry);
  2177. p->addModel(modelFoundryExpander);
  2178. p->addModel(modelFourView);
  2179. p->addModel(modelGateSeq64);
  2180. p->addModel(modelGateSeq64Expander);
  2181. p->addModel(modelHotkey);
  2182. p->addModel(modelPart);
  2183. p->addModel(modelPhraseSeq16);
  2184. p->addModel(modelPhraseSeq32);
  2185. p->addModel(modelPhraseSeqExpander);
  2186. p->addModel(modelProbKey);
  2187. p->addModel(modelSemiModularSynth);
  2188. p->addModel(modelSygen);
  2189. p->addModel(modelTact);
  2190. p->addModel(modelTact1);
  2191. p->addModel(modelTactG);
  2192. p->addModel(modelTwelveKey);
  2193. p->addModel(modelVariations);
  2194. p->addModel(modelWriteSeq32);
  2195. p->addModel(modelWriteSeq64);
  2196. p->addModel(modelBlankPanel);
  2197. }
  2198. }
  2199. static void initStatic__ihtsyn()
  2200. {
  2201. Plugin* const p = new Plugin;
  2202. pluginInstance__ihtsyn = p;
  2203. const StaticPluginLoader spl(p, "ihtsyn");
  2204. if (spl.ok())
  2205. {
  2206. p->addModel(modelPitchMangler);
  2207. p->addModel(modelTwistedVerb);
  2208. p->addModel(modelHiVerb);
  2209. p->addModel(modelMVerb);
  2210. }
  2211. }
  2212. static void initStatic__JW()
  2213. {
  2214. Plugin* const p = new Plugin;
  2215. pluginInstance__JW = p;
  2216. const StaticPluginLoader spl(p, "JW-Modules");
  2217. if (spl.ok())
  2218. {
  2219. #define modelQuantizer modelJWQuantizer
  2220. p->addModel(modelAdd5);
  2221. p->addModel(modelBouncyBalls);
  2222. p->addModel(modelCat);
  2223. p->addModel(modelTree);
  2224. p->addModel(modelFullScope);
  2225. p->addModel(modelGridSeq);
  2226. p->addModel(modelEightSeq);
  2227. p->addModel(modelDivSeq);
  2228. p->addModel(modelMinMax);
  2229. p->addModel(modelNoteSeq);
  2230. p->addModel(modelNoteSeqFu);
  2231. p->addModel(modelNoteSeq16);
  2232. p->addModel(modelTrigs);
  2233. p->addModel(modelOnePattern);
  2234. p->addModel(modelPatterns);
  2235. p->addModel(modelQuantizer);
  2236. p->addModel(modelSimpleClock);
  2237. p->addModel(modelD1v1de);
  2238. p->addModel(modelPres1t);
  2239. p->addModel(modelThingThing);
  2240. p->addModel(modelWavHead);
  2241. p->addModel(modelXYPad);
  2242. p->addModel(modelBlankPanel1hp);
  2243. p->addModel(modelBlankPanelSmall);
  2244. p->addModel(modelBlankPanelMedium);
  2245. p->addModel(modelBlankPanelLarge);
  2246. p->addModel(modelCoolBreeze);
  2247. p->addModel(modelPete);
  2248. #ifndef STATIC_BUILD
  2249. p->addModel(modelStr1ker);
  2250. #else
  2251. spl.removeModule("Str1ker");
  2252. #endif
  2253. #undef modelQuantizer
  2254. }
  2255. }
  2256. static void initStatic__kocmoc()
  2257. {
  2258. Plugin* const p = new Plugin;
  2259. pluginInstance__kocmoc= p;
  2260. const StaticPluginLoader spl(p, "kocmoc");
  2261. if (spl.ok())
  2262. {
  2263. p->addModel(modelSVF_1);
  2264. p->addModel(modelTRG);
  2265. p->addModel(modelLADR);
  2266. p->addModel(modelOP);
  2267. p->addModel(modelPHASR);
  2268. p->addModel(modelMUL);
  2269. p->addModel(modelSKF);
  2270. p->addModel(modelDDLY);
  2271. }
  2272. }
  2273. static void initStatic__LifeFormModular()
  2274. {
  2275. Plugin* const p = new Plugin;
  2276. pluginInstance__LifeFormModular= p;
  2277. const StaticPluginLoader spl(p, "LifeFormModular");
  2278. if (spl.ok())
  2279. {
  2280. p->addModel(modelTimeDiktat);
  2281. p->addModel(modelSequenceModeler);
  2282. p->addModel(modelPitchDiktat);
  2283. p->addModel(modelPitchIntegrator);
  2284. p->addModel(modelBurstIntegrator);
  2285. p->addModel(modelQuadModulator);
  2286. p->addModel(modelImpulseControl);
  2287. p->addModel(modelQuadSteppedOffset);
  2288. p->addModel(modelPercussiveVibration);
  2289. p->addModel(modelQuadUtility);
  2290. p->addModel(modelAdditiveVibration);
  2291. p->addModel(modelComplexOsc);
  2292. p->addModel(modelDriftgen);
  2293. }
  2294. }
  2295. static void initStatic__LilacLoop()
  2296. {
  2297. Plugin* const p = new Plugin;
  2298. pluginInstance__LilacLoop = p;
  2299. const StaticPluginLoader spl(p, "LilacLoop");
  2300. if (spl.ok())
  2301. {
  2302. p->addModel(modelLooperOne);
  2303. }
  2304. }
  2305. static void initStatic__LittleUtils()
  2306. {
  2307. Plugin* const p = new Plugin;
  2308. pluginInstance__LittleUtils = p;
  2309. const StaticPluginLoader spl(p, "LittleUtils");
  2310. if (spl.ok())
  2311. {
  2312. p->addModel(modelButtonModule);
  2313. p->addModel(modelPulseGenerator);
  2314. p->addModel(modelBias_Semitone);
  2315. p->addModel(modelMulDiv);
  2316. p->addModel(modelTeleportInModule);
  2317. p->addModel(modelTeleportOutModule);
  2318. }
  2319. }
  2320. static void initStatic__Lomas()
  2321. {
  2322. Plugin* const p = new Plugin;
  2323. pluginInstance__Lomas = p;
  2324. const StaticPluginLoader spl(p, "LomasModules");
  2325. if (spl.ok())
  2326. {
  2327. p->addModel(modelAdvancedSampler);
  2328. p->addModel(modelGateSequencer);
  2329. }
  2330. }
  2331. static void initStatic__Lyrae()
  2332. {
  2333. Plugin* const p = new Plugin;
  2334. pluginInstance__Lyrae = p;
  2335. const StaticPluginLoader spl(p, "LyraeModules");
  2336. if (spl.ok())
  2337. {
  2338. #define modelDelta modelLyraeDelta
  2339. p->addModel(modelSulafat);
  2340. p->addModel(modelGamma);
  2341. p->addModel(modelDelta);
  2342. p->addModel(modelVega);
  2343. p->addModel(modelBD383238);
  2344. p->addModel(modelZeta);
  2345. #undef modelDelta
  2346. }
  2347. }
  2348. static void initStatic__Meander()
  2349. {
  2350. Plugin* const p = new Plugin;
  2351. pluginInstance__Meander = p;
  2352. const StaticPluginLoader spl(p, "Meander");
  2353. if (spl.ok())
  2354. {
  2355. // for dark theme
  2356. panelTheme = 1;
  2357. p->addModel(modelMeander);
  2358. }
  2359. }
  2360. static void initStatic__MindMeld()
  2361. {
  2362. Plugin* const p = new Plugin;
  2363. pluginInstance__MindMeld = p;
  2364. const StaticPluginLoader spl(p, "MindMeldModular");
  2365. if (spl.ok())
  2366. {
  2367. p->addModel(modelPatchMaster);
  2368. p->addModel(modelPatchMasterBlank);
  2369. p->addModel(modelRouteMasterMono5to1);
  2370. p->addModel(modelRouteMasterStereo5to1);
  2371. p->addModel(modelRouteMasterMono1to5);
  2372. p->addModel(modelRouteMasterStereo1to5);
  2373. p->addModel(modelMasterChannel);
  2374. p->addModel(modelMeld);
  2375. p->addModel(modelUnmeld);
  2376. p->addModel(modelMSMelder);
  2377. p->addModel(modelEqMaster);
  2378. p->addModel(modelEqExpander);
  2379. p->addModel(modelBassMaster);
  2380. p->addModel(modelBassMasterJr);
  2381. p->addModel(modelShapeMaster);
  2382. p->addModel(modelMixMasterJr);
  2383. p->addModel(modelAuxExpanderJr);
  2384. p->addModel(modelMixMaster);
  2385. p->addModel(modelAuxExpander);
  2386. }
  2387. }
  2388. static void initStatic__ML()
  2389. {
  2390. Plugin* const p = new Plugin;
  2391. pluginInstance__ML = p;
  2392. const StaticPluginLoader spl(p, "ML_modules");
  2393. if (spl.ok())
  2394. {
  2395. #define modelQuantizer modelMLQuantizer
  2396. #define modelSH8 modelMLSH8
  2397. p->addModel(modelQuantizer);
  2398. p->addModel(modelQuantum);
  2399. p->addModel(modelTrigBuf);
  2400. p->addModel(modelSeqSwitch);
  2401. p->addModel(modelSeqSwitch2);
  2402. p->addModel(modelShiftRegister);
  2403. p->addModel(modelShiftRegister2);
  2404. p->addModel(modelFreeVerb);
  2405. p->addModel(modelSum8);
  2406. p->addModel(modelSum8mk2);
  2407. p->addModel(modelSum8mk3);
  2408. p->addModel(modelSH8);
  2409. p->addModel(modelConstants);
  2410. p->addModel(modelCounter);
  2411. p->addModel(modelTrigDelay);
  2412. p->addModel(modelBPMdetect);
  2413. p->addModel(modelVoltMeter);
  2414. p->addModel(modelOctaFlop);
  2415. p->addModel(modelOctaTrig);
  2416. p->addModel(modelOctaSwitch);
  2417. p->addModel(modelTrigSwitch);
  2418. p->addModel(modelTrigSwitch2);
  2419. p->addModel(modelTrigSwitch3);
  2420. p->addModel(modelTrigSwitch3_2);
  2421. p->addModel(modelOctaPlus);
  2422. p->addModel(modelOctaTimes);
  2423. p->addModel(modelCloner);
  2424. p->addModel(modelPolySplitter);
  2425. p->addModel(modelArpeggiator);
  2426. #undef modelQuantizer
  2427. #undef modelSH8
  2428. }
  2429. }
  2430. static void initStatic__MockbaModular()
  2431. {
  2432. Plugin* const p = new Plugin;
  2433. pluginInstance__MockbaModular = p;
  2434. const StaticPluginLoader spl(p, "MockbaModular");
  2435. if (spl.ok())
  2436. {
  2437. #define modelBlank modelMockbaModularBlank
  2438. #define modelComparator modelMockbaModularComparator
  2439. p->addModel(modelBlank);
  2440. p->addModel(modelFeidah);
  2441. p->addModel(modelFeidahS);
  2442. p->addModel(modelFiltah);
  2443. p->addModel(modelMixah);
  2444. p->addModel(modelMixah3);
  2445. p->addModel(modelDividah);
  2446. p->addModel(modelCountah);
  2447. p->addModel(modelSelectah);
  2448. p->addModel(modelShapah);
  2449. p->addModel(modelHoldah);
  2450. p->addModel(modelPannah);
  2451. p->addModel(modelReVoltah);
  2452. p->addModel(modelCZSaw);
  2453. p->addModel(modelCZSquare);
  2454. p->addModel(modelCZPulse);
  2455. p->addModel(modelCZDblSine);
  2456. p->addModel(modelCZSawPulse);
  2457. p->addModel(modelCZReso1);
  2458. p->addModel(modelCZReso2);
  2459. p->addModel(modelCZReso3);
  2460. p->addModel(modelCZOsc);
  2461. p->addModel(modelMaugTriangle);
  2462. p->addModel(modelMaugShark);
  2463. p->addModel(modelMaugSaw);
  2464. p->addModel(modelMaugSaw2);
  2465. p->addModel(modelMaugSquare);
  2466. p->addModel(modelMaugSquare2);
  2467. p->addModel(modelMaugSquare3);
  2468. p->addModel(modelMaugOsc);
  2469. p->addModel(modelComparator);
  2470. p->addModel(modelDualBUFFER);
  2471. p->addModel(modelDualNOT);
  2472. p->addModel(modelDualOR);
  2473. p->addModel(modelDualNOR);
  2474. p->addModel(modelDualAND);
  2475. p->addModel(modelDualNAND);
  2476. p->addModel(modelDualXOR);
  2477. p->addModel(modelDualXNOR);
  2478. p->addModel(modelPSelectah);
  2479. // require input files to work
  2480. spl.removeModule("UDPClockMaster");
  2481. spl.removeModule("UDPClockSlave");
  2482. #undef modelBlank
  2483. #undef modelComparator
  2484. }
  2485. }
  2486. static void initStatic__Mog()
  2487. {
  2488. Plugin* const p = new Plugin;
  2489. pluginInstance__Mog = p;
  2490. const StaticPluginLoader spl(p, "Mog");
  2491. if (spl.ok())
  2492. {
  2493. p->addModel(modelNetwork);
  2494. p->addModel(modelNexus);
  2495. }
  2496. }
  2497. static void initStatic__mscHack()
  2498. {
  2499. Plugin* const p = new Plugin;
  2500. pluginInstance__mscHack = p;
  2501. const StaticPluginLoader spl(p, "mscHack");
  2502. if (spl.ok())
  2503. {
  2504. p->addModel(modelCompressor);
  2505. p->addModel(modelSynthDrums);
  2506. p->addModel(modelSEQ_6x32x16);
  2507. p->addModel(modelMasterClockx4);
  2508. //p->addModel(modelMasterClockx8);
  2509. p->addModel(modelSEQ_Envelope_8);
  2510. p->addModel(modelSeq_Triad2);
  2511. p->addModel(modelARP700);
  2512. p->addModel(modelMix_4_0_4);
  2513. p->addModel(modelMix_9_3_4);
  2514. p->addModel(modelMix_16_4_4);
  2515. p->addModel(modelMix_24_4_4);
  2516. p->addModel(modelASAF8);
  2517. p->addModel(modelPingPong);
  2518. p->addModel(modelStepDelay);
  2519. p->addModel(modelOsc_3Ch);
  2520. p->addModel(modelDronez);
  2521. p->addModel(modelMorze);
  2522. p->addModel(modelWindz);
  2523. p->addModel(modelLorenz);
  2524. p->addModel(modelAlienz);
  2525. p->addModel(modelOSC_WaveMorph_3);
  2526. p->addModel(modelMaude_221);
  2527. }
  2528. }
  2529. static void initStatic__MSM()
  2530. {
  2531. Plugin* const p = new Plugin;
  2532. pluginInstance__MSM = p;
  2533. const StaticPluginLoader spl(p, "MSM");
  2534. if (spl.ok())
  2535. {
  2536. #define modelADSR modelMSMADSR
  2537. #define modelBlankPanel modelMSMBlankPanel
  2538. #define modelDelay modelMSMDelay
  2539. #define modelLFO modelMSMLFO
  2540. #define modelMult modelMSMMult
  2541. #define modelNoise modelMSMNoise
  2542. #define modelVCA modelMSMVCA
  2543. #define modelVCO modelMSMVCO
  2544. p->addModel(modelVCO);
  2545. p->addModel(modelBVCO);
  2546. p->addModel(modelExperimentalVCO);
  2547. p->addModel(modelNoise);
  2548. p->addModel(modelLFO);
  2549. p->addModel(modelVCA);
  2550. p->addModel(modelADSR);
  2551. p->addModel(modelDelay);
  2552. p->addModel(modelWaveShaper);
  2553. p->addModel(modelWavefolder);
  2554. p->addModel(modelBitcrusher);
  2555. p->addModel(modelPhaserModule);
  2556. p->addModel(modelMorpher);
  2557. p->addModel(modelRingMod);
  2558. p->addModel(modelRandomSource);
  2559. p->addModel(modelMult);
  2560. p->addModel(modelCrazyMult);
  2561. p->addModel(modelFade);
  2562. p->addModel(modelSimpleSlider);
  2563. p->addModel(modelxseq);
  2564. p->addModel(modelBlankPanel);
  2565. #undef modelADSR
  2566. #undef modelBlankPanel
  2567. #undef modelDelay
  2568. #undef modelLFO
  2569. #undef modelMult
  2570. #undef modelNoise
  2571. #undef modelVCA
  2572. #undef modelVCO
  2573. }
  2574. }
  2575. static void initStatic__myth_modules()
  2576. {
  2577. Plugin* const p = new Plugin;
  2578. pluginInstance__myth_modules = p;
  2579. const StaticPluginLoader spl(p, "myth-modules");
  2580. if (spl.ok())
  2581. {
  2582. p->addModel(modelMavka);
  2583. p->addModel(modelMolphar);
  2584. }
  2585. }
  2586. static void initStatic__nonlinearcircuits()
  2587. {
  2588. Plugin* const p = new Plugin;
  2589. pluginInstance__nonlinearcircuits = p;
  2590. const StaticPluginLoader spl(p, "nonlinearcircuits");
  2591. if (spl.ok())
  2592. {
  2593. p->addModel(model4Seq);
  2594. p->addModel(modelCipher);
  2595. p->addModel(modelBOOLs);
  2596. p->addModel(modelDivideConquer);
  2597. p->addModel(modelDivineCMOS);
  2598. p->addModel(modelDoubleNeuron);
  2599. p->addModel(modelGenie);
  2600. p->addModel(modelLetsSplosh);
  2601. p->addModel(modelNeuron);
  2602. p->addModel(modelNumberwang);
  2603. p->addModel(modelRouter);
  2604. p->addModel(modelSegue);
  2605. p->addModel(modelSlothApathy);
  2606. p->addModel(modelSlothInertia);
  2607. p->addModel(modelSlothTorpor);
  2608. p->addModel(modelSquidAxon);
  2609. p->addModel(modelStatues);
  2610. p->addModel(modelTripleSloth);
  2611. }
  2612. }
  2613. static void initStatic__Orbits()
  2614. {
  2615. Plugin* const p = new Plugin;
  2616. pluginInstance__Orbits = p;
  2617. const StaticPluginLoader spl(p, "Orbits");
  2618. if (spl.ok())
  2619. {
  2620. p->addModel(modelRareBreeds_Orbits_Eugene);
  2621. p->addModel(modelRareBreeds_Orbits_Polygene);
  2622. }
  2623. }
  2624. static void initStatic__ParableInstruments()
  2625. {
  2626. Plugin* const p = new Plugin;
  2627. pluginInstance__ParableInstruments = p;
  2628. const StaticPluginLoader spl(p, "ParableInstruments");
  2629. if (spl.ok())
  2630. {
  2631. #define modelClouds modelParableClouds
  2632. p->addModel(modelClouds);
  2633. #undef modelClouds
  2634. }
  2635. }
  2636. static void initStatic__PathSet()
  2637. {
  2638. Plugin* const p = new Plugin;
  2639. pluginInstance__PathSet = p;
  2640. const StaticPluginLoader spl(p, "PathSet");
  2641. if (spl.ok())
  2642. {
  2643. p->addModel(modelShiftyMod);
  2644. p->addModel(modelShiftyExpander);
  2645. p->addModel(modelIceTray);
  2646. p->addModel(modelAstroVibe);
  2647. p->addModel(modelGlassPane);
  2648. p->addModel(modelPlusPane);
  2649. p->addModel(modelNudge);
  2650. p->addModel(modelOneShot);
  2651. }
  2652. }
  2653. static void initStatic__PinkTrombone()
  2654. {
  2655. Plugin* const p = new Plugin;
  2656. pluginInstance__PinkTrombone = p;
  2657. const StaticPluginLoader spl(p, "PinkTrombone");
  2658. if (spl.ok())
  2659. {
  2660. p->addModel(modelPinkTrombone);
  2661. }
  2662. }
  2663. static void initStatic__Prism()
  2664. {
  2665. Plugin* const p = new Plugin;
  2666. pluginInstance__Prism = p;
  2667. const StaticPluginLoader spl(p, "Prism");
  2668. if (spl.ok())
  2669. {
  2670. p->addModel(modelRainbow);
  2671. p->addModel(modelRainbowScaleExpander);
  2672. p->addModel(modelDroplet);
  2673. }
  2674. }
  2675. static void initStatic__rackwindows()
  2676. {
  2677. Plugin* const p = new Plugin;
  2678. pluginInstance__rackwindows = p;
  2679. const StaticPluginLoader spl(p, "rackwindows");
  2680. if (spl.ok())
  2681. {
  2682. // p->addModel(modelAcceleration);
  2683. p->addModel(modelBitshiftgain);
  2684. p->addModel(modelCapacitor);
  2685. p->addModel(modelCapacitor_stereo);
  2686. p->addModel(modelChorus);
  2687. p->addModel(modelConsole);
  2688. p->addModel(modelConsole_mm);
  2689. p->addModel(modelDistance);
  2690. p->addModel(modelGolem);
  2691. p->addModel(modelHolt);
  2692. p->addModel(modelHombre);
  2693. p->addModel(modelInterstage);
  2694. p->addModel(modelMonitoring);
  2695. p->addModel(modelMv);
  2696. p->addModel(modelRasp);
  2697. p->addModel(modelReseq);
  2698. p->addModel(modelTape);
  2699. p->addModel(modelTremolo);
  2700. p->addModel(modelVibrato);
  2701. }
  2702. }
  2703. static void initStatic__RebelTech()
  2704. {
  2705. Plugin* const p = new Plugin;
  2706. pluginInstance__RebelTech = p;
  2707. const StaticPluginLoader spl(p, "RebelTech");
  2708. if (spl.ok())
  2709. {
  2710. p->addModel(modelStoicheia);
  2711. p->addModel(modelTonic);
  2712. p->addModel(modelKlasmata);
  2713. p->addModel(modelCLK);
  2714. p->addModel(modelLogoi);
  2715. p->addModel(modelPhoreo);
  2716. }
  2717. }
  2718. static void initStatic__repelzen()
  2719. {
  2720. Plugin* const p = new Plugin;
  2721. pluginInstance__repelzen = p;
  2722. const StaticPluginLoader spl(p, "repelzen");
  2723. if (spl.ok())
  2724. {
  2725. #define modelBlank modelrepelzenBlank
  2726. #define modelMixer modelrepelzenMixer
  2727. #define modelWerner modelrepelzenWerner
  2728. p->addModel(modelBlank);
  2729. p->addModel(modelBurst);
  2730. p->addModel(modelFolder);
  2731. p->addModel(modelErwin);
  2732. p->addModel(modelWerner);
  2733. p->addModel(modelMixer);
  2734. #undef modelBlank
  2735. #undef modelMixer
  2736. #undef modelWerner
  2737. }
  2738. }
  2739. static void initStatic__Sapphire()
  2740. {
  2741. Plugin* const p = new Plugin;
  2742. pluginInstance__sapphire = p;
  2743. const StaticPluginLoader spl(p, "Sapphire");
  2744. if (spl.ok())
  2745. {
  2746. p->addModel(modelElastika);
  2747. p->addModel(modelFrolic);
  2748. p->addModel(modelGlee);
  2749. p->addModel(modelHiss);
  2750. p->addModel(modelMoots);
  2751. p->addModel(modelNucleus);
  2752. p->addModel(modelPolynucleus);
  2753. p->addModel(modelTin);
  2754. p->addModel(modelTout);
  2755. p->addModel(modelTricorder);
  2756. p->addModel(modelTubeUnit);
  2757. }
  2758. }
  2759. static void initStatic__sonusmodular()
  2760. {
  2761. Plugin* const p = new Plugin;
  2762. pluginInstance__sonusmodular = p;
  2763. const StaticPluginLoader spl(p, "sonusmodular");
  2764. if (spl.ok())
  2765. {
  2766. p->addModel(modelAddiction);
  2767. p->addModel(modelBitter);
  2768. p->addModel(modelBymidside);
  2769. p->addModel(modelCampione);
  2770. p->addModel(modelChainsaw);
  2771. p->addModel(modelCtrl);
  2772. p->addModel(modelDeathcrush);
  2773. p->addModel(modelFraction);
  2774. p->addModel(modelHarmony);
  2775. p->addModel(modelLadrone);
  2776. p->addModel(modelLuppolo);
  2777. p->addModel(modelLuppolo3);
  2778. p->addModel(modelMicromacro);
  2779. p->addModel(modelMrcheb);
  2780. p->addModel(modelMultimulti);
  2781. p->addModel(modelNeurosc);
  2782. p->addModel(modelOktagon);
  2783. p->addModel(modelOsculum);
  2784. p->addModel(modelParamath);
  2785. p->addModel(modelPiconoise);
  2786. p->addModel(modelPith);
  2787. p->addModel(modelPusher);
  2788. p->addModel(modelRingo);
  2789. p->addModel(modelScramblase);
  2790. p->addModel(modelTropicana);
  2791. p->addModel(modelTwoff);
  2792. p->addModel(modelYabp);
  2793. }
  2794. }
  2795. static void initStatic__StarlingVia()
  2796. {
  2797. Plugin* const p = new Plugin;
  2798. pluginInstance__StarlingVia = p;
  2799. const StaticPluginLoader spl(p, "StarlingVia");
  2800. if (spl.ok())
  2801. {
  2802. #define modelScanner modelStarlingViaScanner
  2803. p->addModel(modelMeta);
  2804. p->addModel(modelGateseq);
  2805. p->addModel(modelScanner);
  2806. p->addModel(modelSync);
  2807. p->addModel(modelAtsr);
  2808. p->addModel(modelOsc3);
  2809. p->addModel(modelSync3);
  2810. p->addModel(modelSync3XL);
  2811. p->addModel(modelSync3XLLevels);
  2812. #undef modelScanner
  2813. }
  2814. }
  2815. static void initStatic__stocaudio()
  2816. {
  2817. Plugin* const p = new Plugin;
  2818. pluginInstance__stocaudio = p;
  2819. const StaticPluginLoader spl(p, "stocaudio");
  2820. if (spl.ok())
  2821. {
  2822. p->addModel(modelPolyturing);
  2823. p->addModel(modelPolydelay);
  2824. p->addModel(modelSpread);
  2825. }
  2826. }
  2827. static void initStatic__stoermelder_p1()
  2828. {
  2829. Plugin* const p = new Plugin;
  2830. pluginInstance__stoermelder_p1 = p;
  2831. const StaticPluginLoader spl(p, "stoermelder-packone");
  2832. if (spl.ok())
  2833. {
  2834. p->addModel(modelCVMap);
  2835. p->addModel(modelCVMapCtx);
  2836. p->addModel(modelCVMapMicro);
  2837. p->addModel(modelCVPam);
  2838. p->addModel(modelRotorA);
  2839. p->addModel(modelReMoveLite);
  2840. p->addModel(modelBolt);
  2841. p->addModel(modelInfix);
  2842. p->addModel(modelInfixMicro);
  2843. p->addModel(modelEightFace);
  2844. p->addModel(modelEightFaceX2);
  2845. p->addModel(modelSipo);
  2846. p->addModel(modelFourRounds);
  2847. p->addModel(modelArena);
  2848. p->addModel(modelMaze);
  2849. p->addModel(modelHive);
  2850. p->addModel(modelIntermix);
  2851. p->addModel(modelIntermixGate);
  2852. p->addModel(modelIntermixEnv);
  2853. p->addModel(modelIntermixFade);
  2854. p->addModel(modelSail);
  2855. p->addModel(modelPile);
  2856. p->addModel(modelPilePoly);
  2857. p->addModel(modelMirror);
  2858. p->addModel(modelAffix);
  2859. p->addModel(modelAffixMicro);
  2860. p->addModel(modelGrip);
  2861. p->addModel(modelGlue);
  2862. p->addModel(modelGoto);
  2863. p->addModel(modelStroke);
  2864. p->addModel(modelSpin);
  2865. p->addModel(modelTransit);
  2866. p->addModel(modelTransitEx);
  2867. p->addModel(modelX4);
  2868. p->addModel(modelMacro);
  2869. p->addModel(modelOrbit);
  2870. p->addModel(modelEightFaceMk2);
  2871. p->addModel(modelEightFaceMk2Ex);
  2872. p->addModel(modelDirt);
  2873. p->addModel(modelMb);
  2874. p->addModel(modelMe);
  2875. p->addModel(modelRaw);
  2876. p->addModel(modelStrip);
  2877. p->addModel(modelStripBay4);
  2878. p->addModel(modelStripPp);
  2879. spl.removeModule("AudioInterface64");
  2880. spl.removeModule("MidiCat");
  2881. spl.removeModule("MidiCatEx");
  2882. spl.removeModule("MidiCatCtx");
  2883. spl.removeModule("MidiKey");
  2884. spl.removeModule("MidiMon");
  2885. spl.removeModule("MidiPlug");
  2886. spl.removeModule("MidiStep");
  2887. }
  2888. }
  2889. static void initStatic__surgext()
  2890. {
  2891. Plugin* const p = new Plugin;
  2892. pluginInstance__surgext = p;
  2893. const StaticPluginLoader spl(p, "surgext");
  2894. if (spl.ok())
  2895. {
  2896. p->addModel(modelVCOClassic);
  2897. p->addModel(modelVCOModern);
  2898. p->addModel(modelVCOWavetable);
  2899. p->addModel(modelVCOWindow);
  2900. p->addModel(modelVCOSine);
  2901. p->addModel(modelVCOFM2);
  2902. p->addModel(modelVCOFM3);
  2903. p->addModel(modelVCOSHNoise);
  2904. p->addModel(modelVCOAlias);
  2905. p->addModel(modelVCOString);
  2906. p->addModel(modelVCOTwist);
  2907. // Add the ported ones
  2908. p->addModel(modelSurgeVCF);
  2909. p->addModel(modelSurgeDelay);
  2910. p->addModel(modelSurgeDelayLineByFreq);
  2911. p->addModel(modelSurgeDelayLineByFreqExpanded);
  2912. p->addModel(modelSurgeDigitalRingMods);
  2913. p->addModel(modelSurgeWaveshaper);
  2914. p->addModel(modelSurgeLFO);
  2915. p->addModel(modelSurgeMixer);
  2916. p->addModel(modelSurgeMixerSlider);
  2917. p->addModel(modelSurgeModMatrix);
  2918. p->addModel(modelFXReverb);
  2919. p->addModel(modelFXPhaser);
  2920. p->addModel(modelFXRotarySpeaker);
  2921. p->addModel(modelFXDistortion);
  2922. p->addModel(modelFXFrequencyShifter);
  2923. p->addModel(modelFXChorus);
  2924. p->addModel(modelFXVocoder);
  2925. p->addModel(modelFXReverb2);
  2926. p->addModel(modelFXFlanger);
  2927. p->addModel(modelFXRingMod);
  2928. p->addModel(modelFXNeuron);
  2929. p->addModel(modelFXResonator);
  2930. p->addModel(modelFXChow);
  2931. p->addModel(modelFXExciter);
  2932. p->addModel(modelFXEnsemble);
  2933. p->addModel(modelFXCombulator);
  2934. p->addModel(modelFXNimbus);
  2935. p->addModel(modelFXSpringReverb);
  2936. p->addModel(modelFXTreeMonster);
  2937. p->addModel(modelFXBonsai);
  2938. p->addModel(modelEGxVCA);
  2939. p->addModel(modelQuadAD);
  2940. p->addModel(modelQuadLFO);
  2941. p->addModel(modelUnisonHelper);
  2942. p->addModel(modelUnisonHelperCVExpander);
  2943. surgext_rack_initialize();
  2944. }
  2945. }
  2946. static void initStatic__unless_modules()
  2947. {
  2948. Plugin* const p = new Plugin;
  2949. pluginInstance__unless_modules = p;
  2950. const StaticPluginLoader spl(p, "unless_modules");
  2951. if (spl.ok())
  2952. {
  2953. // unless_modules::init_theme();
  2954. // theme = _less::Theme();
  2955. p->addModel(modelPiong);
  2956. p->addModel(modelChainkov);
  2957. p->addModel(modelAtoms);
  2958. p->addModel(modelCantor);
  2959. p->addModel(modelRoom);
  2960. p->addModel(modelSnake);
  2961. p->addModel(modelTowers);
  2962. p->addModel(modelPianoid);
  2963. p->addModel(modelPremuter);
  2964. p->addModel(modelAvoider);
  2965. }
  2966. }
  2967. static void initStatic__ValleyAudio()
  2968. {
  2969. Plugin* const p = new Plugin;
  2970. pluginInstance__ValleyAudio = p;
  2971. const StaticPluginLoader spl(p, "ValleyAudio");
  2972. if (spl.ok())
  2973. {
  2974. p->addModel(modelTopograph);
  2975. p->addModel(modelUGraph);
  2976. p->addModel(modelDexter);
  2977. p->addModel(modelPlateau);
  2978. p->addModel(modelInterzone);
  2979. p->addModel(modelAmalgam);
  2980. p->addModel(modelFeline);
  2981. p->addModel(modelTerrorform);
  2982. }
  2983. }
  2984. static void initStatic__Voxglitch()
  2985. {
  2986. Plugin* p = new Plugin;
  2987. pluginInstance__Voxglitch = p;
  2988. const StaticPluginLoader spl(p, "voxglitch");
  2989. if (spl.ok())
  2990. {
  2991. #define modelLooper modelVoxglitchLooper
  2992. p->addModel(modelAutobreak);
  2993. p->addModel(modelByteBeat);
  2994. p->addModel(modelDigitalProgrammer);
  2995. p->addModel(modelDigitalSequencer);
  2996. p->addModel(modelDigitalSequencerXP);
  2997. p->addModel(modelGlitchSequencer);
  2998. p->addModel(modelGhosts);
  2999. p->addModel(modelGrainEngineMK2);
  3000. p->addModel(modelGrainEngineMK2Expander);
  3001. p->addModel(modelGrainFx);
  3002. p->addModel(modelGrooveBox);
  3003. p->addModel(modelGrooveBoxExpander);
  3004. p->addModel(modelHazumi);
  3005. p->addModel(modelLooper);
  3006. p->addModel(modelRepeater);
  3007. p->addModel(modelSamplerX8);
  3008. p->addModel(modelSatanonaut);
  3009. p->addModel(modelWavBank);
  3010. p->addModel(modelWavBankMC);
  3011. p->addModel(modelXY);
  3012. #undef modelLooper
  3013. }
  3014. }
  3015. static void initStatic__WhatTheRack()
  3016. {
  3017. Plugin* p = new Plugin;
  3018. pluginInstance__WhatTheRack = p;
  3019. const StaticPluginLoader spl(p, "WhatTheRack");
  3020. if (spl.ok())
  3021. {
  3022. p->addModel(modelWhatTheRack);
  3023. p->addModel(modelWhatTheMod);
  3024. p->addModel(modelWhatTheJack);
  3025. }
  3026. }
  3027. static void initStatic__ZetaCarinaeModules()
  3028. {
  3029. Plugin* p = new Plugin;
  3030. pluginInstance__ZetaCarinaeModules = p;
  3031. const StaticPluginLoader spl(p, "ZetaCarinaeModules");
  3032. if (spl.ok())
  3033. {
  3034. p->addModel(modelBrownianBridge);
  3035. p->addModel(modelOrnsteinUhlenbeck);
  3036. p->addModel(modelIOU);
  3037. p->addModel(modelWarbler);
  3038. p->addModel(modelRosenchance);
  3039. p->addModel(modelGuildensTurn);
  3040. p->addModel(modelRosslerRustler);
  3041. p->addModel(modelFirefly);
  3042. }
  3043. }
  3044. static void initStatic__ZZC()
  3045. {
  3046. Plugin* p = new Plugin;
  3047. pluginInstance__ZZC = p;
  3048. const StaticPluginLoader spl(p, "ZZC");
  3049. if (spl.ok())
  3050. {
  3051. #define modelClock modelZZCClock
  3052. p->addModel(modelClock);
  3053. p->addModel(modelDivider);
  3054. p->addModel(modelFN3);
  3055. p->addModel(modelSCVCA);
  3056. p->addModel(modelSH8);
  3057. p->addModel(modelSRC);
  3058. p->addModel(modelDiv);
  3059. p->addModel(modelDivExp);
  3060. p->addModel(modelPolygate);
  3061. #undef modelClock
  3062. }
  3063. }
  3064. void initStaticPlugins()
  3065. {
  3066. initStatic__Cardinal();
  3067. initStatic__Fundamental();
  3068. // initStatic__ZamAudio();
  3069. initStatic__21kHz();
  3070. initStatic__8Mode();
  3071. initStatic__AaronStatic();
  3072. initStatic__alefsbits();
  3073. initStatic__Algoritmarte();
  3074. initStatic__AmalgamatedHarmonics();
  3075. initStatic__AnimatedCircuits();
  3076. initStatic__ArableInstruments();
  3077. initStatic__Aria();
  3078. initStatic__AS();
  3079. initStatic__AudibleInstruments();
  3080. initStatic__Autinn();
  3081. initStatic__Axioma();
  3082. initStatic__Bacon();
  3083. initStatic__Befaco();
  3084. initStatic__Bidoo();
  3085. initStatic__Biset();
  3086. initStatic__BogaudioModules();
  3087. initStatic__CatroModulo();
  3088. initStatic__cf();
  3089. initStatic__ChowDSP();
  3090. initStatic__Computerscare();
  3091. initStatic__CVfunk();
  3092. initStatic__dBiz();
  3093. initStatic__DHE();
  3094. initStatic__DrumKit();
  3095. initStatic__EnigmaCurry();
  3096. initStatic__ESeries();
  3097. initStatic__ExpertSleepersEncoders();
  3098. initStatic__Extratone();
  3099. initStatic__FehlerFabrik();
  3100. initStatic__forsitan();
  3101. initStatic__GlueTheGiant();
  3102. initStatic__GoodSheperd();
  3103. initStatic__GrandeModular();
  3104. initStatic__H4N4();
  3105. initStatic__HamptonHarmonics();
  3106. initStatic__HetrickCV();
  3107. initStatic__ImpromptuModular();
  3108. initStatic__ihtsyn();
  3109. initStatic__JW();
  3110. initStatic__kocmoc();
  3111. initStatic__LifeFormModular();
  3112. initStatic__LilacLoop();
  3113. initStatic__LittleUtils();
  3114. initStatic__Lomas();
  3115. initStatic__Lyrae();
  3116. initStatic__Meander();
  3117. initStatic__MindMeld();
  3118. initStatic__ML();
  3119. initStatic__MockbaModular();
  3120. initStatic__Mog();
  3121. initStatic__mscHack();
  3122. initStatic__MSM();
  3123. initStatic__myth_modules();
  3124. initStatic__nonlinearcircuits();
  3125. initStatic__Orbits();
  3126. initStatic__ParableInstruments();
  3127. initStatic__PathSet();
  3128. initStatic__PinkTrombone();
  3129. initStatic__Prism();
  3130. initStatic__rackwindows();
  3131. initStatic__RebelTech();
  3132. initStatic__repelzen();
  3133. initStatic__Sapphire();
  3134. initStatic__sonusmodular();
  3135. initStatic__StarlingVia();
  3136. initStatic__stocaudio();
  3137. initStatic__stoermelder_p1();
  3138. initStatic__surgext();
  3139. initStatic__unless_modules();
  3140. initStatic__ValleyAudio();
  3141. initStatic__Voxglitch();
  3142. initStatic__WhatTheRack();
  3143. initStatic__ZetaCarinaeModules();
  3144. initStatic__ZZC();
  3145. }
  3146. void destroyStaticPlugins()
  3147. {
  3148. for (Plugin* p : plugins)
  3149. delete p;
  3150. plugins.clear();
  3151. }
  3152. void updateStaticPluginsDarkMode()
  3153. {
  3154. const bool darkMode = settings::preferDarkPanels;
  3155. // bogaudio
  3156. {
  3157. Skins& skins(Skins::skins());
  3158. skins._default = darkMode ? "dark" : "light";
  3159. std::lock_guard<std::mutex> lock(skins._defaultSkinListenersLock);
  3160. for (auto listener : skins._defaultSkinListeners) {
  3161. listener->defaultSkinChanged(skins._default);
  3162. }
  3163. }
  3164. // meander
  3165. {
  3166. panelTheme = darkMode ? 1 : 0;
  3167. }
  3168. // glue the giant
  3169. {
  3170. gtg_default_theme = darkMode ? 1 : 0;
  3171. }
  3172. // surgext
  3173. {
  3174. surgext_rack_update_theme();
  3175. }
  3176. }
  3177. }
  3178. }