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

1646 lines
46KB
Raw Blame History 

  1. /*

  2.  * DISTRHO Cardinal Plugin

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

  4.  *

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

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

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

  8.  * the License, or any later version.

  9.  *

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

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

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

  13.  * GNU General Public License for more details.

  14.  *

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

  16.  */

  17. 

  18. #include "rack.hpp"

  19. #include "plugin.hpp"

  20. 

  21. #include "DistrhoUtils.hpp"

  22. 

  23. // Cardinal (built-in)

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

  25. 

  26. #ifndef NOPLUGINS

  27. // AmalgamatedHarmonics

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

  29. 

  30. // AnimatedCircuits

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

  32. 

  33. // Aria

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

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

  36. */

  37. #define modelBlank modelAriaBlank

  38. extern Model *modelSplort;

  39. extern Model *modelSmerge;

  40. extern Model *modelSpleet;

  41. extern Model *modelSwerge;

  42. extern Model *modelSplirge;

  43. // extern Model *modelSrot;

  44. extern Model *modelQqqq;

  45. extern Model *modelQuack;

  46. extern Model *modelQ;

  47. extern Model *modelQuale;

  48. extern Model *modelDarius;

  49. extern Model *modelSolomon4;

  50. extern Model *modelSolomon8;

  51. extern Model *modelSolomon16;

  52. extern Model *modelPsychopump;

  53. extern Model *modelPokies4;

  54. extern Model *modelGrabby;

  55. extern Model *modelRotatoes4;

  56. extern Model *modelUndular;

  57. extern Model *modelBlank;

  58. #undef modelBlank

  59. 

  60. // AS

  61. #define modelADSR modelASADSR

  62. #define modelVCA modelASVCA

  63. #define YellowRedLight ASYellowRedLight

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

  65. #undef modelADSR

  66. #undef modelVCA

  67. #undef YellowRedLight

  68. 

  69. // Atelier

  70. #include "Atelier/src/plugin.hpp"

  71. 

  72. // AudibleInstruments

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

  74. 

  75. // BaconPlugs

  76. #define INCLUDE_COMPONENTS_HPP

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

  78. #undef INCLUDE_COMPONENTS_HPP

  79. #undef SCREW_WIDTH

  80. #undef RACK_HEIGHT

  81. 

  82. // Befaco

  83. #define modelADSR modelBefacoADSR

  84. #define modelMixer modelBefacoMixer

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

  86. #undef modelADSR

  87. #undef modelMixer

  88. 

  89. // Bidoo

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

  91. 

  92. // BogaudioModules - force dark skin as default

  93. #include <mutex>

  94. #include <string>

  95. #include <unordered_map>

  96. #include <unordered_set>

  97. #include <vector>

  98. #define private public

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

  100. #undef private

  101. 

  102. // BogaudioModules

  103. #define modelADSR modelBogaudioADSR

  104. #define modelLFO modelBogaudioLFO

  105. #define modelNoise modelBogaudioNoise

  106. #define modelVCA modelBogaudioVCA

  107. #define modelVCF modelBogaudioVCF

  108. #define modelVCO modelBogaudioVCO

  109. #include "BogaudioModules/src/AD.hpp"

  110. #include "BogaudioModules/src/Additator.hpp"

  111. #include "BogaudioModules/src/AddrSeqX.hpp"

  112. #include "BogaudioModules/src/ADSR.hpp"

  113. #include "BogaudioModules/src/AMRM.hpp"

  114. #include "BogaudioModules/src/Analyzer.hpp"

  115. #include "BogaudioModules/src/AnalyzerXL.hpp"

  116. #include "BogaudioModules/src/Assign.hpp"

  117. #include "BogaudioModules/src/ASR.hpp"

  118. #include "BogaudioModules/src/Arp.hpp"

  119. #include "BogaudioModules/src/Blank3.hpp"

  120. #include "BogaudioModules/src/Blank6.hpp"

  121. #include "BogaudioModules/src/Bool.hpp"

  122. #include "BogaudioModules/src/Chirp.hpp"

  123. #include "BogaudioModules/src/Clpr.hpp"

  124. #include "BogaudioModules/src/Cmp.hpp"

  125. #include "BogaudioModules/src/CmpDist.hpp"

  126. #include "BogaudioModules/src/CVD.hpp"

  127. #include "BogaudioModules/src/DADSRH.hpp"

  128. #include "BogaudioModules/src/DADSRHPlus.hpp"

  129. #include "BogaudioModules/src/Detune.hpp"

  130. #include "BogaudioModules/src/DGate.hpp"

  131. #include "BogaudioModules/src/Edge.hpp"

  132. #include "BogaudioModules/src/EightFO.hpp"

  133. #include "BogaudioModules/src/EightOne.hpp"

  134. #include "BogaudioModules/src/EQ.hpp"

  135. #include "BogaudioModules/src/EQS.hpp"

  136. #include "BogaudioModules/src/FFB.hpp"

  137. #include "BogaudioModules/src/FlipFlop.hpp"

  138. #include "BogaudioModules/src/FMOp.hpp"

  139. #include "BogaudioModules/src/Follow.hpp"

  140. #include "BogaudioModules/src/FourFO.hpp"

  141. #include "BogaudioModules/src/FourMan.hpp"

  142. #include "BogaudioModules/src/Inv.hpp"

  143. #include "BogaudioModules/src/LFO.hpp"

  144. #include "BogaudioModules/src/Lgsw.hpp"

  145. #include "BogaudioModules/src/LLFO.hpp"

  146. #include "BogaudioModules/src/LLPG.hpp"

  147. #include "BogaudioModules/src/Lmtr.hpp"

  148. #include "BogaudioModules/src/LPG.hpp"

  149. #include "BogaudioModules/src/LVCF.hpp"

  150. #include "BogaudioModules/src/LVCO.hpp"

  151. #include "BogaudioModules/src/Manual.hpp"

  152. #include "BogaudioModules/src/Matrix18.hpp"

  153. #include "BogaudioModules/src/Matrix44.hpp"

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

  155. #include "BogaudioModules/src/Matrix88.hpp"

  156. #include "BogaudioModules/src/Matrix88Cv.hpp"

  157. #include "BogaudioModules/src/Matrix88M.hpp"

  158. #include "BogaudioModules/src/MegaGate.hpp"

  159. #include "BogaudioModules/src/Mix1.hpp"

  160. #include "BogaudioModules/src/Mix2.hpp"

  161. #include "BogaudioModules/src/Mix4.hpp"

  162. #include "BogaudioModules/src/Mix4x.hpp"

  163. #include "BogaudioModules/src/Mix8x.hpp"

  164. #include "BogaudioModules/src/Mono.hpp"

  165. #include "BogaudioModules/src/Mult.hpp"

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

  167. #include "BogaudioModules/src/Mute8.hpp"

  168. #include "BogaudioModules/src/Noise.hpp"

  169. #include "BogaudioModules/src/Nsgt.hpp"

  170. #include "BogaudioModules/src/Offset.hpp"

  171. #include "BogaudioModules/src/OneEight.hpp"

  172. #include "BogaudioModules/src/Pan.hpp"

  173. #include "BogaudioModules/src/PEQ.hpp"

  174. #include "BogaudioModules/src/PEQ6.hpp"

  175. #include "BogaudioModules/src/PEQ6XF.hpp"

  176. #include "BogaudioModules/src/PEQ14.hpp"

  177. #include "BogaudioModules/src/PEQ14XF.hpp"

  178. #include "BogaudioModules/src/Pgmr.hpp"

  179. #include "BogaudioModules/src/PgmrX.hpp"

  180. #include "BogaudioModules/src/PolyCon16.hpp"

  181. #include "BogaudioModules/src/PolyCon8.hpp"

  182. #include "BogaudioModules/src/PolyMult.hpp"

  183. #include "BogaudioModules/src/PolyOff16.hpp"

  184. #include "BogaudioModules/src/PolyOff8.hpp"

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

  186. #include "BogaudioModules/src/Pulse.hpp"

  187. #include "BogaudioModules/src/Ranalyzer.hpp"

  188. #include "BogaudioModules/src/Reftone.hpp"

  189. #include "BogaudioModules/src/RGate.hpp"

  190. #include "BogaudioModules/src/SampleHold.hpp"

  191. #include "BogaudioModules/src/Shaper.hpp"

  192. #include "BogaudioModules/src/ShaperPlus.hpp"

  193. #include "BogaudioModules/src/Sine.hpp"

  194. #include "BogaudioModules/src/Slew.hpp"

  195. #include "BogaudioModules/src/Stack.hpp"

  196. #include "BogaudioModules/src/Sums.hpp"

  197. #include "BogaudioModules/src/Switch.hpp"

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

  199. #include "BogaudioModules/src/Switch18.hpp"

  200. #include "BogaudioModules/src/Switch44.hpp"

  201. #include "BogaudioModules/src/Switch81.hpp"

  202. #include "BogaudioModules/src/Switch88.hpp"

  203. #include "BogaudioModules/src/UMix.hpp"

  204. #include "BogaudioModules/src/Unison.hpp"

  205. #include "BogaudioModules/src/VCA.hpp"

  206. #include "BogaudioModules/src/VCAmp.hpp"

  207. #include "BogaudioModules/src/VCF.hpp"

  208. #include "BogaudioModules/src/VCM.hpp"

  209. #include "BogaudioModules/src/VCO.hpp"

  210. #include "BogaudioModules/src/Velo.hpp"

  211. #include "BogaudioModules/src/Vish.hpp"

  212. #include "BogaudioModules/src/VU.hpp"

  213. #include "BogaudioModules/src/Walk.hpp"

  214. #include "BogaudioModules/src/Walk2.hpp"

  215. #include "BogaudioModules/src/XCO.hpp"

  216. #include "BogaudioModules/src/XFade.hpp"

  217. #undef modelADSR

  218. #undef modelLFO

  219. #undef modelNoise

  220. #undef modelVCA

  221. #undef modelVCF

  222. #undef modelVCO

  223. 

  224. // cf

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

  226. 

  227. // ChowDSP

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

  229. #define init initChowDSP

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

  231. #undef init

  232. 

  233. // DrumKit

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

  235. void setupSamples();

  236. 

  237. // ESeries

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

  239. 

  240. // FehlerFabrik

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

  242. 

  243. // Fundamental

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

  245. 

  246. // GlueTheGiant

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

  248. bool audition_mixer = false;

  249. bool audition_depot = false;

  250. int gtg_default_theme = 1;

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

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

  253. 

  254. // GrandeModular

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

  256. 

  257. // ImpromptuModular

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

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

  260. */

  261. extern Model *modelAdaptiveQuantizer;

  262. extern Model *modelBigButtonSeq;

  263. extern Model *modelBigButtonSeq2;

  264. extern Model *modelChordKey;

  265. extern Model *modelChordKeyExpander;

  266. extern Model *modelClocked;

  267. extern Model *modelClockedExpander;

  268. extern Model *modelClkd;

  269. extern Model *modelCvPad;

  270. extern Model *modelFoundry;

  271. extern Model *modelFoundryExpander;

  272. extern Model *modelFourView;

  273. extern Model *modelGateSeq64;

  274. extern Model *modelGateSeq64Expander;

  275. extern Model *modelHotkey;

  276. extern Model *modelPart;

  277. extern Model *modelPhraseSeq16;

  278. extern Model *modelPhraseSeq32;

  279. extern Model *modelPhraseSeqExpander;

  280. extern Model *modelProbKey;

  281. // extern Model *modelProbKeyExpander;

  282. extern Model *modelSemiModularSynth;

  283. extern Model *modelTact;

  284. extern Model *modelTact1;

  285. extern Model *modelTactG;

  286. extern Model *modelTwelveKey;

  287. extern Model *modelWriteSeq32;

  288. extern Model *modelWriteSeq64;

  289. extern Model *modelBlankPanel;

  290. 

  291. // HetrickCV

  292. #include "HetrickCV/src/HetrickCV.hpp"

  293. 

  294. // JW-Modules

  295. #define modelQuantizer modelJWQuantizer

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

  297. #undef modelQuantizer

  298. 

  299. // MindMeldModular

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

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

  302. */

  303. extern Model *modelMixMasterJr;

  304. extern Model *modelAuxExpanderJr;

  305. extern Model *modelMixMaster;

  306. extern Model *modelAuxExpander;

  307. extern Model *modelMeld;

  308. extern Model *modelUnmeld;

  309. extern Model *modelEqMaster;

  310. extern Model *modelEqExpander;

  311. extern Model *modelBassMaster;

  312. extern Model *modelBassMasterJr;

  313. extern Model *modelShapeMaster;

  314. 

  315. // Mog

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

  317. 

  318. // mscHack

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

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

  321. */

  322. extern Model *modelCompressor;

  323. extern Model *modelSynthDrums;

  324. extern Model *modelSEQ_6x32x16;

  325. extern Model *modelMasterClockx8;

  326. extern Model *modelMasterClockx4;

  327. extern Model *modelSEQ_Envelope_8;

  328. extern Model *modelSeq_Triad2;

  329. extern Model *modelARP700;

  330. extern Model *modelMix_24_4_4;

  331. extern Model *modelMix_16_4_4;

  332. extern Model *modelMix_9_3_4;

  333. extern Model *modelMix_4_0_4;

  334. extern Model *modelASAF8;

  335. extern Model *modelPingPong;

  336. extern Model *modelStepDelay;

  337. extern Model *modelOsc_3Ch;

  338. extern Model *modelDronez;

  339. extern Model *modelMorze;

  340. extern Model *modelWindz;

  341. extern Model *modelLorenz;

  342. extern Model *modelAlienz;

  343. extern Model *modelOSC_WaveMorph_3;

  344. extern Model *modelMaude_221;

  345. 

  346. // rackwindows

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

  348. 

  349. // repelzen

  350. #define modelBlank modelrepelzenBlank

  351. #define modelMixer modelrepelzenMixer

  352. #define modelWerner modelrepelzenWerner

  353. #define tanh_pade repelzentanh_pade

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

  355. #undef modelBlank

  356. #undef modelMixer

  357. #undef modelWerner

  358. #undef tanh_pade

  359. 

  360. // sonusmodular

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

  362. 

  363. // ValleyAudio

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

  365. 

  366. // ZetaCarinaeModules

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

  368. 

  369. // ZZC

  370. #define DISPLAYS_H

  371. #define ZZC_SHARED_H

  372. #define ZZC_WIDGETS_H

  373. #define modelClock modelZZCClock

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

  375. #undef modelClock

  376. 

  377. #endif // NOPLUGINS

  378. 

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

  380. int loadConsoleType() { return 0; }

  381. int loadDirectOutMode() { return 0; }

  382. void saveConsoleType(int) {}

  383. void saveDarkAsDefault(bool) {}

  384. void saveDirectOutMode(bool) {}

  385. void saveHighQualityAsDefault(bool) {}

  386. 

  387. // plugin instances

  388. Plugin* pluginInstance__Cardinal;

  389. #ifndef NOPLUGINS

  390. Plugin* pluginInstance__AmalgamatedHarmonics;

  391. Plugin* pluginInstance__AnimatedCircuits;

  392. Plugin* pluginInstance__Aria;

  393. Plugin* pluginInstance__AS;

  394. Plugin* pluginInstance__Atelier;

  395. Plugin* pluginInstance__AudibleInstruments;

  396. Plugin* pluginInstance__Bacon;

  397. Plugin* pluginInstance__Befaco;

  398. Plugin* pluginInstance__Bidoo;

  399. Plugin* pluginInstance__BogaudioModules;

  400. Plugin* pluginInstance__cf;

  401. Plugin* pluginInstance__ChowDSP;

  402. extern Plugin* pluginInstance__DrumKit;

  403. Plugin* pluginInstance__ESeries;

  404. Plugin* pluginInstance__FehlerFabrik;

  405. Plugin* pluginInstance__Fundamental;

  406. Plugin* pluginInstance__GrandeModular;

  407. Plugin* pluginInstance__GlueTheGiant;

  408. Plugin* pluginInstance__HetrickCV;

  409. extern Plugin* pluginInstance__ImpromptuModular;

  410. Plugin* pluginInstance__JW;

  411. extern Plugin* pluginInstance__MindMeld;

  412. Plugin* pluginInstance__Mog;

  413. extern Plugin* pluginInstance__mscHack;

  414. Plugin* pluginInstance__rackwindows;

  415. Plugin* pluginInstance__repelzen;

  416. Plugin* pluginInstance__sonusmodular;

  417. Plugin* pluginInstance__ValleyAudio;

  418. Plugin* pluginInstance__ZetaCarinaeModules;

  419. Plugin* pluginInstance__ZZC;

  420. #endif // NOPLUGINS

  421. 

  422. namespace rack {

  423. 

  424. namespace asset {

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

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

  427. }

  428. 

  429. // core plugins

  430. namespace core {

  431. extern Model* modelAudio2;

  432. extern Model* modelAudio8;

  433. extern Model* modelAudio16;

  434. extern Model* modelMIDI_CV;

  435. extern Model* modelMIDICC_CV;

  436. extern Model* modelMIDI_Gate;

  437. extern Model* modelMIDIMap;

  438. extern Model* modelCV_MIDI;

  439. extern Model* modelCV_MIDICC;

  440. extern Model* modelGate_MIDI;

  441. extern Model* modelBlank;

  442. extern Model* modelNotes;

  443. }

  444. 

  445. // regular plugins

  446. namespace plugin {

  447. 

  448. struct StaticPluginLoader {

  449.     Plugin* const plugin;

  450.     FILE* file;

  451.     json_t* rootJ;

  452. 

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

  454.         : plugin(p),

  455.           file(nullptr),

  456.           rootJ(nullptr)

  457.     {

  458. #ifdef DEBUG

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

  460. #endif

  461. 

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

  463. 

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

  465. 

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

  467.         {

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

  469.             return;

  470.         }

  471. 

  472.         json_error_t error;

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

  474.         {

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

  476.             return;

  477.         }

  478. 

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

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

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

  482.         json_decref(version);

  483.     }

  484. 

  485.     ~StaticPluginLoader()

  486.     {

  487.         if (rootJ != nullptr)

  488.         {

  489.             plugin->fromJson(rootJ);

  490.             json_decref(rootJ);

  491.             plugins.push_back(plugin);

  492.         }

  493. 

  494.         if (file != nullptr)

  495.             std::fclose(file);

  496.     }

  497. 

  498.     bool ok() const noexcept

  499.     {

  500.         return rootJ != nullptr;

  501.     }

  502. 

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

  504.     {

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

  506.         DISTRHO_SAFE_ASSERT_RETURN(modules != nullptr,);

  507. 

  508.         size_t i;

  509.         json_t* v;

  510.         json_array_foreach(modules, i, v)

  511.         {

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

  513.             {

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

  515.                 {

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

  517.                     {

  518.                         json_array_remove(modules, i);

  519.                         break;

  520.                     }

  521.                 }

  522.             }

  523.         }

  524.     }

  525. };

  526. 

  527. static void initStatic__Core()

  528. {

  529.     Plugin* const p = new Plugin;

  530. 

  531.     const StaticPluginLoader spl(p, "Core");

  532.     if (spl.ok())

  533.     {

  534.         p->addModel(rack::core::modelAudio2);

  535.         p->addModel(rack::core::modelAudio8);

  536.         p->addModel(rack::core::modelAudio16);

  537.         p->addModel(rack::core::modelMIDI_CV);

  538.         p->addModel(rack::core::modelMIDICC_CV);

  539.         p->addModel(rack::core::modelMIDI_Gate);

  540.         p->addModel(rack::core::modelMIDIMap);

  541.         p->addModel(rack::core::modelCV_MIDI);

  542.         p->addModel(rack::core::modelCV_MIDICC);

  543.         p->addModel(rack::core::modelGate_MIDI);

  544.         p->addModel(rack::core::modelBlank);

  545.         p->addModel(rack::core::modelNotes);

  546.     }

  547. }

  548. 

  549. static void initStatic__Cardinal()

  550. {

  551.     Plugin* const p = new Plugin;

  552.     pluginInstance__Cardinal = p;

  553. 

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

  555.     if (spl.ok())

  556.     {

  557.         p->addModel(modelCarla);

  558.         p->addModel(modelCardinalBlank);

  559.         p->addModel(modelGlBars);

  560.         p->addModel(modelHostCV);

  561.         p->addModel(modelHostParameters);

  562.         p->addModel(modelHostTime);

  563.         p->addModel(modelIldaeil);

  564.     }

  565. }

  566. 

  567. #ifndef NOPLUGINS

  568. static void initStatic__AmalgamatedHarmonics()

  569. {

  570.     Plugin* const p = new Plugin;

  571.     pluginInstance__AmalgamatedHarmonics = p;

  572. 

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

  574.     if (spl.ok())

  575.     {

  576.         p->addModel(modelArp31);

  577.         p->addModel(modelArp32);

  578.         p->addModel(modelBombe);

  579.         p->addModel(modelChord);

  580.         p->addModel(modelCircle);

  581.         p->addModel(modelGalaxy);

  582.         p->addModel(modelGenerative);

  583.         p->addModel(modelImp);

  584.         p->addModel(modelImperfect2);

  585.         p->addModel(modelProgress2);

  586.         p->addModel(modelRuckus);

  587.         p->addModel(modelScaleQuantizer2);

  588.         p->addModel(modelSLN);

  589.         p->addModel(modelMuxDeMux);

  590.         p->addModel(modelPolyProbe);

  591.         p->addModel(modelPolyScope);

  592.         p->addModel(modelPolyUtils);

  593.         p->addModel(modelPolyVolt);

  594.         p->addModel(modelScaleQuantizer);

  595.         p->addModel(modelArpeggiator2);

  596.         p->addModel(modelProgress);

  597.     }

  598. }

  599. 

  600. static void initStatic__AnimatedCircuits()

  601. {

  602.     Plugin* const p = new Plugin;

  603.     pluginInstance__AnimatedCircuits = p;

  604. 

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

  606.     if (spl.ok())

  607.     {

  608.         p->addModel(model_AC_Folding);

  609.     }

  610. }

  611. 

  612. static void initStatic__Aria()

  613. {

  614.     Plugin* const p = new Plugin;

  615.     pluginInstance__Aria = p;

  616. 

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

  618.     if (spl.ok())

  619.     {

  620. #define modelBlank modelAriaBlank

  621.         p->addModel(modelSplort);

  622.         p->addModel(modelSmerge);

  623.         p->addModel(modelSpleet);

  624.         p->addModel(modelSwerge);

  625.         p->addModel(modelSplirge);

  626.         // p->addModel(modelSrot);

  627.         p->addModel(modelQqqq);

  628.         p->addModel(modelQuack);

  629.         p->addModel(modelQ);

  630.         p->addModel(modelQuale);

  631.         p->addModel(modelDarius);

  632.         p->addModel(modelSolomon4);

  633.         p->addModel(modelSolomon8);

  634.         p->addModel(modelSolomon16);

  635.         p->addModel(modelPsychopump);

  636.         p->addModel(modelPokies4);

  637.         p->addModel(modelGrabby);

  638.         p->addModel(modelRotatoes4);

  639.         p->addModel(modelUndular);

  640.         p->addModel(modelBlank);

  641. #undef modelBlank

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

  643.         spl.removeModule("Arcane");

  644.         spl.removeModule("Atout");

  645.         spl.removeModule("Aleister");

  646.     }

  647. }

  648. 

  649. static void initStatic__AS()

  650. {

  651.     Plugin* const p = new Plugin;

  652.     pluginInstance__AS = p;

  653. 

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

  655.     if (spl.ok())

  656.     {

  657. #define modelADSR modelASADSR

  658. #define modelVCA modelASVCA

  659.         //OSCILLATORS

  660.         p->addModel(modelSineOsc);

  661.         p->addModel(modelSawOsc);

  662. 

  663.         //TOOLS

  664.         p->addModel(modelADSR);

  665.         p->addModel(modelVCA);

  666.         p->addModel(modelQuadVCA);

  667.         p->addModel(modelTriLFO);

  668.         p->addModel(modelAtNuVrTr);

  669.         p->addModel(modelBPMClock);

  670.         p->addModel(modelSEQ16);

  671.         p->addModel(modelMixer2ch);

  672.         p->addModel(modelMixer4ch);

  673.         p->addModel(modelMixer8ch);

  674.         p->addModel(modelMonoVUmeter);

  675.         p->addModel(modelStereoVUmeter);

  676.         p->addModel(modelMultiple2_5);

  677.         p->addModel(modelMerge2_5);

  678.         p->addModel(modelSteps);

  679.         p->addModel(modelLaunchGate);

  680.         p->addModel(modelKillGate);

  681.         p->addModel(modelFlow);

  682.         p->addModel(modelSignalDelay);

  683.         p->addModel(modelTriggersMKI);

  684.         p->addModel(modelTriggersMKII);

  685.         p->addModel(modelTriggersMKIII);

  686.         p->addModel(modelBPMCalc);

  687.         p->addModel(modelBPMCalc2);

  688.         p->addModel(modelCv2T);

  689.         p->addModel(modelZeroCV2T);

  690.         p->addModel(modelReScale);

  691. 

  692.         //EFFECTS

  693.         p->addModel(modelDelayPlusFx);

  694.         p->addModel(modelDelayPlusStereoFx);

  695.         p->addModel(modelPhaserFx);

  696.         p->addModel(modelReverbFx);

  697.         p->addModel(modelReverbStereoFx);

  698.         p->addModel(modelSuperDriveFx);

  699.         p->addModel(modelSuperDriveStereoFx);

  700.         p->addModel(modelTremoloFx);

  701.         p->addModel(modelTremoloStereoFx);

  702.         p->addModel(modelWaveShaper);

  703.         p->addModel(modelWaveShaperStereo);

  704. 

  705.         //BLANK PANELS

  706.         p->addModel(modelBlankPanel4);

  707.         p->addModel(modelBlankPanel6);

  708.         p->addModel(modelBlankPanel8);

  709.         p->addModel(modelBlankPanelSpecial);

  710. #undef modelADSR

  711. #undef modelVCA

  712.     }

  713. }

  714. 

  715. static void initStatic__Atelier()

  716. {

  717.     Plugin* const p = new Plugin;

  718.     pluginInstance__Atelier = p;

  719. 

  720.     const StaticPluginLoader spl(p, "Atelier");

  721.     if (spl.ok())

  722.     {

  723.         p->addModel(modelPalette);

  724.     }

  725. }

  726. 

  727. static void initStatic__AudibleInstruments()

  728. {

  729.     Plugin* const p = new Plugin;

  730.     pluginInstance__AudibleInstruments = p;

  731. 

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

  733.     if (spl.ok())

  734.     {

  735.         p->addModel(modelBraids);

  736.         p->addModel(modelPlaits);

  737.         p->addModel(modelElements);

  738.         p->addModel(modelTides);

  739.         p->addModel(modelTides2);

  740.         p->addModel(modelClouds);

  741.         p->addModel(modelWarps);

  742.         p->addModel(modelRings);

  743.         p->addModel(modelLinks);

  744.         p->addModel(modelKinks);

  745.         p->addModel(modelShades);

  746.         p->addModel(modelBranches);

  747.         p->addModel(modelBlinds);

  748.         p->addModel(modelVeils);

  749.         p->addModel(modelFrames);

  750.         p->addModel(modelMarbles);

  751.         p->addModel(modelStages);

  752.         p->addModel(modelRipples);

  753.         p->addModel(modelShelves);

  754.         p->addModel(modelStreams);

  755.     }

  756. }

  757. 

  758. static void initStatic__Bacon()

  759. {

  760.     Plugin* const p = new Plugin;

  761.     pluginInstance__Bacon = p;

  762. 

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

  764.     if (spl.ok())

  765.     {

  766.         p->addModel(modelHarMoNee);

  767.         p->addModel(modelGlissinator);

  768.         p->addModel(modelPolyGnome);

  769.         p->addModel(modelQuantEyes);

  770.         p->addModel(modelSampleDelay);

  771. #ifdef BUILD_SORTACHORUS

  772.         p->addModel(modelSortaChorus);

  773. #endif

  774.         p->addModel(modelChipNoise);

  775.         p->addModel(modelChipWaves);

  776.         p->addModel(modelChipYourWave);

  777.         p->addModel(modelOpen303);

  778. #ifdef BUILD_GENERICLSFR

  779.         p->addModel(modelGenericLFSR);

  780. #endif

  781.         p->addModel(modelKarplusStrongPoly);

  782.         p->addModel(modelALingADing);

  783.         p->addModel(modelBitulator);

  784. #ifdef BUILD_PHASER

  785.         p->addModel(modelPhaser);

  786. #endif

  787.         p->addModel(modelPolyGenerator);

  788.     }

  789. }

  790. 

  791. static void initStatic__Befaco()

  792. {

  793.     Plugin* const p = new Plugin;

  794.     pluginInstance__Befaco = p;

  795. 

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

  797.     if (spl.ok())

  798.     {

  799. #define modelADSR modelBefacoADSR

  800. #define modelMixer modelBefacoMixer

  801.         p->addModel(modelEvenVCO);

  802.         p->addModel(modelRampage);

  803.         p->addModel(modelABC);

  804.         p->addModel(modelSpringReverb);

  805.         p->addModel(modelMixer);

  806.         p->addModel(modelSlewLimiter);

  807.         p->addModel(modelDualAtenuverter);

  808.         p->addModel(modelPercall);

  809.         p->addModel(modelHexmixVCA);

  810.         p->addModel(modelChoppingKinky);

  811.         p->addModel(modelKickall);

  812.         p->addModel(modelSamplingModulator);

  813.         p->addModel(modelMorphader);

  814.         p->addModel(modelADSR);

  815.         p->addModel(modelSTMix);

  816.         p->addModel(modelMuxlicer);

  817.         p->addModel(modelMex);

  818. #undef modelADSR

  819. #undef modelMixer

  820.     }

  821. }

  822. 

  823. static void initStatic__Bidoo()

  824. {

  825.     Plugin* const p = new Plugin;

  826.     pluginInstance__Bidoo = p;

  827. 

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

  829.     if (spl.ok())

  830.     {

  831.         p->addModel(modelTOCANTE);

  832.         p->addModel(modelLATE);

  833.         p->addModel(modelDIKTAT);

  834.         p->addModel(modelDTROY);

  835.         p->addModel(modelBORDL);

  836.         p->addModel(modelZOUMAI);

  837.         p->addModel(modelMU);

  838.         p->addModel(modelCHUTE);

  839.         p->addModel(modelLOURDE);

  840.         p->addModel(modelDILEMO);

  841.         p->addModel(modelLAMBDA);

  842.         p->addModel(modelBANCAU);

  843.         p->addModel(modelACNE);

  844.         p->addModel(modelMS);

  845.         p->addModel(modelDUKE);

  846.         p->addModel(modelMOIRE);

  847.         p->addModel(modelPILOT);

  848.         p->addModel(modelHUITRE);

  849.         p->addModel(modelOUAIVE);

  850.         p->addModel(modelEDSAROS);

  851.         p->addModel(modelPOUPRE);

  852.         p->addModel(modelMAGMA);

  853.         p->addModel(modelOAI);

  854.         p->addModel(modelCANARD);

  855.         p->addModel(modelEMILE);

  856.         p->addModel(modelFORK);

  857.         p->addModel(modelTIARE);

  858.         p->addModel(modelLIMONADE);

  859.         p->addModel(modelLIMBO);

  860.         p->addModel(modelPERCO);

  861.         p->addModel(modelBAFIS);

  862.         p->addModel(modelBAR);

  863.         p->addModel(modelMINIBAR);

  864.         p->addModel(modelZINC);

  865.         p->addModel(modelFREIN);

  866.         p->addModel(modelHCTIP);

  867.         p->addModel(modelSPORE);

  868.         p->addModel(modelDFUZE);

  869.         p->addModel(modelREI);

  870.         p->addModel(modelRABBIT);

  871.         p->addModel(modelBISTROT);

  872.         p->addModel(modelSIGMA);

  873.         p->addModel(modelFLAME);

  874.         p->addModel(modelVOID);

  875. 

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

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

  878.         spl.removeModule("antN");

  879.     }

  880. }

  881. 

  882. static void initStatic__BogaudioModules()

  883. {

  884.     Plugin* const p = new Plugin;

  885.     pluginInstance__BogaudioModules = p;

  886. 

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

  888.     if (spl.ok())

  889.     {

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

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

  892.         skins._default = "dark";

  893. #define modelADSR modelBogaudioADSR

  894. #define modelLFO modelBogaudioLFO

  895. #define modelNoise modelBogaudioNoise

  896. #define modelVCA modelBogaudioVCA

  897. #define modelVCF modelBogaudioVCF

  898. #define modelVCO modelBogaudioVCO

  899.         p->addModel(modelVCO);

  900.         p->addModel(modelLVCO);

  901.         p->addModel(modelSine);

  902.         p->addModel(modelPulse);

  903.         p->addModel(modelXCO);

  904.         p->addModel(modelAdditator);

  905.         p->addModel(modelFMOp);

  906.         p->addModel(modelChirp);

  907.         p->addModel(modelLFO);

  908.         p->addModel(modelLLFO);

  909.         p->addModel(modelFourFO);

  910.         p->addModel(modelEightFO);

  911.         p->addModel(modelVCF);

  912.         p->addModel(modelLVCF);

  913.         p->addModel(modelFFB);

  914.         p->addModel(modelEQ);

  915.         p->addModel(modelEQS);

  916.         p->addModel(modelLPG);

  917.         p->addModel(modelLLPG);

  918.         p->addModel(modelMegaGate);

  919.         p->addModel(modelPEQ);

  920.         p->addModel(modelPEQ6);

  921.         p->addModel(modelPEQ6XF);

  922.         p->addModel(modelPEQ14);

  923.         p->addModel(modelPEQ14XF);

  924.         p->addModel(modelDADSRH);

  925.         p->addModel(modelDADSRHPlus);

  926.         p->addModel(modelShaper);

  927.         p->addModel(modelShaperPlus);

  928.         p->addModel(modelAD);

  929.         p->addModel(modelASR);

  930.         p->addModel(modelADSR);

  931.         p->addModel(modelVish);

  932.         p->addModel(modelFollow);

  933.         p->addModel(modelDGate);

  934.         p->addModel(modelRGate);

  935.         p->addModel(modelEdge);

  936.         p->addModel(modelNoise);

  937.         p->addModel(modelSampleHold);

  938.         p->addModel(modelWalk2);

  939.         p->addModel(modelWalk);

  940.         p->addModel(modelMix8);

  941.         p->addModel(modelMix8x);

  942.         p->addModel(modelMix4);

  943.         p->addModel(modelMix4x);

  944.         p->addModel(modelMix2);

  945.         p->addModel(modelMix1);

  946.         p->addModel(modelVCM);

  947.         p->addModel(modelMute8);

  948.         p->addModel(modelPan);

  949.         p->addModel(modelXFade);

  950.         p->addModel(modelVCA);

  951.         p->addModel(modelVCAmp);

  952.         p->addModel(modelVelo);

  953.         p->addModel(modelUMix);

  954.         p->addModel(modelMumix);

  955.         p->addModel(modelMatrix81);

  956.         p->addModel(modelMatrix18);

  957.         p->addModel(modelMatrix44);

  958.         p->addModel(modelMatrix44Cvm);

  959.         p->addModel(modelMatrix88);

  960.         p->addModel(modelMatrix88Cv);

  961.         p->addModel(modelMatrix88M);

  962.         p->addModel(modelSwitch81);

  963.         p->addModel(modelSwitch18);

  964.         p->addModel(modelSwitch44);

  965.         p->addModel(modelSwitch88);

  966.         p->addModel(modelSwitch1616);

  967.         p->addModel(modelAMRM);

  968.         p->addModel(modelPressor);

  969.         p->addModel(modelClpr);

  970.         p->addModel(modelLmtr);

  971.         p->addModel(modelNsgt);

  972.         p->addModel(modelCmpDist);

  973.         p->addModel(modelOneEight);

  974.         p->addModel(modelEightOne);

  975.         p->addModel(modelAddrSeq);

  976.         p->addModel(modelAddrSeqX);

  977.         p->addModel(modelPgmr);

  978.         p->addModel(modelPgmrX);

  979.         p->addModel(modelVU);

  980.         p->addModel(modelAnalyzer);

  981.         p->addModel(modelAnalyzerXL);

  982.         p->addModel(modelRanalyzer);

  983.         p->addModel(modelDetune);

  984.         p->addModel(modelStack);

  985.         p->addModel(modelReftone);

  986.         p->addModel(modelMono);

  987.         p->addModel(modelArp);

  988.         p->addModel(modelAssign);

  989.         p->addModel(modelUnison);

  990.         p->addModel(modelPolyCon8);

  991.         p->addModel(modelPolyCon16);

  992.         p->addModel(modelPolyOff8);

  993.         p->addModel(modelPolyOff16);

  994.         p->addModel(modelPolyMult);

  995.         p->addModel(modelBool);

  996.         p->addModel(modelCmp);

  997.         p->addModel(modelCVD);

  998.         p->addModel(modelFlipFlop);

  999.         p->addModel(modelInv);

  1000.         p->addModel(modelManual);

  1001.         p->addModel(modelFourMan);

  1002.         p->addModel(modelMult);

  1003.         p->addModel(modelOffset);

  1004.         p->addModel(modelSlew);

  1005.         p->addModel(modelSums);

  1006.         p->addModel(modelSwitch);

  1007.         p->addModel(modelLgsw);

  1008.         p->addModel(modelBlank3);

  1009.         p->addModel(modelBlank6);

  1010. #ifdef EXPERIMENTAL

  1011.         p->addModel(modelLag);

  1012.         p->addModel(modelPEQ14XR);

  1013.         p->addModel(modelPEQ14XV);

  1014. #endif

  1015. #ifdef TEST

  1016.         p->addModel(modelTest);

  1017.         p->addModel(modelTest2);

  1018.         p->addModel(modelTestExpanderBase);

  1019.         p->addModel(modelTestExpanderExtension);

  1020.         p->addModel(modelTestGl);

  1021.         p->addModel(modelTestVCF);

  1022. #endif

  1023. #undef modelADSR

  1024. #undef modelLFO

  1025. #undef modelNoise

  1026. #undef modelVCA

  1027. #undef modelVCF

  1028. #undef modelVCO

  1029.     }

  1030. }

  1031. 

  1032. static void initStatic__cf()

  1033. {

  1034.     Plugin* const p = new Plugin;

  1035.     pluginInstance__cf = p;

  1036. 

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

  1038.     if (spl.ok())

  1039.     {

  1040.         p->addModel(modelMETRO);

  1041.         p->addModel(modelEACH);

  1042.         p->addModel(modeltrSEQ);

  1043.         p->addModel(modelLEDSEQ);

  1044.         p->addModel(modelL3DS3Q);

  1045.         p->addModel(modelSLIDERSEQ);

  1046.         p->addModel(modelPLAYER);

  1047.         p->addModel(modelPLAY);

  1048.         p->addModel(modelMONO);

  1049.         p->addModel(modelSTEREO);

  1050.         p->addModel(modelSUB);

  1051.         p->addModel(modelMASTER);

  1052.         p->addModel(modelVARIABLE);

  1053.         p->addModel(modelALGEBRA);

  1054.         p->addModel(modelFUNKTION);

  1055.         p->addModel(modelCHOKE);

  1056.         p->addModel(modelFOUR);

  1057.         p->addModel(modelSTEPS);

  1058.         p->addModel(modelPEAK);

  1059.         p->addModel(modelCUTS);

  1060.         p->addModel(modelBUFFER);

  1061.         p->addModel(modelDISTO);

  1062.         p->addModel(modelCUBE);

  1063.         p->addModel(modelPATCH);

  1064.         p->addModel(modelLABEL);

  1065.         p->addModel(modelDAVE);

  1066.     }

  1067. }

  1068. 

  1069. static void initStatic__ChowDSP()

  1070. {

  1071.     Plugin* const p = new Plugin;

  1072.     pluginInstance__ChowDSP = p;

  1073. 

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

  1075.     if (spl.ok())

  1076.     {

  1077.         p->addModel(modelChowTape);

  1078.         p->addModel(modelChowPhaserFeedback);

  1079.         p->addModel(modelChowPhaserMod);

  1080.         p->addModel(modelChowFDN);

  1081.         p->addModel(modelChowRNN);

  1082.         p->addModel(modelChowModal);

  1083.         p->addModel(modelChowDer);

  1084.         p->addModel(modelWarp);

  1085.         p->addModel(modelWerner);

  1086.         p->addModel(modelCredit);

  1087.         p->addModel(modelChowPulse);

  1088.         p->addModel(modelChowTapeCompression);

  1089.         p->addModel(modelChowTapeChew);

  1090.         p->addModel(modelChowTapeDegrade);

  1091.         p->addModel(modelChowTapeLoss);

  1092.         p->addModel(modelChowChorus);

  1093.     }

  1094. }

  1095. 

  1096. static void initStatic__DrumKit()

  1097. {

  1098.     Plugin* const p = new Plugin;

  1099.     pluginInstance__DrumKit = p;

  1100. 

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

  1102.     if (spl.ok())

  1103.     {

  1104.         setupSamples();

  1105.         p->addModel(modelBD9);

  1106.         p->addModel(modelSnare);

  1107.         p->addModel(modelClosedHH);

  1108.         p->addModel(modelOpenHH);

  1109.         p->addModel(modelDMX);

  1110.         p->addModel(modelCR78);

  1111.         p->addModel(modelSBD);

  1112.         p->addModel(modelGnome);

  1113.         p->addModel(modelSequencer);

  1114.         p->addModel(modelTomi);

  1115.         p->addModel(modelBaronial);

  1116.         p->addModel(modelMarionette);

  1117.     }

  1118. }

  1119. 

  1120. static void initStatic__ESeries()

  1121. {

  1122.     Plugin* const p = new Plugin;

  1123.     pluginInstance__ESeries = p;

  1124. 

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

  1126.     if (spl.ok())

  1127.     {

  1128.         p->addModel(modelE340);

  1129.     }

  1130. }

  1131. 

  1132. static void initStatic__FehlerFabrik()

  1133. {

  1134.     Plugin* const p = new Plugin;

  1135.     pluginInstance__FehlerFabrik = p;

  1136. 

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

  1138.     if (spl.ok())

  1139.     {

  1140.         p->addModel(modelPSIOP);

  1141.         p->addModel(modelPlanck);

  1142.         p->addModel(modelLuigi);

  1143.         p->addModel(modelAspect);

  1144.         p->addModel(modelMonte);

  1145.         p->addModel(modelArpanet);

  1146.         p->addModel(modelSigma);

  1147.         p->addModel(modelFax);

  1148.         p->addModel(modelRasoir);

  1149.         p->addModel(modelChi);

  1150.         p->addModel(modelNova);

  1151.         p->addModel(modelLilt);

  1152.         p->addModel(modelBotzinger);

  1153.     }

  1154. }

  1155. 

  1156. static void initStatic__Fundamental()

  1157. {

  1158.     Plugin* const p = new Plugin;

  1159.     pluginInstance__Fundamental = p;

  1160. 

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

  1162.     if (spl.ok())

  1163.     {

  1164.         p->addModel(modelVCO);

  1165.         p->addModel(modelVCO2);

  1166.         p->addModel(modelVCF);

  1167.         p->addModel(modelVCA_1);

  1168.         p->addModel(modelVCA);

  1169.         p->addModel(modelLFO);

  1170.         p->addModel(modelLFO2);

  1171.         p->addModel(modelDelay);

  1172.         p->addModel(modelADSR);

  1173.         p->addModel(modelMixer);

  1174.         p->addModel(modelVCMixer);

  1175.         p->addModel(model_8vert);

  1176.         p->addModel(modelUnity);

  1177.         p->addModel(modelMutes);

  1178.         p->addModel(modelPulses);

  1179.         p->addModel(modelScope);

  1180.         p->addModel(modelSEQ3);

  1181.         p->addModel(modelSequentialSwitch1);

  1182.         p->addModel(modelSequentialSwitch2);

  1183.         p->addModel(modelOctave);

  1184.         p->addModel(modelQuantizer);

  1185.         p->addModel(modelSplit);

  1186.         p->addModel(modelMerge);

  1187.         p->addModel(modelSum);

  1188.         p->addModel(modelViz);

  1189.         p->addModel(modelMidSide);

  1190.         p->addModel(modelNoise);

  1191.         p->addModel(modelRandom);

  1192. 

  1193.         // show all plugins, helping those familiar with v1 Rack modules

  1194.         if (json_t* const modules = json_object_get(spl.rootJ, "modules"))

  1195.         {

  1196.             size_t i;

  1197.             json_t* v;

  1198.             json_array_foreach(modules, i, v)

  1199.             {

  1200.                 json_object_set(v, "hidden", json_false());

  1201.             }

  1202.         }

  1203.     }

  1204. }

  1205. 

  1206. static void initStatic__GlueTheGiant()

  1207. {

  1208.     Plugin* const p = new Plugin;

  1209.     pluginInstance__GlueTheGiant = p;

  1210. 

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

  1212.     if (spl.ok())

  1213.     {

  1214.         p->addModel(modelGigBus);

  1215.         p->addModel(modelMiniBus);

  1216.         p->addModel(modelSchoolBus);

  1217.         p->addModel(modelMetroCityBus);

  1218.         p->addModel(modelBusDepot);

  1219.         p->addModel(modelBusRoute);

  1220.         p->addModel(modelRoad);

  1221.         p->addModel(modelEnterBus);

  1222.         p->addModel(modelExitBus);

  1223.     }

  1224. }

  1225. 

  1226. static void initStatic__GrandeModular()

  1227. {

  1228.     Plugin* const p = new Plugin;

  1229.     pluginInstance__GrandeModular = p;

  1230. 

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

  1232.     if (spl.ok())

  1233.     {

  1234.         p->addModel(modelClip);

  1235.         p->addModel(modelMergeSplit4);

  1236.         p->addModel(modelMicrotonalChords);

  1237.         p->addModel(modelMicrotonalNotes);

  1238.         p->addModel(modelNoteMT);

  1239.         p->addModel(modelPolyMergeResplit);

  1240.         p->addModel(modelQuant);

  1241.         p->addModel(modelQuantIntervals);

  1242.         p->addModel(modelQuantMT);

  1243.         p->addModel(modelSampleDelays);

  1244.         p->addModel(modelScale);

  1245.         p->addModel(modelTails);

  1246.         p->addModel(modelVarSampleDelays);

  1247.     }

  1248. }

  1249. 

  1250. static void initStatic__HetrickCV()

  1251. {

  1252.     Plugin* const p = new Plugin;

  1253.     pluginInstance__HetrickCV = p;

  1254. 

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

  1256.     if (spl.ok())

  1257.     {

  1258.         p->addModel(modelTwoToFour);

  1259.         p->addModel(modelAnalogToDigital);

  1260.         p->addModel(modelASR);

  1261.         p->addModel(modelBinaryGate);

  1262.         p->addModel(modelBinaryNoise);

  1263.         p->addModel(modelBitshift);

  1264.         p->addModel(modelBlankPanel);

  1265.         p->addModel(modelBoolean3);

  1266.         p->addModel(modelChaos1Op);

  1267.         p->addModel(modelChaos2Op);

  1268.         p->addModel(modelChaos3Op);

  1269.         p->addModel(modelChaoticAttractors);

  1270.         p->addModel(modelClockedNoise);

  1271.         p->addModel(modelComparator);

  1272.         p->addModel(modelContrast);

  1273.         p->addModel(modelCrackle);

  1274.         p->addModel(modelDataCompander);

  1275.         p->addModel(modelDelta);

  1276.         p->addModel(modelDigitalToAnalog);

  1277.         p->addModel(modelDust);

  1278.         p->addModel(modelExponent);

  1279.         p->addModel(modelFBSineChaos);

  1280.         p->addModel(modelFlipFlop);

  1281.         p->addModel(modelFlipPan);

  1282.         p->addModel(modelGateJunction);

  1283.         p->addModel(modelGingerbread);

  1284.         p->addModel(modelLogicCombine);

  1285.         p->addModel(modelMidSide);

  1286.         p->addModel(modelMinMax);

  1287.         p->addModel(modelRandomGates);

  1288.         p->addModel(modelRotator);

  1289.         p->addModel(modelRungler);

  1290.         p->addModel(modelScanner);

  1291.         p->addModel(modelWaveshape);

  1292.         p->addModel(modelXYToPolar);

  1293.     }

  1294. }

  1295. 

  1296. static void initStatic__ImpromptuModular()

  1297. {

  1298.     Plugin* const p = new Plugin;

  1299.     pluginInstance__ImpromptuModular = p;

  1300. 

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

  1302.     if (spl.ok())

  1303.     {

  1304.         p->addModel(modelAdaptiveQuantizer);

  1305.         p->addModel(modelBigButtonSeq);

  1306.         p->addModel(modelBigButtonSeq2);

  1307.         p->addModel(modelChordKey);

  1308.         p->addModel(modelChordKeyExpander);

  1309.         p->addModel(modelClocked);

  1310.         p->addModel(modelClockedExpander);

  1311.         p->addModel(modelClkd);

  1312.         p->addModel(modelCvPad);

  1313.         p->addModel(modelFoundry);

  1314.         p->addModel(modelFoundryExpander);

  1315.         p->addModel(modelFourView);

  1316.         p->addModel(modelGateSeq64);

  1317.         p->addModel(modelGateSeq64Expander);

  1318.         p->addModel(modelHotkey);

  1319.         p->addModel(modelPart);

  1320.         p->addModel(modelPhraseSeq16);

  1321.         p->addModel(modelPhraseSeq32);

  1322.         p->addModel(modelPhraseSeqExpander);

  1323.         p->addModel(modelProbKey);

  1324.         // p->addModel(modelProbKeyExpander);

  1325.         p->addModel(modelSemiModularSynth);

  1326.         p->addModel(modelTact);

  1327.         p->addModel(modelTact1);

  1328.         p->addModel(modelTactG);

  1329.         p->addModel(modelTwelveKey);

  1330.         p->addModel(modelWriteSeq32);

  1331.         p->addModel(modelWriteSeq64);

  1332.         p->addModel(modelBlankPanel);

  1333.     }

  1334. }

  1335. 

  1336. static void initStatic__JW()

  1337. {

  1338.     Plugin* const p = new Plugin;

  1339.     pluginInstance__JW = p;

  1340. 

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

  1342.     if (spl.ok())

  1343.     {

  1344. #define modelQuantizer modelJWQuantizer

  1345.         p->addModel(modelAdd5);

  1346.         p->addModel(modelBouncyBalls);

  1347.         p->addModel(modelCat);

  1348.         p->addModel(modelTree);

  1349.         p->addModel(modelFullScope);

  1350.         p->addModel(modelGridSeq);

  1351.         p->addModel(modelEightSeq);

  1352.         p->addModel(modelDivSeq);

  1353.         p->addModel(modelMinMax);

  1354.         p->addModel(modelNoteSeq);

  1355.         p->addModel(modelNoteSeqFu);

  1356.         p->addModel(modelNoteSeq16);

  1357.         p->addModel(modelTrigs);

  1358.         p->addModel(modelOnePattern);

  1359.         p->addModel(modelPatterns);

  1360.         p->addModel(modelQuantizer);

  1361.         p->addModel(modelSimpleClock);

  1362.         p->addModel(modelStr1ker);

  1363.         p->addModel(modelD1v1de);

  1364.         p->addModel(modelPres1t);

  1365.         p->addModel(modelThingThing);

  1366.         p->addModel(modelWavHead);

  1367.         p->addModel(modelXYPad);

  1368.         p->addModel(modelBlankPanel1hp);

  1369.         p->addModel(modelBlankPanelSmall);

  1370.         p->addModel(modelBlankPanelMedium);

  1371.         p->addModel(modelBlankPanelLarge);

  1372.         p->addModel(modelCoolBreeze);

  1373.         p->addModel(modelPete);

  1374. #undef modelQuantizer

  1375.     }

  1376. }

  1377. 

  1378. static void initStatic__MindMeld()

  1379. {

  1380.     Plugin* const p = new Plugin;

  1381.     pluginInstance__MindMeld = p;

  1382. 

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

  1384.     if (spl.ok())

  1385.     {

  1386.         p->addModel(modelMixMasterJr);

  1387.         p->addModel(modelAuxExpanderJr);

  1388.         p->addModel(modelMixMaster);

  1389.         p->addModel(modelAuxExpander);

  1390.         p->addModel(modelMeld);

  1391.         p->addModel(modelUnmeld);

  1392.         p->addModel(modelEqMaster);

  1393.         p->addModel(modelEqExpander);

  1394.         p->addModel(modelBassMaster);

  1395.         p->addModel(modelBassMasterJr);

  1396.         p->addModel(modelShapeMaster);

  1397.     }

  1398. }

  1399. 

  1400. static void initStatic__Mog()

  1401. {

  1402.     Plugin* const p = new Plugin;

  1403.     pluginInstance__Mog = p;

  1404. 

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

  1406.     if (spl.ok())

  1407.     {

  1408.         p->addModel(modelNetwork);

  1409.         p->addModel(modelNexus);

  1410.     }

  1411. }

  1412. 

  1413. static void initStatic__mscHack()

  1414. {

  1415.     Plugin* const p = new Plugin;

  1416.     pluginInstance__mscHack = p;

  1417. 

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

  1419.     if (spl.ok())

  1420.     {

  1421.         p->addModel(modelCompressor);

  1422.         p->addModel(modelSynthDrums);

  1423.         p->addModel(modelSEQ_6x32x16);

  1424.         p->addModel(modelMasterClockx4);

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

  1426.         p->addModel(modelSEQ_Envelope_8);

  1427.         p->addModel(modelSeq_Triad2);

  1428.         p->addModel(modelARP700);

  1429.         p->addModel(modelMix_4_0_4);

  1430.         p->addModel(modelMix_9_3_4);

  1431.         p->addModel(modelMix_16_4_4);

  1432.         p->addModel(modelMix_24_4_4);

  1433.         p->addModel(modelASAF8);

  1434.         p->addModel(modelPingPong);

  1435.         p->addModel(modelStepDelay);

  1436.         p->addModel(modelOsc_3Ch);

  1437.         p->addModel(modelDronez);

  1438.         p->addModel(modelMorze);

  1439.         p->addModel(modelWindz);

  1440.         p->addModel(modelLorenz);

  1441.         p->addModel(modelAlienz);

  1442.         p->addModel(modelOSC_WaveMorph_3);

  1443.         p->addModel(modelMaude_221);

  1444.     }

  1445. }

  1446. 

  1447. static void initStatic__rackwindows()

  1448. {

  1449.     Plugin* const p = new Plugin;

  1450.     pluginInstance__rackwindows = p;

  1451. 

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

  1453.     if (spl.ok())

  1454.     {

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

  1456.         p->addModel(modelBitshiftgain);

  1457.         p->addModel(modelCapacitor);

  1458.         p->addModel(modelCapacitor_stereo);

  1459.         p->addModel(modelChorus);

  1460.         p->addModel(modelConsole);

  1461.         p->addModel(modelConsole_mm);

  1462.         p->addModel(modelDistance);

  1463.         p->addModel(modelGolem);

  1464.         p->addModel(modelHolt);

  1465.         p->addModel(modelHombre);

  1466.         p->addModel(modelInterstage);

  1467.         p->addModel(modelMonitoring);

  1468.         p->addModel(modelMv);

  1469.         p->addModel(modelRasp);

  1470.         p->addModel(modelReseq);

  1471.         p->addModel(modelTape);

  1472.         p->addModel(modelTremolo);

  1473.         p->addModel(modelVibrato);

  1474.     }

  1475. }

  1476. 

  1477. static void initStatic__repelzen()

  1478. {

  1479.     Plugin* const p = new Plugin;

  1480.     pluginInstance__repelzen = p;

  1481. 

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

  1483.     if (spl.ok())

  1484.     {

  1485. #define modelBlank modelrepelzenBlank

  1486. #define modelMixer modelrepelzenMixer

  1487. #define modelWerner modelrepelzenWerner

  1488.         p->addModel(modelBlank);

  1489.         p->addModel(modelBurst);

  1490.         p->addModel(modelFolder);

  1491.         p->addModel(modelErwin);

  1492.         p->addModel(modelWerner);

  1493.         p->addModel(modelMixer);

  1494. #undef modelBlank

  1495. #undef modelMixer

  1496. #undef modelWerner

  1497.     }

  1498. }

  1499. 

  1500. static void initStatic__sonusmodular()

  1501. {

  1502.     Plugin* const p = new Plugin;

  1503.     pluginInstance__sonusmodular = p;

  1504. 

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

  1506.     if (spl.ok())

  1507.     {

  1508.         p->addModel(modelAddiction);

  1509.         p->addModel(modelBitter);

  1510.         p->addModel(modelBymidside);

  1511.         p->addModel(modelCampione);

  1512.         p->addModel(modelChainsaw);

  1513.         p->addModel(modelCtrl);

  1514.         p->addModel(modelDeathcrush);

  1515.         p->addModel(modelFraction);

  1516.         p->addModel(modelHarmony);

  1517.         p->addModel(modelLadrone);

  1518.         p->addModel(modelLuppolo);

  1519.         p->addModel(modelLuppolo3);

  1520.         p->addModel(modelMicromacro);

  1521.         p->addModel(modelMrcheb);

  1522.         p->addModel(modelMultimulti);

  1523.         p->addModel(modelNeurosc);

  1524.         p->addModel(modelOktagon);

  1525.         p->addModel(modelOsculum);

  1526.         p->addModel(modelParamath);

  1527.         p->addModel(modelPiconoise);

  1528.         p->addModel(modelPith);

  1529.         p->addModel(modelPusher);

  1530.         p->addModel(modelRingo);

  1531.         p->addModel(modelScramblase);

  1532.         p->addModel(modelTropicana);

  1533.         p->addModel(modelTwoff);

  1534.         p->addModel(modelYabp);

  1535.     }

  1536. }

  1537. 

  1538. static void initStatic__ValleyAudio()

  1539. {

  1540.     Plugin* const p = new Plugin;

  1541.     pluginInstance__ValleyAudio = p;

  1542. 

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

  1544.     if (spl.ok())

  1545.     {

  1546.         p->addModel(modelTopograph);

  1547.         p->addModel(modelUGraph);

  1548.         p->addModel(modelDexter);

  1549.         p->addModel(modelPlateau);

  1550.         p->addModel(modelInterzone);

  1551.         p->addModel(modelAmalgam);

  1552.         p->addModel(modelFeline);

  1553.         p->addModel(modelTerrorform);

  1554.     }

  1555. }

  1556. 

  1557. static void initStatic__ZetaCarinaeModules()

  1558. {

  1559.     Plugin* p = new Plugin;

  1560.     pluginInstance__ZetaCarinaeModules = p;

  1561. 

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

  1563.     if (spl.ok())

  1564.     {

  1565.         p->addModel(modelBrownianBridge);

  1566.         p->addModel(modelOrnsteinUhlenbeck);

  1567.         p->addModel(modelIOU);

  1568.         p->addModel(modelWarbler);

  1569.         p->addModel(modelRosenchance);

  1570.         p->addModel(modelGuildensTurn);

  1571.         p->addModel(modelRosslerRustler);

  1572.         p->addModel(modelFirefly);

  1573.     }

  1574. }

  1575. 

  1576. static void initStatic__ZZC()

  1577. {

  1578.     Plugin* p = new Plugin;

  1579.     pluginInstance__ZZC = p;

  1580. 

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

  1582.     if (spl.ok())

  1583.     {

  1584. #define modelClock modelZZCClock

  1585.         p->addModel(modelClock);

  1586.         p->addModel(modelDivider);

  1587.         p->addModel(modelFN3);

  1588.         p->addModel(modelSCVCA);

  1589.         p->addModel(modelSH8);

  1590.         p->addModel(modelSRC);

  1591.         p->addModel(modelDiv);

  1592.         p->addModel(modelDivExp);

  1593.         p->addModel(modelPolygate);

  1594. #undef modelClock

  1595.     }

  1596. }

  1597. #endif // NOPLUGINS

  1598. 

  1599. void initStaticPlugins()

  1600. {

  1601.     initStatic__Core();

  1602.     initStatic__Cardinal();

  1603. #ifndef NOPLUGINS

  1604.     initStatic__AmalgamatedHarmonics();

  1605.     initStatic__AnimatedCircuits();

  1606.     initStatic__Aria();

  1607.     initStatic__AS();

  1608.     initStatic__Atelier();

  1609.     initStatic__AudibleInstruments();

  1610.     initStatic__Bacon();

  1611.     initStatic__Befaco();

  1612.     initStatic__Bidoo();

  1613.     initStatic__BogaudioModules();

  1614.     initStatic__cf();

  1615.     initStatic__ChowDSP();

  1616.     initStatic__DrumKit();

  1617.     initStatic__ESeries();

  1618.     initStatic__FehlerFabrik();

  1619.     initStatic__Fundamental();

  1620.     initStatic__GlueTheGiant();

  1621.     initStatic__GrandeModular();

  1622.     initStatic__HetrickCV();

  1623.     initStatic__ImpromptuModular();

  1624.     initStatic__JW();

  1625.     initStatic__MindMeld();

  1626.     initStatic__Mog();

  1627.     initStatic__mscHack();

  1628.     initStatic__rackwindows();

  1629.     initStatic__repelzen();

  1630.     initStatic__sonusmodular();

  1631.     initStatic__ValleyAudio();

  1632.     initStatic__ZetaCarinaeModules();

  1633.     initStatic__ZZC();

  1634. #endif // NOPLUGINS

  1635. }

  1636. 

  1637. void destroyStaticPlugins()

  1638. {

  1639.     for (Plugin* p : plugins)

  1640.         delete p;

  1641.     plugins.clear();

  1642. }

  1643. 

  1644. }

  1645. }