From 4cb46daafdadfaebb9ad8ffc0aa166952f7c36c3 Mon Sep 17 00:00:00 2001 From: GithubActions BaconPaul Bot Date: Sun, 17 Dec 2023 20:18:53 +0000 Subject: [PATCH] Update to Latest Airwin --- libs/airwindows | 2 +- src/ModuleAdd.h | 500 ++++++++++++++++++++++++------------------------ 2 files changed, 251 insertions(+), 251 deletions(-) diff --git a/libs/airwindows b/libs/airwindows index 5ee0c57..1644e74 160000 --- a/libs/airwindows +++ b/libs/airwindows @@ -1 +1 @@ -Subproject commit 5ee0c5711feb2de9da0858600893aeecbdbe91fc +Subproject commit 1644e7457bcc7ff038c41ba6eda7b04865d2c373 diff --git a/src/ModuleAdd.h b/src/ModuleAdd.h index ecb6872..0d0e1d7 100644 --- a/src/ModuleAdd.h +++ b/src/ModuleAdd.h @@ -13,21 +13,21 @@ int Air_unused = AirwinRegistry::registerAirwindow({"Air", "Brightness", 62, "Ai #include "autogen_airwin/Air2.h" int Air2_unused = AirwinRegistry::registerAirwindow({"Air2", "Brightness", 61, "Air2 is a different bright EQ with silk tone and high sample rate support.", airwin2rack::Air2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Apicolypse.h" -int Apicolypse_unused = AirwinRegistry::registerAirwindow({"Apicolypse", "Tone Color", 313, "Apicolypse is a re-release of my old API-style color adder, exacly as it was.", airwin2rack::Apicolypse::kNumParameters, []() { return std::make_unique(0); }}); +int Apicolypse_unused = AirwinRegistry::registerAirwindow({"Apicolypse", "Tone Color", 314, "Apicolypse is a re-release of my old API-style color adder, exacly as it was.", airwin2rack::Apicolypse::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/AtmosphereBuss.h" int AtmosphereBuss_unused = AirwinRegistry::registerAirwindow({"AtmosphereBuss", "Consoles", 112, "AtmosphereBuss is Console5 processing with powerful new acoustic distance effects.", airwin2rack::AtmosphereBuss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/AtmosphereChannel.h" int AtmosphereChannel_unused = AirwinRegistry::registerAirwindow({"AtmosphereChannel", "Consoles", 113, "AtmosphereChannel is Console5 processing with powerful new acoustic distance effects.", airwin2rack::AtmosphereChannel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Aura.h" -int Aura_unused = AirwinRegistry::registerAirwindow({"Aura", "Effects", 186, "Aura is a new kind of resonant lowpass EQ.", airwin2rack::Aura::kNumParameters, []() { return std::make_unique(0); }}); +int Aura_unused = AirwinRegistry::registerAirwindow({"Aura", "Effects", 187, "Aura is a new kind of resonant lowpass EQ.", airwin2rack::Aura::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/AutoPan.h" -int AutoPan_unused = AirwinRegistry::registerAirwindow({"AutoPan", "Stereo", 285, "AutoPan is for getting some organic stereo movement into your mix.", airwin2rack::AutoPan::kNumParameters, []() { return std::make_unique(0); }}); +int AutoPan_unused = AirwinRegistry::registerAirwindow({"AutoPan", "Stereo", 286, "AutoPan is for getting some organic stereo movement into your mix.", airwin2rack::AutoPan::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/AverMatrix.h" -int AverMatrix_unused = AirwinRegistry::registerAirwindow({"AverMatrix", "Filter", 211, "AverMatrix turns averaging into a full-featured EQ.", airwin2rack::AverMatrix::kNumParameters, []() { return std::make_unique(0); }}); +int AverMatrix_unused = AirwinRegistry::registerAirwindow({"AverMatrix", "Filter", 212, "AverMatrix turns averaging into a full-featured EQ.", airwin2rack::AverMatrix::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Average.h" -int Average_unused = AirwinRegistry::registerAirwindow({"Average", "Filter", 212, "Average is a distinctive sort of lowpass filter.", airwin2rack::Average::kNumParameters, []() { return std::make_unique(0); }}); +int Average_unused = AirwinRegistry::registerAirwindow({"Average", "Filter", 213, "Average is a distinctive sort of lowpass filter.", airwin2rack::Average::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Balanced.h" -int Balanced_unused = AirwinRegistry::registerAirwindow({"Balanced", "Utility", 346, "Balanced lets you run an XLR input into a stereo input, sum it to mono, and use it.", airwin2rack::Balanced::kNumParameters, []() { return std::make_unique(0); }}); +int Balanced_unused = AirwinRegistry::registerAirwindow({"Balanced", "Utility", 347, "Balanced lets you run an XLR input into a stereo input, sum it to mono, and use it.", airwin2rack::Balanced::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BassAmp.h" int BassAmp_unused = AirwinRegistry::registerAirwindow({"BassAmp", "Amp Sims", 34, "BassAmp is an old plugin with new tweaks, that gives some bass guitar tones.", airwin2rack::BassAmp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BassDrive.h" @@ -35,11 +35,11 @@ int BassDrive_unused = AirwinRegistry::registerAirwindow({"BassDrive", "Amp Sims #include "autogen_airwin/BassKit.h" int BassKit_unused = AirwinRegistry::registerAirwindow({"BassKit", "Bass", 37, "BassKit is centered bass reinforcement with subs fill. Clean and controllable.", airwin2rack::BassKit::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Baxandall.h" -int Baxandall_unused = AirwinRegistry::registerAirwindow({"Baxandall", "Filter", 214, "Baxandall is a killer general-purpose EQ.", airwin2rack::Baxandall::kNumParameters, []() { return std::make_unique(0); }}); +int Baxandall_unused = AirwinRegistry::registerAirwindow({"Baxandall", "Filter", 215, "Baxandall is a killer general-purpose EQ.", airwin2rack::Baxandall::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Baxandall2.h" -int Baxandall2_unused = AirwinRegistry::registerAirwindow({"Baxandall2", "Filter", 200, "Baxandall2 is Baxandall, extended and made more powerful.", airwin2rack::Baxandall2::kNumParameters, []() { return std::make_unique(0); }}); +int Baxandall2_unused = AirwinRegistry::registerAirwindow({"Baxandall2", "Filter", 201, "Baxandall2 is Baxandall, extended and made more powerful.", airwin2rack::Baxandall2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Beam.h" -int Beam_unused = AirwinRegistry::registerAirwindow({"Beam", "Dithers", 137, "Beam is a wordlength reducer that tries to heighten sonority.", airwin2rack::Beam::kNumParameters, []() { return std::make_unique(0); }}); +int Beam_unused = AirwinRegistry::registerAirwindow({"Beam", "Dithers", 138, "Beam is a wordlength reducer that tries to heighten sonority.", airwin2rack::Beam::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BigAmp.h" int BigAmp_unused = AirwinRegistry::registerAirwindow({"BigAmp", "Amp Sims", 31, "BigAmp is a very flexible amplike thing with a taste for the bizarre.", airwin2rack::BigAmp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Biquad.h" @@ -55,17 +55,17 @@ int BiquadPlus_unused = AirwinRegistry::registerAirwindow({"BiquadPlus", "Biquad #include "autogen_airwin/BiquadTriple.h" int BiquadTriple_unused = AirwinRegistry::registerAirwindow({"BiquadTriple", "Biquads", 47, "BiquadTriple is a handy Airwindows cascaded biquad filter: steeper roll-off before resonance.", airwin2rack::BiquadTriple::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BitGlitter.h" -int BitGlitter_unused = AirwinRegistry::registerAirwindow({"BitGlitter", "Lo-Fi", 233, "BitGlitter is an old-sampler style digital lo-fi plugin.", airwin2rack::BitGlitter::kNumParameters, []() { return std::make_unique(0); }}); +int BitGlitter_unused = AirwinRegistry::registerAirwindow({"BitGlitter", "Lo-Fi", 234, "BitGlitter is an old-sampler style digital lo-fi plugin.", airwin2rack::BitGlitter::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BitShiftGain.h" -int BitShiftGain_unused = AirwinRegistry::registerAirwindow({"BitShiftGain", "Utility", 330, "BitShiftGain is the ‘One Weird Trick’ perfect boost/pad, but in 6db increments ONLY.", airwin2rack::BitShiftGain::kNumParameters, []() { return std::make_unique(0); }}); +int BitShiftGain_unused = AirwinRegistry::registerAirwindow({"BitShiftGain", "Utility", 331, "BitShiftGain is the ‘One Weird Trick’ perfect boost/pad, but in 6db increments ONLY.", airwin2rack::BitShiftGain::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BitShiftPan.h" -int BitShiftPan_unused = AirwinRegistry::registerAirwindow({"BitShiftPan", "Utility", 329, "BitShiftPan gives you a gain and a pan control that are ONLY done using bit shifts.", airwin2rack::BitShiftPan::kNumParameters, []() { return std::make_unique(0); }}); +int BitShiftPan_unused = AirwinRegistry::registerAirwindow({"BitShiftPan", "Utility", 330, "BitShiftPan gives you a gain and a pan control that are ONLY done using bit shifts.", airwin2rack::BitShiftPan::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Bite.h" -int Bite_unused = AirwinRegistry::registerAirwindow({"Bite", "Lo-Fi", 238, "Bite is an unusual edge-maker.", airwin2rack::Bite::kNumParameters, []() { return std::make_unique(0); }}); +int Bite_unused = AirwinRegistry::registerAirwindow({"Bite", "Lo-Fi", 239, "Bite is an unusual edge-maker.", airwin2rack::Bite::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BlockParty.h" -int BlockParty_unused = AirwinRegistry::registerAirwindow({"BlockParty", "Dynamics", 164, "BlockParty is like a moderately saturated analog limiter.", airwin2rack::BlockParty::kNumParameters, []() { return std::make_unique(0); }}); +int BlockParty_unused = AirwinRegistry::registerAirwindow({"BlockParty", "Dynamics", 165, "BlockParty is like a moderately saturated analog limiter.", airwin2rack::BlockParty::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BrassRider.h" -int BrassRider_unused = AirwinRegistry::registerAirwindow({"BrassRider", "Dynamics", 170, "BrassRider is One Weird Trick for drum overheads in metal!", airwin2rack::BrassRider::kNumParameters, []() { return std::make_unique(0); }}); +int BrassRider_unused = AirwinRegistry::registerAirwindow({"BrassRider", "Dynamics", 171, "BrassRider is One Weird Trick for drum overheads in metal!", airwin2rack::BrassRider::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BrightAmbience.h" int BrightAmbience_unused = AirwinRegistry::registerAirwindow({"BrightAmbience", "Ambience", 19, "BrightAmbience is a plugin for very bright gated reverbs.", airwin2rack::BrightAmbience::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BrightAmbience2.h" @@ -73,13 +73,13 @@ int BrightAmbience2_unused = AirwinRegistry::registerAirwindow({"BrightAmbience2 #include "autogen_airwin/BrightAmbience3.h" int BrightAmbience3_unused = AirwinRegistry::registerAirwindow({"BrightAmbience3", "Ambience", 5, "BrightAmbience3 adds undersampling for high sample rates, and better feedback.", airwin2rack::BrightAmbience3::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BuildATPDF.h" -int BuildATPDF_unused = AirwinRegistry::registerAirwindow({"BuildATPDF", "Dithers", 143, "BuildATPDF is a dither-making toolkit.", airwin2rack::BuildATPDF::kNumParameters, []() { return std::make_unique(0); }}); +int BuildATPDF_unused = AirwinRegistry::registerAirwindow({"BuildATPDF", "Dithers", 144, "BuildATPDF is a dither-making toolkit.", airwin2rack::BuildATPDF::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BussColors4.h" -int BussColors4_unused = AirwinRegistry::registerAirwindow({"BussColors4", "Tone Color", 311, "BussColors4 is the Airwindows console emulations, now working up to 192K correctly.", airwin2rack::BussColors4::kNumParameters, []() { return std::make_unique(0); }}); +int BussColors4_unused = AirwinRegistry::registerAirwindow({"BussColors4", "Tone Color", 312, "BussColors4 is the Airwindows console emulations, now working up to 192K correctly.", airwin2rack::BussColors4::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ButterComp.h" -int ButterComp_unused = AirwinRegistry::registerAirwindow({"ButterComp", "Dynamics", 169, "ButterComp is my softest, smoothest compressor.", airwin2rack::ButterComp::kNumParameters, []() { return std::make_unique(0); }}); +int ButterComp_unused = AirwinRegistry::registerAirwindow({"ButterComp", "Dynamics", 170, "ButterComp is my softest, smoothest compressor.", airwin2rack::ButterComp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ButterComp2.h" -int ButterComp2_unused = AirwinRegistry::registerAirwindow({"ButterComp2", "Dynamics", 160, "ButterComp2 is improved ButterComp with an output control and sound upgrades.", airwin2rack::ButterComp2::kNumParameters, []() { return std::make_unique(0); }}); +int ButterComp2_unused = AirwinRegistry::registerAirwindow({"ButterComp2", "Dynamics", 161, "ButterComp2 is improved ButterComp with an output control and sound upgrades.", airwin2rack::ButterComp2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/C5RawBuss.h" int C5RawBuss_unused = AirwinRegistry::registerAirwindow({"C5RawBuss", "Consoles", 110, "C5RawBuss is the original Console5 algorithm, with optional very gentle DC suppression.", airwin2rack::C5RawBuss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/C5RawChannel.h" @@ -87,39 +87,39 @@ int C5RawChannel_unused = AirwinRegistry::registerAirwindow({"C5RawChannel", "Co #include "autogen_airwin/CStrip.h" int CStrip_unused = AirwinRegistry::registerAirwindow({"CStrip", "Unclassified", -1, "CStrip is an Airwindows channel strip.", airwin2rack::CStrip::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/CStrip2.h" -int CStrip2_unused = AirwinRegistry::registerAirwindow({"CStrip2", "Filter", 205, "CStrip2 refines and optimizes CStrip, by request!", airwin2rack::CStrip2::kNumParameters, []() { return std::make_unique(0); }}); +int CStrip2_unused = AirwinRegistry::registerAirwindow({"CStrip2", "Filter", 206, "CStrip2 refines and optimizes CStrip, by request!", airwin2rack::CStrip2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Cabs.h" int Cabs_unused = AirwinRegistry::registerAirwindow({"Cabs", "Amp Sims", 32, "Cabs is an Airwindows guitar speaker cabinet simulator.", airwin2rack::Cabs::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Calibre.h" -int Calibre_unused = AirwinRegistry::registerAirwindow({"Calibre", "Tone Color", 316, "Calibre is a re-release of another old Character plugin.", airwin2rack::Calibre::kNumParameters, []() { return std::make_unique(0); }}); +int Calibre_unused = AirwinRegistry::registerAirwindow({"Calibre", "Tone Color", 317, "Calibre is a re-release of another old Character plugin.", airwin2rack::Calibre::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Capacitor.h" -int Capacitor_unused = AirwinRegistry::registerAirwindow({"Capacitor", "Filter", 217, "Capacitor is a lowpass/highpass filter of a new type.", airwin2rack::Capacitor::kNumParameters, []() { return std::make_unique(0); }}); +int Capacitor_unused = AirwinRegistry::registerAirwindow({"Capacitor", "Filter", 218, "Capacitor is a lowpass/highpass filter of a new type.", airwin2rack::Capacitor::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Capacitor2.h" -int Capacitor2_unused = AirwinRegistry::registerAirwindow({"Capacitor2", "Filter", 201, "Capacitor2 is Capacitor with extra analog modeling and mojo.", airwin2rack::Capacitor2::kNumParameters, []() { return std::make_unique(0); }}); +int Capacitor2_unused = AirwinRegistry::registerAirwindow({"Capacitor2", "Filter", 202, "Capacitor2 is Capacitor with extra analog modeling and mojo.", airwin2rack::Capacitor2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Chamber.h" -int Chamber_unused = AirwinRegistry::registerAirwindow({"Chamber", "Reverb", 259, "Chamber is a feedforward reverb based on the golden ratio.", airwin2rack::Chamber::kNumParameters, []() { return std::make_unique(0); }}); +int Chamber_unused = AirwinRegistry::registerAirwindow({"Chamber", "Reverb", 260, "Chamber is a feedforward reverb based on the golden ratio.", airwin2rack::Chamber::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Chamber2.h" -int Chamber2_unused = AirwinRegistry::registerAirwindow({"Chamber2", "Reverb", 258, "Chamber2 is a feedforward reverb, a blur delay, and a glitch topping!", airwin2rack::Chamber2::kNumParameters, []() { return std::make_unique(0); }}); +int Chamber2_unused = AirwinRegistry::registerAirwindow({"Chamber2", "Reverb", 259, "Chamber2 is a feedforward reverb, a blur delay, and a glitch topping!", airwin2rack::Chamber2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Channel4.h" -int Channel4_unused = AirwinRegistry::registerAirwindow({"Channel4", "Tone Color", 325, "Channel4 is a tone coloring plugin that gives more of an analog feel.", airwin2rack::Channel4::kNumParameters, []() { return std::make_unique(0); }}); +int Channel4_unused = AirwinRegistry::registerAirwindow({"Channel4", "Tone Color", 326, "Channel4 is a tone coloring plugin that gives more of an analog feel.", airwin2rack::Channel4::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Channel5.h" -int Channel5_unused = AirwinRegistry::registerAirwindow({"Channel5", "Tone Color", 324, "Channel5 is Channel for 2018, with new subtleties.", airwin2rack::Channel5::kNumParameters, []() { return std::make_unique(0); }}); +int Channel5_unused = AirwinRegistry::registerAirwindow({"Channel5", "Tone Color", 325, "Channel5 is Channel for 2018, with new subtleties.", airwin2rack::Channel5::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Channel6.h" -int Channel6_unused = AirwinRegistry::registerAirwindow({"Channel6", "Tone Color", 323, "Channel6 uses the Spiral algorithm.", airwin2rack::Channel6::kNumParameters, []() { return std::make_unique(0); }}); +int Channel6_unused = AirwinRegistry::registerAirwindow({"Channel6", "Tone Color", 324, "Channel6 uses the Spiral algorithm.", airwin2rack::Channel6::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Channel7.h" -int Channel7_unused = AirwinRegistry::registerAirwindow({"Channel7", "Tone Color", 322, "Channel7 improves slew clipping and lets you blend Channel 6 and 5.", airwin2rack::Channel7::kNumParameters, []() { return std::make_unique(0); }}); +int Channel7_unused = AirwinRegistry::registerAirwindow({"Channel7", "Tone Color", 323, "Channel7 improves slew clipping and lets you blend Channel 6 and 5.", airwin2rack::Channel7::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Channel8.h" -int Channel8_unused = AirwinRegistry::registerAirwindow({"Channel8", "Tone Color", 321, "Channel8 is Channel7 with updates from Capacitor2 and Slew3. More and better of what Channel is.", airwin2rack::Channel8::kNumParameters, []() { return std::make_unique(0); }}); +int Channel8_unused = AirwinRegistry::registerAirwindow({"Channel8", "Tone Color", 322, "Channel8 is Channel7 with updates from Capacitor2 and Slew3. More and better of what Channel is.", airwin2rack::Channel8::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Channel9.h" -int Channel9_unused = AirwinRegistry::registerAirwindow({"Channel9", "Tone Color", 312, "Channel9 is Channel8 with ultrasonic filtering, and new Teac and Mackie 'low end' settings.", airwin2rack::Channel9::kNumParameters, []() { return std::make_unique(0); }}); +int Channel9_unused = AirwinRegistry::registerAirwindow({"Channel9", "Tone Color", 313, "Channel9 is Channel8 with ultrasonic filtering, and new Teac and Mackie 'low end' settings.", airwin2rack::Channel9::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Chorus.h" int Chorus_unused = AirwinRegistry::registerAirwindow({"Chorus", "Ambience", 22, "Chorus is a mono chorus, also works as a vibrato.", airwin2rack::Chorus::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ChorusEnsemble.h" int ChorusEnsemble_unused = AirwinRegistry::registerAirwindow({"ChorusEnsemble", "Ambience", 23, "ChorusEnsemble is a more complex, multi-tap mono chorus.", airwin2rack::ChorusEnsemble::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ChromeOxide.h" -int ChromeOxide_unused = AirwinRegistry::registerAirwindow({"ChromeOxide", "Lo-Fi", 235, "ChromeOxide is an alternate path to vibey old tape sonics.", airwin2rack::ChromeOxide::kNumParameters, []() { return std::make_unique(0); }}); +int ChromeOxide_unused = AirwinRegistry::registerAirwindow({"ChromeOxide", "Lo-Fi", 236, "ChromeOxide is an alternate path to vibey old tape sonics.", airwin2rack::ChromeOxide::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Cider.h" -int Cider_unused = AirwinRegistry::registerAirwindow({"Cider", "Tone Color", 317, "Cider is a re-release of another old Character plugin.", airwin2rack::Cider::kNumParameters, []() { return std::make_unique(0); }}); +int Cider_unused = AirwinRegistry::registerAirwindow({"Cider", "Tone Color", 318, "Cider is a re-release of another old Character plugin.", airwin2rack::Cider::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ClearCoat.h" int ClearCoat_unused = AirwinRegistry::registerAirwindow({"ClearCoat", "Ambience", 0, "ClearCoat is an array of bright ambience reverbs.", airwin2rack::ClearCoat::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ClipOnly2.h" @@ -127,13 +127,13 @@ int ClipOnly2_unused = AirwinRegistry::registerAirwindow({"ClipOnly2", "Clipping #include "autogen_airwin/ClipSoftly.h" int ClipSoftly_unused = AirwinRegistry::registerAirwindow({"ClipSoftly", "Clipping", 73, "ClipSoftly is ClipOnly2 but as a softclipper: a very handy building block.", airwin2rack::ClipSoftly::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Coils.h" -int Coils_unused = AirwinRegistry::registerAirwindow({"Coils", "Subtlety", 300, "Coils models the types of distortion you'll find in transformers.", airwin2rack::Coils::kNumParameters, []() { return std::make_unique(0); }}); +int Coils_unused = AirwinRegistry::registerAirwindow({"Coils", "Subtlety", 301, "Coils models the types of distortion you'll find in transformers.", airwin2rack::Coils::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Coils2.h" -int Coils2_unused = AirwinRegistry::registerAirwindow({"Coils2", "Subtlety", 295, "Coils2 is a transformer overdrive emulator.", airwin2rack::Coils2::kNumParameters, []() { return std::make_unique(0); }}); +int Coils2_unused = AirwinRegistry::registerAirwindow({"Coils2", "Subtlety", 296, "Coils2 is a transformer overdrive emulator.", airwin2rack::Coils2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Cojones.h" -int Cojones_unused = AirwinRegistry::registerAirwindow({"Cojones", "Lo-Fi", 236, "Cojones is a new kind of distorty.", airwin2rack::Cojones::kNumParameters, []() { return std::make_unique(0); }}); +int Cojones_unused = AirwinRegistry::registerAirwindow({"Cojones", "Lo-Fi", 237, "Cojones is a new kind of distorty.", airwin2rack::Cojones::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Compresaturator.h" -int Compresaturator_unused = AirwinRegistry::registerAirwindow({"Compresaturator", "Dynamics", 167, "Compresaturator fades between compressing and soft clipping.", airwin2rack::Compresaturator::kNumParameters, []() { return std::make_unique(0); }}); +int Compresaturator_unused = AirwinRegistry::registerAirwindow({"Compresaturator", "Dynamics", 168, "Compresaturator fades between compressing and soft clipping.", airwin2rack::Compresaturator::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console0Buss.h" int Console0Buss_unused = AirwinRegistry::registerAirwindow({"Console0Buss", "Consoles", 92, "Console0Buss is a radical, minimalist Console system.", airwin2rack::Console0Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console0Channel.h" @@ -195,19 +195,19 @@ int ConsoleMDBuss_unused = AirwinRegistry::registerAirwindow({"ConsoleMDBuss", " #include "autogen_airwin/ConsoleMDChannel.h" int ConsoleMDChannel_unused = AirwinRegistry::registerAirwindow({"ConsoleMDChannel", "Consoles", 79, "ConsoleMDChannel goes for the tone shaping of the classic MCI console!", airwin2rack::ConsoleMDChannel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Creature.h" -int Creature_unused = AirwinRegistry::registerAirwindow({"Creature", "Saturation", 266, "Creature is a soft slew saturator, a new class of noisechanger.", airwin2rack::Creature::kNumParameters, []() { return std::make_unique(0); }}); +int Creature_unused = AirwinRegistry::registerAirwindow({"Creature", "Saturation", 267, "Creature is a soft slew saturator, a new class of noisechanger.", airwin2rack::Creature::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/CrickBass.h" int CrickBass_unused = AirwinRegistry::registerAirwindow({"CrickBass", "Amp Sims", 28, "CrickBass is a flexible but aggressive bass tone for dual pickups.", airwin2rack::CrickBass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/CrunchyGrooveWear.h" -int CrunchyGrooveWear_unused = AirwinRegistry::registerAirwindow({"CrunchyGrooveWear", "Lo-Fi", 229, "CrunchyGrooveWear is a version of GrooveWear for more edge and distortion.", airwin2rack::CrunchyGrooveWear::kNumParameters, []() { return std::make_unique(0); }}); +int CrunchyGrooveWear_unused = AirwinRegistry::registerAirwindow({"CrunchyGrooveWear", "Lo-Fi", 230, "CrunchyGrooveWear is a version of GrooveWear for more edge and distortion.", airwin2rack::CrunchyGrooveWear::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Crystal.h" -int Crystal_unused = AirwinRegistry::registerAirwindow({"Crystal", "Tone Color", 318, "Crystal is a tone shaper and buss soft-clipper.", airwin2rack::Crystal::kNumParameters, []() { return std::make_unique(0); }}); +int Crystal_unused = AirwinRegistry::registerAirwindow({"Crystal", "Tone Color", 319, "Crystal is a tone shaper and buss soft-clipper.", airwin2rack::Crystal::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DCVoltage.h" -int DCVoltage_unused = AirwinRegistry::registerAirwindow({"DCVoltage", "Utility", 339, "DCVoltage is literally a DC control voltage, in a plugin.", airwin2rack::DCVoltage::kNumParameters, []() { return std::make_unique(0); }}); +int DCVoltage_unused = AirwinRegistry::registerAirwindow({"DCVoltage", "Utility", 340, "DCVoltage is literally a DC control voltage, in a plugin.", airwin2rack::DCVoltage::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Dark.h" -int Dark_unused = AirwinRegistry::registerAirwindow({"Dark", "Dithers", 130, "Dark is a wordlength reducer that gives your music a blacker backdrop.", airwin2rack::Dark::kNumParameters, []() { return std::make_unique(0); }}); +int Dark_unused = AirwinRegistry::registerAirwindow({"Dark", "Dithers", 131, "Dark is a wordlength reducer that gives your music a blacker backdrop.", airwin2rack::Dark::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DarkNoise.h" -int DarkNoise_unused = AirwinRegistry::registerAirwindow({"DarkNoise", "Noise", 245, "DarkNoise is an alternative method for producing bassier noise directly. Sound design stuff.", airwin2rack::DarkNoise::kNumParameters, []() { return std::make_unique(0); }}); +int DarkNoise_unused = AirwinRegistry::registerAirwindow({"DarkNoise", "Noise", 246, "DarkNoise is an alternative method for producing bassier noise directly. Sound design stuff.", airwin2rack::DarkNoise::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DeBess.h" int DeBess_unused = AirwinRegistry::registerAirwindow({"DeBess", "Brightness", 50, "DeBess is an improved DeEss, with perfect rejection of non-ess audio.", airwin2rack::DeBess::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DeEss.h" @@ -215,71 +215,71 @@ int DeEss_unused = AirwinRegistry::registerAirwindow({"DeEss", "Brightness", 55, #include "autogen_airwin/DeHiss.h" int DeHiss_unused = AirwinRegistry::registerAirwindow({"DeHiss", "Brightness", 65, "DeHiss tries to suppress background hiss, like a hiss gate.", airwin2rack::DeHiss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DeRez.h" -int DeRez_unused = AirwinRegistry::registerAirwindow({"DeRez", "Lo-Fi", 234, "DeRez is an analog-style bit and sample rate crusher with continuous adjustments.", airwin2rack::DeRez::kNumParameters, []() { return std::make_unique(0); }}); +int DeRez_unused = AirwinRegistry::registerAirwindow({"DeRez", "Lo-Fi", 235, "DeRez is an analog-style bit and sample rate crusher with continuous adjustments.", airwin2rack::DeRez::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DeRez2.h" -int DeRez2_unused = AirwinRegistry::registerAirwindow({"DeRez2", "Lo-Fi", 232, "DeRez2 brings more authentic retro-digital hardware tones.", airwin2rack::DeRez2::kNumParameters, []() { return std::make_unique(0); }}); +int DeRez2_unused = AirwinRegistry::registerAirwindow({"DeRez2", "Lo-Fi", 233, "DeRez2 brings more authentic retro-digital hardware tones.", airwin2rack::DeRez2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Deckwrecka.h" -int Deckwrecka_unused = AirwinRegistry::registerAirwindow({"Deckwrecka", "Lo-Fi", 239, "Deckwrecka fattens and dirties up beats.", airwin2rack::Deckwrecka::kNumParameters, []() { return std::make_unique(0); }}); +int Deckwrecka_unused = AirwinRegistry::registerAirwindow({"Deckwrecka", "Lo-Fi", 240, "Deckwrecka fattens and dirties up beats.", airwin2rack::Deckwrecka::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Density.h" -int Density_unused = AirwinRegistry::registerAirwindow({"Density", "Distortion", 124, "Density is a Swiss Army Knife of saturation/antisaturation.", airwin2rack::Density::kNumParameters, []() { return std::make_unique(0); }}); +int Density_unused = AirwinRegistry::registerAirwindow({"Density", "Distortion", 125, "Density is a Swiss Army Knife of saturation/antisaturation.", airwin2rack::Density::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Density2.h" -int Density2_unused = AirwinRegistry::registerAirwindow({"Density2", "Distortion", 123, "Density2 is a different color for Density, some old code I had that people wanted.", airwin2rack::Density2::kNumParameters, []() { return std::make_unique(0); }}); +int Density2_unused = AirwinRegistry::registerAirwindow({"Density2", "Distortion", 124, "Density2 is a different color for Density, some old code I had that people wanted.", airwin2rack::Density2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Desk.h" -int Desk_unused = AirwinRegistry::registerAirwindow({"Desk", "Subtlety", 301, "Desk is classic Airwindows subtle analog modeling.", airwin2rack::Desk::kNumParameters, []() { return std::make_unique(0); }}); +int Desk_unused = AirwinRegistry::registerAirwindow({"Desk", "Subtlety", 302, "Desk is classic Airwindows subtle analog modeling.", airwin2rack::Desk::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Desk4.h" -int Desk4_unused = AirwinRegistry::registerAirwindow({"Desk4", "Saturation", 278, "Desk4 is distinctive analog coloration (a tuneable version of the control-less Desk plugins)", airwin2rack::Desk4::kNumParameters, []() { return std::make_unique(0); }}); +int Desk4_unused = AirwinRegistry::registerAirwindow({"Desk4", "Saturation", 279, "Desk4 is distinctive analog coloration (a tuneable version of the control-less Desk plugins)", airwin2rack::Desk4::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DigitalBlack.h" -int DigitalBlack_unused = AirwinRegistry::registerAirwindow({"DigitalBlack", "Dynamics", 157, "DigitalBlack is a quick, staccato gate.", airwin2rack::DigitalBlack::kNumParameters, []() { return std::make_unique(0); }}); +int DigitalBlack_unused = AirwinRegistry::registerAirwindow({"DigitalBlack", "Dynamics", 158, "DigitalBlack is a quick, staccato gate.", airwin2rack::DigitalBlack::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Dirt.h" int Dirt_unused = AirwinRegistry::registerAirwindow({"Dirt", "Distortion", 121, "Dirt is a soft-clip distortion in the spirit of Edge.", airwin2rack::Dirt::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Distance.h" -int Distance_unused = AirwinRegistry::registerAirwindow({"Distance", "Filter", 224, "Distance is a sound design or reverb far-away-izer.", airwin2rack::Distance::kNumParameters, []() { return std::make_unique(0); }}); +int Distance_unused = AirwinRegistry::registerAirwindow({"Distance", "Filter", 225, "Distance is a sound design or reverb far-away-izer.", airwin2rack::Distance::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Distance2.h" -int Distance2_unused = AirwinRegistry::registerAirwindow({"Distance2", "Filter", 223, "Distance2 is a versatile space shaper for creating depth.", airwin2rack::Distance2::kNumParameters, []() { return std::make_unique(0); }}); +int Distance2_unused = AirwinRegistry::registerAirwindow({"Distance2", "Filter", 224, "Distance2 is a versatile space shaper for creating depth.", airwin2rack::Distance2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Distortion.h" int Distortion_unused = AirwinRegistry::registerAirwindow({"Distortion", "Distortion", 119, "Distortion is a slightly dark analog-style distortion with several presets, like Focus.", airwin2rack::Distortion::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DitherFloat.h" -int DitherFloat_unused = AirwinRegistry::registerAirwindow({"DitherFloat", "Dithers", 152, "DitherFloat is a demo of floating point truncation: can also dither to 32 bit float output.", airwin2rack::DitherFloat::kNumParameters, []() { return std::make_unique(0); }}); +int DitherFloat_unused = AirwinRegistry::registerAirwindow({"DitherFloat", "Dithers", 153, "DitherFloat is a demo of floating point truncation: can also dither to 32 bit float output.", airwin2rack::DitherFloat::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DitherMeDiskers.h" -int DitherMeDiskers_unused = AirwinRegistry::registerAirwindow({"DitherMeDiskers", "Dithers", 147, "DitherMeDiskers is dark deep 'dither' in a 16 bit version.", airwin2rack::DitherMeDiskers::kNumParameters, []() { return std::make_unique(0); }}); +int DitherMeDiskers_unused = AirwinRegistry::registerAirwindow({"DitherMeDiskers", "Dithers", 148, "DitherMeDiskers is dark deep 'dither' in a 16 bit version.", airwin2rack::DitherMeDiskers::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DitherMeTimbers.h" -int DitherMeTimbers_unused = AirwinRegistry::registerAirwindow({"DitherMeTimbers", "Dithers", 146, "DitherMeTimbers is dark deep 'dither' in a 24 bit version.", airwin2rack::DitherMeTimbers::kNumParameters, []() { return std::make_unique(0); }}); +int DitherMeTimbers_unused = AirwinRegistry::registerAirwindow({"DitherMeTimbers", "Dithers", 147, "DitherMeTimbers is dark deep 'dither' in a 24 bit version.", airwin2rack::DitherMeTimbers::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Ditherbox.h" -int Ditherbox_unused = AirwinRegistry::registerAirwindow({"Ditherbox", "Dithers", 142, "Ditherbox is a switchable selection of dithers in 16 and 24 bit, plus monitoring tools.", airwin2rack::Ditherbox::kNumParameters, []() { return std::make_unique(0); }}); +int Ditherbox_unused = AirwinRegistry::registerAirwindow({"Ditherbox", "Dithers", 143, "Ditherbox is a switchable selection of dithers in 16 and 24 bit, plus monitoring tools.", airwin2rack::Ditherbox::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DoublePaul.h" -int DoublePaul_unused = AirwinRegistry::registerAirwindow({"DoublePaul", "Dithers", 141, "DoublePaul is like PaulDither but more so.", airwin2rack::DoublePaul::kNumParameters, []() { return std::make_unique(0); }}); +int DoublePaul_unused = AirwinRegistry::registerAirwindow({"DoublePaul", "Dithers", 142, "DoublePaul is like PaulDither but more so.", airwin2rack::DoublePaul::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Doublelay.h" int Doublelay_unused = AirwinRegistry::registerAirwindow({"Doublelay", "Ambience", 2, "Doublelay is StereoDoubler with independent delays and feedback.", airwin2rack::Doublelay::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Drive.h" -int Drive_unused = AirwinRegistry::registerAirwindow({"Drive", "Distortion", 125, "Drive is the angry distortion!", airwin2rack::Drive::kNumParameters, []() { return std::make_unique(0); }}); +int Drive_unused = AirwinRegistry::registerAirwindow({"Drive", "Distortion", 126, "Drive is the angry distortion!", airwin2rack::Drive::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DrumSlam.h" -int DrumSlam_unused = AirwinRegistry::registerAirwindow({"DrumSlam", "Dynamics", 168, "DrumSlam is a heavy-processing tape modeler.", airwin2rack::DrumSlam::kNumParameters, []() { return std::make_unique(0); }}); +int DrumSlam_unused = AirwinRegistry::registerAirwindow({"DrumSlam", "Dynamics", 169, "DrumSlam is a heavy-processing tape modeler.", airwin2rack::DrumSlam::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DubCenter.h" int DubCenter_unused = AirwinRegistry::registerAirwindow({"DubCenter", "Bass", 38, "DubCenter is a version of DubSub where the bass reinforcement is purely mono.", airwin2rack::DubCenter::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DubSub.h" int DubSub_unused = AirwinRegistry::registerAirwindow({"DubSub", "Bass", 39, "DubSub is a fully featured bass doctor.", airwin2rack::DubSub::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Dubly.h" -int Dubly_unused = AirwinRegistry::registerAirwindow({"Dubly", "Effects", 182, "Dubly is a retro vibe and atmosphere maker.", airwin2rack::Dubly::kNumParameters, []() { return std::make_unique(0); }}); +int Dubly_unused = AirwinRegistry::registerAirwindow({"Dubly", "Effects", 183, "Dubly is a retro vibe and atmosphere maker.", airwin2rack::Dubly::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/DustBunny.h" -int DustBunny_unused = AirwinRegistry::registerAirwindow({"DustBunny", "Lo-Fi", 240, "DustBunny is unpredictable distorty noise, like dust wedged under your turntable needle.", airwin2rack::DustBunny::kNumParameters, []() { return std::make_unique(0); }}); +int DustBunny_unused = AirwinRegistry::registerAirwindow({"DustBunny", "Lo-Fi", 241, "DustBunny is unpredictable distorty noise, like dust wedged under your turntable needle.", airwin2rack::DustBunny::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Dynamics.h" -int Dynamics_unused = AirwinRegistry::registerAirwindow({"Dynamics", "Dynamics", 155, "Dynamics is a combination compressor gate.", airwin2rack::Dynamics::kNumParameters, []() { return std::make_unique(0); }}); +int Dynamics_unused = AirwinRegistry::registerAirwindow({"Dynamics", "Dynamics", 156, "Dynamics is a combination compressor gate.", airwin2rack::Dynamics::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Dyno.h" -int Dyno_unused = AirwinRegistry::registerAirwindow({"Dyno", "Saturation", 275, "Dyno is a lot like Mojo, but for intensity instead of loudness.", airwin2rack::Dyno::kNumParameters, []() { return std::make_unique(0); }}); +int Dyno_unused = AirwinRegistry::registerAirwindow({"Dyno", "Saturation", 276, "Dyno is a lot like Mojo, but for intensity instead of loudness.", airwin2rack::Dyno::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/EQ.h" -int EQ_unused = AirwinRegistry::registerAirwindow({"EQ", "Filter", 216, "EQ is just the EQ parts of CStrip.", airwin2rack::EQ::kNumParameters, []() { return std::make_unique(0); }}); +int EQ_unused = AirwinRegistry::registerAirwindow({"EQ", "Filter", 217, "EQ is just the EQ parts of CStrip.", airwin2rack::EQ::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/EdIsDim.h" -int EdIsDim_unused = AirwinRegistry::registerAirwindow({"EdIsDim", "Utility", 340, "EdIsDim is mid/side conversion utility plugins.", airwin2rack::EdIsDim::kNumParameters, []() { return std::make_unique(0); }}); +int EdIsDim_unused = AirwinRegistry::registerAirwindow({"EdIsDim", "Utility", 341, "EdIsDim is mid/side conversion utility plugins.", airwin2rack::EdIsDim::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Edge.h" int Edge_unused = AirwinRegistry::registerAirwindow({"Edge", "Distortion", 120, "Edge is a seven-stage distortion with Hypersonic filtering and tone shaping controls.", airwin2rack::Edge::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Elation.h" -int Elation_unused = AirwinRegistry::registerAirwindow({"Elation", "Tone Color", 315, "Elation is a re-release of another old Character plugin.", airwin2rack::Elation::kNumParameters, []() { return std::make_unique(0); }}); +int Elation_unused = AirwinRegistry::registerAirwindow({"Elation", "Tone Color", 316, "Elation is a re-release of another old Character plugin.", airwin2rack::Elation::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ElectroHat.h" -int ElectroHat_unused = AirwinRegistry::registerAirwindow({"ElectroHat", "Noise", 246, "ElectroHat is a hi-hat tone generator that uses the original sound as a control voltage.", airwin2rack::ElectroHat::kNumParameters, []() { return std::make_unique(0); }}); +int ElectroHat_unused = AirwinRegistry::registerAirwindow({"ElectroHat", "Noise", 247, "ElectroHat is a hi-hat tone generator that uses the original sound as a control voltage.", airwin2rack::ElectroHat::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Energy.h" -int Energy_unused = AirwinRegistry::registerAirwindow({"Energy", "Effects", 193, "Energy is electrifying fixed-frequency treble boosts.", airwin2rack::Energy::kNumParameters, []() { return std::make_unique(0); }}); +int Energy_unused = AirwinRegistry::registerAirwindow({"Energy", "Effects", 194, "Energy is electrifying fixed-frequency treble boosts.", airwin2rack::Energy::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Energy2.h" -int Energy2_unused = AirwinRegistry::registerAirwindow({"Energy2", "Effects", 192, "Energy2 is electrifying fixed-frequency treble boosts for high sample rate.", airwin2rack::Energy2::kNumParameters, []() { return std::make_unique(0); }}); +int Energy2_unused = AirwinRegistry::registerAirwindow({"Energy2", "Effects", 193, "Energy2 is electrifying fixed-frequency treble boosts for high sample rate.", airwin2rack::Energy2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Ensemble.h" int Ensemble_unused = AirwinRegistry::registerAirwindow({"Ensemble", "Ambience", 24, "Ensemble is a weird flangey little modulation effect.", airwin2rack::Ensemble::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/EveryConsole.h" @@ -287,121 +287,121 @@ int EveryConsole_unused = AirwinRegistry::registerAirwindow({"EveryConsole", "Co #include "autogen_airwin/EverySlew.h" int EverySlew_unused = AirwinRegistry::registerAirwindow({"EverySlew", "Brightness", 57, "EverySlew is a wide variety of unique sound processing tools.", airwin2rack::EverySlew::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/EveryTrim.h" -int EveryTrim_unused = AirwinRegistry::registerAirwindow({"EveryTrim", "Utility", 333, "EveryTrim is Left/Right, Mid/Side, and Master in one plugin.", airwin2rack::EveryTrim::kNumParameters, []() { return std::make_unique(0); }}); +int EveryTrim_unused = AirwinRegistry::registerAirwindow({"EveryTrim", "Utility", 334, "EveryTrim is Left/Right, Mid/Side, and Master in one plugin.", airwin2rack::EveryTrim::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Exciter.h" -int Exciter_unused = AirwinRegistry::registerAirwindow({"Exciter", "Effects", 191, "Exciter is an Aural Exciter plugin that can be both subtle and extreme.", airwin2rack::Exciter::kNumParameters, []() { return std::make_unique(0); }}); +int Exciter_unused = AirwinRegistry::registerAirwindow({"Exciter", "Effects", 192, "Exciter is an Aural Exciter plugin that can be both subtle and extreme.", airwin2rack::Exciter::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Facet.h" -int Facet_unused = AirwinRegistry::registerAirwindow({"Facet", "Effects", 194, "Facet is a new kind of hard clip that adds two sharp corners into the wave.", airwin2rack::Facet::kNumParameters, []() { return std::make_unique(0); }}); +int Facet_unused = AirwinRegistry::registerAirwindow({"Facet", "Effects", 195, "Facet is a new kind of hard clip that adds two sharp corners into the wave.", airwin2rack::Facet::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/FathomFive.h" int FathomFive_unused = AirwinRegistry::registerAirwindow({"FathomFive", "Bass", 42, "FathomFive is a way of supplementing extreme bass that’s not just EQ.", airwin2rack::FathomFive::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/FireAmp.h" int FireAmp_unused = AirwinRegistry::registerAirwindow({"FireAmp", "Amp Sims", 26, "FireAmp is a bright, loud, tubey amp sim for leads and dirt guitar.", airwin2rack::FireAmp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Flipity.h" -int Flipity_unused = AirwinRegistry::registerAirwindow({"Flipity", "Utility", 347, "Flipity is a channel phase flipper/swapper utility.", airwin2rack::Flipity::kNumParameters, []() { return std::make_unique(0); }}); +int Flipity_unused = AirwinRegistry::registerAirwindow({"Flipity", "Utility", 348, "Flipity is a channel phase flipper/swapper utility.", airwin2rack::Flipity::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Floor.h" int Floor_unused = AirwinRegistry::registerAirwindow({"Floor", "Bass", 40, "Floor is fake bottom octave for fun and profit!", airwin2rack::Floor::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Flutter.h" -int Flutter_unused = AirwinRegistry::registerAirwindow({"Flutter", "Lo-Fi", 228, "Flutter is the most recent Airwindows flutter, standalone.", airwin2rack::Flutter::kNumParameters, []() { return std::make_unique(0); }}); +int Flutter_unused = AirwinRegistry::registerAirwindow({"Flutter", "Lo-Fi", 229, "Flutter is the most recent Airwindows flutter, standalone.", airwin2rack::Flutter::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Focus.h" -int Focus_unused = AirwinRegistry::registerAirwindow({"Focus", "Saturation", 273, "Focus brings out clarity by distorting. Aggressive, subtle, flexible.", airwin2rack::Focus::kNumParameters, []() { return std::make_unique(0); }}); +int Focus_unused = AirwinRegistry::registerAirwindow({"Focus", "Saturation", 274, "Focus brings out clarity by distorting. Aggressive, subtle, flexible.", airwin2rack::Focus::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Fracture.h" -int Fracture_unused = AirwinRegistry::registerAirwindow({"Fracture", "Effects", 195, "Fracture is a frequency multiplier/waveshaper with a soft disruption to the sound.", airwin2rack::Fracture::kNumParameters, []() { return std::make_unique(0); }}); +int Fracture_unused = AirwinRegistry::registerAirwindow({"Fracture", "Effects", 196, "Fracture is a frequency multiplier/waveshaper with a soft disruption to the sound.", airwin2rack::Fracture::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Fracture2.h" -int Fracture2_unused = AirwinRegistry::registerAirwindow({"Fracture2", "Effects", 181, "Fracture2 is a wavefolder that allows more extreme disruption.", airwin2rack::Fracture2::kNumParameters, []() { return std::make_unique(0); }}); +int Fracture2_unused = AirwinRegistry::registerAirwindow({"Fracture2", "Effects", 182, "Fracture2 is a wavefolder that allows more extreme disruption.", airwin2rack::Fracture2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/FromTape.h" -int FromTape_unused = AirwinRegistry::registerAirwindow({"FromTape", "Tape", 305, "FromTape is a minimalist, cleaner analog tape emulation.", airwin2rack::FromTape::kNumParameters, []() { return std::make_unique(0); }}); +int FromTape_unused = AirwinRegistry::registerAirwindow({"FromTape", "Tape", 306, "FromTape is a minimalist, cleaner analog tape emulation.", airwin2rack::FromTape::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Galactic.h" -int Galactic_unused = AirwinRegistry::registerAirwindow({"Galactic", "Reverb", 254, "Galactic is a super-reverb designed specially for pads and space ambient.", airwin2rack::Galactic::kNumParameters, []() { return std::make_unique(0); }}); +int Galactic_unused = AirwinRegistry::registerAirwindow({"Galactic", "Reverb", 255, "Galactic is a super-reverb designed specially for pads and space ambient.", airwin2rack::Galactic::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Galactic2.h" -int Galactic2_unused = AirwinRegistry::registerAirwindow({"Galactic2", "Reverb", 255, "Galactic2 is a super-reverb REdesigned specially for pads and space ambient.", airwin2rack::Galactic2::kNumParameters, []() { return std::make_unique(0); }}); +int Galactic2_unused = AirwinRegistry::registerAirwindow({"Galactic2", "Reverb", 256, "Galactic2 is a super-reverb REdesigned specially for pads and space ambient.", airwin2rack::Galactic2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/GalacticVibe.h" -int GalacticVibe_unused = AirwinRegistry::registerAirwindow({"GalacticVibe", "Effects", 180, "GalacticVibe is the stereo vibrato from the original Galactic reverb.", airwin2rack::GalacticVibe::kNumParameters, []() { return std::make_unique(0); }}); +int GalacticVibe_unused = AirwinRegistry::registerAirwindow({"GalacticVibe", "Effects", 181, "GalacticVibe is the stereo vibrato from the original Galactic reverb.", airwin2rack::GalacticVibe::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Gatelope.h" -int Gatelope_unused = AirwinRegistry::registerAirwindow({"Gatelope", "Dynamics", 172, "Gatelope is a special gate that applies filters.", airwin2rack::Gatelope::kNumParameters, []() { return std::make_unique(0); }}); +int Gatelope_unused = AirwinRegistry::registerAirwindow({"Gatelope", "Dynamics", 173, "Gatelope is a special gate that applies filters.", airwin2rack::Gatelope::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/GlitchShifter.h" -int GlitchShifter_unused = AirwinRegistry::registerAirwindow({"GlitchShifter", "Effects", 189, "GlitchShifter is a really gnarly, raw-sounding pitch shifter with a dose of insanity!", airwin2rack::GlitchShifter::kNumParameters, []() { return std::make_unique(0); }}); +int GlitchShifter_unused = AirwinRegistry::registerAirwindow({"GlitchShifter", "Effects", 190, "GlitchShifter is a really gnarly, raw-sounding pitch shifter with a dose of insanity!", airwin2rack::GlitchShifter::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/GoldenSlew.h" int GoldenSlew_unused = AirwinRegistry::registerAirwindow({"GoldenSlew", "Brightness", 51, "GoldenSlew is a multistage slew clipper based on the Golden Ratio.", airwin2rack::GoldenSlew::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Golem.h" -int Golem_unused = AirwinRegistry::registerAirwindow({"Golem", "Utility", 338, "Golem lets you blend a stereo track of two mics on an amp.", airwin2rack::Golem::kNumParameters, []() { return std::make_unique(0); }}); +int Golem_unused = AirwinRegistry::registerAirwindow({"Golem", "Utility", 339, "Golem lets you blend a stereo track of two mics on an amp.", airwin2rack::Golem::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/GrindAmp.h" int GrindAmp_unused = AirwinRegistry::registerAirwindow({"GrindAmp", "Amp Sims", 25, "GrindAmp is a heavier amp sim for many purposes.", airwin2rack::GrindAmp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Gringer.h" -int Gringer_unused = AirwinRegistry::registerAirwindow({"Gringer", "Effects", 190, "Gringer is a full-wave rectifier plugin, like a Green Ringer guitar effect.", airwin2rack::Gringer::kNumParameters, []() { return std::make_unique(0); }}); +int Gringer_unused = AirwinRegistry::registerAirwindow({"Gringer", "Effects", 191, "Gringer is a full-wave rectifier plugin, like a Green Ringer guitar effect.", airwin2rack::Gringer::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/GrooveWear.h" -int GrooveWear_unused = AirwinRegistry::registerAirwindow({"GrooveWear", "Lo-Fi", 230, "GrooveWear is for scrubbing highs off mechanically like a stylus would.", airwin2rack::GrooveWear::kNumParameters, []() { return std::make_unique(0); }}); +int GrooveWear_unused = AirwinRegistry::registerAirwindow({"GrooveWear", "Lo-Fi", 231, "GrooveWear is for scrubbing highs off mechanically like a stylus would.", airwin2rack::GrooveWear::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/GuitarConditioner.h" -int GuitarConditioner_unused = AirwinRegistry::registerAirwindow({"GuitarConditioner", "Effects", 185, "GuitarConditioner is like a Tube Screamer voicing without the squishiness and indistinctness.", airwin2rack::GuitarConditioner::kNumParameters, []() { return std::make_unique(0); }}); +int GuitarConditioner_unused = AirwinRegistry::registerAirwindow({"GuitarConditioner", "Effects", 186, "GuitarConditioner is like a Tube Screamer voicing without the squishiness and indistinctness.", airwin2rack::GuitarConditioner::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/HardVacuum.h" -int HardVacuum_unused = AirwinRegistry::registerAirwindow({"HardVacuum", "Distortion", 127, "HardVacuum is tube style saturation effects.", airwin2rack::HardVacuum::kNumParameters, []() { return std::make_unique(0); }}); +int HardVacuum_unused = AirwinRegistry::registerAirwindow({"HardVacuum", "Distortion", 128, "HardVacuum is tube style saturation effects.", airwin2rack::HardVacuum::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/HermeTrim.h" -int HermeTrim_unused = AirwinRegistry::registerAirwindow({"HermeTrim", "Utility", 334, "HermeTrim is Very Fine Adjustments, otherwise just like EveryTrim.", airwin2rack::HermeTrim::kNumParameters, []() { return std::make_unique(0); }}); +int HermeTrim_unused = AirwinRegistry::registerAirwindow({"HermeTrim", "Utility", 335, "HermeTrim is Very Fine Adjustments, otherwise just like EveryTrim.", airwin2rack::HermeTrim::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Hermepass.h" int Hermepass_unused = AirwinRegistry::registerAirwindow({"Hermepass", "Bass", 36, "Hermepass is a mastering highpass to set by ear only.", airwin2rack::Hermepass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/HighGlossDither.h" -int HighGlossDither_unused = AirwinRegistry::registerAirwindow({"HighGlossDither", "Dithers", 151, "HighGlossDither is a hybrid between shiny dither and truncation! Unnatural science experiment.", airwin2rack::HighGlossDither::kNumParameters, []() { return std::make_unique(0); }}); +int HighGlossDither_unused = AirwinRegistry::registerAirwindow({"HighGlossDither", "Dithers", 152, "HighGlossDither is a hybrid between shiny dither and truncation! Unnatural science experiment.", airwin2rack::HighGlossDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/HighImpact.h" -int HighImpact_unused = AirwinRegistry::registerAirwindow({"HighImpact", "Distortion", 128, "HighImpact is distorted grit and punch without fatness.", airwin2rack::HighImpact::kNumParameters, []() { return std::make_unique(0); }}); +int HighImpact_unused = AirwinRegistry::registerAirwindow({"HighImpact", "Distortion", 129, "HighImpact is distorted grit and punch without fatness.", airwin2rack::HighImpact::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Highpass.h" -int Highpass_unused = AirwinRegistry::registerAirwindow({"Highpass", "Filter", 226, "Highpass is a time warp, for retro midrangey sounds.", airwin2rack::Highpass::kNumParameters, []() { return std::make_unique(0); }}); +int Highpass_unused = AirwinRegistry::registerAirwindow({"Highpass", "Filter", 227, "Highpass is a time warp, for retro midrangey sounds.", airwin2rack::Highpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Highpass2.h" -int Highpass2_unused = AirwinRegistry::registerAirwindow({"Highpass2", "Filter", 222, "Highpass2 is an unusual-sounding variable-slope highpass filter.", airwin2rack::Highpass2::kNumParameters, []() { return std::make_unique(0); }}); +int Highpass2_unused = AirwinRegistry::registerAirwindow({"Highpass2", "Filter", 223, "Highpass2 is an unusual-sounding variable-slope highpass filter.", airwin2rack::Highpass2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Holt.h" -int Holt_unused = AirwinRegistry::registerAirwindow({"Holt", "Filter", 209, "Holt is a synth-like resonant lowpass filter focussed on bass frequencies.", airwin2rack::Holt::kNumParameters, []() { return std::make_unique(0); }}); +int Holt_unused = AirwinRegistry::registerAirwindow({"Holt", "Filter", 210, "Holt is a synth-like resonant lowpass filter focussed on bass frequencies.", airwin2rack::Holt::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Holt2.h" -int Holt2_unused = AirwinRegistry::registerAirwindow({"Holt2", "Filter", 208, "Holt2 is a bass-cab-like resonant lowpass filter.", airwin2rack::Holt2::kNumParameters, []() { return std::make_unique(0); }}); +int Holt2_unused = AirwinRegistry::registerAirwindow({"Holt2", "Filter", 209, "Holt2 is a bass-cab-like resonant lowpass filter.", airwin2rack::Holt2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Hombre.h" int Hombre_unused = AirwinRegistry::registerAirwindow({"Hombre", "Ambience", 17, "Hombre is atmosphere and texture (through very short delays).", airwin2rack::Hombre::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Huge.h" -int Huge_unused = AirwinRegistry::registerAirwindow({"Huge", "Saturation", 267, "Huge is a dirty, dirty loudenator.", airwin2rack::Huge::kNumParameters, []() { return std::make_unique(0); }}); +int Huge_unused = AirwinRegistry::registerAirwindow({"Huge", "Saturation", 268, "Huge is a dirty, dirty loudenator.", airwin2rack::Huge::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Hull.h" -int Hull_unused = AirwinRegistry::registerAirwindow({"Hull", "Filter", 215, "Hull is an alternate form of highpass/lowpass filter.", airwin2rack::Hull::kNumParameters, []() { return std::make_unique(0); }}); +int Hull_unused = AirwinRegistry::registerAirwindow({"Hull", "Filter", 216, "Hull is an alternate form of highpass/lowpass filter.", airwin2rack::Hull::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Hull2.h" int Hull2_unused = AirwinRegistry::registerAirwindow({"Hull2", "Unclassified", -1, "", airwin2rack::Hull2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Hype.h" -int Hype_unused = AirwinRegistry::registerAirwindow({"Hype", "Subtlety", 289, "Hype is a treble softening experiment gone strangely awry :)", airwin2rack::Hype::kNumParameters, []() { return std::make_unique(0); }}); +int Hype_unused = AirwinRegistry::registerAirwindow({"Hype", "Subtlety", 290, "Hype is a treble softening experiment gone strangely awry :)", airwin2rack::Hype::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/HypersonX.h" int HypersonX_unused = AirwinRegistry::registerAirwindow({"HypersonX", "Brightness", 67, "HypersonX is like UltrasonX but with seven stages instead of five.", airwin2rack::HypersonX::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Hypersonic.h" int Hypersonic_unused = AirwinRegistry::registerAirwindow({"Hypersonic", "Brightness", 66, "Hypersonic is Ultrasonic, but steeper and higher cutoff.", airwin2rack::Hypersonic::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Infinity.h" -int Infinity_unused = AirwinRegistry::registerAirwindow({"Infinity", "Reverb", 262, "Infinity is a MatrixVerb specifically designed to sustain and layer sounds forever.", airwin2rack::Infinity::kNumParameters, []() { return std::make_unique(0); }}); +int Infinity_unused = AirwinRegistry::registerAirwindow({"Infinity", "Reverb", 263, "Infinity is a MatrixVerb specifically designed to sustain and layer sounds forever.", airwin2rack::Infinity::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Infinity2.h" -int Infinity2_unused = AirwinRegistry::registerAirwindow({"Infinity2", "Reverb", 260, "Infinity2 expands Infinity with more tone shaping and a much-requested kill-switch!", airwin2rack::Infinity2::kNumParameters, []() { return std::make_unique(0); }}); +int Infinity2_unused = AirwinRegistry::registerAirwindow({"Infinity2", "Reverb", 261, "Infinity2 expands Infinity with more tone shaping and a much-requested kill-switch!", airwin2rack::Infinity2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Inflamer.h" -int Inflamer_unused = AirwinRegistry::registerAirwindow({"Inflamer", "Subtlety", 291, "Inflamer is an Airwindowsized take on the waveshapers in Oxford Inflator.", airwin2rack::Inflamer::kNumParameters, []() { return std::make_unique(0); }}); +int Inflamer_unused = AirwinRegistry::registerAirwindow({"Inflamer", "Subtlety", 292, "Inflamer is an Airwindowsized take on the waveshapers in Oxford Inflator.", airwin2rack::Inflamer::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Infrasonic.h" int Infrasonic_unused = AirwinRegistry::registerAirwindow({"Infrasonic", "Bass", 41, "Infrasonic is a very steep subsonic filter, built like Ultrasonic.", airwin2rack::Infrasonic::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Interstage.h" -int Interstage_unused = AirwinRegistry::registerAirwindow({"Interstage", "Subtlety", 296, "Interstage is a subtle and sophisticated analogifier.", airwin2rack::Interstage::kNumParameters, []() { return std::make_unique(0); }}); +int Interstage_unused = AirwinRegistry::registerAirwindow({"Interstage", "Subtlety", 297, "Interstage is a subtle and sophisticated analogifier.", airwin2rack::Interstage::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/IronOxide5.h" -int IronOxide5_unused = AirwinRegistry::registerAirwindow({"IronOxide5", "Tape", 308, "IronOxide5 is the old school, heavily colored Airwindows tape emulation.", airwin2rack::IronOxide5::kNumParameters, []() { return std::make_unique(0); }}); +int IronOxide5_unused = AirwinRegistry::registerAirwindow({"IronOxide5", "Tape", 309, "IronOxide5 is the old school, heavily colored Airwindows tape emulation.", airwin2rack::IronOxide5::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/IronOxideClassic.h" -int IronOxideClassic_unused = AirwinRegistry::registerAirwindow({"IronOxideClassic", "Tape", 310, "IronOxideClassic is the purer, simpler, early form of Iron Oxide before all the features.", airwin2rack::IronOxideClassic::kNumParameters, []() { return std::make_unique(0); }}); +int IronOxideClassic_unused = AirwinRegistry::registerAirwindow({"IronOxideClassic", "Tape", 311, "IronOxideClassic is the purer, simpler, early form of Iron Oxide before all the features.", airwin2rack::IronOxideClassic::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/IronOxideClassic2.h" -int IronOxideClassic2_unused = AirwinRegistry::registerAirwindow({"IronOxideClassic2", "Tape", 307, "IronOxideClassic2 is my bandpassy tape sim, updated for high sample rate and aliasing control.", airwin2rack::IronOxideClassic2::kNumParameters, []() { return std::make_unique(0); }}); +int IronOxideClassic2_unused = AirwinRegistry::registerAirwindow({"IronOxideClassic2", "Tape", 308, "IronOxideClassic2 is my bandpassy tape sim, updated for high sample rate and aliasing control.", airwin2rack::IronOxideClassic2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Isolator.h" -int Isolator_unused = AirwinRegistry::registerAirwindow({"Isolator", "Filter", 218, "Isolator is a steep highpass or lowpass filter, like you might find in a speaker crossover.", airwin2rack::Isolator::kNumParameters, []() { return std::make_unique(0); }}); +int Isolator_unused = AirwinRegistry::registerAirwindow({"Isolator", "Filter", 219, "Isolator is a steep highpass or lowpass filter, like you might find in a speaker crossover.", airwin2rack::Isolator::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Isolator2.h" -int Isolator2_unused = AirwinRegistry::registerAirwindow({"Isolator2", "Filter", 207, "Isolator2 is Isolator, but with control smoothing and a new resonance booster.", airwin2rack::Isolator2::kNumParameters, []() { return std::make_unique(0); }}); +int Isolator2_unused = AirwinRegistry::registerAirwindow({"Isolator2", "Filter", 208, "Isolator2 is Isolator, but with control smoothing and a new resonance booster.", airwin2rack::Isolator2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/LRFlipTimer.h" -int LRFlipTimer_unused = AirwinRegistry::registerAirwindow({"LRFlipTimer", "Stereo", 286, "LRFlipTimer is a utility that swaps Left with Right every few (1-10) minutes.", airwin2rack::LRFlipTimer::kNumParameters, []() { return std::make_unique(0); }}); +int LRFlipTimer_unused = AirwinRegistry::registerAirwindow({"LRFlipTimer", "Stereo", 287, "LRFlipTimer is a utility that swaps Left with Right every few (1-10) minutes.", airwin2rack::LRFlipTimer::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/LeadAmp.h" int LeadAmp_unused = AirwinRegistry::registerAirwindow({"LeadAmp", "Amp Sims", 27, "LeadAmp is an amp sim with a clear, penetrating, vocal tone.", airwin2rack::LeadAmp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/LeftoMono.h" -int LeftoMono_unused = AirwinRegistry::registerAirwindow({"LeftoMono", "Utility", 345, "LeftoMono copies one channel to both, losslessly.", airwin2rack::LeftoMono::kNumParameters, []() { return std::make_unique(0); }}); +int LeftoMono_unused = AirwinRegistry::registerAirwindow({"LeftoMono", "Utility", 346, "LeftoMono copies one channel to both, losslessly.", airwin2rack::LeftoMono::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/LilAmp.h" int LilAmp_unused = AirwinRegistry::registerAirwindow({"LilAmp", "Amp Sims", 29, "LilAmp is a tiny amp sim, like a little bitty practice amp without that much gain.", airwin2rack::LilAmp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Logical4.h" -int Logical4_unused = AirwinRegistry::registerAirwindow({"Logical4", "Dynamics", 158, "Logical4 is a classic 2-buss compressor.", airwin2rack::Logical4::kNumParameters, []() { return std::make_unique(0); }}); +int Logical4_unused = AirwinRegistry::registerAirwindow({"Logical4", "Dynamics", 159, "Logical4 is a classic 2-buss compressor.", airwin2rack::Logical4::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Loud.h" -int Loud_unused = AirwinRegistry::registerAirwindow({"Loud", "Distortion", 126, "Loud is distortion and demolition of air molecules, modeled.", airwin2rack::Loud::kNumParameters, []() { return std::make_unique(0); }}); +int Loud_unused = AirwinRegistry::registerAirwindow({"Loud", "Distortion", 127, "Loud is distortion and demolition of air molecules, modeled.", airwin2rack::Loud::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Lowpass.h" -int Lowpass_unused = AirwinRegistry::registerAirwindow({"Lowpass", "Filter", 225, "Lowpass deepens the tone, leaves a gloss and textural modifications.", airwin2rack::Lowpass::kNumParameters, []() { return std::make_unique(0); }}); +int Lowpass_unused = AirwinRegistry::registerAirwindow({"Lowpass", "Filter", 226, "Lowpass deepens the tone, leaves a gloss and textural modifications.", airwin2rack::Lowpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Lowpass2.h" -int Lowpass2_unused = AirwinRegistry::registerAirwindow({"Lowpass2", "Filter", 221, "Lowpass2 is an unusual-sounding variable-slope lowpass filter.", airwin2rack::Lowpass2::kNumParameters, []() { return std::make_unique(0); }}); +int Lowpass2_unused = AirwinRegistry::registerAirwindow({"Lowpass2", "Filter", 222, "Lowpass2 is an unusual-sounding variable-slope lowpass filter.", airwin2rack::Lowpass2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Luxor.h" -int Luxor_unused = AirwinRegistry::registerAirwindow({"Luxor", "Tone Color", 320, "Luxor is a re-release of another old Character plugin.", airwin2rack::Luxor::kNumParameters, []() { return std::make_unique(0); }}); +int Luxor_unused = AirwinRegistry::registerAirwindow({"Luxor", "Tone Color", 321, "Luxor is a re-release of another old Character plugin.", airwin2rack::Luxor::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MSFlipTimer.h" int MSFlipTimer_unused = AirwinRegistry::registerAirwindow({"MSFlipTimer", "Unclassified", -1, "", airwin2rack::MSFlipTimer::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MV.h" @@ -409,47 +409,47 @@ int MV_unused = AirwinRegistry::registerAirwindow({"MV", "Ambience", 9, "MV is a #include "autogen_airwin/MV2.h" int MV2_unused = AirwinRegistry::registerAirwindow({"MV2", "Ambience", 8, "MV2 is a dual-mono reverb based on BitShiftGain and the old Midiverbs, adapted to high sample rates.", airwin2rack::MV2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MackEQ.h" -int MackEQ_unused = AirwinRegistry::registerAirwindow({"MackEQ", "Filter", 213, "MackEQ is the Mackie distortion but with treble and bass controls added.", airwin2rack::MackEQ::kNumParameters, []() { return std::make_unique(0); }}); +int MackEQ_unused = AirwinRegistry::registerAirwindow({"MackEQ", "Filter", 214, "MackEQ is the Mackie distortion but with treble and bass controls added.", airwin2rack::MackEQ::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Mackity.h" int Mackity_unused = AirwinRegistry::registerAirwindow({"Mackity", "Distortion", 122, "Mackity is an emulation of the input stage of a vintage Mackie 1202!", airwin2rack::Mackity::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MatrixVerb.h" -int MatrixVerb_unused = AirwinRegistry::registerAirwindow({"MatrixVerb", "Reverb", 263, "MatrixVerb is a wildly adjustable, strangely colorful reverb for deep and flexible spaces.", airwin2rack::MatrixVerb::kNumParameters, []() { return std::make_unique(0); }}); +int MatrixVerb_unused = AirwinRegistry::registerAirwindow({"MatrixVerb", "Reverb", 264, "MatrixVerb is a wildly adjustable, strangely colorful reverb for deep and flexible spaces.", airwin2rack::MatrixVerb::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Melt.h" int Melt_unused = AirwinRegistry::registerAirwindow({"Melt", "Ambience", 7, "Melt is a wobbly chorusy weird diffuse effect.", airwin2rack::Melt::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MidAmp.h" int MidAmp_unused = AirwinRegistry::registerAirwindow({"MidAmp", "Amp Sims", 30, "MidAmp is a clean amp sim meant to work like a loud Twin or something of that nature.", airwin2rack::MidAmp::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MidSide.h" -int MidSide_unused = AirwinRegistry::registerAirwindow({"MidSide", "Utility", 341, "MidSide is the other side of the EdIsDim mid/side conversion utility plugin.", airwin2rack::MidSide::kNumParameters, []() { return std::make_unique(0); }}); +int MidSide_unused = AirwinRegistry::registerAirwindow({"MidSide", "Utility", 342, "MidSide is the other side of the EdIsDim mid/side conversion utility plugin.", airwin2rack::MidSide::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MoNoam.h" -int MoNoam_unused = AirwinRegistry::registerAirwindow({"MoNoam", "Utility", 348, "MoNoam gives you variations on mono, mid, and side in different channels.", airwin2rack::MoNoam::kNumParameters, []() { return std::make_unique(0); }}); +int MoNoam_unused = AirwinRegistry::registerAirwindow({"MoNoam", "Utility", 349, "MoNoam gives you variations on mono, mid, and side in different channels.", airwin2rack::MoNoam::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Mojo.h" -int Mojo_unused = AirwinRegistry::registerAirwindow({"Mojo", "Saturation", 274, "Mojo is a biggenator that also works as a loudenator.", airwin2rack::Mojo::kNumParameters, []() { return std::make_unique(0); }}); +int Mojo_unused = AirwinRegistry::registerAirwindow({"Mojo", "Saturation", 275, "Mojo is a biggenator that also works as a loudenator.", airwin2rack::Mojo::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Monitoring.h" -int Monitoring_unused = AirwinRegistry::registerAirwindow({"Monitoring", "Utility", 328, "Monitoring is your one-stop shop for final 2-buss work!", airwin2rack::Monitoring::kNumParameters, []() { return std::make_unique(0); }}); +int Monitoring_unused = AirwinRegistry::registerAirwindow({"Monitoring", "Utility", 329, "Monitoring is your one-stop shop for final 2-buss work!", airwin2rack::Monitoring::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Monitoring2.h" -int Monitoring2_unused = AirwinRegistry::registerAirwindow({"Monitoring2", "Utility", 327, "Monitoring2 is Monitoring, but with Dark as the wordlength reducer.", airwin2rack::Monitoring2::kNumParameters, []() { return std::make_unique(0); }}); +int Monitoring2_unused = AirwinRegistry::registerAirwindow({"Monitoring2", "Utility", 328, "Monitoring2 is Monitoring, but with Dark as the wordlength reducer.", airwin2rack::Monitoring2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Monitoring3.h" -int Monitoring3_unused = AirwinRegistry::registerAirwindow({"Monitoring3", "Utility", 326, "Monitoring3 is Monitoring, but with Ten Nines into Dark as the wordlength reducer.", airwin2rack::Monitoring3::kNumParameters, []() { return std::make_unique(0); }}); +int Monitoring3_unused = AirwinRegistry::registerAirwindow({"Monitoring3", "Utility", 327, "Monitoring3 is Monitoring, but with Ten Nines into Dark as the wordlength reducer.", airwin2rack::Monitoring3::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MultiBandDistortion.h" -int MultiBandDistortion_unused = AirwinRegistry::registerAirwindow({"MultiBandDistortion", "Distortion", 129, "MultiBandDistortion is an old weird gnarly sound wrecker :)", airwin2rack::MultiBandDistortion::kNumParameters, []() { return std::make_unique(0); }}); +int MultiBandDistortion_unused = AirwinRegistry::registerAirwindow({"MultiBandDistortion", "Distortion", 130, "MultiBandDistortion is an old weird gnarly sound wrecker :)", airwin2rack::MultiBandDistortion::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/NCSeventeen.h" -int NCSeventeen_unused = AirwinRegistry::registerAirwindow({"NCSeventeen", "Saturation", 268, "NCSeventeen is Dirty Loud!", airwin2rack::NCSeventeen::kNumParameters, []() { return std::make_unique(0); }}); +int NCSeventeen_unused = AirwinRegistry::registerAirwindow({"NCSeventeen", "Saturation", 269, "NCSeventeen is Dirty Loud!", airwin2rack::NCSeventeen::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/NaturalizeDither.h" -int NaturalizeDither_unused = AirwinRegistry::registerAirwindow({"NaturalizeDither", "Dithers", 150, "NaturalizeDither is deterministic dither that uses Benford Realness calculations for each sample.", airwin2rack::NaturalizeDither::kNumParameters, []() { return std::make_unique(0); }}); +int NaturalizeDither_unused = AirwinRegistry::registerAirwindow({"NaturalizeDither", "Dithers", 151, "NaturalizeDither is deterministic dither that uses Benford Realness calculations for each sample.", airwin2rack::NaturalizeDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Neverland.h" -int Neverland_unused = AirwinRegistry::registerAirwindow({"Neverland", "Tone Color", 314, "Neverland is a re-release of my old Neve-style color adder, exacly as it was.", airwin2rack::Neverland::kNumParameters, []() { return std::make_unique(0); }}); +int Neverland_unused = AirwinRegistry::registerAirwindow({"Neverland", "Tone Color", 315, "Neverland is a re-release of my old Neve-style color adder, exacly as it was.", airwin2rack::Neverland::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Nikola.h" -int Nikola_unused = AirwinRegistry::registerAirwindow({"Nikola", "Effects", 199, "Nikola is an Audio Tesla Coil plugin! Note: audio tesla coils don't sound nice.", airwin2rack::Nikola::kNumParameters, []() { return std::make_unique(0); }}); +int Nikola_unused = AirwinRegistry::registerAirwindow({"Nikola", "Effects", 200, "Nikola is an Audio Tesla Coil plugin! Note: audio tesla coils don't sound nice.", airwin2rack::Nikola::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/NodeDither.h" -int NodeDither_unused = AirwinRegistry::registerAirwindow({"NodeDither", "Dithers", 144, "NodeDither is adjusta-TPDF-dither, like a dither flanger. Can do Paul and Tape settings.", airwin2rack::NodeDither::kNumParameters, []() { return std::make_unique(0); }}); +int NodeDither_unused = AirwinRegistry::registerAirwindow({"NodeDither", "Dithers", 145, "NodeDither is adjusta-TPDF-dither, like a dither flanger. Can do Paul and Tape settings.", airwin2rack::NodeDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Noise.h" -int Noise_unused = AirwinRegistry::registerAirwindow({"Noise", "Noise", 241, "Noise is the Airwindows deep noise oscillator, as a sound reinforcer.", airwin2rack::Noise::kNumParameters, []() { return std::make_unique(0); }}); +int Noise_unused = AirwinRegistry::registerAirwindow({"Noise", "Noise", 242, "Noise is the Airwindows deep noise oscillator, as a sound reinforcer.", airwin2rack::Noise::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/NonlinearSpace.h" -int NonlinearSpace_unused = AirwinRegistry::registerAirwindow({"NonlinearSpace", "Reverb", 261, "NonlinearSpace is a flexible reverb plugin.", airwin2rack::NonlinearSpace::kNumParameters, []() { return std::make_unique(0); }}); +int NonlinearSpace_unused = AirwinRegistry::registerAirwindow({"NonlinearSpace", "Reverb", 262, "NonlinearSpace is a flexible reverb plugin.", airwin2rack::NonlinearSpace::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/NotJustAnotherCD.h" -int NotJustAnotherCD_unused = AirwinRegistry::registerAirwindow({"NotJustAnotherCD", "Dithers", 136, "NotJustAnotherCD is a next-gen wordlength reducers for 16 bit with DeRez.", airwin2rack::NotJustAnotherCD::kNumParameters, []() { return std::make_unique(0); }}); +int NotJustAnotherCD_unused = AirwinRegistry::registerAirwindow({"NotJustAnotherCD", "Dithers", 137, "NotJustAnotherCD is a next-gen wordlength reducers for 16 bit with DeRez.", airwin2rack::NotJustAnotherCD::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/NotJustAnotherDither.h" -int NotJustAnotherDither_unused = AirwinRegistry::registerAirwindow({"NotJustAnotherDither", "Dithers", 135, "NotJustAnotherDither is a next-gen wordlength reducers for 24 bit with DeRez.", airwin2rack::NotJustAnotherDither::kNumParameters, []() { return std::make_unique(0); }}); +int NotJustAnotherDither_unused = AirwinRegistry::registerAirwindow({"NotJustAnotherDither", "Dithers", 136, "NotJustAnotherDither is a next-gen wordlength reducers for 24 bit with DeRez.", airwin2rack::NotJustAnotherDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/OneCornerClip.h" int OneCornerClip_unused = AirwinRegistry::registerAirwindow({"OneCornerClip", "Clipping", 74, "OneCornerClip is an ultimate full-bandwidth clipper.", airwin2rack::OneCornerClip::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/OrbitKick.h" @@ -463,51 +463,51 @@ int PDChannel_unused = AirwinRegistry::registerAirwindow({"PDChannel", "Consoles #include "autogen_airwin/Pafnuty.h" int Pafnuty_unused = AirwinRegistry::registerAirwindow({"Pafnuty", "Unclassified", -1, "Pafnuty is a Chebyshev filter, that adds harmonics.", airwin2rack::Pafnuty::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pafnuty2.h" -int Pafnuty2_unused = AirwinRegistry::registerAirwindow({"Pafnuty2", "Effects", 183, "Pafnuty2 is a Chebyshev filter, that adds harmonics, and fits in the VCV Rack port.", airwin2rack::Pafnuty2::kNumParameters, []() { return std::make_unique(0); }}); +int Pafnuty2_unused = AirwinRegistry::registerAirwindow({"Pafnuty2", "Effects", 184, "Pafnuty2 is a Chebyshev filter, that adds harmonics, and fits in the VCV Rack port.", airwin2rack::Pafnuty2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PaulDither.h" -int PaulDither_unused = AirwinRegistry::registerAirwindow({"PaulDither", "Dithers", 132, "PaulDither is a highpassed TPDF dither. (quieter, airier)", airwin2rack::PaulDither::kNumParameters, []() { return std::make_unique(0); }}); +int PaulDither_unused = AirwinRegistry::registerAirwindow({"PaulDither", "Dithers", 133, "PaulDither is a highpassed TPDF dither. (quieter, airier)", airwin2rack::PaulDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PaulWide.h" -int PaulWide_unused = AirwinRegistry::registerAirwindow({"PaulWide", "Dithers", 131, "PaulWide is a highpassed TPDF wide dither. (quieter, airier AND wider)", airwin2rack::PaulWide::kNumParameters, []() { return std::make_unique(0); }}); +int PaulWide_unused = AirwinRegistry::registerAirwindow({"PaulWide", "Dithers", 132, "PaulWide is a highpassed TPDF wide dither. (quieter, airier AND wider)", airwin2rack::PaulWide::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PeaksOnly.h" -int PeaksOnly_unused = AirwinRegistry::registerAirwindow({"PeaksOnly", "Utility", 337, "PeaksOnly is a transformative mix check tool.", airwin2rack::PeaksOnly::kNumParameters, []() { return std::make_unique(0); }}); +int PeaksOnly_unused = AirwinRegistry::registerAirwindow({"PeaksOnly", "Utility", 338, "PeaksOnly is a transformative mix check tool.", airwin2rack::PeaksOnly::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pear.h" -int Pear_unused = AirwinRegistry::registerAirwindow({"Pear", "Filter", 202, "Pear is the testbed for a new filter, implemented as a highpass/lowpass shelf.", airwin2rack::Pear::kNumParameters, []() { return std::make_unique(0); }}); +int Pear_unused = AirwinRegistry::registerAirwindow({"Pear", "Filter", 203, "Pear is the testbed for a new filter, implemented as a highpass/lowpass shelf.", airwin2rack::Pear::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PhaseNudge.h" -int PhaseNudge_unused = AirwinRegistry::registerAirwindow({"PhaseNudge", "Subtlety", 297, "PhaseNudge is a phase rotator/allpass filter.", airwin2rack::PhaseNudge::kNumParameters, []() { return std::make_unique(0); }}); +int PhaseNudge_unused = AirwinRegistry::registerAirwindow({"PhaseNudge", "Subtlety", 298, "PhaseNudge is a phase rotator/allpass filter.", airwin2rack::PhaseNudge::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PitchDelay.h" int PitchDelay_unused = AirwinRegistry::registerAirwindow({"PitchDelay", "Ambience", 3, "PitchDelay is TapeDelay2 but with pitch shift instead of flutter.", airwin2rack::PitchDelay::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PitchNasty.h" -int PitchNasty_unused = AirwinRegistry::registerAirwindow({"PitchNasty", "Effects", 184, "PitchNasty is a primitive pitch shifter that also has primitive time-stretch artifacts.", airwin2rack::PitchNasty::kNumParameters, []() { return std::make_unique(0); }}); +int PitchNasty_unused = AirwinRegistry::registerAirwindow({"PitchNasty", "Effects", 185, "PitchNasty is a primitive pitch shifter that also has primitive time-stretch artifacts.", airwin2rack::PitchNasty::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PlatinumSlew.h" int PlatinumSlew_unused = AirwinRegistry::registerAirwindow({"PlatinumSlew", "Brightness", 49, "PlatinumSlew is the best easy-to-use slew clipper.", airwin2rack::PlatinumSlew::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PocketVerbs.h" -int PocketVerbs_unused = AirwinRegistry::registerAirwindow({"PocketVerbs", "Reverb", 264, "PocketVerbs is my popular old special effects reverbs plugin!", airwin2rack::PocketVerbs::kNumParameters, []() { return std::make_unique(0); }}); +int PocketVerbs_unused = AirwinRegistry::registerAirwindow({"PocketVerbs", "Reverb", 265, "PocketVerbs is my popular old special effects reverbs plugin!", airwin2rack::PocketVerbs::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pockey.h" -int Pockey_unused = AirwinRegistry::registerAirwindow({"Pockey", "Lo-Fi", 231, "Pockey is 12 bit (and under) lo-fi hiphop in a plugin.", airwin2rack::Pockey::kNumParameters, []() { return std::make_unique(0); }}); +int Pockey_unused = AirwinRegistry::registerAirwindow({"Pockey", "Lo-Fi", 232, "Pockey is 12 bit (and under) lo-fi hiphop in a plugin.", airwin2rack::Pockey::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pockey2.h" -int Pockey2_unused = AirwinRegistry::registerAirwindow({"Pockey2", "Lo-Fi", 227, "Pockey2 is more efficient, more intense lo-fi hiphop in a plugin.", airwin2rack::Pockey2::kNumParameters, []() { return std::make_unique(0); }}); +int Pockey2_unused = AirwinRegistry::registerAirwindow({"Pockey2", "Lo-Fi", 228, "Pockey2 is more efficient, more intense lo-fi hiphop in a plugin.", airwin2rack::Pockey2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Podcast.h" -int Podcast_unused = AirwinRegistry::registerAirwindow({"Podcast", "Dynamics", 174, "Podcast is a simpler pile of curve-style compressors with hard clipping.", airwin2rack::Podcast::kNumParameters, []() { return std::make_unique(0); }}); +int Podcast_unused = AirwinRegistry::registerAirwindow({"Podcast", "Dynamics", 175, "Podcast is a simpler pile of curve-style compressors with hard clipping.", airwin2rack::Podcast::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PodcastDeluxe.h" -int PodcastDeluxe_unused = AirwinRegistry::registerAirwindow({"PodcastDeluxe", "Dynamics", 173, "PodcastDeluxe is a pile of compressors (curve style) and phase rotators.", airwin2rack::PodcastDeluxe::kNumParameters, []() { return std::make_unique(0); }}); +int PodcastDeluxe_unused = AirwinRegistry::registerAirwindow({"PodcastDeluxe", "Dynamics", 174, "PodcastDeluxe is a pile of compressors (curve style) and phase rotators.", airwin2rack::PodcastDeluxe::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Point.h" -int Point_unused = AirwinRegistry::registerAirwindow({"Point", "Dynamics", 171, "Point is an explosive transient designer.", airwin2rack::Point::kNumParameters, []() { return std::make_unique(0); }}); +int Point_unused = AirwinRegistry::registerAirwindow({"Point", "Dynamics", 172, "Point is an explosive transient designer.", airwin2rack::Point::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pop.h" -int Pop_unused = AirwinRegistry::registerAirwindow({"Pop", "Dynamics", 156, "Pop is a crazy overcompressor with a very exaggerated sound.", airwin2rack::Pop::kNumParameters, []() { return std::make_unique(0); }}); +int Pop_unused = AirwinRegistry::registerAirwindow({"Pop", "Dynamics", 157, "Pop is a crazy overcompressor with a very exaggerated sound.", airwin2rack::Pop::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pop2.h" -int Pop2_unused = AirwinRegistry::registerAirwindow({"Pop2", "Dynamics", 153, "Pop2 adds control and punch to Pop.", airwin2rack::Pop2::kNumParameters, []() { return std::make_unique(0); }}); +int Pop2_unused = AirwinRegistry::registerAirwindow({"Pop2", "Dynamics", 154, "Pop2 adds control and punch to Pop.", airwin2rack::Pop2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PowerSag.h" -int PowerSag_unused = AirwinRegistry::registerAirwindow({"PowerSag", "Effects", 197, "PowerSag is for emulating power supply limitations in analog modeling.", airwin2rack::PowerSag::kNumParameters, []() { return std::make_unique(0); }}); +int PowerSag_unused = AirwinRegistry::registerAirwindow({"PowerSag", "Effects", 198, "PowerSag is for emulating power supply limitations in analog modeling.", airwin2rack::PowerSag::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PowerSag2.h" -int PowerSag2_unused = AirwinRegistry::registerAirwindow({"PowerSag2", "Effects", 196, "PowerSag2 is my improved circuit-starve plugin, now with inverse effect!", airwin2rack::PowerSag2::kNumParameters, []() { return std::make_unique(0); }}); +int PowerSag2_unused = AirwinRegistry::registerAirwindow({"PowerSag2", "Effects", 197, "PowerSag2 is my improved circuit-starve plugin, now with inverse effect!", airwin2rack::PowerSag2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Precious.h" -int Precious_unused = AirwinRegistry::registerAirwindow({"Precious", "Tone Color", 319, "Precious is a re-release of another old Character plugin.", airwin2rack::Precious::kNumParameters, []() { return std::make_unique(0); }}); +int Precious_unused = AirwinRegistry::registerAirwindow({"Precious", "Tone Color", 320, "Precious is a re-release of another old Character plugin.", airwin2rack::Precious::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Preponderant.h" -int Preponderant_unused = AirwinRegistry::registerAirwindow({"Preponderant", "Effects", 198, "Preponderant is Airwindows Anti-Soothe, a strange tone intensifier and balancer.", airwin2rack::Preponderant::kNumParameters, []() { return std::make_unique(0); }}); +int Preponderant_unused = AirwinRegistry::registerAirwindow({"Preponderant", "Effects", 199, "Preponderant is Airwindows Anti-Soothe, a strange tone intensifier and balancer.", airwin2rack::Preponderant::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pressure4.h" -int Pressure4_unused = AirwinRegistry::registerAirwindow({"Pressure4", "Dynamics", 177, "Pressure4 is a compressor adjustable between vari-mu and ‘new york’ peak-retaining behaviors.", airwin2rack::Pressure4::kNumParameters, []() { return std::make_unique(0); }}); +int Pressure4_unused = AirwinRegistry::registerAirwindow({"Pressure4", "Dynamics", 178, "Pressure4 is a compressor adjustable between vari-mu and ‘new york’ peak-retaining behaviors.", airwin2rack::Pressure4::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pressure5.h" -int Pressure5_unused = AirwinRegistry::registerAirwindow({"Pressure5", "Dynamics", 154, "Pressure5 expands Pressure4 with after-boost and built-in ClipOnly2.", airwin2rack::Pressure5::kNumParameters, []() { return std::make_unique(0); }}); +int Pressure5_unused = AirwinRegistry::registerAirwindow({"Pressure5", "Dynamics", 155, "Pressure5 expands Pressure4 with after-boost and built-in ClipOnly2.", airwin2rack::Pressure5::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestAir.h" int PurestAir_unused = AirwinRegistry::registerAirwindow({"PurestAir", "Brightness", 63, "PurestAir is a brightness experiment.", airwin2rack::PurestAir::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestConsole2Buss.h" @@ -523,53 +523,53 @@ int PurestConsoleBuss_unused = AirwinRegistry::registerAirwindow({"PurestConsole #include "autogen_airwin/PurestConsoleChannel.h" int PurestConsoleChannel_unused = AirwinRegistry::registerAirwindow({"PurestConsoleChannel", "Consoles", 102, "PurestConsoleChannel is the most free from coloration Console system.", airwin2rack::PurestConsoleChannel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestDrive.h" -int PurestDrive_unused = AirwinRegistry::registerAirwindow({"PurestDrive", "Saturation", 272, "PurestDrive is the magic saturation plugin of subtlety and French House tone.", airwin2rack::PurestDrive::kNumParameters, []() { return std::make_unique(0); }}); +int PurestDrive_unused = AirwinRegistry::registerAirwindow({"PurestDrive", "Saturation", 273, "PurestDrive is the magic saturation plugin of subtlety and French House tone.", airwin2rack::PurestDrive::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestEcho.h" int PurestEcho_unused = AirwinRegistry::registerAirwindow({"PurestEcho", "Ambience", 13, "PurestEcho is optimized Airwindows echo with exactly four evenly spaced taps on tap.", airwin2rack::PurestEcho::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestFade.h" -int PurestFade_unused = AirwinRegistry::registerAirwindow({"PurestFade", "Utility", 332, "PurestFade is just like PurestGain, but for LONG fades.", airwin2rack::PurestFade::kNumParameters, []() { return std::make_unique(0); }}); +int PurestFade_unused = AirwinRegistry::registerAirwindow({"PurestFade", "Utility", 333, "PurestFade is just like PurestGain, but for LONG fades.", airwin2rack::PurestFade::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestGain.h" -int PurestGain_unused = AirwinRegistry::registerAirwindow({"PurestGain", "Utility", 331, "PurestGain is a high-res noise shaped gain, with smoothed fader.", airwin2rack::PurestGain::kNumParameters, []() { return std::make_unique(0); }}); +int PurestGain_unused = AirwinRegistry::registerAirwindow({"PurestGain", "Utility", 332, "PurestGain is a high-res noise shaped gain, with smoothed fader.", airwin2rack::PurestGain::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestSquish.h" -int PurestSquish_unused = AirwinRegistry::registerAirwindow({"PurestSquish", "Dynamics", 176, "PurestSquish is an open-sounding compressor with bass bloom.", airwin2rack::PurestSquish::kNumParameters, []() { return std::make_unique(0); }}); +int PurestSquish_unused = AirwinRegistry::registerAirwindow({"PurestSquish", "Dynamics", 177, "PurestSquish is an open-sounding compressor with bass bloom.", airwin2rack::PurestSquish::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestWarm.h" -int PurestWarm_unused = AirwinRegistry::registerAirwindow({"PurestWarm", "Subtlety", 294, "PurestWarm is a subtle tone shaper and warmth adder.", airwin2rack::PurestWarm::kNumParameters, []() { return std::make_unique(0); }}); +int PurestWarm_unused = AirwinRegistry::registerAirwindow({"PurestWarm", "Subtlety", 295, "PurestWarm is a subtle tone shaper and warmth adder.", airwin2rack::PurestWarm::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestWarm2.h" -int PurestWarm2_unused = AirwinRegistry::registerAirwindow({"PurestWarm2", "Subtlety", 293, "PurestWarm2 adds dual dry/wet controls for each side of the waveform.", airwin2rack::PurestWarm2::kNumParameters, []() { return std::make_unique(0); }}); +int PurestWarm2_unused = AirwinRegistry::registerAirwindow({"PurestWarm2", "Subtlety", 294, "PurestWarm2 adds dual dry/wet controls for each side of the waveform.", airwin2rack::PurestWarm2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Pyewacket.h" -int Pyewacket_unused = AirwinRegistry::registerAirwindow({"Pyewacket", "Dynamics", 163, "Pyewacket is an old school compressor for high definition transients. Adds no fatness, just energy.", airwin2rack::Pyewacket::kNumParameters, []() { return std::make_unique(0); }}); +int Pyewacket_unused = AirwinRegistry::registerAirwindow({"Pyewacket", "Dynamics", 164, "Pyewacket is an old school compressor for high definition transients. Adds no fatness, just energy.", airwin2rack::Pyewacket::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/RawGlitters.h" -int RawGlitters_unused = AirwinRegistry::registerAirwindow({"RawGlitters", "Dithers", 149, "RawGlitters is just the quantization from Dither Me Timbers… and the opposite, as a brightener.", airwin2rack::RawGlitters::kNumParameters, []() { return std::make_unique(0); }}); +int RawGlitters_unused = AirwinRegistry::registerAirwindow({"RawGlitters", "Dithers", 150, "RawGlitters is just the quantization from Dither Me Timbers… and the opposite, as a brightener.", airwin2rack::RawGlitters::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/RawTimbers.h" -int RawTimbers_unused = AirwinRegistry::registerAirwindow({"RawTimbers", "Dithers", 148, "RawTimbers is just the quantization from Dither Me Timbers… and the opposite, as a brightener.", airwin2rack::RawTimbers::kNumParameters, []() { return std::make_unique(0); }}); +int RawTimbers_unused = AirwinRegistry::registerAirwindow({"RawTimbers", "Dithers", 149, "RawTimbers is just the quantization from Dither Me Timbers… and the opposite, as a brightener.", airwin2rack::RawTimbers::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Recurve.h" -int Recurve_unused = AirwinRegistry::registerAirwindow({"Recurve", "Dynamics", 162, "Recurve is a special buss compressor with no threshold point.", airwin2rack::Recurve::kNumParameters, []() { return std::make_unique(0); }}); +int Recurve_unused = AirwinRegistry::registerAirwindow({"Recurve", "Dynamics", 163, "Recurve is a special buss compressor with no threshold point.", airwin2rack::Recurve::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Remap.h" -int Remap_unused = AirwinRegistry::registerAirwindow({"Remap", "Subtlety", 298, "Remap puts the guts back into overloudenated audio!", airwin2rack::Remap::kNumParameters, []() { return std::make_unique(0); }}); +int Remap_unused = AirwinRegistry::registerAirwindow({"Remap", "Subtlety", 299, "Remap puts the guts back into overloudenated audio!", airwin2rack::Remap::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ResEQ.h" -int ResEQ_unused = AirwinRegistry::registerAirwindow({"ResEQ", "Filter", 220, "ResEQ is a bank of mostly midrange resonances.", airwin2rack::ResEQ::kNumParameters, []() { return std::make_unique(0); }}); +int ResEQ_unused = AirwinRegistry::registerAirwindow({"ResEQ", "Filter", 221, "ResEQ is a bank of mostly midrange resonances.", airwin2rack::ResEQ::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ResEQ2.h" -int ResEQ2_unused = AirwinRegistry::registerAirwindow({"ResEQ2", "Filter", 203, "ResEQ2 is a single, sharp, sonorous mid peak.", airwin2rack::ResEQ2::kNumParameters, []() { return std::make_unique(0); }}); +int ResEQ2_unused = AirwinRegistry::registerAirwindow({"ResEQ2", "Filter", 204, "ResEQ2 is a single, sharp, sonorous mid peak.", airwin2rack::ResEQ2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Reverb.h" -int Reverb_unused = AirwinRegistry::registerAirwindow({"Reverb", "Reverb", 265, "Reverb is simplified and tuned MatrixVerb, adjusting everything for each optimum verb size.", airwin2rack::Reverb::kNumParameters, []() { return std::make_unique(0); }}); +int Reverb_unused = AirwinRegistry::registerAirwindow({"Reverb", "Reverb", 266, "Reverb is simplified and tuned MatrixVerb, adjusting everything for each optimum verb size.", airwin2rack::Reverb::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Righteous4.h" -int Righteous4_unused = AirwinRegistry::registerAirwindow({"Righteous4", "Saturation", 279, "Righteous4 is a final output stage for targeting dynamic range.", airwin2rack::Righteous4::kNumParameters, []() { return std::make_unique(0); }}); +int Righteous4_unused = AirwinRegistry::registerAirwindow({"Righteous4", "Saturation", 280, "Righteous4 is a final output stage for targeting dynamic range.", airwin2rack::Righteous4::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/RightoMono.h" -int RightoMono_unused = AirwinRegistry::registerAirwindow({"RightoMono", "Utility", 344, "RightoMono copies one channel to both, losslessly.", airwin2rack::RightoMono::kNumParameters, []() { return std::make_unique(0); }}); +int RightoMono_unused = AirwinRegistry::registerAirwindow({"RightoMono", "Utility", 345, "RightoMono copies one channel to both, losslessly.", airwin2rack::RightoMono::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SampleDelay.h" int SampleDelay_unused = AirwinRegistry::registerAirwindow({"SampleDelay", "Ambience", 4, "SampleDelay is three delays combined: millisecond, sample and subsample.", airwin2rack::SampleDelay::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Shape.h" -int Shape_unused = AirwinRegistry::registerAirwindow({"Shape", "Subtlety", 290, "Shape is an asymmetrical waveshaper for peak manipulating.", airwin2rack::Shape::kNumParameters, []() { return std::make_unique(0); }}); +int Shape_unused = AirwinRegistry::registerAirwindow({"Shape", "Subtlety", 291, "Shape is an asymmetrical waveshaper for peak manipulating.", airwin2rack::Shape::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SideDull.h" -int SideDull_unused = AirwinRegistry::registerAirwindow({"SideDull", "Stereo", 288, "SideDull is like Sidepass, but a lowpass on the side channel. Treble-centerer.", airwin2rack::SideDull::kNumParameters, []() { return std::make_unique(0); }}); +int SideDull_unused = AirwinRegistry::registerAirwindow({"SideDull", "Stereo", 289, "SideDull is like Sidepass, but a lowpass on the side channel. Treble-centerer.", airwin2rack::SideDull::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Sidepass.h" -int Sidepass_unused = AirwinRegistry::registerAirwindow({"Sidepass", "Stereo", 287, "Sidepass is a simple utility plugin, a highpass on the side channel. Mono-maker.", airwin2rack::Sidepass::kNumParameters, []() { return std::make_unique(0); }}); +int Sidepass_unused = AirwinRegistry::registerAirwindow({"Sidepass", "Stereo", 288, "Sidepass is a simple utility plugin, a highpass on the side channel. Mono-maker.", airwin2rack::Sidepass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Silhouette.h" -int Silhouette_unused = AirwinRegistry::registerAirwindow({"Silhouette", "Noise", 247, "Silhouette replaces the sound with raw noise sculpted to match its dynamics.", airwin2rack::Silhouette::kNumParameters, []() { return std::make_unique(0); }}); +int Silhouette_unused = AirwinRegistry::registerAirwindow({"Silhouette", "Noise", 248, "Silhouette replaces the sound with raw noise sculpted to match its dynamics.", airwin2rack::Silhouette::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Sinew.h" int Sinew_unused = AirwinRegistry::registerAirwindow({"Sinew", "Brightness", 52, "Sinew combines sines and slew clipping for a tape bias effect!", airwin2rack::Sinew::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SingleEndedTriode.h" -int SingleEndedTriode_unused = AirwinRegistry::registerAirwindow({"SingleEndedTriode", "Subtlety", 299, "SingleEndedTriode is unusual analog modeling effects.", airwin2rack::SingleEndedTriode::kNumParameters, []() { return std::make_unique(0); }}); +int SingleEndedTriode_unused = AirwinRegistry::registerAirwindow({"SingleEndedTriode", "Subtlety", 300, "SingleEndedTriode is unusual analog modeling effects.", airwin2rack::SingleEndedTriode::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Slew.h" int Slew_unused = AirwinRegistry::registerAirwindow({"Slew", "Brightness", 60, "Slew is a slew clipper, which darkens treble in an unusual way.", airwin2rack::Slew::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Slew2.h" @@ -577,23 +577,23 @@ int Slew2_unused = AirwinRegistry::registerAirwindow({"Slew2", "Brightness", 59, #include "autogen_airwin/Slew3.h" int Slew3_unused = AirwinRegistry::registerAirwindow({"Slew3", "Brightness", 58, "Slew3 is a new approach to slew clipping meant for a more analog-like darkening effect.", airwin2rack::Slew3::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SlewOnly.h" -int SlewOnly_unused = AirwinRegistry::registerAirwindow({"SlewOnly", "Utility", 335, "SlewOnly is a mix check plugin that shows you only the extreme highs.", airwin2rack::SlewOnly::kNumParameters, []() { return std::make_unique(0); }}); +int SlewOnly_unused = AirwinRegistry::registerAirwindow({"SlewOnly", "Utility", 336, "SlewOnly is a mix check plugin that shows you only the extreme highs.", airwin2rack::SlewOnly::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SlewSonic.h" int SlewSonic_unused = AirwinRegistry::registerAirwindow({"SlewSonic", "Brightness", 53, "SlewSonic combines SlewOnly with ultrasonic filtering to solo brightness.", airwin2rack::SlewSonic::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Smooth.h" int Smooth_unused = AirwinRegistry::registerAirwindow({"Smooth", "Brightness", 56, "Smooth can tame pointy sounds or make drums explode.", airwin2rack::Smooth::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SoftGate.h" -int SoftGate_unused = AirwinRegistry::registerAirwindow({"SoftGate", "Dynamics", 165, "SoftGate is a gate that can mute hiss and smooth sample tails.", airwin2rack::SoftGate::kNumParameters, []() { return std::make_unique(0); }}); +int SoftGate_unused = AirwinRegistry::registerAirwindow({"SoftGate", "Dynamics", 166, "SoftGate is a gate that can mute hiss and smooth sample tails.", airwin2rack::SoftGate::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SpatializeDither.h" -int SpatializeDither_unused = AirwinRegistry::registerAirwindow({"SpatializeDither", "Dithers", 139, "SpatializeDither is a high-performance clarity and accuracy dither.", airwin2rack::SpatializeDither::kNumParameters, []() { return std::make_unique(0); }}); +int SpatializeDither_unused = AirwinRegistry::registerAirwindow({"SpatializeDither", "Dithers", 140, "SpatializeDither is a high-performance clarity and accuracy dither.", airwin2rack::SpatializeDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Spiral.h" -int Spiral_unused = AirwinRegistry::registerAirwindow({"Spiral", "Saturation", 276, "Spiral is the new best smoothest distortion algorithm.", airwin2rack::Spiral::kNumParameters, []() { return std::make_unique(0); }}); +int Spiral_unused = AirwinRegistry::registerAirwindow({"Spiral", "Saturation", 277, "Spiral is the new best smoothest distortion algorithm.", airwin2rack::Spiral::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Spiral2.h" -int Spiral2_unused = AirwinRegistry::registerAirwindow({"Spiral2", "Saturation", 271, "Spiral2 is Spiral with controls including Presence.", airwin2rack::Spiral2::kNumParameters, []() { return std::make_unique(0); }}); +int Spiral2_unused = AirwinRegistry::registerAirwindow({"Spiral2", "Saturation", 272, "Spiral2 is Spiral with controls including Presence.", airwin2rack::Spiral2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Srsly.h" -int Srsly_unused = AirwinRegistry::registerAirwindow({"Srsly", "Stereo", 280, "Srsly is a psychoacoustic stereo processor.", airwin2rack::Srsly::kNumParameters, []() { return std::make_unique(0); }}); +int Srsly_unused = AirwinRegistry::registerAirwindow({"Srsly", "Stereo", 281, "Srsly is a psychoacoustic stereo processor.", airwin2rack::Srsly::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Srsly2.h" -int Srsly2_unused = AirwinRegistry::registerAirwindow({"Srsly2", "Stereo", 281, "Srsly2 is a revisit of Srsly, to make the stereo widening more extreme.", airwin2rack::Srsly2::kNumParameters, []() { return std::make_unique(0); }}); +int Srsly2_unused = AirwinRegistry::registerAirwindow({"Srsly2", "Stereo", 282, "Srsly2 is a revisit of Srsly, to make the stereo widening more extreme.", airwin2rack::Srsly2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/StarChild.h" int StarChild_unused = AirwinRegistry::registerAirwindow({"StarChild", "Ambience", 16, "StarChild is a weird digital ambience/echo plugin.", airwin2rack::StarChild::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/StarChild2.h" @@ -605,65 +605,65 @@ int StereoDoubler_unused = AirwinRegistry::registerAirwindow({"StereoDoubler", " #include "autogen_airwin/StereoEnsemble.h" int StereoEnsemble_unused = AirwinRegistry::registerAirwindow({"StereoEnsemble", "Ambience", 20, "StereoEnsemble is a sort of hyperchorus blast from the past.", airwin2rack::StereoEnsemble::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/StereoFX.h" -int StereoFX_unused = AirwinRegistry::registerAirwindow({"StereoFX", "Stereo", 283, "StereoFX is an aggressive stereo widener.", airwin2rack::StereoFX::kNumParameters, []() { return std::make_unique(0); }}); +int StereoFX_unused = AirwinRegistry::registerAirwindow({"StereoFX", "Stereo", 284, "StereoFX is an aggressive stereo widener.", airwin2rack::StereoFX::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/StudioTan.h" -int StudioTan_unused = AirwinRegistry::registerAirwindow({"StudioTan", "Dithers", 145, "StudioTan is all the 'non-dither' dithers, up to date and convenient.", airwin2rack::StudioTan::kNumParameters, []() { return std::make_unique(0); }}); +int StudioTan_unused = AirwinRegistry::registerAirwindow({"StudioTan", "Dithers", 146, "StudioTan is all the 'non-dither' dithers, up to date and convenient.", airwin2rack::StudioTan::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SubTight.h" -int SubTight_unused = AirwinRegistry::registerAirwindow({"SubTight", "Filter", 204, "SubTight uses a variation on the Creature algorithm to tighten sub-lows.", airwin2rack::SubTight::kNumParameters, []() { return std::make_unique(0); }}); +int SubTight_unused = AirwinRegistry::registerAirwindow({"SubTight", "Filter", 205, "SubTight uses a variation on the Creature algorithm to tighten sub-lows.", airwin2rack::SubTight::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SubsOnly.h" -int SubsOnly_unused = AirwinRegistry::registerAirwindow({"SubsOnly", "Utility", 336, "SubsOnly is a mix check plugin that shows you only the extreme lows.", airwin2rack::SubsOnly::kNumParameters, []() { return std::make_unique(0); }}); +int SubsOnly_unused = AirwinRegistry::registerAirwindow({"SubsOnly", "Utility", 337, "SubsOnly is a mix check plugin that shows you only the extreme lows.", airwin2rack::SubsOnly::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Surge.h" -int Surge_unused = AirwinRegistry::registerAirwindow({"Surge", "Dynamics", 178, "Surge is a compressor for accentuating beats and pulses.", airwin2rack::Surge::kNumParameters, []() { return std::make_unique(0); }}); +int Surge_unused = AirwinRegistry::registerAirwindow({"Surge", "Dynamics", 179, "Surge is a compressor for accentuating beats and pulses.", airwin2rack::Surge::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/SurgeTide.h" -int SurgeTide_unused = AirwinRegistry::registerAirwindow({"SurgeTide", "Dynamics", 179, "SurgeTide is a surge and flow dynamics plugin.", airwin2rack::SurgeTide::kNumParameters, []() { return std::make_unique(0); }}); +int SurgeTide_unused = AirwinRegistry::registerAirwindow({"SurgeTide", "Dynamics", 180, "SurgeTide is a surge and flow dynamics plugin.", airwin2rack::SurgeTide::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Sweeten.h" -int Sweeten_unused = AirwinRegistry::registerAirwindow({"Sweeten", "Subtlety", 292, "Sweeten is where you can find super-clean second harmonic.", airwin2rack::Sweeten::kNumParameters, []() { return std::make_unique(0); }}); +int Sweeten_unused = AirwinRegistry::registerAirwindow({"Sweeten", "Subtlety", 293, "Sweeten is where you can find super-clean second harmonic.", airwin2rack::Sweeten::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Swell.h" -int Swell_unused = AirwinRegistry::registerAirwindow({"Swell", "Dynamics", 175, "Swell is Dial-an-attack, like sidechaining.", airwin2rack::Swell::kNumParameters, []() { return std::make_unique(0); }}); +int Swell_unused = AirwinRegistry::registerAirwindow({"Swell", "Dynamics", 176, "Swell is Dial-an-attack, like sidechaining.", airwin2rack::Swell::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TPDFDither.h" -int TPDFDither_unused = AirwinRegistry::registerAirwindow({"TPDFDither", "Dithers", 134, "TPDFDither is TPDF dither. With 16/24 bit output and a DeRez control.", airwin2rack::TPDFDither::kNumParameters, []() { return std::make_unique(0); }}); +int TPDFDither_unused = AirwinRegistry::registerAirwindow({"TPDFDither", "Dithers", 135, "TPDFDither is TPDF dither. With 16/24 bit output and a DeRez control.", airwin2rack::TPDFDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TPDFWide.h" -int TPDFWide_unused = AirwinRegistry::registerAirwindow({"TPDFWide", "Dithers", 133, "TPDFWide is still TPDF dither but better and wider. With 16/24 bit output and a DeRez control.", airwin2rack::TPDFWide::kNumParameters, []() { return std::make_unique(0); }}); +int TPDFWide_unused = AirwinRegistry::registerAirwindow({"TPDFWide", "Dithers", 134, "TPDFWide is still TPDF dither but better and wider. With 16/24 bit output and a DeRez control.", airwin2rack::TPDFWide::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Tape.h" -int Tape_unused = AirwinRegistry::registerAirwindow({"Tape", "Tape", 306, "Tape is simplified, all-purpose tape mojo: my personal jam.", airwin2rack::Tape::kNumParameters, []() { return std::make_unique(0); }}); +int Tape_unused = AirwinRegistry::registerAirwindow({"Tape", "Tape", 307, "Tape is simplified, all-purpose tape mojo: my personal jam.", airwin2rack::Tape::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TapeDelay.h" int TapeDelay_unused = AirwinRegistry::registerAirwindow({"TapeDelay", "Ambience", 14, "TapeDelay is an old school tape echo with pitch swerve effects.", airwin2rack::TapeDelay::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TapeDelay2.h" int TapeDelay2_unused = AirwinRegistry::registerAirwindow({"TapeDelay2", "Ambience", 1, "TapeDelay2 is a new implementation of a flexible tape echo.", airwin2rack::TapeDelay2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TapeDither.h" -int TapeDither_unused = AirwinRegistry::registerAirwindow({"TapeDither", "Dithers", 138, "TapeDither is TPDF dither with noise like reel-to-reel tape.", airwin2rack::TapeDither::kNumParameters, []() { return std::make_unique(0); }}); +int TapeDither_unused = AirwinRegistry::registerAirwindow({"TapeDither", "Dithers", 139, "TapeDither is TPDF dither with noise like reel-to-reel tape.", airwin2rack::TapeDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TapeDust.h" -int TapeDust_unused = AirwinRegistry::registerAirwindow({"TapeDust", "Noise", 248, "TapeDust is just a special treble-erode noise, a ‘slew noise’ plugin.", airwin2rack::TapeDust::kNumParameters, []() { return std::make_unique(0); }}); +int TapeDust_unused = AirwinRegistry::registerAirwindow({"TapeDust", "Noise", 249, "TapeDust is just a special treble-erode noise, a ‘slew noise’ plugin.", airwin2rack::TapeDust::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TapeFat.h" -int TapeFat_unused = AirwinRegistry::registerAirwindow({"TapeFat", "Filter", 219, "TapeFat is the tone control from TapeDelay.", airwin2rack::TapeFat::kNumParameters, []() { return std::make_unique(0); }}); +int TapeFat_unused = AirwinRegistry::registerAirwindow({"TapeFat", "Filter", 220, "TapeFat is the tone control from TapeDelay.", airwin2rack::TapeFat::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Texturize.h" -int Texturize_unused = AirwinRegistry::registerAirwindow({"Texturize", "Noise", 242, "Texturize is a hidden-noise plugin for adding sonic texture to things.", airwin2rack::Texturize::kNumParameters, []() { return std::make_unique(0); }}); +int Texturize_unused = AirwinRegistry::registerAirwindow({"Texturize", "Noise", 243, "Texturize is a hidden-noise plugin for adding sonic texture to things.", airwin2rack::Texturize::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TexturizeMS.h" -int TexturizeMS_unused = AirwinRegistry::registerAirwindow({"TexturizeMS", "Noise", 243, "TexturizeMS is a hidden-noise plugin for adding mid-side sonic texture to things.", airwin2rack::TexturizeMS::kNumParameters, []() { return std::make_unique(0); }}); +int TexturizeMS_unused = AirwinRegistry::registerAirwindow({"TexturizeMS", "Noise", 244, "TexturizeMS is a hidden-noise plugin for adding mid-side sonic texture to things.", airwin2rack::TexturizeMS::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Thunder.h" -int Thunder_unused = AirwinRegistry::registerAirwindow({"Thunder", "Dynamics", 166, "Thunder is a compressor that retains or exaggerates subsonic bass when you push it.", airwin2rack::Thunder::kNumParameters, []() { return std::make_unique(0); }}); +int Thunder_unused = AirwinRegistry::registerAirwindow({"Thunder", "Dynamics", 167, "Thunder is a compressor that retains or exaggerates subsonic bass when you push it.", airwin2rack::Thunder::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ToTape5.h" -int ToTape5_unused = AirwinRegistry::registerAirwindow({"ToTape5", "Tape", 309, "ToTape5 is Airwindows analog tape emulation.", airwin2rack::ToTape5::kNumParameters, []() { return std::make_unique(0); }}); +int ToTape5_unused = AirwinRegistry::registerAirwindow({"ToTape5", "Tape", 310, "ToTape5 is Airwindows analog tape emulation.", airwin2rack::ToTape5::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ToTape6.h" -int ToTape6_unused = AirwinRegistry::registerAirwindow({"ToTape6", "Tape", 304, "ToTape6 is Airwindows tape emulation for 2020!", airwin2rack::ToTape6::kNumParameters, []() { return std::make_unique(0); }}); +int ToTape6_unused = AirwinRegistry::registerAirwindow({"ToTape6", "Tape", 305, "ToTape6 is Airwindows tape emulation for 2020!", airwin2rack::ToTape6::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ToVinyl4.h" -int ToVinyl4_unused = AirwinRegistry::registerAirwindow({"ToVinyl4", "Stereo", 284, "ToVinyl4 is a vinyl-mastering simulator bringing several vinyl-type colors.", airwin2rack::ToVinyl4::kNumParameters, []() { return std::make_unique(0); }}); +int ToVinyl4_unused = AirwinRegistry::registerAirwindow({"ToVinyl4", "Stereo", 285, "ToVinyl4 is a vinyl-mastering simulator bringing several vinyl-type colors.", airwin2rack::ToVinyl4::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ToneSlant.h" -int ToneSlant_unused = AirwinRegistry::registerAirwindow({"ToneSlant", "Filter", 210, "ToneSlant is a super-transparent ‘tilt EQ’ with very low Q.", airwin2rack::ToneSlant::kNumParameters, []() { return std::make_unique(0); }}); +int ToneSlant_unused = AirwinRegistry::registerAirwindow({"ToneSlant", "Filter", 211, "ToneSlant is a super-transparent ‘tilt EQ’ with very low Q.", airwin2rack::ToneSlant::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TransDesk.h" -int TransDesk_unused = AirwinRegistry::registerAirwindow({"TransDesk", "Subtlety", 302, "TransDesk is more of a transistory, rock desk analog modeling.", airwin2rack::TransDesk::kNumParameters, []() { return std::make_unique(0); }}); +int TransDesk_unused = AirwinRegistry::registerAirwindow({"TransDesk", "Subtlety", 303, "TransDesk is more of a transistory, rock desk analog modeling.", airwin2rack::TransDesk::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TremoSquare.h" -int TremoSquare_unused = AirwinRegistry::registerAirwindow({"TremoSquare", "Effects", 187, "TremoSquare is a squarewave tremolo effect that only switches on zero crossings.", airwin2rack::TremoSquare::kNumParameters, []() { return std::make_unique(0); }}); +int TremoSquare_unused = AirwinRegistry::registerAirwindow({"TremoSquare", "Effects", 188, "TremoSquare is a squarewave tremolo effect that only switches on zero crossings.", airwin2rack::TremoSquare::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Tremolo.h" -int Tremolo_unused = AirwinRegistry::registerAirwindow({"Tremolo", "Effects", 188, "Tremolo is fluctuating saturation curves for a tubey tremolo.", airwin2rack::Tremolo::kNumParameters, []() { return std::make_unique(0); }}); +int Tremolo_unused = AirwinRegistry::registerAirwindow({"Tremolo", "Effects", 189, "Tremolo is fluctuating saturation curves for a tubey tremolo.", airwin2rack::Tremolo::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TripleSpread.h" int TripleSpread_unused = AirwinRegistry::registerAirwindow({"TripleSpread", "Ambience", 6, "TripleSpread is a stereo tripler with extra wideness and GlitchShifter processing.", airwin2rack::TripleSpread::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Tube.h" -int Tube_unused = AirwinRegistry::registerAirwindow({"Tube", "Saturation", 270, "Tube is a tube style SoundBetterIzer using a new algorithm for analog modeling!", airwin2rack::Tube::kNumParameters, []() { return std::make_unique(0); }}); +int Tube_unused = AirwinRegistry::registerAirwindow({"Tube", "Saturation", 271, "Tube is a tube style SoundBetterIzer using a new algorithm for analog modeling!", airwin2rack::Tube::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Tube2.h" -int Tube2_unused = AirwinRegistry::registerAirwindow({"Tube2", "Saturation", 269, "Tube2 extends Tube, with more sophisticated processing and input trim.", airwin2rack::Tube2::kNumParameters, []() { return std::make_unique(0); }}); +int Tube2_unused = AirwinRegistry::registerAirwindow({"Tube2", "Saturation", 270, "Tube2 extends Tube, with more sophisticated processing and input trim.", airwin2rack::Tube2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/TubeDesk.h" -int TubeDesk_unused = AirwinRegistry::registerAirwindow({"TubeDesk", "Subtlety", 303, "TubeDesk is a tube recording console type tone coloring.", airwin2rack::TubeDesk::kNumParameters, []() { return std::make_unique(0); }}); +int TubeDesk_unused = AirwinRegistry::registerAirwindow({"TubeDesk", "Subtlety", 304, "TubeDesk is a tube recording console type tone coloring.", airwin2rack::TubeDesk::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/UltrasonX.h" int UltrasonX_unused = AirwinRegistry::registerAirwindow({"UltrasonX", "Brightness", 71, "UltrasonX is a method for rolling your own Console-type systems with total control over your ultrasonic filtering.", airwin2rack::UltrasonX::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Ultrasonic.h" @@ -673,89 +673,89 @@ int UltrasonicLite_unused = AirwinRegistry::registerAirwindow({"UltrasonicLite", #include "autogen_airwin/UltrasonicMed.h" int UltrasonicMed_unused = AirwinRegistry::registerAirwindow({"UltrasonicMed", "Brightness", 70, "UltrasonicMed is two stages of supersonic filter, for using inside digital mixes.", airwin2rack::UltrasonicMed::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/UnBox.h" -int UnBox_unused = AirwinRegistry::registerAirwindow({"UnBox", "Saturation", 277, "UnBox is a distortion where only the harmonics that don't alias are allowed to distort.", airwin2rack::UnBox::kNumParameters, []() { return std::make_unique(0); }}); +int UnBox_unused = AirwinRegistry::registerAirwindow({"UnBox", "Saturation", 278, "UnBox is a distortion where only the harmonics that don't alias are allowed to distort.", airwin2rack::UnBox::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/VariMu.h" -int VariMu_unused = AirwinRegistry::registerAirwindow({"VariMu", "Dynamics", 159, "VariMu is a more organic variation on Pressure (a compressor)", airwin2rack::VariMu::kNumParameters, []() { return std::make_unique(0); }}); +int VariMu_unused = AirwinRegistry::registerAirwindow({"VariMu", "Dynamics", 160, "VariMu is a more organic variation on Pressure (a compressor)", airwin2rack::VariMu::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Verbity.h" -int Verbity_unused = AirwinRegistry::registerAirwindow({"Verbity", "Reverb", 257, "Verbity is a dual-mono reverb, which uses feedforward reverb topology.", airwin2rack::Verbity::kNumParameters, []() { return std::make_unique(0); }}); +int Verbity_unused = AirwinRegistry::registerAirwindow({"Verbity", "Reverb", 258, "Verbity is a dual-mono reverb, which uses feedforward reverb topology.", airwin2rack::Verbity::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Verbity2.h" -int Verbity2_unused = AirwinRegistry::registerAirwindow({"Verbity2", "Reverb", 253, "Verbity2 adds stereo crossmodulation and expands Verbity's feedforward reverb topology.", airwin2rack::Verbity2::kNumParameters, []() { return std::make_unique(0); }}); +int Verbity2_unused = AirwinRegistry::registerAirwindow({"Verbity2", "Reverb", 254, "Verbity2 adds stereo crossmodulation and expands Verbity's feedforward reverb topology.", airwin2rack::Verbity2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Vibrato.h" -int Vibrato_unused = AirwinRegistry::registerAirwindow({"Vibrato", "Lo-Fi", 237, "Vibrato lets you vibrato, chorus, flange, and make odd FM noises.", airwin2rack::Vibrato::kNumParameters, []() { return std::make_unique(0); }}); +int Vibrato_unused = AirwinRegistry::registerAirwindow({"Vibrato", "Lo-Fi", 238, "Vibrato lets you vibrato, chorus, flange, and make odd FM noises.", airwin2rack::Vibrato::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/VinylDither.h" -int VinylDither_unused = AirwinRegistry::registerAirwindow({"VinylDither", "Dithers", 140, "VinylDither is a high-performance dither that converts digital noise to ‘groove noise’.", airwin2rack::VinylDither::kNumParameters, []() { return std::make_unique(0); }}); +int VinylDither_unused = AirwinRegistry::registerAirwindow({"VinylDither", "Dithers", 141, "VinylDither is a high-performance dither that converts digital noise to ‘groove noise’.", airwin2rack::VinylDither::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/VoiceOfTheStarship.h" -int VoiceOfTheStarship_unused = AirwinRegistry::registerAirwindow({"VoiceOfTheStarship", "Noise", 244, "VoiceOfTheStarship is a deep noise tone source.", airwin2rack::VoiceOfTheStarship::kNumParameters, []() { return std::make_unique(0); }}); +int VoiceOfTheStarship_unused = AirwinRegistry::registerAirwindow({"VoiceOfTheStarship", "Noise", 245, "VoiceOfTheStarship is a deep noise tone source.", airwin2rack::VoiceOfTheStarship::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/VoiceTrick.h" -int VoiceTrick_unused = AirwinRegistry::registerAirwindow({"VoiceTrick", "Utility", 349, "VoiceTrick lets you record vocals while monitoring over speakers.", airwin2rack::VoiceTrick::kNumParameters, []() { return std::make_unique(0); }}); +int VoiceTrick_unused = AirwinRegistry::registerAirwindow({"VoiceTrick", "Utility", 350, "VoiceTrick lets you record vocals while monitoring over speakers.", airwin2rack::VoiceTrick::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Weight.h" -int Weight_unused = AirwinRegistry::registerAirwindow({"Weight", "Filter", 206, "Weight is a very accurate sub-bass boost based on Holt.", airwin2rack::Weight::kNumParameters, []() { return std::make_unique(0); }}); +int Weight_unused = AirwinRegistry::registerAirwindow({"Weight", "Filter", 207, "Weight is a very accurate sub-bass boost based on Holt.", airwin2rack::Weight::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Wider.h" -int Wider_unused = AirwinRegistry::registerAirwindow({"Wider", "Stereo", 282, "Wider is Airwindows stereo space shaping.", airwin2rack::Wider::kNumParameters, []() { return std::make_unique(0); }}); +int Wider_unused = AirwinRegistry::registerAirwindow({"Wider", "Stereo", 283, "Wider is Airwindows stereo space shaping.", airwin2rack::Wider::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/XBandpass.h" -int XBandpass_unused = AirwinRegistry::registerAirwindow({"XBandpass", "XYZ Filters", 367, "XBandpass is a distorted digital EQ, inspired by retro sampler DSP.", airwin2rack::XBandpass::kNumParameters, []() { return std::make_unique(0); }}); +int XBandpass_unused = AirwinRegistry::registerAirwindow({"XBandpass", "XYZ Filters", 368, "XBandpass is a distorted digital EQ, inspired by retro sampler DSP.", airwin2rack::XBandpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/XHighpass.h" -int XHighpass_unused = AirwinRegistry::registerAirwindow({"XHighpass", "XYZ Filters", 368, "XHighpass is a distorted digital EQ, inspired by retro sampler DSP.", airwin2rack::XHighpass::kNumParameters, []() { return std::make_unique(0); }}); +int XHighpass_unused = AirwinRegistry::registerAirwindow({"XHighpass", "XYZ Filters", 369, "XHighpass is a distorted digital EQ, inspired by retro sampler DSP.", airwin2rack::XHighpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/XLowpass.h" -int XLowpass_unused = AirwinRegistry::registerAirwindow({"XLowpass", "XYZ Filters", 369, "XLowpass is a distorted digital EQ, inspired by retro sampler DSP.", airwin2rack::XLowpass::kNumParameters, []() { return std::make_unique(0); }}); +int XLowpass_unused = AirwinRegistry::registerAirwindow({"XLowpass", "XYZ Filters", 370, "XLowpass is a distorted digital EQ, inspired by retro sampler DSP.", airwin2rack::XLowpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/XNotch.h" -int XNotch_unused = AirwinRegistry::registerAirwindow({"XNotch", "XYZ Filters", 370, "XNotch is a distorted digital EQ, not as glitchy as the others.", airwin2rack::XNotch::kNumParameters, []() { return std::make_unique(0); }}); +int XNotch_unused = AirwinRegistry::registerAirwindow({"XNotch", "XYZ Filters", 371, "XNotch is a distorted digital EQ, not as glitchy as the others.", airwin2rack::XNotch::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/XRegion.h" -int XRegion_unused = AirwinRegistry::registerAirwindow({"XRegion", "XYZ Filters", 371, "XRegion is distorted staggered bandpasses, for extreme soundmangling.", airwin2rack::XRegion::kNumParameters, []() { return std::make_unique(0); }}); +int XRegion_unused = AirwinRegistry::registerAirwindow({"XRegion", "XYZ Filters", 372, "XRegion is distorted staggered bandpasses, for extreme soundmangling.", airwin2rack::XRegion::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YBandpass.h" -int YBandpass_unused = AirwinRegistry::registerAirwindow({"YBandpass", "XYZ Filters", 360, "YBandpass is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YBandpass::kNumParameters, []() { return std::make_unique(0); }}); +int YBandpass_unused = AirwinRegistry::registerAirwindow({"YBandpass", "XYZ Filters", 361, "YBandpass is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YBandpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YHighpass.h" -int YHighpass_unused = AirwinRegistry::registerAirwindow({"YHighpass", "XYZ Filters", 362, "YHighpass is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YHighpass::kNumParameters, []() { return std::make_unique(0); }}); +int YHighpass_unused = AirwinRegistry::registerAirwindow({"YHighpass", "XYZ Filters", 363, "YHighpass is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YHighpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YLowpass.h" -int YLowpass_unused = AirwinRegistry::registerAirwindow({"YLowpass", "XYZ Filters", 364, "YLowpass is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YLowpass::kNumParameters, []() { return std::make_unique(0); }}); +int YLowpass_unused = AirwinRegistry::registerAirwindow({"YLowpass", "XYZ Filters", 365, "YLowpass is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YLowpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YNotBandpass.h" -int YNotBandpass_unused = AirwinRegistry::registerAirwindow({"YNotBandpass", "XYZ Filters", 361, "YNotBandpass is soft and smooth to nasty, edgy texture-varying filtering, no control smoothing.", airwin2rack::YNotBandpass::kNumParameters, []() { return std::make_unique(0); }}); +int YNotBandpass_unused = AirwinRegistry::registerAirwindow({"YNotBandpass", "XYZ Filters", 362, "YNotBandpass is soft and smooth to nasty, edgy texture-varying filtering, no control smoothing.", airwin2rack::YNotBandpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YNotHighpass.h" -int YNotHighpass_unused = AirwinRegistry::registerAirwindow({"YNotHighpass", "XYZ Filters", 363, "YNotHighpass is soft and smooth to nasty, edgy texture-varying filtering, no control smoothing.", airwin2rack::YNotHighpass::kNumParameters, []() { return std::make_unique(0); }}); +int YNotHighpass_unused = AirwinRegistry::registerAirwindow({"YNotHighpass", "XYZ Filters", 364, "YNotHighpass is soft and smooth to nasty, edgy texture-varying filtering, no control smoothing.", airwin2rack::YNotHighpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YNotLowpass.h" -int YNotLowpass_unused = AirwinRegistry::registerAirwindow({"YNotLowpass", "XYZ Filters", 365, "YNotLowpass is soft and smooth to nasty, edgy texture-varying filtering, no control smoothing.", airwin2rack::YNotLowpass::kNumParameters, []() { return std::make_unique(0); }}); +int YNotLowpass_unused = AirwinRegistry::registerAirwindow({"YNotLowpass", "XYZ Filters", 366, "YNotLowpass is soft and smooth to nasty, edgy texture-varying filtering, no control smoothing.", airwin2rack::YNotLowpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YNotNotch.h" int YNotNotch_unused = AirwinRegistry::registerAirwindow({"YNotNotch", "Unclassified", -1, "YNotNotch is soft and smooth to nasty, edgy texture-varying filtering, no control smoothing.", airwin2rack::YNotNotch::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YNotch.h" -int YNotch_unused = AirwinRegistry::registerAirwindow({"YNotch", "XYZ Filters", 366, "YNotch is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YNotch::kNumParameters, []() { return std::make_unique(0); }}); +int YNotch_unused = AirwinRegistry::registerAirwindow({"YNotch", "XYZ Filters", 367, "YNotch is soft and smooth to nasty, edgy texture-varying filtering.", airwin2rack::YNotch::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZBandpass.h" -int ZBandpass_unused = AirwinRegistry::registerAirwindow({"ZBandpass", "XYZ Filters", 355, "ZBandpass is a bandpass made to sound and act like the Emu e6400 Ultra bandpass.", airwin2rack::ZBandpass::kNumParameters, []() { return std::make_unique(0); }}); +int ZBandpass_unused = AirwinRegistry::registerAirwindow({"ZBandpass", "XYZ Filters", 356, "ZBandpass is a bandpass made to sound and act like the Emu e6400 Ultra bandpass.", airwin2rack::ZBandpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZBandpass2.h" -int ZBandpass2_unused = AirwinRegistry::registerAirwindow({"ZBandpass2", "XYZ Filters", 350, "ZBandpass2 acts more like the Emu e6400 Ultra bandpass in motion, with control smoothing.", airwin2rack::ZBandpass2::kNumParameters, []() { return std::make_unique(0); }}); +int ZBandpass2_unused = AirwinRegistry::registerAirwindow({"ZBandpass2", "XYZ Filters", 351, "ZBandpass2 acts more like the Emu e6400 Ultra bandpass in motion, with control smoothing.", airwin2rack::ZBandpass2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZHighpass.h" -int ZHighpass_unused = AirwinRegistry::registerAirwindow({"ZHighpass", "XYZ Filters", 356, "ZHighpass is a highpass made to sound and act like the Emu e6400 Ultra highpass.", airwin2rack::ZHighpass::kNumParameters, []() { return std::make_unique(0); }}); +int ZHighpass_unused = AirwinRegistry::registerAirwindow({"ZHighpass", "XYZ Filters", 357, "ZHighpass is a highpass made to sound and act like the Emu e6400 Ultra highpass.", airwin2rack::ZHighpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZHighpass2.h" -int ZHighpass2_unused = AirwinRegistry::registerAirwindow({"ZHighpass2", "XYZ Filters", 351, "ZHighpass2 acts more like the Emu e6400 Ultra highpass in motion, with control smoothing.", airwin2rack::ZHighpass2::kNumParameters, []() { return std::make_unique(0); }}); +int ZHighpass2_unused = AirwinRegistry::registerAirwindow({"ZHighpass2", "XYZ Filters", 352, "ZHighpass2 acts more like the Emu e6400 Ultra highpass in motion, with control smoothing.", airwin2rack::ZHighpass2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZLowpass.h" -int ZLowpass_unused = AirwinRegistry::registerAirwindow({"ZLowpass", "XYZ Filters", 357, "ZLowpass is a lowpass made to sound and act like the Emu e6400 Ultra lowpass.", airwin2rack::ZLowpass::kNumParameters, []() { return std::make_unique(0); }}); +int ZLowpass_unused = AirwinRegistry::registerAirwindow({"ZLowpass", "XYZ Filters", 358, "ZLowpass is a lowpass made to sound and act like the Emu e6400 Ultra lowpass.", airwin2rack::ZLowpass::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZLowpass2.h" -int ZLowpass2_unused = AirwinRegistry::registerAirwindow({"ZLowpass2", "XYZ Filters", 352, "ZLowpass2 acts more like the Emu e6400 Ultra lowpass in motion, with control smoothing.", airwin2rack::ZLowpass2::kNumParameters, []() { return std::make_unique(0); }}); +int ZLowpass2_unused = AirwinRegistry::registerAirwindow({"ZLowpass2", "XYZ Filters", 353, "ZLowpass2 acts more like the Emu e6400 Ultra lowpass in motion, with control smoothing.", airwin2rack::ZLowpass2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZNotch.h" -int ZNotch_unused = AirwinRegistry::registerAirwindow({"ZNotch", "XYZ Filters", 358, "ZNotch is a notch filter made to sound and act like the Emu e6400 Phaser.", airwin2rack::ZNotch::kNumParameters, []() { return std::make_unique(0); }}); +int ZNotch_unused = AirwinRegistry::registerAirwindow({"ZNotch", "XYZ Filters", 359, "ZNotch is a notch filter made to sound and act like the Emu e6400 Phaser.", airwin2rack::ZNotch::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZNotch2.h" -int ZNotch2_unused = AirwinRegistry::registerAirwindow({"ZNotch2", "XYZ Filters", 353, "ZNotch2 acts more like the Emu e6400 Ultra phaser in motion, with control smoothing.", airwin2rack::ZNotch2::kNumParameters, []() { return std::make_unique(0); }}); +int ZNotch2_unused = AirwinRegistry::registerAirwindow({"ZNotch2", "XYZ Filters", 354, "ZNotch2 acts more like the Emu e6400 Ultra phaser in motion, with control smoothing.", airwin2rack::ZNotch2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZOutputStage.h" -int ZOutputStage_unused = AirwinRegistry::registerAirwindow({"ZOutputStage", "Unclassified", -1, "ZOutputStage is the output clipping from the Emu e6400 style Z filters.", airwin2rack::ZOutputStage::kNumParameters, []() { return std::make_unique(0); }}); +int ZOutputStage_unused = AirwinRegistry::registerAirwindow({"ZOutputStage", "Distortion", 123, "ZOutputStage is the output clipping from the Emu e6400 style Z filters.", airwin2rack::ZOutputStage::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZRegion.h" -int ZRegion_unused = AirwinRegistry::registerAirwindow({"ZRegion", "XYZ Filters", 359, "ZRegion is an Emu e6400 style Airwindows Region filter.", airwin2rack::ZRegion::kNumParameters, []() { return std::make_unique(0); }}); +int ZRegion_unused = AirwinRegistry::registerAirwindow({"ZRegion", "XYZ Filters", 360, "ZRegion is an Emu e6400 style Airwindows Region filter.", airwin2rack::ZRegion::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ZRegion2.h" -int ZRegion2_unused = AirwinRegistry::registerAirwindow({"ZRegion2", "XYZ Filters", 354, "ZRegion2 is an Emu e6400 style Airwindows Region filter, with control smoothing.", airwin2rack::ZRegion2::kNumParameters, []() { return std::make_unique(0); }}); +int ZRegion2_unused = AirwinRegistry::registerAirwindow({"ZRegion2", "XYZ Filters", 355, "ZRegion2 is an Emu e6400 style Airwindows Region filter, with control smoothing.", airwin2rack::ZRegion2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/curve.h" -int curve_unused = AirwinRegistry::registerAirwindow({"curve", "Dynamics", 161, "curve is the simplest, purest form of Recurve with no extra boosts.", airwin2rack::curve::kNumParameters, []() { return std::make_unique(0); }}); +int curve_unused = AirwinRegistry::registerAirwindow({"curve", "Dynamics", 162, "curve is the simplest, purest form of Recurve with no extra boosts.", airwin2rack::curve::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/kCathedral.h" -int kCathedral_unused = AirwinRegistry::registerAirwindow({"kCathedral", "Reverb", 256, "kCathedral is a giant reverby space.", airwin2rack::kCathedral::kNumParameters, []() { return std::make_unique(0); }}); +int kCathedral_unused = AirwinRegistry::registerAirwindow({"kCathedral", "Reverb", 257, "kCathedral is a giant reverby space.", airwin2rack::kCathedral::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/kChamberAR.h" int kChamberAR_unused = AirwinRegistry::registerAirwindow({"kChamberAR", "Ambience", 11, "kChamberAR is a take on tape echo into chamber echo.", airwin2rack::kChamberAR::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/kPlateA.h" -int kPlateA_unused = AirwinRegistry::registerAirwindow({"kPlateA", "Reverb", 251, "kPlateA is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateA::kNumParameters, []() { return std::make_unique(0); }}); +int kPlateA_unused = AirwinRegistry::registerAirwindow({"kPlateA", "Reverb", 252, "kPlateA is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateA::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/kPlateB.h" -int kPlateB_unused = AirwinRegistry::registerAirwindow({"kPlateB", "Reverb", 250, "kPlateB is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateB::kNumParameters, []() { return std::make_unique(0); }}); +int kPlateB_unused = AirwinRegistry::registerAirwindow({"kPlateB", "Reverb", 251, "kPlateB is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateB::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/kPlateC.h" -int kPlateC_unused = AirwinRegistry::registerAirwindow({"kPlateC", "Reverb", 252, "kPlateC is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateC::kNumParameters, []() { return std::make_unique(0); }}); +int kPlateC_unused = AirwinRegistry::registerAirwindow({"kPlateC", "Reverb", 253, "kPlateC is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateC::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/kPlateD.h" -int kPlateD_unused = AirwinRegistry::registerAirwindow({"kPlateD", "Reverb", 249, "kPlateD is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateD::kNumParameters, []() { return std::make_unique(0); }}); +int kPlateD_unused = AirwinRegistry::registerAirwindow({"kPlateD", "Reverb", 250, "kPlateD is a plate reverb, not unlike its namesake atop Abbey Road.", airwin2rack::kPlateD::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/uLawDecode.h" -int uLawDecode_unused = AirwinRegistry::registerAirwindow({"uLawDecode", "Utility", 343, "uLawDecode is a Console-like encode/decode pair, but much more extreme.", airwin2rack::uLawDecode::kNumParameters, []() { return std::make_unique(0); }}); +int uLawDecode_unused = AirwinRegistry::registerAirwindow({"uLawDecode", "Utility", 344, "uLawDecode is a Console-like encode/decode pair, but much more extreme.", airwin2rack::uLawDecode::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/uLawEncode.h" -int uLawEncode_unused = AirwinRegistry::registerAirwindow({"uLawEncode", "Utility", 342, "uLawEncode is a Console-like encode/decode pair, but much more extreme.", airwin2rack::uLawEncode::kNumParameters, []() { return std::make_unique(0); }}); +int uLawEncode_unused = AirwinRegistry::registerAirwindow({"uLawEncode", "Utility", 343, "uLawEncode is a Console-like encode/decode pair, but much more extreme.", airwin2rack::uLawEncode::kNumParameters, []() { return std::make_unique(0); }}); int unusedComplete = AirwinRegistry::completeRegistry();