From 72d08d50fe660b6f921e36e81ba51efa4f36958f Mon Sep 17 00:00:00 2001 From: GithubActions BaconPaul Bot Date: Sun, 29 Oct 2023 00:55:06 +0000 Subject: [PATCH] Update to Latest Airwin --- libs/airwindows | 2 +- res/awpdoc/ConsoleMCBuss.txt | 19 + res/awpdoc/ConsoleMCChannel.txt | 19 + src/ModuleAdd.h | 586 +++++++------- src/autogen_airwin/CMakeLists.txt | 4 + src/autogen_airwin/ClearCoat.cpp | 220 +++++ src/autogen_airwin/ClearCoat.h | 205 +++++ src/autogen_airwin/ClearCoatProc.cpp | 746 +++++++++++++++++ src/autogen_airwin/kCathedral.cpp | 267 ++++++ src/autogen_airwin/kCathedral.h | 310 +++++++ src/autogen_airwin/kCathedralProc.cpp | 1072 +++++++++++++++++++++++++ 11 files changed, 3158 insertions(+), 292 deletions(-) create mode 100644 res/awpdoc/ConsoleMCBuss.txt create mode 100644 res/awpdoc/ConsoleMCChannel.txt create mode 100644 src/autogen_airwin/ClearCoat.cpp create mode 100644 src/autogen_airwin/ClearCoat.h create mode 100644 src/autogen_airwin/ClearCoatProc.cpp create mode 100644 src/autogen_airwin/kCathedral.cpp create mode 100644 src/autogen_airwin/kCathedral.h create mode 100644 src/autogen_airwin/kCathedralProc.cpp diff --git a/libs/airwindows b/libs/airwindows index 08ade46..cefb199 160000 --- a/libs/airwindows +++ b/libs/airwindows @@ -1 +1 @@ -Subproject commit 08ade46aad71815ee0dfcd95ff54fcfcc5836f3a +Subproject commit cefb199ff87c9bc987d87ce0972120c84d9e5a5d diff --git a/res/awpdoc/ConsoleMCBuss.txt b/res/awpdoc/ConsoleMCBuss.txt new file mode 100644 index 0000000..479a689 --- /dev/null +++ b/res/awpdoc/ConsoleMCBuss.txt @@ -0,0 +1,19 @@ +# ConsoleMCBuss goes for the tone shaping of the classic MCI console! + +This has been a real journey, to get to this point. + +ConsoleMC is replacing my fully analog mixing system, which I'm now looking to sell off. Technically, just the mixer, as I can re-use the Lavry for tracking, where I used to have it dedicated to re-capturing the mixdown from the Heritage Audio mixer. This is what it took, to retire that glorious beast. + +It's a channel strip that functions like a normal Console Channel, except it's got treble, a sweepable mid that only boosts (like the classic MCI mid boost), bass, a fader that runs before the EQ section like the classic MCI, and a special pan switching network that's like an evil cousin of LCR panning. And it's a summing buss that brings the summing character of the big MCI desks with a gnarly analog dirtiness that's not simply 'add a distortion box' but is actually a modification of other recent and unique work I've put out. + +ConsoleMC draws on the following recent plugins: Creature. SubTight. Sinew. ResEQ2. Pear. BitShiftPan. There is not a single normal DSP algorithm in this thing unless you count sin() and asin() functions. It is ALL built out of current, 2023 Airwindows plugins that have all been pretty well received, sometimes with a fair bit of excitement. I told you all this was working up to something. This is it. + +Specifically, this is the first 'it' to come together: I've got at least five other big console concepts that deserve this treatment, but ConsoleMC is right here for you to jump into, right now. There's a couple reverbs in the demo, including kCathedral which is a call-out to the corresponding Bricasti patch. Those are for later. + +ConsoleMC is designed around running at 96k (or possibly 192k if you're so inclined) but ought to work at 44.1k. If you're at low sample rate and seek to oversample it 2x or 4x it shouldn't do it any harm but try running it at 1x to see if you get more immediacy, as it learns from Console Zero and can put across a very clean signal path. + +All of the EQ options are designed to be pristine when flat (mids, being boost only, are flat at 0.0 boost, not 0.5) and bring in multiple stages as you crank them harder and harder, whether it's the highs and mids getting increasingly saturated or the mids getting increasingly high-Q, allowing for everything from clarity to tonal extremeness thoroughly beyond what any real MCI console would do. This is not a clone, it's a tone in its own right, that tries to do the same job as some of the greatest big analog consoles ever to exist, but does it by the unforgiving and touchy rules of digital. + +I hope it brings you joy, and helps you get your sound as it helps me get mine. + + diff --git a/res/awpdoc/ConsoleMCChannel.txt b/res/awpdoc/ConsoleMCChannel.txt new file mode 100644 index 0000000..44d18bf --- /dev/null +++ b/res/awpdoc/ConsoleMCChannel.txt @@ -0,0 +1,19 @@ +# ConsoleMCChannel goes for the tone shaping of the classic MCI console! + +This has been a real journey, to get to this point. + +ConsoleMC is replacing my fully analog mixing system, which I'm now looking to sell off. Technically, just the mixer, as I can re-use the Lavry for tracking, where I used to have it dedicated to re-capturing the mixdown from the Heritage Audio mixer. This is what it took, to retire that glorious beast. + +It's a channel strip that functions like a normal Console Channel, except it's got treble, a sweepable mid that only boosts (like the classic MCI mid boost), bass, a fader that runs before the EQ section like the classic MCI, and a special pan switching network that's like an evil cousin of LCR panning. And it's a summing buss that brings the summing character of the big MCI desks with a gnarly analog dirtiness that's not simply 'add a distortion box' but is actually a modification of other recent and unique work I've put out. + +ConsoleMC draws on the following recent plugins: Creature. SubTight. Sinew. ResEQ2. Pear. BitShiftPan. There is not a single normal DSP algorithm in this thing unless you count sin() and asin() functions. It is ALL built out of current, 2023 Airwindows plugins that have all been pretty well received, sometimes with a fair bit of excitement. I told you all this was working up to something. This is it. + +Specifically, this is the first 'it' to come together: I've got at least five other big console concepts that deserve this treatment, but ConsoleMC is right here for you to jump into, right now. There's a couple reverbs in the demo, including kCathedral which is a call-out to the corresponding Bricasti patch. Those are for later. + +ConsoleMC is designed around running at 96k (or possibly 192k if you're so inclined) but ought to work at 44.1k. If you're at low sample rate and seek to oversample it 2x or 4x it shouldn't do it any harm but try running it at 1x to see if you get more immediacy, as it learns from Console Zero and can put across a very clean signal path. + +All of the EQ options are designed to be pristine when flat (mids, being boost only, are flat at 0.0 boost, not 0.5) and bring in multiple stages as you crank them harder and harder, whether it's the highs and mids getting increasingly saturated or the mids getting increasingly high-Q, allowing for everything from clarity to tonal extremeness thoroughly beyond what any real MCI console would do. This is not a clone, it's a tone in its own right, that tries to do the same job as some of the greatest big analog consoles ever to exist, but does it by the unforgiving and touchy rules of digital. + +I hope it brings you joy, and helps you get your sound as it helps me get mine. + + diff --git a/src/ModuleAdd.h b/src/ModuleAdd.h index 5c75fa5..8b317d0 100644 --- a/src/ModuleAdd.h +++ b/src/ModuleAdd.h @@ -13,21 +13,21 @@ int Air_unused = AirwinRegistry::registerAirwindow({"Air", "Brightness", 61, "Ai #include "autogen_airwin/Air2.h" int Air2_unused = AirwinRegistry::registerAirwindow({"Air2", "Brightness", 60, "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", 308, "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", 309, "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", 109, "AtmosphereBuss is Console5 processing with powerful new acoustic distance effects.", airwin2rack::AtmosphereBuss::kNumParameters, []() { return std::make_unique(0); }}); +int AtmosphereBuss_unused = AirwinRegistry::registerAirwindow({"AtmosphereBuss", "Consoles", 111, "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", 110, "AtmosphereChannel is Console5 processing with powerful new acoustic distance effects.", airwin2rack::AtmosphereChannel::kNumParameters, []() { return std::make_unique(0); }}); +int AtmosphereChannel_unused = AirwinRegistry::registerAirwindow({"AtmosphereChannel", "Consoles", 112, "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", 182, "Aura is a new kind of resonant lowpass EQ.", airwin2rack::Aura::kNumParameters, []() { return std::make_unique(0); }}); +int Aura_unused = AirwinRegistry::registerAirwindow({"Aura", "Effects", 183, "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", 280, "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", 281, "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", 207, "AverMatrix turns averaging into a full-featured EQ.", airwin2rack::AverMatrix::kNumParameters, []() { return std::make_unique(0); }}); +int AverMatrix_unused = AirwinRegistry::registerAirwindow({"AverMatrix", "Filter", 208, "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", 208, "Average is a distinctive sort of lowpass filter.", airwin2rack::Average::kNumParameters, []() { return std::make_unique(0); }}); +int Average_unused = AirwinRegistry::registerAirwindow({"Average", "Filter", 209, "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", 341, "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", 342, "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", 33, "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", 36, "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", 210, "Baxandall is a killer general-purpose EQ.", airwin2rack::Baxandall::kNumParameters, []() { return std::make_unique(0); }}); +int Baxandall_unused = AirwinRegistry::registerAirwindow({"Baxandall", "Filter", 211, "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", 196, "Baxandall2 is Baxandall, extended and made more powerful.", airwin2rack::Baxandall2::kNumParameters, []() { return std::make_unique(0); }}); +int Baxandall2_unused = AirwinRegistry::registerAirwindow({"Baxandall2", "Filter", 197, "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", 133, "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", 134, "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", 30, "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", 46, "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", 229, "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", 230, "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", 325, "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", 326, "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", 324, "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", 325, "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", 234, "Bite is an unusual edge-maker.", airwin2rack::Bite::kNumParameters, []() { return std::make_unique(0); }}); +int Bite_unused = AirwinRegistry::registerAirwindow({"Bite", "Lo-Fi", 235, "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", 160, "BlockParty is like a moderately saturated analog limiter.", airwin2rack::BlockParty::kNumParameters, []() { return std::make_unique(0); }}); +int BlockParty_unused = AirwinRegistry::registerAirwindow({"BlockParty", "Dynamics", 161, "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", 166, "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", 167, "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", 18, "BrightAmbience is a plugin for very bright gated reverbs.", airwin2rack::BrightAmbience::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/BrightAmbience2.h" @@ -73,131 +73,133 @@ int BrightAmbience2_unused = AirwinRegistry::registerAirwindow({"BrightAmbience2 #include "autogen_airwin/BrightAmbience3.h" int BrightAmbience3_unused = AirwinRegistry::registerAirwindow({"BrightAmbience3", "Ambience", 4, "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", 139, "BuildATPDF is a dither-making toolkit.", airwin2rack::BuildATPDF::kNumParameters, []() { return std::make_unique(0); }}); +int BuildATPDF_unused = AirwinRegistry::registerAirwindow({"BuildATPDF", "Dithers", 140, "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", 306, "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", 307, "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", 165, "ButterComp is my softest, smoothest compressor.", airwin2rack::ButterComp::kNumParameters, []() { return std::make_unique(0); }}); +int ButterComp_unused = AirwinRegistry::registerAirwindow({"ButterComp", "Dynamics", 166, "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", 156, "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", 157, "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", 107, "C5RawBuss is the original Console5 algorithm, with optional very gentle DC suppression.", airwin2rack::C5RawBuss::kNumParameters, []() { return std::make_unique(0); }}); +int C5RawBuss_unused = AirwinRegistry::registerAirwindow({"C5RawBuss", "Consoles", 109, "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" -int C5RawChannel_unused = AirwinRegistry::registerAirwindow({"C5RawChannel", "Consoles", 108, "C5RawChannel is the original Console5 algorithm, with optional very gentle DC suppression.", airwin2rack::C5RawChannel::kNumParameters, []() { return std::make_unique(0); }}); +int C5RawChannel_unused = AirwinRegistry::registerAirwindow({"C5RawChannel", "Consoles", 110, "C5RawChannel is the original Console5 algorithm, with optional very gentle DC suppression.", airwin2rack::C5RawChannel::kNumParameters, []() { return std::make_unique(0); }}); #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", 201, "CStrip2 refines and optimizes CStrip, by request!", airwin2rack::CStrip2::kNumParameters, []() { return std::make_unique(0); }}); +int CStrip2_unused = AirwinRegistry::registerAirwindow({"CStrip2", "Filter", 202, "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", 31, "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", 311, "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", 312, "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", 213, "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", 214, "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", 197, "Capacitor2 is Capacitor with extra analog modeling and mojo.", airwin2rack::Capacitor2::kNumParameters, []() { return std::make_unique(0); }}); +int Capacitor2_unused = AirwinRegistry::registerAirwindow({"Capacitor2", "Filter", 198, "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", 254, "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", 255, "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", 253, "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", 254, "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", 320, "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", 321, "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", 319, "Channel5 is Channel for 2018, with new subtleties.", airwin2rack::Channel5::kNumParameters, []() { return std::make_unique(0); }}); +int Channel5_unused = AirwinRegistry::registerAirwindow({"Channel5", "Tone Color", 320, "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", 318, "Channel6 uses the Spiral algorithm.", airwin2rack::Channel6::kNumParameters, []() { return std::make_unique(0); }}); +int Channel6_unused = AirwinRegistry::registerAirwindow({"Channel6", "Tone Color", 319, "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", 317, "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", 318, "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", 316, "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", 317, "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", 307, "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", 308, "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", 21, "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", 22, "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", 231, "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", 232, "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", 312, "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", 313, "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", "Unclassified", -1, "", airwin2rack::ClearCoat::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ClipOnly2.h" int ClipOnly2_unused = AirwinRegistry::registerAirwindow({"ClipOnly2", "Clipping", 71, "ClipOnly2 suppresses the brightness of digital clipping without affecting unclipped samples, at any sample rate.", airwin2rack::ClipOnly2::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ClipSoftly.h" int ClipSoftly_unused = AirwinRegistry::registerAirwindow({"ClipSoftly", "Clipping", 72, "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", 295, "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", 296, "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", 290, "Coils2 is a transformer overdrive emulator.", airwin2rack::Coils2::kNumParameters, []() { return std::make_unique(0); }}); +int Coils2_unused = AirwinRegistry::registerAirwindow({"Coils2", "Subtlety", 291, "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", 232, "Cojones is a new kind of distorty.", airwin2rack::Cojones::kNumParameters, []() { return std::make_unique(0); }}); +int Cojones_unused = AirwinRegistry::registerAirwindow({"Cojones", "Lo-Fi", 233, "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", 163, "Compresaturator fades between compressing and soft clipping.", airwin2rack::Compresaturator::kNumParameters, []() { return std::make_unique(0); }}); +int Compresaturator_unused = AirwinRegistry::registerAirwindow({"Compresaturator", "Dynamics", 164, "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", 89, "Console0Buss is a radical, minimalist Console system.", airwin2rack::Console0Buss::kNumParameters, []() { return std::make_unique(0); }}); +int Console0Buss_unused = AirwinRegistry::registerAirwindow({"Console0Buss", "Consoles", 91, "Console0Buss is a radical, minimalist Console system.", airwin2rack::Console0Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console0Channel.h" -int Console0Channel_unused = AirwinRegistry::registerAirwindow({"Console0Channel", "Consoles", 88, "Console0Channel is a radical, minimalist Console system.", airwin2rack::Console0Channel::kNumParameters, []() { return std::make_unique(0); }}); +int Console0Channel_unused = AirwinRegistry::registerAirwindow({"Console0Channel", "Consoles", 90, "Console0Channel is a radical, minimalist Console system.", airwin2rack::Console0Channel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console4Buss.h" -int Console4Buss_unused = AirwinRegistry::registerAirwindow({"Console4Buss", "Consoles", 112, "Console4Buss is the original Airwindows ITB mixing system, a two-plugin mix buss replacement for DAWs.", airwin2rack::Console4Buss::kNumParameters, []() { return std::make_unique(0); }}); +int Console4Buss_unused = AirwinRegistry::registerAirwindow({"Console4Buss", "Consoles", 113, "Console4Buss is the original Airwindows ITB mixing system, a two-plugin mix buss replacement for DAWs.", airwin2rack::Console4Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console4Channel.h" -int Console4Channel_unused = AirwinRegistry::registerAirwindow({"Console4Channel", "Consoles", 113, "Console4Channel is the original Airwindows ITB mixing system, a two-plugin mix buss replacement for DAWs.", airwin2rack::Console4Channel::kNumParameters, []() { return std::make_unique(0); }}); +int Console4Channel_unused = AirwinRegistry::registerAirwindow({"Console4Channel", "Consoles", 114, "Console4Channel is the original Airwindows ITB mixing system, a two-plugin mix buss replacement for DAWs.", airwin2rack::Console4Channel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console5Buss.h" -int Console5Buss_unused = AirwinRegistry::registerAirwindow({"Console5Buss", "Consoles", 104, "Console5Buss is a richer, warmer Console system.", airwin2rack::Console5Buss::kNumParameters, []() { return std::make_unique(0); }}); +int Console5Buss_unused = AirwinRegistry::registerAirwindow({"Console5Buss", "Consoles", 106, "Console5Buss is a richer, warmer Console system.", airwin2rack::Console5Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console5Channel.h" -int Console5Channel_unused = AirwinRegistry::registerAirwindow({"Console5Channel", "Consoles", 105, "Console5Channel is a richer, warmer Console system.", airwin2rack::Console5Channel::kNumParameters, []() { return std::make_unique(0); }}); +int Console5Channel_unused = AirwinRegistry::registerAirwindow({"Console5Channel", "Consoles", 107, "Console5Channel is a richer, warmer Console system.", airwin2rack::Console5Channel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console5DarkCh.h" -int Console5DarkCh_unused = AirwinRegistry::registerAirwindow({"Console5DarkCh", "Consoles", 106, "Console5DarkCh is a richer, warmer Console system.", airwin2rack::Console5DarkCh::kNumParameters, []() { return std::make_unique(0); }}); +int Console5DarkCh_unused = AirwinRegistry::registerAirwindow({"Console5DarkCh", "Consoles", 108, "Console5DarkCh is a richer, warmer Console system.", airwin2rack::Console5DarkCh::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console6Buss.h" -int Console6Buss_unused = AirwinRegistry::registerAirwindow({"Console6Buss", "Consoles", 100, "Console6Buss is a new more intense Console that peaks at lower dB.", airwin2rack::Console6Buss::kNumParameters, []() { return std::make_unique(0); }}); +int Console6Buss_unused = AirwinRegistry::registerAirwindow({"Console6Buss", "Consoles", 102, "Console6Buss is a new more intense Console that peaks at lower dB.", airwin2rack::Console6Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console6Channel.h" -int Console6Channel_unused = AirwinRegistry::registerAirwindow({"Console6Channel", "Consoles", 101, "Console6Channel is a new more intense Console that peaks at lower dB.", airwin2rack::Console6Channel::kNumParameters, []() { return std::make_unique(0); }}); +int Console6Channel_unused = AirwinRegistry::registerAirwindow({"Console6Channel", "Consoles", 103, "Console6Channel is a new more intense Console that peaks at lower dB.", airwin2rack::Console6Channel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console7Buss.h" -int Console7Buss_unused = AirwinRegistry::registerAirwindow({"Console7Buss", "Consoles", 94, "Console7Buss adds anti-alias filtering and special saturation curves.", airwin2rack::Console7Buss::kNumParameters, []() { return std::make_unique(0); }}); +int Console7Buss_unused = AirwinRegistry::registerAirwindow({"Console7Buss", "Consoles", 96, "Console7Buss adds anti-alias filtering and special saturation curves.", airwin2rack::Console7Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console7Cascade.h" -int Console7Cascade_unused = AirwinRegistry::registerAirwindow({"Console7Cascade", "Consoles", 96, "Console7Cascade is a drop-in replacement for Console7Channel that allows for MUCH higher gain.", airwin2rack::Console7Cascade::kNumParameters, []() { return std::make_unique(0); }}); +int Console7Cascade_unused = AirwinRegistry::registerAirwindow({"Console7Cascade", "Consoles", 98, "Console7Cascade is a drop-in replacement for Console7Channel that allows for MUCH higher gain.", airwin2rack::Console7Cascade::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console7Channel.h" -int Console7Channel_unused = AirwinRegistry::registerAirwindow({"Console7Channel", "Consoles", 95, "Console7Channel adds anti-alias filtering and special saturation curves.", airwin2rack::Console7Channel::kNumParameters, []() { return std::make_unique(0); }}); +int Console7Channel_unused = AirwinRegistry::registerAirwindow({"Console7Channel", "Consoles", 97, "Console7Channel adds anti-alias filtering and special saturation curves.", airwin2rack::Console7Channel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console7Crunch.h" -int Console7Crunch_unused = AirwinRegistry::registerAirwindow({"Console7Crunch", "Consoles", 97, "Console7Crunch shows you Cascade but with its EQ weighted for more edge and grit.", airwin2rack::Console7Crunch::kNumParameters, []() { return std::make_unique(0); }}); +int Console7Crunch_unused = AirwinRegistry::registerAirwindow({"Console7Crunch", "Consoles", 99, "Console7Crunch shows you Cascade but with its EQ weighted for more edge and grit.", airwin2rack::Console7Crunch::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8BussHype.h" -int Console8BussHype_unused = AirwinRegistry::registerAirwindow({"Console8BussHype", "Consoles", 79, "Console8BussHype swaps out just the In section of Console8BussIn, for a brighter sparklier circuit.", airwin2rack::Console8BussHype::kNumParameters, []() { return std::make_unique(0); }}); +int Console8BussHype_unused = AirwinRegistry::registerAirwindow({"Console8BussHype", "Consoles", 81, "Console8BussHype swaps out just the In section of Console8BussIn, for a brighter sparklier circuit.", airwin2rack::Console8BussHype::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8BussIn.h" -int Console8BussIn_unused = AirwinRegistry::registerAirwindow({"Console8BussIn", "Consoles", 80, "Console8BussIn moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8BussIn::kNumParameters, []() { return std::make_unique(0); }}); +int Console8BussIn_unused = AirwinRegistry::registerAirwindow({"Console8BussIn", "Consoles", 82, "Console8BussIn moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8BussIn::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8BussOut.h" -int Console8BussOut_unused = AirwinRegistry::registerAirwindow({"Console8BussOut", "Consoles", 81, "Console8BussOut moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8BussOut::kNumParameters, []() { return std::make_unique(0); }}); +int Console8BussOut_unused = AirwinRegistry::registerAirwindow({"Console8BussOut", "Consoles", 83, "Console8BussOut moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8BussOut::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8ChannelHype.h" -int Console8ChannelHype_unused = AirwinRegistry::registerAirwindow({"Console8ChannelHype", "Consoles", 82, "Console8ChannelHype swaps out just the In section of Console8ChannelIn, for a brighter sparklier circuit.", airwin2rack::Console8ChannelHype::kNumParameters, []() { return std::make_unique(0); }}); +int Console8ChannelHype_unused = AirwinRegistry::registerAirwindow({"Console8ChannelHype", "Consoles", 84, "Console8ChannelHype swaps out just the In section of Console8ChannelIn, for a brighter sparklier circuit.", airwin2rack::Console8ChannelHype::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8ChannelIn.h" -int Console8ChannelIn_unused = AirwinRegistry::registerAirwindow({"Console8ChannelIn", "Consoles", 83, "Console8ChannelIn moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8ChannelIn::kNumParameters, []() { return std::make_unique(0); }}); +int Console8ChannelIn_unused = AirwinRegistry::registerAirwindow({"Console8ChannelIn", "Consoles", 85, "Console8ChannelIn moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8ChannelIn::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8ChannelOut.h" -int Console8ChannelOut_unused = AirwinRegistry::registerAirwindow({"Console8ChannelOut", "Consoles", 84, "Console8ChannelOut moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8ChannelOut::kNumParameters, []() { return std::make_unique(0); }}); +int Console8ChannelOut_unused = AirwinRegistry::registerAirwindow({"Console8ChannelOut", "Consoles", 86, "Console8ChannelOut moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8ChannelOut::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8LiteBuss.h" -int Console8LiteBuss_unused = AirwinRegistry::registerAirwindow({"Console8LiteBuss", "Consoles", 78, "Console8LiteBuss is simplified Console8, working with just a single mix buss.", airwin2rack::Console8LiteBuss::kNumParameters, []() { return std::make_unique(0); }}); +int Console8LiteBuss_unused = AirwinRegistry::registerAirwindow({"Console8LiteBuss", "Consoles", 80, "Console8LiteBuss is simplified Console8, working with just a single mix buss.", airwin2rack::Console8LiteBuss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8LiteChannel.h" -int Console8LiteChannel_unused = AirwinRegistry::registerAirwindow({"Console8LiteChannel", "Consoles", 77, "Console8LiteChannel is simplified Console8, working with just a single mix buss.", airwin2rack::Console8LiteChannel::kNumParameters, []() { return std::make_unique(0); }}); +int Console8LiteChannel_unused = AirwinRegistry::registerAirwindow({"Console8LiteChannel", "Consoles", 79, "Console8LiteChannel is simplified Console8, working with just a single mix buss.", airwin2rack::Console8LiteChannel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8SubHype.h" -int Console8SubHype_unused = AirwinRegistry::registerAirwindow({"Console8SubHype", "Consoles", 85, "Console8SubHype swaps out just the In section of Console8SubIn, for a brighter sparklier circuit.", airwin2rack::Console8SubHype::kNumParameters, []() { return std::make_unique(0); }}); +int Console8SubHype_unused = AirwinRegistry::registerAirwindow({"Console8SubHype", "Consoles", 87, "Console8SubHype swaps out just the In section of Console8SubIn, for a brighter sparklier circuit.", airwin2rack::Console8SubHype::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8SubIn.h" -int Console8SubIn_unused = AirwinRegistry::registerAirwindow({"Console8SubIn", "Consoles", 86, "Console8SubIn moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8SubIn::kNumParameters, []() { return std::make_unique(0); }}); +int Console8SubIn_unused = AirwinRegistry::registerAirwindow({"Console8SubIn", "Consoles", 88, "Console8SubIn moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8SubIn::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Console8SubOut.h" -int Console8SubOut_unused = AirwinRegistry::registerAirwindow({"Console8SubOut", "Consoles", 87, "Console8SubOut moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8SubOut::kNumParameters, []() { return std::make_unique(0); }}); +int Console8SubOut_unused = AirwinRegistry::registerAirwindow({"Console8SubOut", "Consoles", 89, "Console8SubOut moves to a channel/submix/buss topology and adds analog simulation.", airwin2rack::Console8SubOut::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ConsoleMCBuss.h" -int ConsoleMCBuss_unused = AirwinRegistry::registerAirwindow({"ConsoleMCBuss", "Unclassified", -1, "", airwin2rack::ConsoleMCBuss::kNumParameters, []() { return std::make_unique(0); }}); +int ConsoleMCBuss_unused = AirwinRegistry::registerAirwindow({"ConsoleMCBuss", "Consoles", 77, "ConsoleMCBuss goes for the tone shaping of the classic MCI console!", airwin2rack::ConsoleMCBuss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/ConsoleMCChannel.h" -int ConsoleMCChannel_unused = AirwinRegistry::registerAirwindow({"ConsoleMCChannel", "Unclassified", -1, "", airwin2rack::ConsoleMCChannel::kNumParameters, []() { return std::make_unique(0); }}); +int ConsoleMCChannel_unused = AirwinRegistry::registerAirwindow({"ConsoleMCChannel", "Consoles", 78, "ConsoleMCChannel goes for the tone shaping of the classic MCI console!", airwin2rack::ConsoleMCChannel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Creature.h" -int Creature_unused = AirwinRegistry::registerAirwindow({"Creature", "Saturation", 261, "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", 262, "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", 27, "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", 225, "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", 226, "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", 313, "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", 314, "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", 334, "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", 335, "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", 126, "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", 127, "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", 241, "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", 242, "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", 49, "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" @@ -205,355 +207,355 @@ int DeEss_unused = AirwinRegistry::registerAirwindow({"DeEss", "Brightness", 54, #include "autogen_airwin/DeHiss.h" int DeHiss_unused = AirwinRegistry::registerAirwindow({"DeHiss", "Brightness", 64, "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", 230, "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", 231, "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", 228, "DeRez2 brings more authentic retro-digital hardware tones.", airwin2rack::DeRez2::kNumParameters, []() { return std::make_unique(0); }}); +int DeRez2_unused = AirwinRegistry::registerAirwindow({"DeRez2", "Lo-Fi", 229, "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", 235, "Deckwrecka fattens and dirties up beats.", airwin2rack::Deckwrecka::kNumParameters, []() { return std::make_unique(0); }}); +int Deckwrecka_unused = AirwinRegistry::registerAirwindow({"Deckwrecka", "Lo-Fi", 236, "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", 120, "Density is a Swiss Army Knife of saturation/antisaturation.", airwin2rack::Density::kNumParameters, []() { return std::make_unique(0); }}); +int Density_unused = AirwinRegistry::registerAirwindow({"Density", "Distortion", 121, "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", 119, "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", 120, "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", 296, "Desk is classic Airwindows subtle analog modeling.", airwin2rack::Desk::kNumParameters, []() { return std::make_unique(0); }}); +int Desk_unused = AirwinRegistry::registerAirwindow({"Desk", "Subtlety", 297, "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", 273, "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", 274, "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", 153, "DigitalBlack is a quick, staccato gate.", airwin2rack::DigitalBlack::kNumParameters, []() { return std::make_unique(0); }}); +int DigitalBlack_unused = AirwinRegistry::registerAirwindow({"DigitalBlack", "Dynamics", 154, "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", 117, "Dirt is a soft-clip distortion in the spirit of Edge.", airwin2rack::Dirt::kNumParameters, []() { return std::make_unique(0); }}); +int Dirt_unused = AirwinRegistry::registerAirwindow({"Dirt", "Distortion", 118, "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", 220, "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", 221, "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", 219, "Distance2 is a versatile space shaper for creating depth.", airwin2rack::Distance2::kNumParameters, []() { return std::make_unique(0); }}); +int Distance2_unused = AirwinRegistry::registerAirwindow({"Distance2", "Filter", 220, "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", 115, "Distortion is a slightly dark analog-style distortion with several presets, like Focus.", airwin2rack::Distortion::kNumParameters, []() { return std::make_unique(0); }}); +int Distortion_unused = AirwinRegistry::registerAirwindow({"Distortion", "Distortion", 116, "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", 148, "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", 149, "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", 143, "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", 144, "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", 142, "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", 143, "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", 138, "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", 139, "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", 137, "DoublePaul is like PaulDither but more so.", airwin2rack::DoublePaul::kNumParameters, []() { return std::make_unique(0); }}); +int DoublePaul_unused = AirwinRegistry::registerAirwindow({"DoublePaul", "Dithers", 138, "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", 1, "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", 121, "Drive is the angry distortion!", airwin2rack::Drive::kNumParameters, []() { return std::make_unique(0); }}); +int Drive_unused = AirwinRegistry::registerAirwindow({"Drive", "Distortion", 122, "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", 164, "DrumSlam is a heavy-processing tape modeler.", airwin2rack::DrumSlam::kNumParameters, []() { return std::make_unique(0); }}); +int DrumSlam_unused = AirwinRegistry::registerAirwindow({"DrumSlam", "Dynamics", 165, "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", 37, "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", 38, "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", 178, "Dubly is a retro vibe and atmosphere maker.", airwin2rack::Dubly::kNumParameters, []() { return std::make_unique(0); }}); +int Dubly_unused = AirwinRegistry::registerAirwindow({"Dubly", "Effects", 179, "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", 236, "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", 237, "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", 151, "Dynamics is a combination compressor gate.", airwin2rack::Dynamics::kNumParameters, []() { return std::make_unique(0); }}); +int Dynamics_unused = AirwinRegistry::registerAirwindow({"Dynamics", "Dynamics", 152, "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", 270, "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", 271, "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", 212, "EQ is just the EQ parts of CStrip.", airwin2rack::EQ::kNumParameters, []() { return std::make_unique(0); }}); +int EQ_unused = AirwinRegistry::registerAirwindow({"EQ", "Filter", 213, "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", 335, "EdIsDim is mid/side conversion utility plugins.", airwin2rack::EdIsDim::kNumParameters, []() { return std::make_unique(0); }}); +int EdIsDim_unused = AirwinRegistry::registerAirwindow({"EdIsDim", "Utility", 336, "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", 116, "Edge is a seven-stage distortion with Hypersonic filtering and tone shaping controls.", airwin2rack::Edge::kNumParameters, []() { return std::make_unique(0); }}); +int Edge_unused = AirwinRegistry::registerAirwindow({"Edge", "Distortion", 117, "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", 310, "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", 311, "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", 242, "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", 243, "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", 189, "Energy is electrifying fixed-frequency treble boosts.", airwin2rack::Energy::kNumParameters, []() { return std::make_unique(0); }}); +int Energy_unused = AirwinRegistry::registerAirwindow({"Energy", "Effects", 190, "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", 188, "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", 189, "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", 23, "Ensemble is a weird flangey little modulation effect.", airwin2rack::Ensemble::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/EveryConsole.h" -int EveryConsole_unused = AirwinRegistry::registerAirwindow({"EveryConsole", "Consoles", 114, "EveryConsole is mix-and-match Airwindows Console.", airwin2rack::EveryConsole::kNumParameters, []() { return std::make_unique(0); }}); +int EveryConsole_unused = AirwinRegistry::registerAirwindow({"EveryConsole", "Consoles", 115, "EveryConsole is mix-and-match Airwindows Console.", airwin2rack::EveryConsole::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/EverySlew.h" int EverySlew_unused = AirwinRegistry::registerAirwindow({"EverySlew", "Brightness", 56, "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", 328, "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", 329, "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", 187, "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", 188, "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", 190, "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", 191, "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", 41, "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", 25, "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", 342, "Flipity is a channel phase flipper/swapper utility.", airwin2rack::Flipity::kNumParameters, []() { return std::make_unique(0); }}); +int Flipity_unused = AirwinRegistry::registerAirwindow({"Flipity", "Utility", 343, "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", 39, "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", 224, "Flutter is the most recent Airwindows flutter, standalone.", airwin2rack::Flutter::kNumParameters, []() { return std::make_unique(0); }}); +int Flutter_unused = AirwinRegistry::registerAirwindow({"Flutter", "Lo-Fi", 225, "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", 268, "Focus brings out clarity by distorting. Aggressive, subtle, flexible.", airwin2rack::Focus::kNumParameters, []() { return std::make_unique(0); }}); +int Focus_unused = AirwinRegistry::registerAirwindow({"Focus", "Saturation", 269, "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", 191, "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", 192, "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", 177, "Fracture2 is a wavefolder that allows more extreme disruption.", airwin2rack::Fracture2::kNumParameters, []() { return std::make_unique(0); }}); +int Fracture2_unused = AirwinRegistry::registerAirwindow({"Fracture2", "Effects", 178, "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", 300, "FromTape is a minimalist, cleaner analog tape emulation.", airwin2rack::FromTape::kNumParameters, []() { return std::make_unique(0); }}); +int FromTape_unused = AirwinRegistry::registerAirwindow({"FromTape", "Tape", 301, "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", 251, "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", 252, "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", 250, "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", 251, "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", 176, "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", 177, "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", 168, "Gatelope is a special gate that applies filters.", airwin2rack::Gatelope::kNumParameters, []() { return std::make_unique(0); }}); +int Gatelope_unused = AirwinRegistry::registerAirwindow({"Gatelope", "Dynamics", 169, "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", 185, "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", 186, "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", 50, "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", 333, "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", 334, "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", 24, "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", 186, "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", 187, "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", 226, "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", 227, "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", 181, "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", 182, "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", 123, "HardVacuum is tube style saturation effects.", airwin2rack::HardVacuum::kNumParameters, []() { return std::make_unique(0); }}); +int HardVacuum_unused = AirwinRegistry::registerAirwindow({"HardVacuum", "Distortion", 124, "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", 329, "HermeTrim is Very Fine Adjustments, otherwise just like EveryTrim.", airwin2rack::HermeTrim::kNumParameters, []() { return std::make_unique(0); }}); +int HermeTrim_unused = AirwinRegistry::registerAirwindow({"HermeTrim", "Utility", 330, "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", 35, "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", 147, "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", 148, "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", 124, "HighImpact is distorted grit and punch without fatness.", airwin2rack::HighImpact::kNumParameters, []() { return std::make_unique(0); }}); +int HighImpact_unused = AirwinRegistry::registerAirwindow({"HighImpact", "Distortion", 125, "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", 222, "Highpass is a time warp, for retro midrangey sounds.", airwin2rack::Highpass::kNumParameters, []() { return std::make_unique(0); }}); +int Highpass_unused = AirwinRegistry::registerAirwindow({"Highpass", "Filter", 223, "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", 218, "Highpass2 is an unusual-sounding variable-slope highpass filter.", airwin2rack::Highpass2::kNumParameters, []() { return std::make_unique(0); }}); +int Highpass2_unused = AirwinRegistry::registerAirwindow({"Highpass2", "Filter", 219, "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", 205, "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", 206, "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", 204, "Holt2 is a bass-cab-like resonant lowpass filter.", airwin2rack::Holt2::kNumParameters, []() { return std::make_unique(0); }}); +int Holt2_unused = AirwinRegistry::registerAirwindow({"Holt2", "Filter", 205, "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", 16, "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", 262, "Huge is a dirty, dirty loudenator.", airwin2rack::Huge::kNumParameters, []() { return std::make_unique(0); }}); +int Huge_unused = AirwinRegistry::registerAirwindow({"Huge", "Saturation", 263, "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", 211, "Hull is an alternate form of highpass/lowpass filter.", airwin2rack::Hull::kNumParameters, []() { return std::make_unique(0); }}); +int Hull_unused = AirwinRegistry::registerAirwindow({"Hull", "Filter", 212, "Hull is an alternate form of highpass/lowpass filter.", airwin2rack::Hull::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/Hype.h" -int Hype_unused = AirwinRegistry::registerAirwindow({"Hype", "Subtlety", 284, "Hype is a treble softening experiment gone strangely awry :)", airwin2rack::Hype::kNumParameters, []() { return std::make_unique(0); }}); +int Hype_unused = AirwinRegistry::registerAirwindow({"Hype", "Subtlety", 285, "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", 66, "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", 65, "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", 257, "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", 258, "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", 255, "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", 256, "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", 286, "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", 287, "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", 40, "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", 291, "Interstage is a subtle and sophisticated analogifier.", airwin2rack::Interstage::kNumParameters, []() { return std::make_unique(0); }}); +int Interstage_unused = AirwinRegistry::registerAirwindow({"Interstage", "Subtlety", 292, "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", 303, "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", 304, "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", 305, "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", 306, "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", 302, "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", 303, "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", 214, "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", 215, "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", 203, "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", 204, "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", 281, "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", 282, "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", 26, "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", 340, "LeftoMono copies one channel to both, losslessly.", airwin2rack::LeftoMono::kNumParameters, []() { return std::make_unique(0); }}); +int LeftoMono_unused = AirwinRegistry::registerAirwindow({"LeftoMono", "Utility", 341, "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", 28, "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", 154, "Logical4 is a classic 2-buss compressor.", airwin2rack::Logical4::kNumParameters, []() { return std::make_unique(0); }}); +int Logical4_unused = AirwinRegistry::registerAirwindow({"Logical4", "Dynamics", 155, "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", 122, "Loud is distortion and demolition of air molecules, modeled.", airwin2rack::Loud::kNumParameters, []() { return std::make_unique(0); }}); +int Loud_unused = AirwinRegistry::registerAirwindow({"Loud", "Distortion", 123, "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", 221, "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", 222, "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", 217, "Lowpass2 is an unusual-sounding variable-slope lowpass filter.", airwin2rack::Lowpass2::kNumParameters, []() { return std::make_unique(0); }}); +int Lowpass2_unused = AirwinRegistry::registerAirwindow({"Lowpass2", "Filter", 218, "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", 315, "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", 316, "Luxor is a re-release of another old Character plugin.", airwin2rack::Luxor::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MV.h" int MV_unused = AirwinRegistry::registerAirwindow({"MV", "Ambience", 8, "MV is a dual-mono reverb based on BitShiftGain and the old Midiverbs.", airwin2rack::MV::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/MV2.h" int MV2_unused = AirwinRegistry::registerAirwindow({"MV2", "Ambience", 7, "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", 209, "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", 210, "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", 118, "Mackity is an emulation of the input stage of a vintage Mackie 1202!", airwin2rack::Mackity::kNumParameters, []() { return std::make_unique(0); }}); +int Mackity_unused = AirwinRegistry::registerAirwindow({"Mackity", "Distortion", 119, "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", 258, "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", 259, "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", 6, "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", 29, "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", 336, "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", 337, "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", 343, "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", 344, "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", 269, "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", 270, "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", 323, "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", 324, "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", 322, "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", 323, "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", 321, "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", 322, "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", 125, "MultiBandDistortion is an old weird gnarly sound wrecker :)", airwin2rack::MultiBandDistortion::kNumParameters, []() { return std::make_unique(0); }}); +int MultiBandDistortion_unused = AirwinRegistry::registerAirwindow({"MultiBandDistortion", "Distortion", 126, "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", 263, "NCSeventeen is Dirty Loud!", airwin2rack::NCSeventeen::kNumParameters, []() { return std::make_unique(0); }}); +int NCSeventeen_unused = AirwinRegistry::registerAirwindow({"NCSeventeen", "Saturation", 264, "NCSeventeen is Dirty Loud!", airwin2rack::NCSeventeen::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/NaturalizeDither.h" -int NaturalizeDither_unused = AirwinRegistry::registerAirwindow({"NaturalizeDither", "Dithers", 146, "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", 147, "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", 309, "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", 310, "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", 195, "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", 196, "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", 140, "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", 141, "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", 237, "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", 238, "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", 256, "NonlinearSpace is a flexible reverb plugin.", airwin2rack::NonlinearSpace::kNumParameters, []() { return std::make_unique(0); }}); +int NonlinearSpace_unused = AirwinRegistry::registerAirwindow({"NonlinearSpace", "Reverb", 257, "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", 132, "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", 133, "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", 131, "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", 132, "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", 73, "OneCornerClip is an ultimate full-bandwidth clipper.", airwin2rack::OneCornerClip::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/OrbitKick.h" int OrbitKick_unused = AirwinRegistry::registerAirwindow({"OrbitKick", "Bass", 34, "OrbitKick is a bass generator and kick drum reinforcer.", airwin2rack::OrbitKick::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PDBuss.h" -int PDBuss_unused = AirwinRegistry::registerAirwindow({"PDBuss", "Consoles", 102, "PDBuss is Console5 and PurestDrive, sittin’ in a tree… (i.e. both at once, on channels and buss)", airwin2rack::PDBuss::kNumParameters, []() { return std::make_unique(0); }}); +int PDBuss_unused = AirwinRegistry::registerAirwindow({"PDBuss", "Consoles", 104, "PDBuss is Console5 and PurestDrive, sittin’ in a tree… (i.e. both at once, on channels and buss)", airwin2rack::PDBuss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PDChannel.h" -int PDChannel_unused = AirwinRegistry::registerAirwindow({"PDChannel", "Consoles", 103, "PDChannel is Console5 and PurestDrive, sittin’ in a tree… (i.e. both at once, on channels and buss)", airwin2rack::PDChannel::kNumParameters, []() { return std::make_unique(0); }}); +int PDChannel_unused = AirwinRegistry::registerAirwindow({"PDChannel", "Consoles", 105, "PDChannel is Console5 and PurestDrive, sittin’ in a tree… (i.e. both at once, on channels and buss)", airwin2rack::PDChannel::kNumParameters, []() { return std::make_unique(0); }}); #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", 179, "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", 180, "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", 128, "PaulDither is a highpassed TPDF dither. (quieter, airier)", airwin2rack::PaulDither::kNumParameters, []() { return std::make_unique(0); }}); +int PaulDither_unused = AirwinRegistry::registerAirwindow({"PaulDither", "Dithers", 129, "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", 127, "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", 128, "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", 332, "PeaksOnly is a transformative mix check tool.", airwin2rack::PeaksOnly::kNumParameters, []() { return std::make_unique(0); }}); +int PeaksOnly_unused = AirwinRegistry::registerAirwindow({"PeaksOnly", "Utility", 333, "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", 198, "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", 199, "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", 292, "PhaseNudge is a phase rotator/allpass filter.", airwin2rack::PhaseNudge::kNumParameters, []() { return std::make_unique(0); }}); +int PhaseNudge_unused = AirwinRegistry::registerAirwindow({"PhaseNudge", "Subtlety", 293, "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", 2, "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", 180, "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", 181, "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", 48, "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", 259, "PocketVerbs is my popular old special effects reverbs plugin!", airwin2rack::PocketVerbs::kNumParameters, []() { return std::make_unique(0); }}); +int PocketVerbs_unused = AirwinRegistry::registerAirwindow({"PocketVerbs", "Reverb", 260, "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", 227, "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", 228, "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", 223, "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", 224, "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", 170, "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", 171, "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", 169, "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", 170, "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", 167, "Point is an explosive transient designer.", airwin2rack::Point::kNumParameters, []() { return std::make_unique(0); }}); +int Point_unused = AirwinRegistry::registerAirwindow({"Point", "Dynamics", 168, "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", 152, "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", 153, "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", 149, "Pop2 adds control and punch to Pop.", airwin2rack::Pop2::kNumParameters, []() { return std::make_unique(0); }}); +int Pop2_unused = AirwinRegistry::registerAirwindow({"Pop2", "Dynamics", 150, "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", 193, "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", 194, "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", 192, "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", 193, "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", 314, "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", 315, "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", 194, "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", 195, "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", 173, "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", 174, "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", 150, "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", 151, "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", 62, "PurestAir is a brightness experiment.", airwin2rack::PurestAir::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestConsole2Buss.h" -int PurestConsole2Buss_unused = AirwinRegistry::registerAirwindow({"PurestConsole2Buss", "Consoles", 92, "PurestConsole2Buss is the distributed filter version of PurestConsole.", airwin2rack::PurestConsole2Buss::kNumParameters, []() { return std::make_unique(0); }}); +int PurestConsole2Buss_unused = AirwinRegistry::registerAirwindow({"PurestConsole2Buss", "Consoles", 94, "PurestConsole2Buss is the distributed filter version of PurestConsole.", airwin2rack::PurestConsole2Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestConsole2Channel.h" -int PurestConsole2Channel_unused = AirwinRegistry::registerAirwindow({"PurestConsole2Channel", "Consoles", 93, "PurestConsole2Channel is the distributed filter version of PurestConsole.", airwin2rack::PurestConsole2Channel::kNumParameters, []() { return std::make_unique(0); }}); +int PurestConsole2Channel_unused = AirwinRegistry::registerAirwindow({"PurestConsole2Channel", "Consoles", 95, "PurestConsole2Channel is the distributed filter version of PurestConsole.", airwin2rack::PurestConsole2Channel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestConsole3Buss.h" -int PurestConsole3Buss_unused = AirwinRegistry::registerAirwindow({"PurestConsole3Buss", "Consoles", 90, "PurestConsole3Buss is an alternate algorithm for minimalist Console.", airwin2rack::PurestConsole3Buss::kNumParameters, []() { return std::make_unique(0); }}); +int PurestConsole3Buss_unused = AirwinRegistry::registerAirwindow({"PurestConsole3Buss", "Consoles", 92, "PurestConsole3Buss is an alternate algorithm for minimalist Console.", airwin2rack::PurestConsole3Buss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestConsole3Channel.h" -int PurestConsole3Channel_unused = AirwinRegistry::registerAirwindow({"PurestConsole3Channel", "Consoles", 91, "PurestConsole3Channel is an alternate algorithm for minimalist Console.", airwin2rack::PurestConsole3Channel::kNumParameters, []() { return std::make_unique(0); }}); +int PurestConsole3Channel_unused = AirwinRegistry::registerAirwindow({"PurestConsole3Channel", "Consoles", 93, "PurestConsole3Channel is an alternate algorithm for minimalist Console.", airwin2rack::PurestConsole3Channel::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestConsoleBuss.h" -int PurestConsoleBuss_unused = AirwinRegistry::registerAirwindow({"PurestConsoleBuss", "Consoles", 98, "PurestConsoleBuss is the most free from coloration Console system.", airwin2rack::PurestConsoleBuss::kNumParameters, []() { return std::make_unique(0); }}); +int PurestConsoleBuss_unused = AirwinRegistry::registerAirwindow({"PurestConsoleBuss", "Consoles", 100, "PurestConsoleBuss is the most free from coloration Console system.", airwin2rack::PurestConsoleBuss::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/PurestConsoleChannel.h" -int PurestConsoleChannel_unused = AirwinRegistry::registerAirwindow({"PurestConsoleChannel", "Consoles", 99, "PurestConsoleChannel is the most free from coloration Console system.", airwin2rack::PurestConsoleChannel::kNumParameters, []() { return std::make_unique(0); }}); +int PurestConsoleChannel_unused = AirwinRegistry::registerAirwindow({"PurestConsoleChannel", "Consoles", 101, "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", 267, "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", 268, "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", 12, "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", 327, "PurestFade is just like PurestGain, but for LONG fades.", airwin2rack::PurestFade::kNumParameters, []() { return std::make_unique(0); }}); +int PurestFade_unused = AirwinRegistry::registerAirwindow({"PurestFade", "Utility", 328, "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", 326, "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", 327, "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", 172, "PurestSquish is an open-sounding compressor with bass bloom.", airwin2rack::PurestSquish::kNumParameters, []() { return std::make_unique(0); }}); +int PurestSquish_unused = AirwinRegistry::registerAirwindow({"PurestSquish", "Dynamics", 173, "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", 289, "PurestWarm is a subtle tone shaper and warmth adder.", airwin2rack::PurestWarm::kNumParameters, []() { return std::make_unique(0); }}); +int PurestWarm_unused = AirwinRegistry::registerAirwindow({"PurestWarm", "Subtlety", 290, "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", 288, "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", 289, "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", 159, "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", 160, "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", 145, "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", 146, "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", 144, "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", 145, "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", 158, "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", 159, "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", 293, "Remap puts the guts back into overloudenated audio!", airwin2rack::Remap::kNumParameters, []() { return std::make_unique(0); }}); +int Remap_unused = AirwinRegistry::registerAirwindow({"Remap", "Subtlety", 294, "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", 216, "ResEQ is a bank of mostly midrange resonances.", airwin2rack::ResEQ::kNumParameters, []() { return std::make_unique(0); }}); +int ResEQ_unused = AirwinRegistry::registerAirwindow({"ResEQ", "Filter", 217, "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", 199, "ResEQ2 is a single, sharp, sonorous mid peak.", airwin2rack::ResEQ2::kNumParameters, []() { return std::make_unique(0); }}); +int ResEQ2_unused = AirwinRegistry::registerAirwindow({"ResEQ2", "Filter", 200, "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", 260, "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", 261, "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", 274, "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", 275, "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", 339, "RightoMono copies one channel to both, losslessly.", airwin2rack::RightoMono::kNumParameters, []() { return std::make_unique(0); }}); +int RightoMono_unused = AirwinRegistry::registerAirwindow({"RightoMono", "Utility", 340, "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", 3, "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", 285, "Shape is an asymmetrical waveshaper for peak manipulating.", airwin2rack::Shape::kNumParameters, []() { return std::make_unique(0); }}); +int Shape_unused = AirwinRegistry::registerAirwindow({"Shape", "Subtlety", 286, "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", 283, "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", 284, "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", 282, "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", 283, "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", 243, "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", 244, "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", 51, "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", 294, "SingleEndedTriode is unusual analog modeling effects.", airwin2rack::SingleEndedTriode::kNumParameters, []() { return std::make_unique(0); }}); +int SingleEndedTriode_unused = AirwinRegistry::registerAirwindow({"SingleEndedTriode", "Subtlety", 295, "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", 59, "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" @@ -561,23 +563,23 @@ int Slew2_unused = AirwinRegistry::registerAirwindow({"Slew2", "Brightness", 58, #include "autogen_airwin/Slew3.h" int Slew3_unused = AirwinRegistry::registerAirwindow({"Slew3", "Brightness", 57, "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", 330, "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", 331, "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", 52, "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", 55, "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", 161, "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", 162, "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", 135, "SpatializeDither is a high-performance clarity and accuracy dither.", airwin2rack::SpatializeDither::kNumParameters, []() { return std::make_unique(0); }}); +int SpatializeDither_unused = AirwinRegistry::registerAirwindow({"SpatializeDither", "Dithers", 136, "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", 271, "Spiral is the new best smoothest distortion algorithm.", airwin2rack::Spiral::kNumParameters, []() { return std::make_unique(0); }}); +int Spiral_unused = AirwinRegistry::registerAirwindow({"Spiral", "Saturation", 272, "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", 266, "Spiral2 is Spiral with controls including Presence.", airwin2rack::Spiral2::kNumParameters, []() { return std::make_unique(0); }}); +int Spiral2_unused = AirwinRegistry::registerAirwindow({"Spiral2", "Saturation", 267, "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", 275, "Srsly is a psychoacoustic stereo processor.", airwin2rack::Srsly::kNumParameters, []() { return std::make_unique(0); }}); +int Srsly_unused = AirwinRegistry::registerAirwindow({"Srsly", "Stereo", 276, "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", 276, "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", 277, "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", 15, "StarChild is a weird digital ambience/echo plugin.", airwin2rack::StarChild::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/StarChild2.h" @@ -589,65 +591,65 @@ int StereoDoubler_unused = AirwinRegistry::registerAirwindow({"StereoDoubler", " #include "autogen_airwin/StereoEnsemble.h" int StereoEnsemble_unused = AirwinRegistry::registerAirwindow({"StereoEnsemble", "Ambience", 19, "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", 278, "StereoFX is an aggressive stereo widener.", airwin2rack::StereoFX::kNumParameters, []() { return std::make_unique(0); }}); +int StereoFX_unused = AirwinRegistry::registerAirwindow({"StereoFX", "Stereo", 279, "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", 141, "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", 142, "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", 200, "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", 201, "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", 331, "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", 332, "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", 174, "Surge is a compressor for accentuating beats and pulses.", airwin2rack::Surge::kNumParameters, []() { return std::make_unique(0); }}); +int Surge_unused = AirwinRegistry::registerAirwindow({"Surge", "Dynamics", 175, "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", 175, "SurgeTide is a surge and flow dynamics plugin.", airwin2rack::SurgeTide::kNumParameters, []() { return std::make_unique(0); }}); +int SurgeTide_unused = AirwinRegistry::registerAirwindow({"SurgeTide", "Dynamics", 176, "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", 287, "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", 288, "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", 171, "Swell is Dial-an-attack, like sidechaining.", airwin2rack::Swell::kNumParameters, []() { return std::make_unique(0); }}); +int Swell_unused = AirwinRegistry::registerAirwindow({"Swell", "Dynamics", 172, "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", 130, "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", 131, "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", 129, "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", 130, "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", 301, "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", 302, "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", 13, "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", 0, "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", 134, "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", 135, "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", 244, "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", 245, "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", 215, "TapeFat is the tone control from TapeDelay.", airwin2rack::TapeFat::kNumParameters, []() { return std::make_unique(0); }}); +int TapeFat_unused = AirwinRegistry::registerAirwindow({"TapeFat", "Filter", 216, "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", 238, "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", 239, "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", 239, "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", 240, "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", 162, "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", 163, "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", 304, "ToTape5 is Airwindows analog tape emulation.", airwin2rack::ToTape5::kNumParameters, []() { return std::make_unique(0); }}); +int ToTape5_unused = AirwinRegistry::registerAirwindow({"ToTape5", "Tape", 305, "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", 299, "ToTape6 is Airwindows tape emulation for 2020!", airwin2rack::ToTape6::kNumParameters, []() { return std::make_unique(0); }}); +int ToTape6_unused = AirwinRegistry::registerAirwindow({"ToTape6", "Tape", 300, "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", 279, "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", 280, "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", 206, "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", 207, "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", 297, "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", 298, "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", 183, "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", 184, "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", 184, "Tremolo is fluctuating saturation curves for a tubey tremolo.", airwin2rack::Tremolo::kNumParameters, []() { return std::make_unique(0); }}); +int Tremolo_unused = AirwinRegistry::registerAirwindow({"Tremolo", "Effects", 185, "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", 5, "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", 265, "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", 266, "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", 264, "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", 265, "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", 298, "TubeDesk is a tube recording console type tone coloring.", airwin2rack::TubeDesk::kNumParameters, []() { return std::make_unique(0); }}); +int TubeDesk_unused = AirwinRegistry::registerAirwindow({"TubeDesk", "Subtlety", 299, "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", 70, "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" @@ -657,85 +659,87 @@ int UltrasonicLite_unused = AirwinRegistry::registerAirwindow({"UltrasonicLite", #include "autogen_airwin/UltrasonicMed.h" int UltrasonicMed_unused = AirwinRegistry::registerAirwindow({"UltrasonicMed", "Brightness", 69, "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", 272, "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", 273, "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", 155, "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", 156, "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", 252, "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", 253, "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", 249, "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", 250, "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", 233, "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", 234, "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", 136, "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", 137, "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", 240, "VoiceOfTheStarship is a deep noise tone source.", airwin2rack::VoiceOfTheStarship::kNumParameters, []() { return std::make_unique(0); }}); +int VoiceOfTheStarship_unused = AirwinRegistry::registerAirwindow({"VoiceOfTheStarship", "Noise", 241, "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", 344, "VoiceTrick lets you record vocals while monitoring over speakers.", airwin2rack::VoiceTrick::kNumParameters, []() { return std::make_unique(0); }}); +int VoiceTrick_unused = AirwinRegistry::registerAirwindow({"VoiceTrick", "Utility", 345, "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", 202, "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", 203, "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", 277, "Wider is Airwindows stereo space shaping.", airwin2rack::Wider::kNumParameters, []() { return std::make_unique(0); }}); +int Wider_unused = AirwinRegistry::registerAirwindow({"Wider", "Stereo", 278, "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", 362, "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", 363, "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", 363, "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", 364, "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", 364, "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", 365, "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", 365, "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", 366, "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", 366, "XRegion is distorted staggered bandpasses, for extreme soundmangling.", airwin2rack::XRegion::kNumParameters, []() { return std::make_unique(0); }}); +int XRegion_unused = AirwinRegistry::registerAirwindow({"XRegion", "XYZ Filters", 367, "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", 355, "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", 356, "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", 357, "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", 358, "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", 359, "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", 360, "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", 356, "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", 357, "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", 358, "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", 359, "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", 360, "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", 361, "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, "", airwin2rack::YNotNotch::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/YNotch.h" -int YNotch_unused = AirwinRegistry::registerAirwindow({"YNotch", "XYZ Filters", 361, "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", 362, "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", 350, "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", 351, "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", 345, "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", 346, "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", 351, "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", 352, "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", 346, "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", 347, "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", 352, "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", 353, "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", 347, "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", 348, "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", 353, "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", 354, "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", 348, "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", 349, "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/ZRegion.h" -int ZRegion_unused = AirwinRegistry::registerAirwindow({"ZRegion", "XYZ Filters", 354, "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", 355, "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", 349, "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", 350, "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", 157, "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", 158, "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", "Unclassified", -1, "", airwin2rack::kCathedral::kNumParameters, []() { return std::make_unique(0); }}); #include "autogen_airwin/kChamberAR.h" int kChamberAR_unused = AirwinRegistry::registerAirwindow({"kChamberAR", "Ambience", 10, "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", 247, "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", 248, "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", 246, "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", 247, "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", 248, "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", 249, "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", 245, "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", 246, "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", 338, "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", 339, "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", 337, "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", 338, "uLawEncode is a Console-like encode/decode pair, but much more extreme.", airwin2rack::uLawEncode::kNumParameters, []() { return std::make_unique(0); }}); int unusedComplete = AirwinRegistry::completeRegistry(); diff --git a/src/autogen_airwin/CMakeLists.txt b/src/autogen_airwin/CMakeLists.txt index c9fe913..ea2e03a 100644 --- a/src/autogen_airwin/CMakeLists.txt +++ b/src/autogen_airwin/CMakeLists.txt @@ -121,6 +121,8 @@ set(AIRWIN_SOURCES src/autogen_airwin/ChromeOxideProc.cpp src/autogen_airwin/Cider.cpp src/autogen_airwin/CiderProc.cpp + src/autogen_airwin/ClearCoat.cpp + src/autogen_airwin/ClearCoatProc.cpp src/autogen_airwin/ClipOnly2.cpp src/autogen_airwin/ClipOnly2Proc.cpp src/autogen_airwin/ClipSoftly.cpp @@ -725,6 +727,8 @@ set(AIRWIN_SOURCES src/autogen_airwin/ZRegion2Proc.cpp src/autogen_airwin/curve.cpp src/autogen_airwin/curveProc.cpp + src/autogen_airwin/kCathedral.cpp + src/autogen_airwin/kCathedralProc.cpp src/autogen_airwin/kChamberAR.cpp src/autogen_airwin/kChamberARProc.cpp src/autogen_airwin/kPlateA.cpp diff --git a/src/autogen_airwin/ClearCoat.cpp b/src/autogen_airwin/ClearCoat.cpp new file mode 100644 index 0000000..08f7134 --- /dev/null +++ b/src/autogen_airwin/ClearCoat.cpp @@ -0,0 +1,220 @@ +/* ======================================== + * ClearCoat - ClearCoat.h + * Copyright (c) airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __ClearCoat_H +#include "ClearCoat.h" +#endif +namespace airwin2rack::ClearCoat { + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new ClearCoat(audioMaster);} + +ClearCoat::ClearCoat(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 0.5; + B = 1.0; + + for(int count = 0; count < kshortA+2; count++) {aAL[count] = 0.0; aAR[count] = 0.0;} + for(int count = 0; count < kshortB+2; count++) {aBL[count] = 0.0; aBR[count] = 0.0;} + for(int count = 0; count < kshortC+2; count++) {aCL[count] = 0.0; aCR[count] = 0.0;} + for(int count = 0; count < kshortD+2; count++) {aDL[count] = 0.0; aDR[count] = 0.0;} + for(int count = 0; count < kshortE+2; count++) {aEL[count] = 0.0; aER[count] = 0.0;} + for(int count = 0; count < kshortF+2; count++) {aFL[count] = 0.0; aFR[count] = 0.0;} + for(int count = 0; count < kshortG+2; count++) {aGL[count] = 0.0; aGR[count] = 0.0;} + for(int count = 0; count < kshortH+2; count++) {aHL[count] = 0.0; aHR[count] = 0.0;} + for(int count = 0; count < kshortI+2; count++) {aIL[count] = 0.0; aIR[count] = 0.0;} + for(int count = 0; count < kshortJ+2; count++) {aJL[count] = 0.0; aJR[count] = 0.0;} + for(int count = 0; count < kshortK+2; count++) {aKL[count] = 0.0; aKR[count] = 0.0;} + for(int count = 0; count < kshortL+2; count++) {aLL[count] = 0.0; aLR[count] = 0.0;} + for(int count = 0; count < kshortM+2; count++) {aML[count] = 0.0; aMR[count] = 0.0;} + for(int count = 0; count < kshortN+2; count++) {aNL[count] = 0.0; aNR[count] = 0.0;} + for(int count = 0; count < kshortO+2; count++) {aOL[count] = 0.0; aOR[count] = 0.0;} + for(int count = 0; count < kshortP+2; count++) {aPL[count] = 0.0; aPR[count] = 0.0;} + + feedbackAL = 0.0; + feedbackBL = 0.0; + feedbackCL = 0.0; + feedbackDL = 0.0; + + previousAL = 0.0; + previousBL = 0.0; + previousCL = 0.0; + previousDL = 0.0; + previousEL = 0.0; + + feedbackDR = 0.0; + feedbackHR = 0.0; + feedbackLR = 0.0; + feedbackPR = 0.0; + + previousAR = 0.0; + previousBR = 0.0; + previousCR = 0.0; + previousDR = 0.0; + previousER = 0.0; + + prevMulchAL = 0.0; + prevMulchAR = 0.0; + + tailL = 0.0; + tailR = 0.0; + + for(int count = 0; count < 6; count++) {lastRefL[count] = 0.0; lastRefR[count] = 0.0;} + + countAL = 1; + countBL = 1; + countCL = 1; + countDL = 1; + countEL = 1; + countFL = 1; + countGL = 1; + countHL = 1; + countIL = 1; + countJL = 1; + countKL = 1; + countLL = 1; + countML = 1; + countNL = 1; + countOL = 1; + countPL = 1; + + countAR = 1; + countBR = 1; + countCR = 1; + countDR = 1; + countER = 1; + countFR = 1; + countGR = 1; + countHR = 1; + countIR = 1; + countJR = 1; + countKR = 1; + countLR = 1; + countMR = 1; + countNR = 1; + countOR = 1; + countPR = 1; + + cycle = 0; + + shortA = 336; + shortB = 1660; + shortC = 386; + shortD = 623; + shortE = 693; + shortF = 1079; + shortG = 891; + shortH = 1574; + shortI = 24; + shortJ = 2641; + shortK = 1239; + shortL = 775; + shortM = 11; + shortN = 3104; + shortO = 55; + shortP = 2366; + prevclearcoat = -1; + + fpdL = 1.0; while (fpdL < 16386) fpdL = rand()*UINT32_MAX; + fpdR = 1.0; while (fpdR < 16386) fpdR = rand()*UINT32_MAX; + //this is reset: values being initialized only once. Startup values, whatever they are. + + _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect. + _canDo.insert("plugAsSend"); // plug-in can be used as a send effect. + _canDo.insert("x2in2out"); + setNumInputs(kNumInputs); + setNumOutputs(kNumOutputs); + setUniqueID(kUniqueId); + canProcessReplacing(); // supports output replacing + canDoubleReplacing(); // supports double precision processing + programsAreChunks(true); + vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name +} + +ClearCoat::~ClearCoat() {} +VstInt32 ClearCoat::getVendorVersion () {return 1000;} +void ClearCoat::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void ClearCoat::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);} +//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than +//trying to do versioning and preventing people from using older versions. Maybe they like the old one! + +static float pinParameter(float data) +{ + if (data < 0.0f) return 0.0f; + if (data > 1.0f) return 1.0f; + return data; +} + +void ClearCoat::setParameter(VstInt32 index, float value) { + switch (index) { + case kParamA: A = value; break; + case kParamB: B = value; break; + default: break; // unknown parameter, shouldn't happen! + } +} + +float ClearCoat::getParameter(VstInt32 index) { + switch (index) { + case kParamA: return A; break; + case kParamB: return B; break; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void ClearCoat::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Select", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void ClearCoat::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: int2string ((VstInt32)( A * 16.999 ), text, kVstMaxParamStrLen); break; + case kParamB: float2string (B, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void ClearCoat::getParameterLabel(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break; + case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 ClearCoat::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool ClearCoat::getEffectName(char* name) { + vst_strncpy(name, "ClearCoat", kVstMaxProductStrLen); return true; +} + +VstPlugCategory ClearCoat::getPlugCategory() {return kPlugCategEffect;} + +bool ClearCoat::getProductString(char* text) { + vst_strncpy (text, "airwindows ClearCoat", kVstMaxProductStrLen); return true; +} + +bool ClearCoat::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} +bool ClearCoat::parameterTextToValue(VstInt32 index, const char *text, float &value) { + switch(index) { + case kParamB: { auto b = string2float(text, value); return b; break; } + + } + return false; +} +bool ClearCoat::canConvertParameterTextToValue(VstInt32 index) { + switch(index) { + case kParamB: return true; + + } + return false; +} +} // end namespace diff --git a/src/autogen_airwin/ClearCoat.h b/src/autogen_airwin/ClearCoat.h new file mode 100644 index 0000000..491f5ca --- /dev/null +++ b/src/autogen_airwin/ClearCoat.h @@ -0,0 +1,205 @@ +/* ======================================== + * ClearCoat - ClearCoat.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) Airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __ClearCoat_ClearCoat_H +#define __ClearCoat_ClearCoat_H + +#ifndef __audioeffect__ +#include "../airwin2rackbase.h" +#endif + +#include +#include +#include + +namespace airwin2rack::ClearCoat { +enum { + kParamA = 0, + kParamB = 1, + kNumParameters = 2 +}; // + +const int kshortA = 350; +const int kshortB = 1710; +const int kshortC = 1610; +const int kshortD = 835; +const int kshortE = 700; +const int kshortF = 1260; +const int kshortG = 1110; +const int kshortH = 1768; +const int kshortI = 280; +const int kshortJ = 2645; +const int kshortK = 1410; +const int kshortL = 1175; +const int kshortM = 12; +const int kshortN = 3110; +const int kshortO = 120; +const int kshortP = 2370; + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'clco'; //Change this to what the AU identity is! + +class ClearCoat : + public AudioEffectX +{ +public: + ClearCoat(audioMasterCallback audioMaster); + ~ClearCoat(); + virtual bool getEffectName(char* name); // The plug-in name + virtual VstPlugCategory getPlugCategory(); // The general category for the plug-in + virtual bool getProductString(char* text); // This is a unique plug-in string provided by Steinberg + virtual bool getVendorString(char* text); // Vendor info + virtual VstInt32 getVendorVersion(); // Version number + virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames); + virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames); + virtual void getProgramName(char *name); // read the name from the host + virtual void setProgramName(char *name); // changes the name of the preset displayed in the host + virtual float getParameter(VstInt32 index); // get the parameter value at the specified index + virtual void setParameter(VstInt32 index, float value); // set the parameter at index to value + virtual void getParameterLabel(VstInt32 index, char *text); // label for the parameter (eg dB) + virtual void getParameterName(VstInt32 index, char *text); // name of the parameter + virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value + // Added by the perl as inverses + virtual bool parameterTextToValue(VstInt32 index, const char *text, float &value); + virtual bool canConvertParameterTextToValue(VstInt32 index); + virtual VstInt32 canDo(char *text); +private: + char _programName[kVstMaxProgNameLen + 1]; + std::set< std::string > _canDo; + + uint32_t fpdL; + uint32_t fpdR; + //default stuff + + double aAL[kshortA+5]; + double aBL[kshortB+5]; + double aCL[kshortC+5]; + double aDL[kshortD+5]; + double aEL[kshortE+5]; + double aFL[kshortF+5]; + double aGL[kshortG+5]; + double aHL[kshortH+5]; + double aIL[kshortI+5]; + double aJL[kshortJ+5]; + double aKL[kshortK+5]; + double aLL[kshortL+5]; + double aML[kshortM+5]; + double aNL[kshortN+5]; + double aOL[kshortO+5]; + double aPL[kshortP+5]; + + double aAR[kshortA+5]; + double aBR[kshortB+5]; + double aCR[kshortC+5]; + double aDR[kshortD+5]; + double aER[kshortE+5]; + double aFR[kshortF+5]; + double aGR[kshortG+5]; + double aHR[kshortH+5]; + double aIR[kshortI+5]; + double aJR[kshortJ+5]; + double aKR[kshortK+5]; + double aLR[kshortL+5]; + double aMR[kshortM+5]; + double aNR[kshortN+5]; + double aOR[kshortO+5]; + double aPR[kshortP+5]; + + double feedbackAL; + double feedbackBL; + double feedbackCL; + double feedbackDL; + + double feedbackDR; + double feedbackHR; + double feedbackLR; + double feedbackPR; + + double previousAL; + double previousBL; + double previousCL; + double previousDL; + double previousEL; + + double lastRefL[7]; + + double previousAR; + double previousBR; + double previousCR; + double previousDR; + double previousER; + + double lastRefR[7]; + + int countAL; + int countBL; + int countCL; + int countDL; + int countEL; + int countFL; + int countGL; + int countHL; + int countIL; + int countJL; + int countKL; + int countLL; + int countML; + int countNL; + int countOL; + int countPL; + + int countAR; + int countBR; + int countCR; + int countDR; + int countER; + int countFR; + int countGR; + int countHR; + int countIR; + int countJR; + int countKR; + int countLR; + int countMR; + int countNR; + int countOR; + int countPR; + + int cycle; + + double prevMulchAL; + double prevMulchAR; + + double tailL; + double tailR; + + int shortA; + int shortB; + int shortC; + int shortD; + int shortE; + int shortF; + int shortG; + int shortH; + int shortI; + int shortJ; + int shortK; + int shortL; + int shortM; + int shortN; + int shortO; + int shortP; + + int prevclearcoat; + + float A; + float B; +}; + +#endif +} // end namespace diff --git a/src/autogen_airwin/ClearCoatProc.cpp b/src/autogen_airwin/ClearCoatProc.cpp new file mode 100644 index 0000000..2d9527a --- /dev/null +++ b/src/autogen_airwin/ClearCoatProc.cpp @@ -0,0 +1,746 @@ +/* ======================================== + * ClearCoat - ClearCoat.h + * Copyright (c) airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __ClearCoat_H +#include "ClearCoat.h" +#endif +namespace airwin2rack::ClearCoat { + +void ClearCoat::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + + int clearcoat = (int)(A*16.999); + + if (clearcoat != prevclearcoat) { + for(int count = 0; count < kshortA+2; count++) {aAL[count] = 0.0; aAR[count] = 0.0;} + for(int count = 0; count < kshortB+2; count++) {aBL[count] = 0.0; aBR[count] = 0.0;} + for(int count = 0; count < kshortC+2; count++) {aCL[count] = 0.0; aCR[count] = 0.0;} + for(int count = 0; count < kshortD+2; count++) {aDL[count] = 0.0; aDR[count] = 0.0;} + for(int count = 0; count < kshortE+2; count++) {aEL[count] = 0.0; aER[count] = 0.0;} + for(int count = 0; count < kshortF+2; count++) {aFL[count] = 0.0; aFR[count] = 0.0;} + for(int count = 0; count < kshortG+2; count++) {aGL[count] = 0.0; aGR[count] = 0.0;} + for(int count = 0; count < kshortH+2; count++) {aHL[count] = 0.0; aHR[count] = 0.0;} + for(int count = 0; count < kshortI+2; count++) {aIL[count] = 0.0; aIR[count] = 0.0;} + for(int count = 0; count < kshortJ+2; count++) {aJL[count] = 0.0; aJR[count] = 0.0;} + for(int count = 0; count < kshortK+2; count++) {aKL[count] = 0.0; aKR[count] = 0.0;} + for(int count = 0; count < kshortL+2; count++) {aLL[count] = 0.0; aLR[count] = 0.0;} + for(int count = 0; count < kshortM+2; count++) {aML[count] = 0.0; aMR[count] = 0.0;} + for(int count = 0; count < kshortN+2; count++) {aNL[count] = 0.0; aNR[count] = 0.0;} + for(int count = 0; count < kshortO+2; count++) {aOL[count] = 0.0; aOR[count] = 0.0;} + for(int count = 0; count < kshortP+2; count++) {aPL[count] = 0.0; aPR[count] = 0.0;} + countAL = 1; + countBL = 1; + countCL = 1; + countDL = 1; + countEL = 1; + countFL = 1; + countGL = 1; + countHL = 1; + countIL = 1; + countJL = 1; + countKL = 1; + countLL = 1; + countML = 1; + countNL = 1; + countOL = 1; + countPL = 1; + + countAR = 1; + countBR = 1; + countCR = 1; + countDR = 1; + countER = 1; + countFR = 1; + countGR = 1; + countHR = 1; + countIR = 1; + countJR = 1; + countKR = 1; + countLR = 1; + countMR = 1; + countNR = 1; + countOR = 1; + countPR = 1; + switch (clearcoat) + { + case 0: + shortA = 65; shortB = 124; shortC = 83; shortD = 180; shortE = 200; shortF = 291; shortG = 108; shortH = 189; shortI = 73; shortJ = 410; shortK = 479; shortL = 310; shortM = 11; shortN = 928; shortO = 23; shortP = 654; break; //5 to 51 ms, 96 seat room. Scarcity, 1 in 125324 + //Short96 + case 1: + shortA = 114; shortB = 205; shortC = 498; shortD = 195; shortE = 205; shortF = 318; shortG = 143; shortH = 254; shortI = 64; shortJ = 721; shortK = 512; shortL = 324; shortM = 11; shortN = 782; shortO = 26; shortP = 394; break; //7 to 52 ms, 107 seat club. Scarcity, 1 in 65537 + //Short107 + case 2: + shortA = 118; shortB = 272; shortC = 292; shortD = 145; shortE = 200; shortF = 241; shortG = 204; shortH = 504; shortI = 50; shortJ = 678; shortK = 424; shortL = 412; shortM = 11; shortN = 1124; shortO = 47; shortP = 766; break; //8 to 58 ms, 135 seat club. Scarcity, 1 in 196272 + //Short135 + case 3: + shortA = 19; shortB = 474; shortC = 301; shortD = 275; shortE = 260; shortF = 321; shortG = 371; shortH = 571; shortI = 50; shortJ = 410; shortK = 697; shortL = 414; shortM = 11; shortN = 986; shortO = 47; shortP = 522; break; //7 to 61 ms, 143 seat club. Scarcity, 1 in 165738 + //Short143 + case 4: + shortA = 112; shortB = 387; shortC = 452; shortD = 289; shortE = 173; shortF = 476; shortG = 321; shortH = 593; shortI = 73; shortJ = 343; shortK = 829; shortL = 91; shortM = 11; shortN = 1055; shortO = 43; shortP = 862; break; //8 to 66 ms, 166 seat club. Scarcity, 1 in 158437 + //Short166 + case 5: + shortA = 60; shortB = 368; shortC = 295; shortD = 272; shortE = 210; shortF = 284; shortG = 326; shortH = 830; shortI = 125; shortJ = 236; shortK = 737; shortL = 486; shortM = 11; shortN = 1178; shortO = 75; shortP = 902; break; //9 to 70 ms, 189 seat club. Scarcity, 1 in 94790 + //Short189 + case 6: + shortA = 73; shortB = 311; shortC = 472; shortD = 251; shortE = 134; shortF = 509; shortG = 393; shortH = 591; shortI = 124; shortJ = 1070; shortK = 340; shortL = 525; shortM = 11; shortN = 1367; shortO = 75; shortP = 816; break; //7 to 79 ms, 225 seat club. Scarcity, 1 in 257803 + //Short225 + case 7: + shortA = 159; shortB = 518; shortC = 514; shortD = 165; shortE = 275; shortF = 494; shortG = 296; shortH = 667; shortI = 75; shortJ = 1101; shortK = 116; shortL = 414; shortM = 11; shortN = 1261; shortO = 79; shortP = 998; break; //11 to 80 ms, 252 seat club. Scarcity, 1 in 175192 + //Short252 + case 8: + shortA = 41; shortB = 741; shortC = 274; shortD = 59; shortE = 306; shortF = 332; shortG = 291; shortH = 767; shortI = 42; shortJ = 881; shortK = 959; shortL = 422; shortM = 11; shortN = 1237; shortO = 45; shortP = 958; break; //8 to 83 ms, 255 seat club. Scarcity, 1 in 185708 + //Short255 + case 9: + shortA = 251; shortB = 437; shortC = 783; shortD = 189; shortE = 130; shortF = 272; shortG = 244; shortH = 761; shortI = 128; shortJ = 1190; shortK = 320; shortL = 491; shortM = 11; shortN = 1409; shortO = 58; shortP = 455; break; //10 to 93 ms, 323 seat club. Scarcity, 1 in 334044 + //Short323 + case 10: + shortA = 316; shortB = 510; shortC = 1087; shortD = 349; shortE = 359; shortF = 74; shortG = 79; shortH = 1269; shortI = 34; shortJ = 693; shortK = 749; shortL = 511; shortM = 11; shortN = 1751; shortO = 93; shortP = 403; break; //9 to 110 ms, 427 seat theater. Scarcity, 1 in 200715 + //Short427 + case 11: + shortA = 254; shortB = 651; shortC = 845; shortD = 316; shortE = 373; shortF = 267; shortG = 182; shortH = 857; shortI = 215; shortJ = 1535; shortK = 1127; shortL = 315; shortM = 11; shortN = 1649; shortO = 97; shortP = 829; break; //15 to 110 ms, 470 seat theater. Scarcity, 1 in 362673 + //Short470 + case 12: + shortA = 113; shortB = 101; shortC = 673; shortD = 357; shortE = 340; shortF = 229; shortG = 278; shortH = 1008; shortI = 265; shortJ = 1890; shortK = 155; shortL = 267; shortM = 11; shortN = 2233; shortO = 116; shortP = 600; break; //11 to 131 ms, 606 seat theater. Scarcity, 1 in 238058 + //Short606 + case 13: + shortA = 218; shortB = 1058; shortC = 862; shortD = 505; shortE = 297; shortF = 580; shortG = 532; shortH = 1387; shortI = 120; shortJ = 576; shortK = 1409; shortL = 473; shortM = 11; shortN = 1991; shortO = 76; shortP = 685; break; //14 to 132 ms, 643 seat theater. Scarcity, 1 in 193432 + //Short643 + case 14: + shortA = 78; shortB = 760; shortC = 982; shortD = 528; shortE = 445; shortF = 1128; shortG = 130; shortH = 708; shortI = 22; shortJ = 2144; shortK = 354; shortL = 1169; shortM = 11; shortN = 2782; shortO = 58; shortP = 1515; break; //5 to 159 ms, 809 seat hall. Scarcity, 1 in 212274 + //Short809 + case 15: + shortA = 330; shortB = 107; shortC = 1110; shortD = 371; shortE = 620; shortF = 143; shortG = 1014; shortH = 1763; shortI = 184; shortJ = 2068; shortK = 1406; shortL = 595; shortM = 11; shortN = 2639; shortO = 33; shortP = 1594; break; //10 to 171 ms, 984 seat hall. Scarcity, 1 in 226499 + //Short984 + case 16: + default: + shortA = 336; shortB = 1660; shortC = 386; shortD = 623; shortE = 693; shortF = 1079; shortG = 891; shortH = 1574; shortI = 24; shortJ = 2641; shortK = 1239; shortL = 775; shortM = 11; shortN = 3104; shortO = 55; shortP = 2366; break; //24 to 203 ms, 1541 seat hall. Scarcity, 1 in 275025 + //Short1541 + } + prevclearcoat = clearcoat; + } + + double wet = B*2.0; + double dry = 2.0 - wet; + if (wet > 1.0) wet = 1.0; + if (wet < 0.0) wet = 0.0; + if (dry > 1.0) dry = 1.0; + if (dry < 0.0) dry = 0.0; + //this reverb makes 50% full dry AND full wet, not crossfaded. + //that's so it can be on submixes without cutting back dry channel when adjusted: + //unless you go super heavy, you are only adjusting the added verb loudness. + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + cycle++; + if (cycle == cycleEnd) { //hit the end point and we do a reverb sample + aAL[countAL] = inputSampleL + (feedbackAL * 0.04166666666); + aBL[countBL] = inputSampleL + (feedbackBL * 0.04166666666); + aCL[countCL] = inputSampleL + (feedbackCL * 0.04166666666); + aDL[countDL] = inputSampleL + (feedbackDL * 0.04166666666); + + aDR[countDR] = inputSampleR + (feedbackDR * 0.04166666666); + aHR[countHR] = inputSampleR + (feedbackHR * 0.04166666666); + aLR[countLR] = inputSampleR + (feedbackLR * 0.04166666666); + aPR[countPR] = inputSampleR + (feedbackPR * 0.04166666666); + //exactly halfway between infinite sustain at 0.0625 + //and 6dB down, almost no regen at 0.03125 + //means roughly half the results work as BitShiftGain + + countAL++; if (countAL < 0 || countAL > shortA) countAL = 0; + countBL++; if (countBL < 0 || countBL > shortB) countBL = 0; + countCL++; if (countCL < 0 || countCL > shortC) countCL = 0; + countDL++; if (countDL < 0 || countDL > shortD) countDL = 0; + + countDR++; if (countDR < 0 || countDR > shortD) countDR = 0; + countHR++; if (countHR < 0 || countHR > shortH) countHR = 0; + countLR++; if (countLR < 0 || countLR > shortL) countLR = 0; + countPR++; if (countPR < 0 || countPR > shortP) countPR = 0; + + double outAL = aAL[countAL-((countAL > shortA)?shortA+1:0)]; + double outBL = aBL[countBL-((countBL > shortB)?shortB+1:0)]; + double outCL = aCL[countCL-((countCL > shortC)?shortC+1:0)]; + double outDL = aDL[countDL-((countDL > shortD)?shortD+1:0)]; + + double outDR = aDR[countDR-((countDR > shortD)?shortD+1:0)]; + double outHR = aHR[countHR-((countHR > shortH)?shortH+1:0)]; + double outLR = aLR[countLR-((countLR > shortL)?shortL+1:0)]; + double outPR = aPR[countPR-((countPR > shortP)?shortP+1:0)]; + + aEL[countEL] = outAL - (outBL + outCL + outDL); + aFL[countFL] = outBL - (outAL + outCL + outDL); + aGL[countGL] = outCL - (outAL + outBL + outDL); + aHL[countHL] = outDL - (outAL + outBL + outCL); + + aCR[countCR] = outDR - (outHR + outLR + outPR); + aGR[countGR] = outHR - (outDR + outLR + outPR); + aKR[countKR] = outLR - (outDR + outHR + outPR); + aOR[countOR] = outPR - (outDR + outHR + outLR); + + countEL++; if (countEL < 0 || countEL > shortE) countEL = 0; + countFL++; if (countFL < 0 || countFL > shortF) countFL = 0; + countGL++; if (countGL < 0 || countGL > shortG) countGL = 0; + countHL++; if (countHL < 0 || countHL > shortH) countHL = 0; + + countCR++; if (countCR < 0 || countCR > shortC) countCR = 0; + countGR++; if (countGR < 0 || countGR > shortG) countGR = 0; + countKR++; if (countKR < 0 || countKR > shortK) countKR = 0; + countOR++; if (countOR < 0 || countOR > shortO) countOR = 0; + + double outEL = aEL[countEL-((countEL > shortE)?shortE+1:0)]; + double outFL = aFL[countFL-((countFL > shortF)?shortF+1:0)]; + double outGL = aGL[countGL-((countGL > shortG)?shortG+1:0)]; + double outHL = aHL[countHL-((countHL > shortH)?shortH+1:0)]; + + double outCR = aCR[countCR-((countCR > shortC)?shortC+1:0)]; + double outGR = aGR[countGR-((countGR > shortG)?shortG+1:0)]; + double outKR = aKR[countKR-((countKR > shortK)?shortK+1:0)]; + double outOR = aOR[countOR-((countOR > shortO)?shortO+1:0)]; + + aIL[countIL] = outEL - (outFL + outGL + outHL); + aJL[countJL] = outFL - (outEL + outGL + outHL); + aKL[countKL] = outGL - (outEL + outFL + outHL); + aLL[countLL] = outHL - (outEL + outFL + outGL); + + aBR[countBR] = outCR - (outGR + outKR + outOR); + aFR[countFR] = outGR - (outCR + outKR + outOR); + aJR[countJR] = outKR - (outCR + outGR + outOR); + aNR[countNR] = outOR - (outCR + outGR + outKR); + + countIL++; if (countIL < 0 || countIL > shortI) countIL = 0; + countJL++; if (countJL < 0 || countJL > shortJ) countJL = 0; + countKL++; if (countKL < 0 || countKL > shortK) countKL = 0; + countLL++; if (countLL < 0 || countLL > shortL) countLL = 0; + + countBR++; if (countBR < 0 || countBR > shortB) countBR = 0; + countFR++; if (countFR < 0 || countFR > shortF) countFR = 0; + countJR++; if (countJR < 0 || countJR > shortJ) countJR = 0; + countNR++; if (countNR < 0 || countNR > shortN) countNR = 0; + + double outIL = aIL[countIL-((countIL > shortI)?shortI+1:0)]; + double outJL = aJL[countJL-((countJL > shortJ)?shortJ+1:0)]; + double outKL = aKL[countKL-((countKL > shortK)?shortK+1:0)]; + double outLL = aLL[countLL-((countLL > shortL)?shortL+1:0)]; + + double outBR = aBR[countBR-((countBR > shortB)?shortB+1:0)]; + double outFR = aFR[countFR-((countFR > shortF)?shortF+1:0)]; + double outJR = aJR[countJR-((countJR > shortJ)?shortJ+1:0)]; + double outNR = aNR[countNR-((countNR > shortN)?shortN+1:0)]; + + aML[countML] = outIL - (outJL + outKL + outLL); + aNL[countNL] = outJL - (outIL + outKL + outLL); + aOL[countOL] = outKL - (outIL + outJL + outLL); + aPL[countPL] = outLL - (outIL + outJL + outKL); + + aAR[countAR] = outBR - (outFR + outJR + outNR); + aER[countER] = outFR - (outBR + outJR + outNR); + aIR[countIR] = outJR - (outBR + outFR + outNR); + aMR[countMR] = outNR - (outBR + outFR + outJR); + + countML++; if (countML < 0 || countML > shortM) countML = 0; + countNL++; if (countNL < 0 || countNL > shortN) countNL = 0; + countOL++; if (countOL < 0 || countOL > shortO) countOL = 0; + countPL++; if (countPL < 0 || countPL > shortP) countPL = 0; + + countAR++; if (countAR < 0 || countAR > shortA) countAR = 0; + countER++; if (countER < 0 || countER > shortE) countER = 0; + countIR++; if (countIR < 0 || countIR > shortI) countIR = 0; + countMR++; if (countMR < 0 || countMR > shortM) countMR = 0; + + double outML = aML[countML-((countML > shortM)?shortM+1:0)]; + double outNL = aNL[countNL-((countNL > shortN)?shortN+1:0)]; + double outOL = aOL[countOL-((countOL > shortO)?shortO+1:0)]; + double outPL = aPL[countPL-((countPL > shortP)?shortP+1:0)]; + + double outAR = aAR[countAR-((countAR > shortA)?shortA+1:0)]; + double outER = aER[countER-((countER > shortE)?shortE+1:0)]; + double outIR = aIR[countIR-((countIR > shortI)?shortI+1:0)]; + double outMR = aMR[countMR-((countMR > shortM)?shortM+1:0)]; + double outSample = (outML + outML + outML + prevMulchAL)*0.25; + prevMulchAL = outML; outML = outSample; + outSample = (outAR + outAR + outAR + prevMulchAR)*0.25; + prevMulchAR = outAR; outAR = outSample; + + feedbackAL = outML - (outNL + outOL + outPL); + feedbackDR = outAR - (outER + outIR + outMR); + feedbackBL = outNL - (outML + outOL + outPL); + feedbackHR = outER - (outAR + outIR + outMR); + feedbackCL = outOL - (outML + outNL + outPL); + feedbackLR = outIR - (outAR + outER + outMR); + feedbackDL = outPL - (outML + outNL + outOL); + feedbackPR = outMR - (outAR + outER + outIR); + //which we need to feed back into the input again, a bit + + inputSampleL = (outML + outNL + outOL + outPL)/8.0; + inputSampleR = (outAR + outER + outIR + outMR)/8.0; + //and take the final combined sum of outputs, corrected for Householder gain + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + + if (cycleEnd > 1) { + double outSample = (inputSampleL + tailL)*0.5; + tailL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + tailR)*0.5; + tailR = inputSampleR; inputSampleR = outSample; + } //let's average only at elevated sample rates + + if (wet < 1.0) {inputSampleL *= wet; inputSampleR *= wet;} + if (dry < 1.0) {drySampleL *= dry; drySampleR *= dry;} + inputSampleL += drySampleL; inputSampleR += drySampleR; + //this is our submix verb dry/wet: 0.5 is BOTH at FULL VOLUME + //purpose is that, if you're adding verb, you're not altering other balances + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} + +void ClearCoat::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + + int clearcoat = (int)(A*16.999); + + if (clearcoat != prevclearcoat) { + for(int count = 0; count < kshortA+2; count++) {aAL[count] = 0.0; aAR[count] = 0.0;} + for(int count = 0; count < kshortB+2; count++) {aBL[count] = 0.0; aBR[count] = 0.0;} + for(int count = 0; count < kshortC+2; count++) {aCL[count] = 0.0; aCR[count] = 0.0;} + for(int count = 0; count < kshortD+2; count++) {aDL[count] = 0.0; aDR[count] = 0.0;} + for(int count = 0; count < kshortE+2; count++) {aEL[count] = 0.0; aER[count] = 0.0;} + for(int count = 0; count < kshortF+2; count++) {aFL[count] = 0.0; aFR[count] = 0.0;} + for(int count = 0; count < kshortG+2; count++) {aGL[count] = 0.0; aGR[count] = 0.0;} + for(int count = 0; count < kshortH+2; count++) {aHL[count] = 0.0; aHR[count] = 0.0;} + for(int count = 0; count < kshortI+2; count++) {aIL[count] = 0.0; aIR[count] = 0.0;} + for(int count = 0; count < kshortJ+2; count++) {aJL[count] = 0.0; aJR[count] = 0.0;} + for(int count = 0; count < kshortK+2; count++) {aKL[count] = 0.0; aKR[count] = 0.0;} + for(int count = 0; count < kshortL+2; count++) {aLL[count] = 0.0; aLR[count] = 0.0;} + for(int count = 0; count < kshortM+2; count++) {aML[count] = 0.0; aMR[count] = 0.0;} + for(int count = 0; count < kshortN+2; count++) {aNL[count] = 0.0; aNR[count] = 0.0;} + for(int count = 0; count < kshortO+2; count++) {aOL[count] = 0.0; aOR[count] = 0.0;} + for(int count = 0; count < kshortP+2; count++) {aPL[count] = 0.0; aPR[count] = 0.0;} + countAL = 1; + countBL = 1; + countCL = 1; + countDL = 1; + countEL = 1; + countFL = 1; + countGL = 1; + countHL = 1; + countIL = 1; + countJL = 1; + countKL = 1; + countLL = 1; + countML = 1; + countNL = 1; + countOL = 1; + countPL = 1; + + countAR = 1; + countBR = 1; + countCR = 1; + countDR = 1; + countER = 1; + countFR = 1; + countGR = 1; + countHR = 1; + countIR = 1; + countJR = 1; + countKR = 1; + countLR = 1; + countMR = 1; + countNR = 1; + countOR = 1; + countPR = 1; + switch (clearcoat) + { + case 0: + shortA = 65; shortB = 124; shortC = 83; shortD = 180; shortE = 200; shortF = 291; shortG = 108; shortH = 189; shortI = 73; shortJ = 410; shortK = 479; shortL = 310; shortM = 11; shortN = 928; shortO = 23; shortP = 654; break; //5 to 51 ms, 96 seat room. Scarcity, 1 in 125324 + //Short96 + case 1: + shortA = 114; shortB = 205; shortC = 498; shortD = 195; shortE = 205; shortF = 318; shortG = 143; shortH = 254; shortI = 64; shortJ = 721; shortK = 512; shortL = 324; shortM = 11; shortN = 782; shortO = 26; shortP = 394; break; //7 to 52 ms, 107 seat club. Scarcity, 1 in 65537 + //Short107 + case 2: + shortA = 118; shortB = 272; shortC = 292; shortD = 145; shortE = 200; shortF = 241; shortG = 204; shortH = 504; shortI = 50; shortJ = 678; shortK = 424; shortL = 412; shortM = 11; shortN = 1124; shortO = 47; shortP = 766; break; //8 to 58 ms, 135 seat club. Scarcity, 1 in 196272 + //Short135 + case 3: + shortA = 19; shortB = 474; shortC = 301; shortD = 275; shortE = 260; shortF = 321; shortG = 371; shortH = 571; shortI = 50; shortJ = 410; shortK = 697; shortL = 414; shortM = 11; shortN = 986; shortO = 47; shortP = 522; break; //7 to 61 ms, 143 seat club. Scarcity, 1 in 165738 + //Short143 + case 4: + shortA = 112; shortB = 387; shortC = 452; shortD = 289; shortE = 173; shortF = 476; shortG = 321; shortH = 593; shortI = 73; shortJ = 343; shortK = 829; shortL = 91; shortM = 11; shortN = 1055; shortO = 43; shortP = 862; break; //8 to 66 ms, 166 seat club. Scarcity, 1 in 158437 + //Short166 + case 5: + shortA = 60; shortB = 368; shortC = 295; shortD = 272; shortE = 210; shortF = 284; shortG = 326; shortH = 830; shortI = 125; shortJ = 236; shortK = 737; shortL = 486; shortM = 11; shortN = 1178; shortO = 75; shortP = 902; break; //9 to 70 ms, 189 seat club. Scarcity, 1 in 94790 + //Short189 + case 6: + shortA = 73; shortB = 311; shortC = 472; shortD = 251; shortE = 134; shortF = 509; shortG = 393; shortH = 591; shortI = 124; shortJ = 1070; shortK = 340; shortL = 525; shortM = 11; shortN = 1367; shortO = 75; shortP = 816; break; //7 to 79 ms, 225 seat club. Scarcity, 1 in 257803 + //Short225 + case 7: + shortA = 159; shortB = 518; shortC = 514; shortD = 165; shortE = 275; shortF = 494; shortG = 296; shortH = 667; shortI = 75; shortJ = 1101; shortK = 116; shortL = 414; shortM = 11; shortN = 1261; shortO = 79; shortP = 998; break; //11 to 80 ms, 252 seat club. Scarcity, 1 in 175192 + //Short252 + case 8: + shortA = 41; shortB = 741; shortC = 274; shortD = 59; shortE = 306; shortF = 332; shortG = 291; shortH = 767; shortI = 42; shortJ = 881; shortK = 959; shortL = 422; shortM = 11; shortN = 1237; shortO = 45; shortP = 958; break; //8 to 83 ms, 255 seat club. Scarcity, 1 in 185708 + //Short255 + case 9: + shortA = 251; shortB = 437; shortC = 783; shortD = 189; shortE = 130; shortF = 272; shortG = 244; shortH = 761; shortI = 128; shortJ = 1190; shortK = 320; shortL = 491; shortM = 11; shortN = 1409; shortO = 58; shortP = 455; break; //10 to 93 ms, 323 seat club. Scarcity, 1 in 334044 + //Short323 + case 10: + shortA = 316; shortB = 510; shortC = 1087; shortD = 349; shortE = 359; shortF = 74; shortG = 79; shortH = 1269; shortI = 34; shortJ = 693; shortK = 749; shortL = 511; shortM = 11; shortN = 1751; shortO = 93; shortP = 403; break; //9 to 110 ms, 427 seat theater. Scarcity, 1 in 200715 + //Short427 + case 11: + shortA = 254; shortB = 651; shortC = 845; shortD = 316; shortE = 373; shortF = 267; shortG = 182; shortH = 857; shortI = 215; shortJ = 1535; shortK = 1127; shortL = 315; shortM = 11; shortN = 1649; shortO = 97; shortP = 829; break; //15 to 110 ms, 470 seat theater. Scarcity, 1 in 362673 + //Short470 + case 12: + shortA = 113; shortB = 101; shortC = 673; shortD = 357; shortE = 340; shortF = 229; shortG = 278; shortH = 1008; shortI = 265; shortJ = 1890; shortK = 155; shortL = 267; shortM = 11; shortN = 2233; shortO = 116; shortP = 600; break; //11 to 131 ms, 606 seat theater. Scarcity, 1 in 238058 + //Short606 + case 13: + shortA = 218; shortB = 1058; shortC = 862; shortD = 505; shortE = 297; shortF = 580; shortG = 532; shortH = 1387; shortI = 120; shortJ = 576; shortK = 1409; shortL = 473; shortM = 11; shortN = 1991; shortO = 76; shortP = 685; break; //14 to 132 ms, 643 seat theater. Scarcity, 1 in 193432 + //Short643 + case 14: + shortA = 78; shortB = 760; shortC = 982; shortD = 528; shortE = 445; shortF = 1128; shortG = 130; shortH = 708; shortI = 22; shortJ = 2144; shortK = 354; shortL = 1169; shortM = 11; shortN = 2782; shortO = 58; shortP = 1515; break; //5 to 159 ms, 809 seat hall. Scarcity, 1 in 212274 + //Short809 + case 15: + shortA = 330; shortB = 107; shortC = 1110; shortD = 371; shortE = 620; shortF = 143; shortG = 1014; shortH = 1763; shortI = 184; shortJ = 2068; shortK = 1406; shortL = 595; shortM = 11; shortN = 2639; shortO = 33; shortP = 1594; break; //10 to 171 ms, 984 seat hall. Scarcity, 1 in 226499 + //Short984 + case 16: + default: + shortA = 336; shortB = 1660; shortC = 386; shortD = 623; shortE = 693; shortF = 1079; shortG = 891; shortH = 1574; shortI = 24; shortJ = 2641; shortK = 1239; shortL = 775; shortM = 11; shortN = 3104; shortO = 55; shortP = 2366; break; //24 to 203 ms, 1541 seat hall. Scarcity, 1 in 275025 + //Short1541 + } + prevclearcoat = clearcoat; + } + + double wet = B*2.0; + double dry = 2.0 - wet; + if (wet > 1.0) wet = 1.0; + if (wet < 0.0) wet = 0.0; + if (dry > 1.0) dry = 1.0; + if (dry < 0.0) dry = 0.0; + //this reverb makes 50% full dry AND full wet, not crossfaded. + //that's so it can be on submixes without cutting back dry channel when adjusted: + //unless you go super heavy, you are only adjusting the added verb loudness. + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + cycle++; + if (cycle == cycleEnd) { //hit the end point and we do a reverb sample + aAL[countAL] = inputSampleL + (feedbackAL * 0.04166666666); + aBL[countBL] = inputSampleL + (feedbackBL * 0.04166666666); + aCL[countCL] = inputSampleL + (feedbackCL * 0.04166666666); + aDL[countDL] = inputSampleL + (feedbackDL * 0.04166666666); + + aDR[countDR] = inputSampleR + (feedbackDR * 0.04166666666); + aHR[countHR] = inputSampleR + (feedbackHR * 0.04166666666); + aLR[countLR] = inputSampleR + (feedbackLR * 0.04166666666); + aPR[countPR] = inputSampleR + (feedbackPR * 0.04166666666); + //exactly halfway between infinite sustain at 0.0625 + //and 6dB down, almost no regen at 0.03125 + //means roughly half the results work as BitShiftGain + + countAL++; if (countAL < 0 || countAL > shortA) countAL = 0; + countBL++; if (countBL < 0 || countBL > shortB) countBL = 0; + countCL++; if (countCL < 0 || countCL > shortC) countCL = 0; + countDL++; if (countDL < 0 || countDL > shortD) countDL = 0; + + countDR++; if (countDR < 0 || countDR > shortD) countDR = 0; + countHR++; if (countHR < 0 || countHR > shortH) countHR = 0; + countLR++; if (countLR < 0 || countLR > shortL) countLR = 0; + countPR++; if (countPR < 0 || countPR > shortP) countPR = 0; + + double outAL = aAL[countAL-((countAL > shortA)?shortA+1:0)]; + double outBL = aBL[countBL-((countBL > shortB)?shortB+1:0)]; + double outCL = aCL[countCL-((countCL > shortC)?shortC+1:0)]; + double outDL = aDL[countDL-((countDL > shortD)?shortD+1:0)]; + + double outDR = aDR[countDR-((countDR > shortD)?shortD+1:0)]; + double outHR = aHR[countHR-((countHR > shortH)?shortH+1:0)]; + double outLR = aLR[countLR-((countLR > shortL)?shortL+1:0)]; + double outPR = aPR[countPR-((countPR > shortP)?shortP+1:0)]; + + aEL[countEL] = outAL - (outBL + outCL + outDL); + aFL[countFL] = outBL - (outAL + outCL + outDL); + aGL[countGL] = outCL - (outAL + outBL + outDL); + aHL[countHL] = outDL - (outAL + outBL + outCL); + + aCR[countCR] = outDR - (outHR + outLR + outPR); + aGR[countGR] = outHR - (outDR + outLR + outPR); + aKR[countKR] = outLR - (outDR + outHR + outPR); + aOR[countOR] = outPR - (outDR + outHR + outLR); + + countEL++; if (countEL < 0 || countEL > shortE) countEL = 0; + countFL++; if (countFL < 0 || countFL > shortF) countFL = 0; + countGL++; if (countGL < 0 || countGL > shortG) countGL = 0; + countHL++; if (countHL < 0 || countHL > shortH) countHL = 0; + + countCR++; if (countCR < 0 || countCR > shortC) countCR = 0; + countGR++; if (countGR < 0 || countGR > shortG) countGR = 0; + countKR++; if (countKR < 0 || countKR > shortK) countKR = 0; + countOR++; if (countOR < 0 || countOR > shortO) countOR = 0; + + double outEL = aEL[countEL-((countEL > shortE)?shortE+1:0)]; + double outFL = aFL[countFL-((countFL > shortF)?shortF+1:0)]; + double outGL = aGL[countGL-((countGL > shortG)?shortG+1:0)]; + double outHL = aHL[countHL-((countHL > shortH)?shortH+1:0)]; + + double outCR = aCR[countCR-((countCR > shortC)?shortC+1:0)]; + double outGR = aGR[countGR-((countGR > shortG)?shortG+1:0)]; + double outKR = aKR[countKR-((countKR > shortK)?shortK+1:0)]; + double outOR = aOR[countOR-((countOR > shortO)?shortO+1:0)]; + + aIL[countIL] = outEL - (outFL + outGL + outHL); + aJL[countJL] = outFL - (outEL + outGL + outHL); + aKL[countKL] = outGL - (outEL + outFL + outHL); + aLL[countLL] = outHL - (outEL + outFL + outGL); + + aBR[countBR] = outCR - (outGR + outKR + outOR); + aFR[countFR] = outGR - (outCR + outKR + outOR); + aJR[countJR] = outKR - (outCR + outGR + outOR); + aNR[countNR] = outOR - (outCR + outGR + outKR); + + countIL++; if (countIL < 0 || countIL > shortI) countIL = 0; + countJL++; if (countJL < 0 || countJL > shortJ) countJL = 0; + countKL++; if (countKL < 0 || countKL > shortK) countKL = 0; + countLL++; if (countLL < 0 || countLL > shortL) countLL = 0; + + countBR++; if (countBR < 0 || countBR > shortB) countBR = 0; + countFR++; if (countFR < 0 || countFR > shortF) countFR = 0; + countJR++; if (countJR < 0 || countJR > shortJ) countJR = 0; + countNR++; if (countNR < 0 || countNR > shortN) countNR = 0; + + double outIL = aIL[countIL-((countIL > shortI)?shortI+1:0)]; + double outJL = aJL[countJL-((countJL > shortJ)?shortJ+1:0)]; + double outKL = aKL[countKL-((countKL > shortK)?shortK+1:0)]; + double outLL = aLL[countLL-((countLL > shortL)?shortL+1:0)]; + + double outBR = aBR[countBR-((countBR > shortB)?shortB+1:0)]; + double outFR = aFR[countFR-((countFR > shortF)?shortF+1:0)]; + double outJR = aJR[countJR-((countJR > shortJ)?shortJ+1:0)]; + double outNR = aNR[countNR-((countNR > shortN)?shortN+1:0)]; + + aML[countML] = outIL - (outJL + outKL + outLL); + aNL[countNL] = outJL - (outIL + outKL + outLL); + aOL[countOL] = outKL - (outIL + outJL + outLL); + aPL[countPL] = outLL - (outIL + outJL + outKL); + + aAR[countAR] = outBR - (outFR + outJR + outNR); + aER[countER] = outFR - (outBR + outJR + outNR); + aIR[countIR] = outJR - (outBR + outFR + outNR); + aMR[countMR] = outNR - (outBR + outFR + outJR); + + countML++; if (countML < 0 || countML > shortM) countML = 0; + countNL++; if (countNL < 0 || countNL > shortN) countNL = 0; + countOL++; if (countOL < 0 || countOL > shortO) countOL = 0; + countPL++; if (countPL < 0 || countPL > shortP) countPL = 0; + + countAR++; if (countAR < 0 || countAR > shortA) countAR = 0; + countER++; if (countER < 0 || countER > shortE) countER = 0; + countIR++; if (countIR < 0 || countIR > shortI) countIR = 0; + countMR++; if (countMR < 0 || countMR > shortM) countMR = 0; + + double outML = aML[countML-((countML > shortM)?shortM+1:0)]; + double outNL = aNL[countNL-((countNL > shortN)?shortN+1:0)]; + double outOL = aOL[countOL-((countOL > shortO)?shortO+1:0)]; + double outPL = aPL[countPL-((countPL > shortP)?shortP+1:0)]; + + double outAR = aAR[countAR-((countAR > shortA)?shortA+1:0)]; + double outER = aER[countER-((countER > shortE)?shortE+1:0)]; + double outIR = aIR[countIR-((countIR > shortI)?shortI+1:0)]; + double outMR = aMR[countMR-((countMR > shortM)?shortM+1:0)]; + double outSample = (outML + outML + outML + prevMulchAL)*0.25; + prevMulchAL = outML; outML = outSample; + outSample = (outAR + outAR + outAR + prevMulchAR)*0.25; + prevMulchAR = outAR; outAR = outSample; + + feedbackAL = outML - (outNL + outOL + outPL); + feedbackDR = outAR - (outER + outIR + outMR); + feedbackBL = outNL - (outML + outOL + outPL); + feedbackHR = outER - (outAR + outIR + outMR); + feedbackCL = outOL - (outML + outNL + outPL); + feedbackLR = outIR - (outAR + outER + outMR); + feedbackDL = outPL - (outML + outNL + outOL); + feedbackPR = outMR - (outAR + outER + outIR); + //which we need to feed back into the input again, a bit + + inputSampleL = (outML + outNL + outOL + outPL)/8.0; + inputSampleR = (outAR + outER + outIR + outMR)/8.0; + //and take the final combined sum of outputs, corrected for Householder gain + + if (inputSampleL > 1.0) inputSampleL = 1.0; + if (inputSampleL < -1.0) inputSampleL = -1.0; + if (inputSampleR > 1.0) inputSampleR = 1.0; + if (inputSampleR < -1.0) inputSampleR = -1.0; + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + + if (cycleEnd > 1) { + double outSample = (inputSampleL + tailL)*0.5; + tailL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + tailR)*0.5; + tailR = inputSampleR; inputSampleR = outSample; + } //let's average only at elevated sample rates + + if (wet < 1.0) {inputSampleL *= wet; inputSampleR *= wet;} + if (dry < 1.0) {drySampleL *= dry; drySampleR *= dry;} + inputSampleL += drySampleL; inputSampleR += drySampleR; + //this is our submix verb dry/wet: 0.5 is BOTH at FULL VOLUME + //purpose is that, if you're adding verb, you're not altering other balances + + //begin 64 bit stereo floating point dither + //int expon; frexp((double)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + //inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //frexp((double)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + //inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} +} // end namespace diff --git a/src/autogen_airwin/kCathedral.cpp b/src/autogen_airwin/kCathedral.cpp new file mode 100644 index 0000000..c21fc98 --- /dev/null +++ b/src/autogen_airwin/kCathedral.cpp @@ -0,0 +1,267 @@ +/* ======================================== + * kCathedral - kCathedral.h + * Copyright (c) airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __kCathedral_H +#include "kCathedral.h" +#endif +namespace airwin2rack::kCathedral { + +AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new kCathedral(audioMaster);} + +kCathedral::kCathedral(audioMasterCallback audioMaster) : + AudioEffectX(audioMaster, kNumPrograms, kNumParameters) +{ + A = 1.0; + + gainOutL = gainOutR = 1.0; + + for(int count = 0; count < delayA+2; count++) {aAL[count] = 0.0; aAR[count] = 0.0;} + for(int count = 0; count < delayB+2; count++) {aBL[count] = 0.0; aBR[count] = 0.0;} + for(int count = 0; count < delayC+2; count++) {aCL[count] = 0.0; aCR[count] = 0.0;} + for(int count = 0; count < delayD+2; count++) {aDL[count] = 0.0; aDR[count] = 0.0;} + for(int count = 0; count < delayE+2; count++) {aEL[count] = 0.0; aER[count] = 0.0;} + for(int count = 0; count < delayF+2; count++) {aFL[count] = 0.0; aFR[count] = 0.0;} + for(int count = 0; count < delayG+2; count++) {aGL[count] = 0.0; aGR[count] = 0.0;} + for(int count = 0; count < delayH+2; count++) {aHL[count] = 0.0; aHR[count] = 0.0;} + for(int count = 0; count < delayI+2; count++) {aIL[count] = 0.0; aIR[count] = 0.0;} + for(int count = 0; count < delayJ+2; count++) {aJL[count] = 0.0; aJR[count] = 0.0;} + for(int count = 0; count < delayK+2; count++) {aKL[count] = 0.0; aKR[count] = 0.0;} + for(int count = 0; count < delayL+2; count++) {aLL[count] = 0.0; aLR[count] = 0.0;} + for(int count = 0; count < delayM+2; count++) {aML[count] = 0.0; aMR[count] = 0.0;} + for(int count = 0; count < delayN+2; count++) {aNL[count] = 0.0; aNR[count] = 0.0;} + for(int count = 0; count < delayO+2; count++) {aOL[count] = 0.0; aOR[count] = 0.0;} + for(int count = 0; count < delayP+2; count++) {aPL[count] = 0.0; aPR[count] = 0.0;} + for(int count = 0; count < delayQ+2; count++) {aQL[count] = 0.0; aQR[count] = 0.0;} + for(int count = 0; count < delayR+2; count++) {aRL[count] = 0.0; aRR[count] = 0.0;} + for(int count = 0; count < delayS+2; count++) {aSL[count] = 0.0; aSR[count] = 0.0;} + for(int count = 0; count < delayT+2; count++) {aTL[count] = 0.0; aTR[count] = 0.0;} + for(int count = 0; count < delayU+2; count++) {aUL[count] = 0.0; aUR[count] = 0.0;} + for(int count = 0; count < delayV+2; count++) {aVL[count] = 0.0; aVR[count] = 0.0;} + for(int count = 0; count < delayW+2; count++) {aWL[count] = 0.0; aWR[count] = 0.0;} + for(int count = 0; count < delayX+2; count++) {aXL[count] = 0.0; aXR[count] = 0.0;} + for(int count = 0; count < delayY+2; count++) {aYL[count] = 0.0; aYR[count] = 0.0;} + + for(int count = 0; count < earlyA+2; count++) {eAL[count] = 0.0; eAR[count] = 0.0;} + for(int count = 0; count < earlyB+2; count++) {eBL[count] = 0.0; eBR[count] = 0.0;} + for(int count = 0; count < earlyC+2; count++) {eCL[count] = 0.0; eCR[count] = 0.0;} + for(int count = 0; count < earlyD+2; count++) {eDL[count] = 0.0; eDR[count] = 0.0;} + for(int count = 0; count < earlyE+2; count++) {eEL[count] = 0.0; eER[count] = 0.0;} + for(int count = 0; count < earlyF+2; count++) {eFL[count] = 0.0; eFR[count] = 0.0;} + for(int count = 0; count < earlyG+2; count++) {eGL[count] = 0.0; eGR[count] = 0.0;} + for(int count = 0; count < earlyH+2; count++) {eHL[count] = 0.0; eHR[count] = 0.0;} + for(int count = 0; count < earlyI+2; count++) {eIL[count] = 0.0; eIR[count] = 0.0;} + + for(int count = 0; count < predelay+2; count++) {aZL[count] = 0.0; aZR[count] = 0.0;} + for(int count = 0; count < vlfpredelay+2; count++) {aVLFL[count] = 0.0; aVLFR[count] = 0.0;} + + feedbackAL = 0.0; + feedbackBL = 0.0; + feedbackCL = 0.0; + feedbackDL = 0.0; + feedbackEL = 0.0; + + feedbackER = 0.0; + feedbackJR = 0.0; + feedbackOR = 0.0; + feedbackTR = 0.0; + feedbackYR = 0.0; + + prevMulchBL = 0.0; + prevMulchBR = 0.0; + prevMulchCL = 0.0; + prevMulchCR = 0.0; + prevMulchDL = 0.0; + prevMulchDR = 0.0; + prevMulchEL = 0.0; + prevMulchER = 0.0; + + tailL = 0.0; + tailR = 0.0; + + prevOutEL = 0.0; + prevOutER = 0.0; + prevInEL = 0.0; + prevInER = 0.0; + + for(int count = 0; count < 6; count++) {lastRefL[count] = 0.0; lastRefR[count] = 0.0;} + + earlyAL = 1; + earlyBL = 1; + earlyCL = 1; + earlyDL = 1; + earlyEL = 1; + earlyFL = 1; + earlyGL = 1; + earlyHL = 1; + earlyIL = 1; + + earlyAR = 1; + earlyBR = 1; + earlyCR = 1; + earlyDR = 1; + earlyER = 1; + earlyFR = 1; + earlyGR = 1; + earlyHR = 1; + earlyIR = 1; + + countAL = 1; + countBL = 1; + countCL = 1; + countDL = 1; + countEL = 1; + countFL = 1; + countGL = 1; + countHL = 1; + countIL = 1; + countJL = 1; + countKL = 1; + countLL = 1; + countML = 1; + countNL = 1; + countOL = 1; + countPL = 1; + countQL = 1; + countRL = 1; + countSL = 1; + countTL = 1; + countUL = 1; + countVL = 1; + countWL = 1; + countXL = 1; + countYL = 1; + + countAR = 1; + countBR = 1; + countCR = 1; + countDR = 1; + countER = 1; + countFR = 1; + countGR = 1; + countHR = 1; + countIR = 1; + countJR = 1; + countKR = 1; + countLR = 1; + countMR = 1; + countNR = 1; + countOR = 1; + countPR = 1; + countQR = 1; + countRR = 1; + countSR = 1; + countTR = 1; + countUR = 1; + countVR = 1; + countWR = 1; + countXR = 1; + countYR = 1; + + countZ = 1; + + cycle = 0; + + for (int x = 0; x < pear_total; x++) {pearA[x] = 0.0; pearB[x] = 0.0; pearC[x] = 0.0;} + //from PearEQ + + subAL = subAR = subBL = subBR = subCL = subCR = 0.0; + //from SubTight + + fpdL = 1.0; while (fpdL < 16386) fpdL = rand()*UINT32_MAX; + fpdR = 1.0; while (fpdR < 16386) fpdR = rand()*UINT32_MAX; + //this is reset: values being initialized only once. Startup values, whatever they are. + + _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect. + _canDo.insert("plugAsSend"); // plug-in can be used as a send effect. + _canDo.insert("x2in2out"); + setNumInputs(kNumInputs); + setNumOutputs(kNumOutputs); + setUniqueID(kUniqueId); + canProcessReplacing(); // supports output replacing + canDoubleReplacing(); // supports double precision processing + programsAreChunks(true); + vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name +} + +kCathedral::~kCathedral() {} +VstInt32 kCathedral::getVendorVersion () {return 1000;} +void kCathedral::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);} +void kCathedral::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);} +//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than +//trying to do versioning and preventing people from using older versions. Maybe they like the old one! + +static float pinParameter(float data) +{ + if (data < 0.0f) return 0.0f; + if (data > 1.0f) return 1.0f; + return data; +} + +void kCathedral::setParameter(VstInt32 index, float value) { + switch (index) { + case kParamA: A = value; break; + default: break; // unknown parameter, shouldn't happen! + } +} + +float kCathedral::getParameter(VstInt32 index) { + switch (index) { + case kParamA: return A; break; + default: break; // unknown parameter, shouldn't happen! + } return 0.0; //we only need to update the relevant name, this is simple to manage +} + +void kCathedral::getParameterName(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "Wetness", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this is our labels for displaying in the VST host +} + +void kCathedral::getParameterDisplay(VstInt32 index, char *text) { + switch (index) { + case kParamA: float2string (A, text, kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } //this displays the values and handles 'popups' where it's discrete choices +} + +void kCathedral::getParameterLabel(VstInt32 index, char *text) { + switch (index) { + case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break; + default: break; // unknown parameter, shouldn't happen! + } +} + +VstInt32 kCathedral::canDo(char *text) +{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know + +bool kCathedral::getEffectName(char* name) { + vst_strncpy(name, "kCathedral", kVstMaxProductStrLen); return true; +} + +VstPlugCategory kCathedral::getPlugCategory() {return kPlugCategEffect;} + +bool kCathedral::getProductString(char* text) { + vst_strncpy (text, "airwindows kCathedral", kVstMaxProductStrLen); return true; +} + +bool kCathedral::getVendorString(char* text) { + vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true; +} +bool kCathedral::parameterTextToValue(VstInt32 index, const char *text, float &value) { + switch(index) { + case kParamA: { auto b = string2float(text, value); return b; break; } + + } + return false; +} +bool kCathedral::canConvertParameterTextToValue(VstInt32 index) { + switch(index) { + case kParamA: return true; + + } + return false; +} +} // end namespace diff --git a/src/autogen_airwin/kCathedral.h b/src/autogen_airwin/kCathedral.h new file mode 100644 index 0000000..2d80022 --- /dev/null +++ b/src/autogen_airwin/kCathedral.h @@ -0,0 +1,310 @@ +/* ======================================== + * kCathedral - kCathedral.h + * Created 8/12/11 by SPIAdmin + * Copyright (c) Airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __kCathedral_kCathedral_H +#define __kCathedral_kCathedral_H + +#ifndef __audioeffect__ +#include "../airwin2rackbase.h" +#endif + +#include +#include +#include + +namespace airwin2rack::kCathedral { +enum { + kParamA = 0, + kNumParameters = 1 +}; // + +//regular3x3 +const int earlyA = 437; const int earlyB = 284; const int earlyC = 754; const int earlyD = 1538; const int earlyE = 59; const int earlyF = 1829; const int earlyG = 37; const int earlyH = 3304; const int earlyI = 200; const int predelay = 1014; const int vlfpredelay = 3275; //6 to 151 ms, 741 seat theater. Scarcity, 1 in 17259 +//kCathedralEarly741 + +const int delayA = 253; const int delayB = 1395; const int delayC = 248; const int delayD = 284; const int delayE = 952; const int delayF = 430; const int delayG = 1253; const int delayH = 889; const int delayI = 798; const int delayJ = 397; const int delayK = 1166; const int delayL = 250; const int delayM = 38; const int delayN = 1389; const int delayO = 1103; const int delayP = 50; const int delayQ = 1317; const int delayR = 40; const int delayS = 1393; const int delayT = 325; const int delayU = 11; const int delayV = 265; const int delayW = 1339; const int delayX = 315; const int delayY = 753; //16 to 153 ms, 860 seat hall. Scarcity, 1 in 60182 +//###RevSmooth860 + +const int kNumPrograms = 0; +const int kNumInputs = 2; +const int kNumOutputs = 2; +const unsigned long kUniqueId = 'kcth'; //Change this to what the AU identity is! + +class kCathedral : + public AudioEffectX +{ +public: + kCathedral(audioMasterCallback audioMaster); + ~kCathedral(); + virtual bool getEffectName(char* name); // The plug-in name + virtual VstPlugCategory getPlugCategory(); // The general category for the plug-in + virtual bool getProductString(char* text); // This is a unique plug-in string provided by Steinberg + virtual bool getVendorString(char* text); // Vendor info + virtual VstInt32 getVendorVersion(); // Version number + virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames); + virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames); + virtual void getProgramName(char *name); // read the name from the host + virtual void setProgramName(char *name); // changes the name of the preset displayed in the host + virtual float getParameter(VstInt32 index); // get the parameter value at the specified index + virtual void setParameter(VstInt32 index, float value); // set the parameter at index to value + virtual void getParameterLabel(VstInt32 index, char *text); // label for the parameter (eg dB) + virtual void getParameterName(VstInt32 index, char *text); // name of the parameter + virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value + // Added by the perl as inverses + virtual bool parameterTextToValue(VstInt32 index, const char *text, float &value); + virtual bool canConvertParameterTextToValue(VstInt32 index); + virtual VstInt32 canDo(char *text); +private: + char _programName[kVstMaxProgNameLen + 1]; + std::set< std::string > _canDo; + + double gainOutL; + double gainOutR; + + double eAL[earlyA+5]; + double eBL[earlyB+5]; + double eCL[earlyC+5]; + double eDL[earlyD+5]; + double eEL[earlyE+5]; + double eFL[earlyF+5]; + double eGL[earlyG+5]; + double eHL[earlyH+5]; + double eIL[earlyI+5]; + + double eAR[earlyA+5]; + double eBR[earlyB+5]; + double eCR[earlyC+5]; + double eDR[earlyD+5]; + double eER[earlyE+5]; + double eFR[earlyF+5]; + double eGR[earlyG+5]; + double eHR[earlyH+5]; + double eIR[earlyI+5]; + + int earlyAL, earlyAR; + int earlyBL, earlyBR; + int earlyCL, earlyCR; + int earlyDL, earlyDR; + int earlyEL, earlyER; + int earlyFL, earlyFR; + int earlyGL, earlyGR; + int earlyHL, earlyHR; + int earlyIL, earlyIR; + + double aAL[delayA+5]; + double aBL[delayB+5]; + double aCL[delayC+5]; + double aDL[delayD+5]; + double aEL[delayE+5]; + double aFL[delayF+5]; + double aGL[delayG+5]; + double aHL[delayH+5]; + double aIL[delayI+5]; + double aJL[delayJ+5]; + double aKL[delayK+5]; + double aLL[delayL+5]; + double aML[delayM+5]; + double aNL[delayN+5]; + double aOL[delayO+5]; + double aPL[delayP+5]; + double aQL[delayQ+5]; + double aRL[delayR+5]; + double aSL[delayS+5]; + double aTL[delayT+5]; + double aUL[delayU+5]; + double aVL[delayV+5]; + double aWL[delayW+5]; + double aXL[delayX+5]; + double aYL[delayY+5]; + + double aAR[delayA+5]; + double aBR[delayB+5]; + double aCR[delayC+5]; + double aDR[delayD+5]; + double aER[delayE+5]; + double aFR[delayF+5]; + double aGR[delayG+5]; + double aHR[delayH+5]; + double aIR[delayI+5]; + double aJR[delayJ+5]; + double aKR[delayK+5]; + double aLR[delayL+5]; + double aMR[delayM+5]; + double aNR[delayN+5]; + double aOR[delayO+5]; + double aPR[delayP+5]; + double aQR[delayQ+5]; + double aRR[delayR+5]; + double aSR[delayS+5]; + double aTR[delayT+5]; + double aUR[delayU+5]; + double aVR[delayV+5]; + double aWR[delayW+5]; + double aXR[delayX+5]; + double aYR[delayY+5]; + + double aZL[predelay+5]; + double aZR[predelay+5]; + + double aVLFL[vlfpredelay+5]; + double aVLFR[vlfpredelay+5]; + + + double feedbackAL; + double feedbackBL; + double feedbackCL; + double feedbackDL; + double feedbackEL; + + double feedbackER; + double feedbackJR; + double feedbackOR; + double feedbackTR; + double feedbackYR; + + double lastRefL[7]; + double lastRefR[7]; + + int countAL; + int countBL; + int countCL; + int countDL; + int countEL; + int countFL; + int countGL; + int countHL; + int countIL; + int countJL; + int countKL; + int countLL; + int countML; + int countNL; + int countOL; + int countPL; + int countQL; + int countRL; + int countSL; + int countTL; + int countUL; + int countVL; + int countWL; + int countXL; + int countYL; + + int countAR; + int countBR; + int countCR; + int countDR; + int countER; + int countFR; + int countGR; + int countHR; + int countIR; + int countJR; + int countKR; + int countLR; + int countMR; + int countNR; + int countOR; + int countPR; + int countQR; + int countRR; + int countSR; + int countTR; + int countUR; + int countVR; + int countWR; + int countXR; + int countYR; + + int countZ; + int countVLF; + + int cycle; + + enum { + prevSampL1, + prevSlewL1, + prevSampR1, + prevSlewR1, + prevSampL2, + prevSlewL2, + prevSampR2, + prevSlewR2, + prevSampL3, + prevSlewL3, + prevSampR3, + prevSlewR3, + prevSampL4, + prevSlewL4, + prevSampR4, + prevSlewR4, + prevSampL5, + prevSlewL5, + prevSampR5, + prevSlewR5, + prevSampL6, + prevSlewL6, + prevSampR6, + prevSlewR6, + prevSampL7, + prevSlewL7, + prevSampR7, + prevSlewR7, + prevSampL8, + prevSlewL8, + prevSampR8, + prevSlewR8, + prevSampL9, + prevSlewL9, + prevSampR9, + prevSlewR9, + prevSampL10, + prevSlewL10, + prevSampR10, + prevSlewR10, + pear_total + }; //fixed frequency pear filter for ultrasonics, stereo + + double pearA[pear_total]; //probably worth just using a number here + double pearB[pear_total]; //probably worth just using a number here + double pearC[pear_total]; //probably worth just using a number here + + double subAL; + double subAR; + double subBL; + double subBR; + double subCL; + double subCR; + + double prevMulchBL; + double prevMulchBR; + double prevMulchCL; + double prevMulchCR; + double prevMulchDL; + double prevMulchDR; + double prevMulchEL; + double prevMulchER; + + double prevOutEL; + double prevOutER; + double prevInEL; + double prevInER; + + double tailL; + double tailR; + + uint32_t fpdL; + uint32_t fpdR; + //default stuff + + + + float A; +}; + +#endif +} // end namespace diff --git a/src/autogen_airwin/kCathedralProc.cpp b/src/autogen_airwin/kCathedralProc.cpp new file mode 100644 index 0000000..cc2373a --- /dev/null +++ b/src/autogen_airwin/kCathedralProc.cpp @@ -0,0 +1,1072 @@ +/* ======================================== + * kCathedral - kCathedral.h + * Copyright (c) airwindows, Airwindows uses the MIT license + * ======================================== */ + +#ifndef __kCathedral_H +#include "kCathedral.h" +#endif +namespace airwin2rack::kCathedral { + +void kCathedral::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) +{ + float* in1 = inputs[0]; + float* in2 = inputs[1]; + float* out1 = outputs[0]; + float* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + int adjPredelay = predelay; + int adjSubDelay = vlfpredelay; + double wet = A*2.0; + double dry = 2.0 - wet; + if (wet > 1.0) wet = 1.0; + if (wet < 0.0) wet = 0.0; + if (dry > 1.0) dry = 1.0; + if (dry < 0.0) dry = 0.0; + //this reverb makes 50% full dry AND full wet, not crossfaded. + //that's so it can be on submixes without cutting back dry channel when adjusted: + //unless you go super heavy, you are only adjusting the added verb loudness. + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + cycle++; + if (cycle == cycleEnd) { //hit the end point and we do a reverb sample + double outSample; + outSample = (inputSampleL + prevInEL)*0.5; + prevInEL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + prevInER)*0.5; + prevInER = inputSampleR; inputSampleR = outSample; + + //predelay + aZL[countZ] = inputSampleL; + aZR[countZ] = inputSampleR; + countZ++; if (countZ < 0 || countZ > adjPredelay) countZ = 0; + inputSampleL = aZL[countZ-((countZ > adjPredelay)?adjPredelay+1:0)]; + inputSampleR = aZR[countZ-((countZ > adjPredelay)?adjPredelay+1:0)]; + //end predelay + + //begin SubTight section + double outSampleL = inputSampleL * 0.0026856; + double outSampleR = inputSampleR * 0.0026856; + double scale = 0.5+fabs(outSampleL*0.5); + outSampleL = (subAL+(sin(subAL-outSampleL)*scale)); + subAL = outSampleL*scale; + scale = 0.5+fabs(outSampleR*0.5); + outSampleR = (subAR+(sin(subAR-outSampleR)*scale)); + subAR = outSampleR*scale; + scale = 0.5+fabs(outSampleL*0.5); + outSampleL = (subBL+(sin(subBL-outSampleL)*scale)); + subBL = outSampleL*scale; + scale = 0.5+fabs(outSampleR*0.5); + outSampleR = (subBR+(sin(subBR-outSampleR)*scale)); + subBR = outSampleR*scale; + scale = 0.5+fabs(outSampleL*0.5); + outSampleL = (subCL+(sin(subCL-outSampleL)*scale)); + subCL = outSampleL*scale; + scale = 0.5+fabs(outSampleR*0.5); + outSampleR = (subCR+(sin(subCR-outSampleR)*scale)); + subCR = outSampleR*scale; + outSampleL = -outSampleL; outSampleR = -outSampleR; + if (outSampleL > 0.25) outSampleL = 0.25; if (outSampleL < -0.25) outSampleL = -0.25; + if (outSampleR > 0.25) outSampleR = 0.25; if (outSampleR < -0.25) outSampleR = -0.25; + outSampleL *= 16.0; + outSampleR *= 16.0; + inputSampleL -= outSampleL; + inputSampleR -= outSampleR; + //end SubTight section + + //VLF predelay + aVLFL[countVLF] = outSampleL; + aVLFR[countVLF] = outSampleR; + countVLF++; if (countVLF < 0 || countVLF > adjSubDelay) countVLF = 0; + outSampleL = aVLFL[countVLF-((countVLF > adjSubDelay)?adjSubDelay+1:0)] * 2.0; + outSampleR = aVLFR[countVLF-((countVLF > adjSubDelay)?adjSubDelay+1:0)] * 2.0; + //end VLF predelay + + //begin with early reflections + eAL[earlyAL] = inputSampleL; + eBL[earlyBL] = inputSampleL; + eCL[earlyCL] = inputSampleL; + eCR[earlyCR] = inputSampleR; + eFR[earlyFR] = inputSampleR; + eIR[earlyIR] = inputSampleR; + + earlyAL++; if (earlyAL < 0 || earlyAL > earlyA) earlyAL = 0; + earlyBL++; if (earlyBL < 0 || earlyBL > earlyB) earlyBL = 0; + earlyCL++; if (earlyCL < 0 || earlyCL > earlyC) earlyCL = 0; + earlyCR++; if (earlyCR < 0 || earlyCR > earlyC) earlyCR = 0; + earlyFR++; if (earlyFR < 0 || earlyFR > earlyF) earlyFR = 0; + earlyIR++; if (earlyIR < 0 || earlyIR > earlyI) earlyIR = 0; + + double oeAL = eAL[earlyAL-((earlyAL > earlyA)?earlyA+1:0)]; + double oeBL = eBL[earlyBL-((earlyBL > earlyB)?earlyB+1:0)]; + double oeCL = eCL[earlyCL-((earlyCL > earlyC)?earlyC+1:0)]; + double oeCR = eCR[earlyCR-((earlyCR > earlyC)?earlyC+1:0)]; + double oeFR = eFR[earlyFR-((earlyFR > earlyF)?earlyF+1:0)]; + double oeIR = eIR[earlyIR-((earlyIR > earlyI)?earlyI+1:0)]; + + eDL[earlyDL] = ((oeBL + oeCL) - oeAL); + eEL[earlyEL] = ((oeAL + oeCL) - oeBL); + eFL[earlyFL] = ((oeAL + oeBL) - oeCL); + eBR[earlyBR] = ((oeFR + oeIR) - oeCR); + eER[earlyER] = ((oeCR + oeIR) - oeFR); + eHR[earlyHR] = ((oeCR + oeFR) - oeIR); + + earlyDL++; if (earlyDL < 0 || earlyDL > earlyD) earlyDL = 0; + earlyEL++; if (earlyEL < 0 || earlyEL > earlyE) earlyEL = 0; + earlyFL++; if (earlyFL < 0 || earlyFL > earlyF) earlyFL = 0; + earlyBR++; if (earlyBR < 0 || earlyBR > earlyB) earlyBR = 0; + earlyER++; if (earlyER < 0 || earlyER > earlyE) earlyER = 0; + earlyHR++; if (earlyHR < 0 || earlyHR > earlyH) earlyHR = 0; + + double oeDL = eDL[earlyDL-((earlyDL > earlyD)?earlyD+1:0)]; + double oeEL = eEL[earlyEL-((earlyEL > earlyE)?earlyE+1:0)]; + double oeFL = eFL[earlyFL-((earlyFL > earlyF)?earlyF+1:0)]; + double oeBR = eBR[earlyBR-((earlyBR > earlyB)?earlyB+1:0)]; + double oeER = eER[earlyER-((earlyER > earlyE)?earlyE+1:0)]; + double oeHR = eHR[earlyHR-((earlyHR > earlyH)?earlyH+1:0)]; + + eGL[earlyGL] = ((oeEL + oeFL) - oeDL); + eHL[earlyHL] = ((oeDL + oeFL) - oeEL); + eIL[earlyIL] = ((oeDL + oeEL) - oeFL); + eAR[earlyAR] = ((oeER + oeHR) - oeBR); + eDR[earlyDR] = ((oeBR + oeHR) - oeER); + eGR[earlyGR] = ((oeBR + oeER) - oeHR); + + earlyGL++; if (earlyGL < 0 || earlyGL > earlyG) earlyGL = 0; + earlyHL++; if (earlyHL < 0 || earlyHL > earlyH) earlyHL = 0; + earlyIL++; if (earlyIL < 0 || earlyIL > earlyI) earlyIL = 0; + earlyAR++; if (earlyAR < 0 || earlyAR > earlyA) earlyAR = 0; + earlyDR++; if (earlyDR < 0 || earlyDR > earlyD) earlyDR = 0; + earlyGR++; if (earlyGR < 0 || earlyGR > earlyG) earlyGR = 0; + + double oeGL = eGL[earlyGL-((earlyGL > earlyG)?earlyG+1:0)]; + double oeHL = eHL[earlyHL-((earlyHL > earlyH)?earlyH+1:0)]; + double oeIL = eIL[earlyIL-((earlyIL > earlyI)?earlyI+1:0)]; + double oeAR = eAR[earlyAR-((earlyAR > earlyA)?earlyA+1:0)]; + double oeDR = eDR[earlyDR-((earlyDR > earlyD)?earlyD+1:0)]; + double oeGR = eGR[earlyGR-((earlyGR > earlyG)?earlyG+1:0)]; + + double earlyReflectionsL = oeGL + oeHL + oeIL; + double earlyReflectionsR = oeAR + oeDR + oeGR; + + inputSampleL += outSampleL; + inputSampleR += outSampleR; + //having re-added our VLF delayed channel we can now re-use outSample + + aAL[countAL] = inputSampleL + (feedbackAL * 0.000293); + aBL[countBL] = inputSampleL + (feedbackBL * 0.000293); + aCL[countCL] = inputSampleL + (feedbackCL * 0.000293); + aDL[countDL] = inputSampleL + (feedbackDL * 0.000293); + aEL[countEL] = inputSampleL + (feedbackEL * 0.000293); + + aER[countER] = inputSampleR + (feedbackER * 0.000293); + aJR[countJR] = inputSampleR + (feedbackJR * 0.000293); + aOR[countOR] = inputSampleR + (feedbackOR * 0.000293); + aTR[countTR] = inputSampleR + (feedbackTR * 0.000293); + aYR[countYR] = inputSampleR + (feedbackYR * 0.000293); + + countAL++; if (countAL < 0 || countAL > delayA) countAL = 0; + countBL++; if (countBL < 0 || countBL > delayB) countBL = 0; + countCL++; if (countCL < 0 || countCL > delayC) countCL = 0; + countDL++; if (countDL < 0 || countDL > delayD) countDL = 0; + countEL++; if (countEL < 0 || countEL > delayE) countEL = 0; + + countER++; if (countER < 0 || countER > delayE) countER = 0; + countJR++; if (countJR < 0 || countJR > delayJ) countJR = 0; + countOR++; if (countOR < 0 || countOR > delayO) countOR = 0; + countTR++; if (countTR < 0 || countTR > delayT) countTR = 0; + countYR++; if (countYR < 0 || countYR > delayY) countYR = 0; + + double outAL = aAL[countAL-((countAL > delayA)?delayA+1:0)]; + double outBL = aBL[countBL-((countBL > delayB)?delayB+1:0)]; + double outCL = aCL[countCL-((countCL > delayC)?delayC+1:0)]; + double outDL = aDL[countDL-((countDL > delayD)?delayD+1:0)]; + double outEL = aEL[countEL-((countEL > delayE)?delayE+1:0)]; + + double outER = aER[countER-((countER > delayE)?delayE+1:0)]; + double outJR = aJR[countJR-((countJR > delayJ)?delayJ+1:0)]; + double outOR = aOR[countOR-((countOR > delayO)?delayO+1:0)]; + double outTR = aTR[countTR-((countTR > delayT)?delayT+1:0)]; + double outYR = aYR[countYR-((countYR > delayY)?delayY+1:0)]; + + //-------- one + + for (int x = 0; x < 31.32; x += 4) { + double slew = ((outAL - pearA[x]) + pearA[x+1])*0.304*0.5; + pearA[x] = outAL = (0.304 * outAL) + ((1.0-0.304) * (pearA[x] + pearA[x+1])); + pearA[x+1] = slew; + slew = ((outER - pearA[x+2]) + pearA[x+3])*0.304*0.5; + pearA[x+2] = outER = (0.304 * outER) + ((1.0-0.304) * (pearA[x+2] + pearA[x+3])); + pearA[x+3] = slew; + } + + aFL[countFL] = ((outAL*3.0) - ((outBL + outCL + outDL + outEL)*2.0)); + aGL[countGL] = ((outBL*3.0) - ((outAL + outCL + outDL + outEL)*2.0)); + aHL[countHL] = ((outCL*3.0) - ((outAL + outBL + outDL + outEL)*2.0)); + aIL[countIL] = ((outDL*3.0) - ((outAL + outBL + outCL + outEL)*2.0)); + aJL[countJL] = ((outEL*3.0) - ((outAL + outBL + outCL + outDL)*2.0)); + + aDR[countDR] = ((outER*3.0) - ((outJR + outOR + outTR + outYR)*2.0)); + aIR[countIR] = ((outJR*3.0) - ((outER + outOR + outTR + outYR)*2.0)); + aNR[countNR] = ((outOR*3.0) - ((outER + outJR + outTR + outYR)*2.0)); + aSR[countSR] = ((outTR*3.0) - ((outER + outJR + outOR + outYR)*2.0)); + aXR[countXR] = ((outYR*3.0) - ((outER + outJR + outOR + outTR)*2.0)); + + countFL++; if (countFL < 0 || countFL > delayF) countFL = 0; + countGL++; if (countGL < 0 || countGL > delayG) countGL = 0; + countHL++; if (countHL < 0 || countHL > delayH) countHL = 0; + countIL++; if (countIL < 0 || countIL > delayI) countIL = 0; + countJL++; if (countJL < 0 || countJL > delayJ) countJL = 0; + + countDR++; if (countDR < 0 || countDR > delayD) countDR = 0; + countIR++; if (countIR < 0 || countIR > delayI) countIR = 0; + countNR++; if (countNR < 0 || countNR > delayN) countNR = 0; + countSR++; if (countSR < 0 || countSR > delayS) countSR = 0; + countXR++; if (countXR < 0 || countXR > delayX) countXR = 0; + + double outFL = aFL[countFL-((countFL > delayF)?delayF+1:0)]; + double outGL = aGL[countGL-((countGL > delayG)?delayG+1:0)]; + double outHL = aHL[countHL-((countHL > delayH)?delayH+1:0)]; + double outIL = aIL[countIL-((countIL > delayI)?delayI+1:0)]; + double outJL = aJL[countJL-((countJL > delayJ)?delayJ+1:0)]; + + double outDR = aDR[countDR-((countDR > delayD)?delayD+1:0)]; + double outIR = aIR[countIR-((countIR > delayI)?delayI+1:0)]; + double outNR = aNR[countNR-((countNR > delayN)?delayN+1:0)]; + double outSR = aSR[countSR-((countSR > delayS)?delayS+1:0)]; + double outXR = aXR[countXR-((countXR > delayX)?delayX+1:0)]; + + //-------- mulch + + for (int x = 0; x < 31.32; x += 4) { + double slew = ((outFL - pearB[x]) + pearB[x+1])*0.566*0.5; + pearB[x] = outFL = (0.566 * outFL) + ((1.0-0.566) * (pearB[x] + pearB[x+1])); + pearB[x+1] = slew; + slew = ((outDR - pearB[x+2]) + pearB[x+3])*0.566*0.5; + pearB[x+2] = outDR = (0.566 * outDR) + ((1.0-0.566) * (pearB[x+2] + pearB[x+3])); + pearB[x+3] = slew; + } + + outSample = (outGL + prevMulchBL)*0.5; + prevMulchBL = outGL; outGL = outSample; + + outSample = (outIR + prevMulchBR)*0.5; + prevMulchBR = outIR; outIR = outSample; + + //-------- two + + aKL[countKL] = ((outFL*3.0) - ((outGL + outHL + outIL + outJL)*2.0)); + aLL[countLL] = ((outGL*3.0) - ((outFL + outHL + outIL + outJL)*2.0)); + aML[countML] = ((outHL*3.0) - ((outFL + outGL + outIL + outJL)*2.0)); + aNL[countNL] = ((outIL*3.0) - ((outFL + outGL + outHL + outJL)*2.0)); + aOL[countOL] = ((outJL*3.0) - ((outFL + outGL + outHL + outIL)*2.0)); + + aCR[countCR] = ((outDR*3.0) - ((outIR + outNR + outSR + outXR)*2.0)); + aHR[countHR] = ((outIR*3.0) - ((outDR + outNR + outSR + outXR)*2.0)); + aMR[countMR] = ((outNR*3.0) - ((outDR + outIR + outSR + outXR)*2.0)); + aRR[countRR] = ((outSR*3.0) - ((outDR + outIR + outNR + outXR)*2.0)); + aWR[countWR] = ((outXR*3.0) - ((outDR + outIR + outNR + outSR)*2.0)); + + countKL++; if (countKL < 0 || countKL > delayK) countKL = 0; + countLL++; if (countLL < 0 || countLL > delayL) countLL = 0; + countML++; if (countML < 0 || countML > delayM) countML = 0; + countNL++; if (countNL < 0 || countNL > delayN) countNL = 0; + countOL++; if (countOL < 0 || countOL > delayO) countOL = 0; + + countCR++; if (countCR < 0 || countCR > delayC) countCR = 0; + countHR++; if (countHR < 0 || countHR > delayH) countHR = 0; + countMR++; if (countMR < 0 || countMR > delayM) countMR = 0; + countRR++; if (countRR < 0 || countRR > delayR) countRR = 0; + countWR++; if (countWR < 0 || countWR > delayW) countWR = 0; + + double outKL = aKL[countKL-((countKL > delayK)?delayK+1:0)]; + double outLL = aLL[countLL-((countLL > delayL)?delayL+1:0)]; + double outML = aML[countML-((countML > delayM)?delayM+1:0)]; + double outNL = aNL[countNL-((countNL > delayN)?delayN+1:0)]; + double outOL = aOL[countOL-((countOL > delayO)?delayO+1:0)]; + + double outCR = aCR[countCR-((countCR > delayC)?delayC+1:0)]; + double outHR = aHR[countHR-((countHR > delayH)?delayH+1:0)]; + double outMR = aMR[countMR-((countMR > delayM)?delayM+1:0)]; + double outRR = aRR[countRR-((countRR > delayR)?delayR+1:0)]; + double outWR = aWR[countWR-((countWR > delayW)?delayW+1:0)]; + + //-------- mulch + + for (int x = 0; x < 31.32; x += 4) { + double slew = ((outKL - pearC[x]) + pearC[x+1])*0.416*0.5; + pearC[x] = outKL = (0.416 * outKL) + ((1.0-0.416) * (pearC[x] + pearC[x+1])); + pearC[x+1] = slew; + slew = ((outCR - pearC[x+2]) + pearC[x+3])*0.416*0.5; + pearC[x+2] = outCR = (0.416 * outCR) + ((1.0-0.416) * (pearC[x+2] + pearC[x+3])); + pearC[x+3] = slew; + } + + outSample = (outLL + prevMulchCL)*0.5; + prevMulchCL = outLL; outLL = outSample; + + outSample = (outHR + prevMulchCR)*0.5; + prevMulchCR = outHR; outHR = outSample; + + //-------- three + + aPL[countPL] = ((outKL*3.0) - ((outLL + outML + outNL + outOL)*2.0)); + aQL[countQL] = ((outLL*3.0) - ((outKL + outML + outNL + outOL)*2.0)); + aRL[countRL] = ((outML*3.0) - ((outKL + outLL + outNL + outOL)*2.0)); + aSL[countSL] = ((outNL*3.0) - ((outKL + outLL + outML + outOL)*2.0)); + aTL[countTL] = ((outOL*3.0) - ((outKL + outLL + outML + outNL)*2.0)); + + aBR[countBR] = ((outCR*3.0) - ((outHR + outMR + outRR + outWR)*2.0)); + aGR[countGR] = ((outHR*3.0) - ((outCR + outMR + outRR + outWR)*2.0)); + aLR[countLR] = ((outMR*3.0) - ((outCR + outHR + outRR + outWR)*2.0)); + aQR[countQR] = ((outRR*3.0) - ((outCR + outHR + outMR + outWR)*2.0)); + aVR[countVR] = ((outWR*3.0) - ((outCR + outHR + outMR + outRR)*2.0)); + + countPL++; if (countPL < 0 || countPL > delayP) countPL = 0; + countQL++; if (countQL < 0 || countQL > delayQ) countQL = 0; + countRL++; if (countRL < 0 || countRL > delayR) countRL = 0; + countSL++; if (countSL < 0 || countSL > delayS) countSL = 0; + countTL++; if (countTL < 0 || countTL > delayT) countTL = 0; + + countBR++; if (countBR < 0 || countBR > delayB) countBR = 0; + countGR++; if (countGR < 0 || countGR > delayG) countGR = 0; + countLR++; if (countLR < 0 || countLR > delayL) countLR = 0; + countQR++; if (countQR < 0 || countQR > delayQ) countQR = 0; + countVR++; if (countVR < 0 || countVR > delayV) countVR = 0; + + double outPL = aPL[countPL-((countPL > delayP)?delayP+1:0)]; + double outQL = aQL[countQL-((countQL > delayQ)?delayQ+1:0)]; + double outRL = aRL[countRL-((countRL > delayR)?delayR+1:0)]; + double outSL = aSL[countSL-((countSL > delayS)?delayS+1:0)]; + double outTL = aTL[countTL-((countTL > delayT)?delayT+1:0)]; + + double outBR = aBR[countBR-((countBR > delayB)?delayB+1:0)]; + double outGR = aGR[countGR-((countGR > delayG)?delayG+1:0)]; + double outLR = aLR[countLR-((countLR > delayL)?delayL+1:0)]; + double outQR = aQR[countQR-((countQR > delayQ)?delayQ+1:0)]; + double outVR = aVR[countVR-((countVR > delayV)?delayV+1:0)]; + + outSample = (outQL + prevMulchDL)*0.5; + prevMulchDL = outQL; outQL = outSample; + + outSample = (outGR + prevMulchDR)*0.5; + prevMulchDR = outGR; outGR = outSample; + + //-------- four + + aUL[countUL] = ((outPL*3.0) - ((outQL + outRL + outSL + outTL)*2.0)); + aVL[countVL] = ((outQL*3.0) - ((outPL + outRL + outSL + outTL)*2.0)); + aWL[countWL] = ((outRL*3.0) - ((outPL + outQL + outSL + outTL)*2.0)); + aXL[countXL] = ((outSL*3.0) - ((outPL + outQL + outRL + outTL)*2.0)); + aYL[countYL] = ((outTL*3.0) - ((outPL + outQL + outRL + outSL)*2.0)); + + aAR[countAR] = ((outBR*3.0) - ((outGR + outLR + outQR + outVR)*2.0)); + aFR[countFR] = ((outGR*3.0) - ((outBR + outLR + outQR + outVR)*2.0)); + aKR[countKR] = ((outLR*3.0) - ((outBR + outGR + outQR + outVR)*2.0)); + aPR[countPR] = ((outQR*3.0) - ((outBR + outGR + outLR + outVR)*2.0)); + aUR[countUR] = ((outVR*3.0) - ((outBR + outGR + outLR + outQR)*2.0)); + + countUL++; if (countUL < 0 || countUL > delayU) countUL = 0; + countVL++; if (countVL < 0 || countVL > delayV) countVL = 0; + countWL++; if (countWL < 0 || countWL > delayW) countWL = 0; + countXL++; if (countXL < 0 || countXL > delayX) countXL = 0; + countYL++; if (countYL < 0 || countYL > delayY) countYL = 0; + + countAR++; if (countAR < 0 || countAR > delayA) countAR = 0; + countFR++; if (countFR < 0 || countFR > delayF) countFR = 0; + countKR++; if (countKR < 0 || countKR > delayK) countKR = 0; + countPR++; if (countPR < 0 || countPR > delayP) countPR = 0; + countUR++; if (countUR < 0 || countUR > delayU) countUR = 0; + + double outUL = aUL[countUL-((countUL > delayU)?delayU+1:0)]; + double outVL = aVL[countVL-((countVL > delayV)?delayV+1:0)]; + double outWL = aWL[countWL-((countWL > delayW)?delayW+1:0)]; + double outXL = aXL[countXL-((countXL > delayX)?delayX+1:0)]; + double outYL = aYL[countYL-((countYL > delayY)?delayY+1:0)]; + + double outAR = aAR[countAR-((countAR > delayA)?delayA+1:0)]; + double outFR = aFR[countFR-((countFR > delayF)?delayF+1:0)]; + double outKR = aKR[countKR-((countKR > delayK)?delayK+1:0)]; + double outPR = aPR[countPR-((countPR > delayP)?delayP+1:0)]; + double outUR = aUR[countUR-((countUR > delayU)?delayU+1:0)]; + + //-------- mulch + + outSample = (outVL + prevMulchEL)*0.5; + prevMulchEL = outVL; outVL = outSample; + + outSample = (outFR + prevMulchER)*0.5; + prevMulchER = outFR; outFR = outSample; + + //-------- five + + feedbackER = ((outUL*3.0) - ((outVL + outWL + outXL + outYL)*2.0)); + feedbackAL = ((outAR*3.0) - ((outFR + outKR + outPR + outUR)*2.0)); + feedbackJR = ((outVL*3.0) - ((outUL + outWL + outXL + outYL)*2.0)); + feedbackBL = ((outFR*3.0) - ((outAR + outKR + outPR + outUR)*2.0)); + feedbackCL = ((outWL*3.0) - ((outUL + outVL + outXL + outYL)*2.0)); + feedbackOR = ((outKR*3.0) - ((outAR + outFR + outPR + outUR)*2.0)); + feedbackDL = ((outXL*3.0) - ((outUL + outVL + outWL + outYL)*2.0)); + feedbackTR = ((outPR*3.0) - ((outAR + outFR + outKR + outUR)*2.0)); + feedbackEL = ((outYL*3.0) - ((outUL + outVL + outWL + outXL)*2.0)); + feedbackYR = ((outUR*3.0) - ((outAR + outFR + outKR + outPR)*2.0)); + //which we need to feed back into the input again, a bit + + inputSampleL = (outUL + outVL + outWL + outXL + outYL)*0.0016; + inputSampleR = (outAR + outFR + outKR + outPR + outUR)*0.0016; + //and take the final combined sum of outputs, corrected for Householder gain + + inputSampleL += (earlyReflectionsL*0.2); + inputSampleR += (earlyReflectionsR*0.2); + + inputSampleL *= 0.25; inputSampleR *= 0.25; + if (gainOutL < 0.0078125) gainOutL = 0.0078125; if (gainOutL > 1.0) gainOutL = 1.0; + if (gainOutR < 0.0078125) gainOutR = 0.0078125; if (gainOutR > 1.0) gainOutR = 1.0; + //gain of 1,0 gives you a super-clean one, gain of 2 is obviously compressing + //smaller number is maximum clamping, if too small it'll take a while to bounce back + inputSampleL *= gainOutL; inputSampleR *= gainOutR; + gainOutL += sin((fabs(inputSampleL*4)>1)?4:fabs(inputSampleL*4))*pow(inputSampleL,4); + gainOutR += sin((fabs(inputSampleR*4)>1)?4:fabs(inputSampleR*4))*pow(inputSampleR,4); + //4.71239 radians sined will turn to -1 which is the maximum gain reduction speed + inputSampleL *= 4.0; inputSampleR *= 4.0; + //curve! To get a compressed effect that matches a certain other plugin + //that is too overprocessed for its own good :) + + outSample = (inputSampleL + prevOutEL)*0.5; + prevOutEL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + prevOutER)*0.5; + prevOutER = inputSampleR; inputSampleR = outSample; + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + + inputSampleL *= 0.25; inputSampleR *= 0.25; + if (inputSampleL > 2.8) inputSampleL = 2.8; + if (inputSampleL < -2.8) inputSampleL = -2.8; + if (inputSampleR > 2.8) inputSampleR = 2.8; + if (inputSampleR < -2.8) inputSampleR = -2.8;//clip BigFastArcSin harder + if (inputSampleL > 0.0) inputSampleL = (inputSampleL*2.0)/(2.8274333882308-inputSampleL); + else inputSampleL = -(inputSampleL*-2.0)/(2.8274333882308+inputSampleL); + if (inputSampleR > 0.0) inputSampleR = (inputSampleR*2.0)/(2.8274333882308-inputSampleR); + else inputSampleR = -(inputSampleR*-2.0)/(2.8274333882308+inputSampleR); + //BigFastArcSin output stage + + if (cycleEnd > 1) { + double outSample = (inputSampleL + tailL)*0.5; + tailL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + tailR)*0.5; + tailR = inputSampleR; inputSampleR = outSample; + } //let's average only at elevated sample rates + + if (wet < 1.0) {inputSampleL *= wet; inputSampleR *= wet;} + if (dry < 1.0) {drySampleL *= dry; drySampleR *= dry;} + inputSampleL += drySampleL; inputSampleR += drySampleR; + //this is our submix verb dry/wet: 0.5 is BOTH at FULL VOLUME + //purpose is that, if you're adding verb, you're not altering other balances + + //begin 32 bit stereo floating point dither + int expon; frexpf((float)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + frexpf((float)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62)); + //end 32 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} + +void kCathedral::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) +{ + double* in1 = inputs[0]; + double* in2 = inputs[1]; + double* out1 = outputs[0]; + double* out2 = outputs[1]; + + double overallscale = 1.0; + overallscale /= 44100.0; + overallscale *= getSampleRate(); + int cycleEnd = floor(overallscale); + if (cycleEnd < 1) cycleEnd = 1; + if (cycleEnd > 4) cycleEnd = 4; + //this is going to be 2 for 88.1 or 96k, 3 for silly people, 4 for 176 or 192k + if (cycle > cycleEnd-1) cycle = cycleEnd-1; //sanity check + int adjPredelay = predelay; + int adjSubDelay = vlfpredelay; + double wet = A*2.0; + double dry = 2.0 - wet; + if (wet > 1.0) wet = 1.0; + if (wet < 0.0) wet = 0.0; + if (dry > 1.0) dry = 1.0; + if (dry < 0.0) dry = 0.0; + //this reverb makes 50% full dry AND full wet, not crossfaded. + //that's so it can be on submixes without cutting back dry channel when adjusted: + //unless you go super heavy, you are only adjusting the added verb loudness. + + while (--sampleFrames >= 0) + { + double inputSampleL = *in1; + double inputSampleR = *in2; + if (fabs(inputSampleL)<1.18e-23) inputSampleL = fpdL * 1.18e-17; + if (fabs(inputSampleR)<1.18e-23) inputSampleR = fpdR * 1.18e-17; + double drySampleL = inputSampleL; + double drySampleR = inputSampleR; + + cycle++; + if (cycle == cycleEnd) { //hit the end point and we do a reverb sample + double outSample; + outSample = (inputSampleL + prevInEL)*0.5; + prevInEL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + prevInER)*0.5; + prevInER = inputSampleR; inputSampleR = outSample; + + //predelay + aZL[countZ] = inputSampleL; + aZR[countZ] = inputSampleR; + countZ++; if (countZ < 0 || countZ > adjPredelay) countZ = 0; + inputSampleL = aZL[countZ-((countZ > adjPredelay)?adjPredelay+1:0)]; + inputSampleR = aZR[countZ-((countZ > adjPredelay)?adjPredelay+1:0)]; + //end predelay + + //begin SubTight section + double outSampleL = inputSampleL * 0.0026856; + double outSampleR = inputSampleR * 0.0026856; + double scale = 0.5+fabs(outSampleL*0.5); + outSampleL = (subAL+(sin(subAL-outSampleL)*scale)); + subAL = outSampleL*scale; + scale = 0.5+fabs(outSampleR*0.5); + outSampleR = (subAR+(sin(subAR-outSampleR)*scale)); + subAR = outSampleR*scale; + scale = 0.5+fabs(outSampleL*0.5); + outSampleL = (subBL+(sin(subBL-outSampleL)*scale)); + subBL = outSampleL*scale; + scale = 0.5+fabs(outSampleR*0.5); + outSampleR = (subBR+(sin(subBR-outSampleR)*scale)); + subBR = outSampleR*scale; + scale = 0.5+fabs(outSampleL*0.5); + outSampleL = (subCL+(sin(subCL-outSampleL)*scale)); + subCL = outSampleL*scale; + scale = 0.5+fabs(outSampleR*0.5); + outSampleR = (subCR+(sin(subCR-outSampleR)*scale)); + subCR = outSampleR*scale; + outSampleL = -outSampleL; outSampleR = -outSampleR; + if (outSampleL > 0.25) outSampleL = 0.25; if (outSampleL < -0.25) outSampleL = -0.25; + if (outSampleR > 0.25) outSampleR = 0.25; if (outSampleR < -0.25) outSampleR = -0.25; + outSampleL *= 16.0; + outSampleR *= 16.0; + inputSampleL -= outSampleL; + inputSampleR -= outSampleR; + //end SubTight section + + //VLF predelay + aVLFL[countVLF] = outSampleL; + aVLFR[countVLF] = outSampleR; + countVLF++; if (countVLF < 0 || countVLF > adjSubDelay) countVLF = 0; + outSampleL = aVLFL[countVLF-((countVLF > adjSubDelay)?adjSubDelay+1:0)] * 2.0; + outSampleR = aVLFR[countVLF-((countVLF > adjSubDelay)?adjSubDelay+1:0)] * 2.0; + //end VLF predelay + + //begin with early reflections + eAL[earlyAL] = inputSampleL; + eBL[earlyBL] = inputSampleL; + eCL[earlyCL] = inputSampleL; + eCR[earlyCR] = inputSampleR; + eFR[earlyFR] = inputSampleR; + eIR[earlyIR] = inputSampleR; + + earlyAL++; if (earlyAL < 0 || earlyAL > earlyA) earlyAL = 0; + earlyBL++; if (earlyBL < 0 || earlyBL > earlyB) earlyBL = 0; + earlyCL++; if (earlyCL < 0 || earlyCL > earlyC) earlyCL = 0; + earlyCR++; if (earlyCR < 0 || earlyCR > earlyC) earlyCR = 0; + earlyFR++; if (earlyFR < 0 || earlyFR > earlyF) earlyFR = 0; + earlyIR++; if (earlyIR < 0 || earlyIR > earlyI) earlyIR = 0; + + double oeAL = eAL[earlyAL-((earlyAL > earlyA)?earlyA+1:0)]; + double oeBL = eBL[earlyBL-((earlyBL > earlyB)?earlyB+1:0)]; + double oeCL = eCL[earlyCL-((earlyCL > earlyC)?earlyC+1:0)]; + double oeCR = eCR[earlyCR-((earlyCR > earlyC)?earlyC+1:0)]; + double oeFR = eFR[earlyFR-((earlyFR > earlyF)?earlyF+1:0)]; + double oeIR = eIR[earlyIR-((earlyIR > earlyI)?earlyI+1:0)]; + + eDL[earlyDL] = ((oeBL + oeCL) - oeAL); + eEL[earlyEL] = ((oeAL + oeCL) - oeBL); + eFL[earlyFL] = ((oeAL + oeBL) - oeCL); + eBR[earlyBR] = ((oeFR + oeIR) - oeCR); + eER[earlyER] = ((oeCR + oeIR) - oeFR); + eHR[earlyHR] = ((oeCR + oeFR) - oeIR); + + earlyDL++; if (earlyDL < 0 || earlyDL > earlyD) earlyDL = 0; + earlyEL++; if (earlyEL < 0 || earlyEL > earlyE) earlyEL = 0; + earlyFL++; if (earlyFL < 0 || earlyFL > earlyF) earlyFL = 0; + earlyBR++; if (earlyBR < 0 || earlyBR > earlyB) earlyBR = 0; + earlyER++; if (earlyER < 0 || earlyER > earlyE) earlyER = 0; + earlyHR++; if (earlyHR < 0 || earlyHR > earlyH) earlyHR = 0; + + double oeDL = eDL[earlyDL-((earlyDL > earlyD)?earlyD+1:0)]; + double oeEL = eEL[earlyEL-((earlyEL > earlyE)?earlyE+1:0)]; + double oeFL = eFL[earlyFL-((earlyFL > earlyF)?earlyF+1:0)]; + double oeBR = eBR[earlyBR-((earlyBR > earlyB)?earlyB+1:0)]; + double oeER = eER[earlyER-((earlyER > earlyE)?earlyE+1:0)]; + double oeHR = eHR[earlyHR-((earlyHR > earlyH)?earlyH+1:0)]; + + eGL[earlyGL] = ((oeEL + oeFL) - oeDL); + eHL[earlyHL] = ((oeDL + oeFL) - oeEL); + eIL[earlyIL] = ((oeDL + oeEL) - oeFL); + eAR[earlyAR] = ((oeER + oeHR) - oeBR); + eDR[earlyDR] = ((oeBR + oeHR) - oeER); + eGR[earlyGR] = ((oeBR + oeER) - oeHR); + + earlyGL++; if (earlyGL < 0 || earlyGL > earlyG) earlyGL = 0; + earlyHL++; if (earlyHL < 0 || earlyHL > earlyH) earlyHL = 0; + earlyIL++; if (earlyIL < 0 || earlyIL > earlyI) earlyIL = 0; + earlyAR++; if (earlyAR < 0 || earlyAR > earlyA) earlyAR = 0; + earlyDR++; if (earlyDR < 0 || earlyDR > earlyD) earlyDR = 0; + earlyGR++; if (earlyGR < 0 || earlyGR > earlyG) earlyGR = 0; + + double oeGL = eGL[earlyGL-((earlyGL > earlyG)?earlyG+1:0)]; + double oeHL = eHL[earlyHL-((earlyHL > earlyH)?earlyH+1:0)]; + double oeIL = eIL[earlyIL-((earlyIL > earlyI)?earlyI+1:0)]; + double oeAR = eAR[earlyAR-((earlyAR > earlyA)?earlyA+1:0)]; + double oeDR = eDR[earlyDR-((earlyDR > earlyD)?earlyD+1:0)]; + double oeGR = eGR[earlyGR-((earlyGR > earlyG)?earlyG+1:0)]; + + double earlyReflectionsL = oeGL + oeHL + oeIL; + double earlyReflectionsR = oeAR + oeDR + oeGR; + + inputSampleL += outSampleL; + inputSampleR += outSampleR; + //having re-added our VLF delayed channel we can now re-use outSample + + aAL[countAL] = inputSampleL + (feedbackAL * 0.000293); + aBL[countBL] = inputSampleL + (feedbackBL * 0.000293); + aCL[countCL] = inputSampleL + (feedbackCL * 0.000293); + aDL[countDL] = inputSampleL + (feedbackDL * 0.000293); + aEL[countEL] = inputSampleL + (feedbackEL * 0.000293); + + aER[countER] = inputSampleR + (feedbackER * 0.000293); + aJR[countJR] = inputSampleR + (feedbackJR * 0.000293); + aOR[countOR] = inputSampleR + (feedbackOR * 0.000293); + aTR[countTR] = inputSampleR + (feedbackTR * 0.000293); + aYR[countYR] = inputSampleR + (feedbackYR * 0.000293); + + countAL++; if (countAL < 0 || countAL > delayA) countAL = 0; + countBL++; if (countBL < 0 || countBL > delayB) countBL = 0; + countCL++; if (countCL < 0 || countCL > delayC) countCL = 0; + countDL++; if (countDL < 0 || countDL > delayD) countDL = 0; + countEL++; if (countEL < 0 || countEL > delayE) countEL = 0; + + countER++; if (countER < 0 || countER > delayE) countER = 0; + countJR++; if (countJR < 0 || countJR > delayJ) countJR = 0; + countOR++; if (countOR < 0 || countOR > delayO) countOR = 0; + countTR++; if (countTR < 0 || countTR > delayT) countTR = 0; + countYR++; if (countYR < 0 || countYR > delayY) countYR = 0; + + double outAL = aAL[countAL-((countAL > delayA)?delayA+1:0)]; + double outBL = aBL[countBL-((countBL > delayB)?delayB+1:0)]; + double outCL = aCL[countCL-((countCL > delayC)?delayC+1:0)]; + double outDL = aDL[countDL-((countDL > delayD)?delayD+1:0)]; + double outEL = aEL[countEL-((countEL > delayE)?delayE+1:0)]; + + double outER = aER[countER-((countER > delayE)?delayE+1:0)]; + double outJR = aJR[countJR-((countJR > delayJ)?delayJ+1:0)]; + double outOR = aOR[countOR-((countOR > delayO)?delayO+1:0)]; + double outTR = aTR[countTR-((countTR > delayT)?delayT+1:0)]; + double outYR = aYR[countYR-((countYR > delayY)?delayY+1:0)]; + + //-------- one + + for (int x = 0; x < 31.32; x += 4) { + double slew = ((outAL - pearA[x]) + pearA[x+1])*0.304*0.5; + pearA[x] = outAL = (0.304 * outAL) + ((1.0-0.304) * (pearA[x] + pearA[x+1])); + pearA[x+1] = slew; + slew = ((outER - pearA[x+2]) + pearA[x+3])*0.304*0.5; + pearA[x+2] = outER = (0.304 * outER) + ((1.0-0.304) * (pearA[x+2] + pearA[x+3])); + pearA[x+3] = slew; + } + + aFL[countFL] = ((outAL*3.0) - ((outBL + outCL + outDL + outEL)*2.0)); + aGL[countGL] = ((outBL*3.0) - ((outAL + outCL + outDL + outEL)*2.0)); + aHL[countHL] = ((outCL*3.0) - ((outAL + outBL + outDL + outEL)*2.0)); + aIL[countIL] = ((outDL*3.0) - ((outAL + outBL + outCL + outEL)*2.0)); + aJL[countJL] = ((outEL*3.0) - ((outAL + outBL + outCL + outDL)*2.0)); + + aDR[countDR] = ((outER*3.0) - ((outJR + outOR + outTR + outYR)*2.0)); + aIR[countIR] = ((outJR*3.0) - ((outER + outOR + outTR + outYR)*2.0)); + aNR[countNR] = ((outOR*3.0) - ((outER + outJR + outTR + outYR)*2.0)); + aSR[countSR] = ((outTR*3.0) - ((outER + outJR + outOR + outYR)*2.0)); + aXR[countXR] = ((outYR*3.0) - ((outER + outJR + outOR + outTR)*2.0)); + + countFL++; if (countFL < 0 || countFL > delayF) countFL = 0; + countGL++; if (countGL < 0 || countGL > delayG) countGL = 0; + countHL++; if (countHL < 0 || countHL > delayH) countHL = 0; + countIL++; if (countIL < 0 || countIL > delayI) countIL = 0; + countJL++; if (countJL < 0 || countJL > delayJ) countJL = 0; + + countDR++; if (countDR < 0 || countDR > delayD) countDR = 0; + countIR++; if (countIR < 0 || countIR > delayI) countIR = 0; + countNR++; if (countNR < 0 || countNR > delayN) countNR = 0; + countSR++; if (countSR < 0 || countSR > delayS) countSR = 0; + countXR++; if (countXR < 0 || countXR > delayX) countXR = 0; + + double outFL = aFL[countFL-((countFL > delayF)?delayF+1:0)]; + double outGL = aGL[countGL-((countGL > delayG)?delayG+1:0)]; + double outHL = aHL[countHL-((countHL > delayH)?delayH+1:0)]; + double outIL = aIL[countIL-((countIL > delayI)?delayI+1:0)]; + double outJL = aJL[countJL-((countJL > delayJ)?delayJ+1:0)]; + + double outDR = aDR[countDR-((countDR > delayD)?delayD+1:0)]; + double outIR = aIR[countIR-((countIR > delayI)?delayI+1:0)]; + double outNR = aNR[countNR-((countNR > delayN)?delayN+1:0)]; + double outSR = aSR[countSR-((countSR > delayS)?delayS+1:0)]; + double outXR = aXR[countXR-((countXR > delayX)?delayX+1:0)]; + + //-------- mulch + + for (int x = 0; x < 31.32; x += 4) { + double slew = ((outFL - pearB[x]) + pearB[x+1])*0.566*0.5; + pearB[x] = outFL = (0.566 * outFL) + ((1.0-0.566) * (pearB[x] + pearB[x+1])); + pearB[x+1] = slew; + slew = ((outDR - pearB[x+2]) + pearB[x+3])*0.566*0.5; + pearB[x+2] = outDR = (0.566 * outDR) + ((1.0-0.566) * (pearB[x+2] + pearB[x+3])); + pearB[x+3] = slew; + } + + outSample = (outGL + prevMulchBL)*0.5; + prevMulchBL = outGL; outGL = outSample; + + outSample = (outIR + prevMulchBR)*0.5; + prevMulchBR = outIR; outIR = outSample; + + //-------- two + + aKL[countKL] = ((outFL*3.0) - ((outGL + outHL + outIL + outJL)*2.0)); + aLL[countLL] = ((outGL*3.0) - ((outFL + outHL + outIL + outJL)*2.0)); + aML[countML] = ((outHL*3.0) - ((outFL + outGL + outIL + outJL)*2.0)); + aNL[countNL] = ((outIL*3.0) - ((outFL + outGL + outHL + outJL)*2.0)); + aOL[countOL] = ((outJL*3.0) - ((outFL + outGL + outHL + outIL)*2.0)); + + aCR[countCR] = ((outDR*3.0) - ((outIR + outNR + outSR + outXR)*2.0)); + aHR[countHR] = ((outIR*3.0) - ((outDR + outNR + outSR + outXR)*2.0)); + aMR[countMR] = ((outNR*3.0) - ((outDR + outIR + outSR + outXR)*2.0)); + aRR[countRR] = ((outSR*3.0) - ((outDR + outIR + outNR + outXR)*2.0)); + aWR[countWR] = ((outXR*3.0) - ((outDR + outIR + outNR + outSR)*2.0)); + + countKL++; if (countKL < 0 || countKL > delayK) countKL = 0; + countLL++; if (countLL < 0 || countLL > delayL) countLL = 0; + countML++; if (countML < 0 || countML > delayM) countML = 0; + countNL++; if (countNL < 0 || countNL > delayN) countNL = 0; + countOL++; if (countOL < 0 || countOL > delayO) countOL = 0; + + countCR++; if (countCR < 0 || countCR > delayC) countCR = 0; + countHR++; if (countHR < 0 || countHR > delayH) countHR = 0; + countMR++; if (countMR < 0 || countMR > delayM) countMR = 0; + countRR++; if (countRR < 0 || countRR > delayR) countRR = 0; + countWR++; if (countWR < 0 || countWR > delayW) countWR = 0; + + double outKL = aKL[countKL-((countKL > delayK)?delayK+1:0)]; + double outLL = aLL[countLL-((countLL > delayL)?delayL+1:0)]; + double outML = aML[countML-((countML > delayM)?delayM+1:0)]; + double outNL = aNL[countNL-((countNL > delayN)?delayN+1:0)]; + double outOL = aOL[countOL-((countOL > delayO)?delayO+1:0)]; + + double outCR = aCR[countCR-((countCR > delayC)?delayC+1:0)]; + double outHR = aHR[countHR-((countHR > delayH)?delayH+1:0)]; + double outMR = aMR[countMR-((countMR > delayM)?delayM+1:0)]; + double outRR = aRR[countRR-((countRR > delayR)?delayR+1:0)]; + double outWR = aWR[countWR-((countWR > delayW)?delayW+1:0)]; + + //-------- mulch + + for (int x = 0; x < 31.32; x += 4) { + double slew = ((outKL - pearC[x]) + pearC[x+1])*0.416*0.5; + pearC[x] = outKL = (0.416 * outKL) + ((1.0-0.416) * (pearC[x] + pearC[x+1])); + pearC[x+1] = slew; + slew = ((outCR - pearC[x+2]) + pearC[x+3])*0.416*0.5; + pearC[x+2] = outCR = (0.416 * outCR) + ((1.0-0.416) * (pearC[x+2] + pearC[x+3])); + pearC[x+3] = slew; + } + + outSample = (outLL + prevMulchCL)*0.5; + prevMulchCL = outLL; outLL = outSample; + + outSample = (outHR + prevMulchCR)*0.5; + prevMulchCR = outHR; outHR = outSample; + + //-------- three + + aPL[countPL] = ((outKL*3.0) - ((outLL + outML + outNL + outOL)*2.0)); + aQL[countQL] = ((outLL*3.0) - ((outKL + outML + outNL + outOL)*2.0)); + aRL[countRL] = ((outML*3.0) - ((outKL + outLL + outNL + outOL)*2.0)); + aSL[countSL] = ((outNL*3.0) - ((outKL + outLL + outML + outOL)*2.0)); + aTL[countTL] = ((outOL*3.0) - ((outKL + outLL + outML + outNL)*2.0)); + + aBR[countBR] = ((outCR*3.0) - ((outHR + outMR + outRR + outWR)*2.0)); + aGR[countGR] = ((outHR*3.0) - ((outCR + outMR + outRR + outWR)*2.0)); + aLR[countLR] = ((outMR*3.0) - ((outCR + outHR + outRR + outWR)*2.0)); + aQR[countQR] = ((outRR*3.0) - ((outCR + outHR + outMR + outWR)*2.0)); + aVR[countVR] = ((outWR*3.0) - ((outCR + outHR + outMR + outRR)*2.0)); + + countPL++; if (countPL < 0 || countPL > delayP) countPL = 0; + countQL++; if (countQL < 0 || countQL > delayQ) countQL = 0; + countRL++; if (countRL < 0 || countRL > delayR) countRL = 0; + countSL++; if (countSL < 0 || countSL > delayS) countSL = 0; + countTL++; if (countTL < 0 || countTL > delayT) countTL = 0; + + countBR++; if (countBR < 0 || countBR > delayB) countBR = 0; + countGR++; if (countGR < 0 || countGR > delayG) countGR = 0; + countLR++; if (countLR < 0 || countLR > delayL) countLR = 0; + countQR++; if (countQR < 0 || countQR > delayQ) countQR = 0; + countVR++; if (countVR < 0 || countVR > delayV) countVR = 0; + + double outPL = aPL[countPL-((countPL > delayP)?delayP+1:0)]; + double outQL = aQL[countQL-((countQL > delayQ)?delayQ+1:0)]; + double outRL = aRL[countRL-((countRL > delayR)?delayR+1:0)]; + double outSL = aSL[countSL-((countSL > delayS)?delayS+1:0)]; + double outTL = aTL[countTL-((countTL > delayT)?delayT+1:0)]; + + double outBR = aBR[countBR-((countBR > delayB)?delayB+1:0)]; + double outGR = aGR[countGR-((countGR > delayG)?delayG+1:0)]; + double outLR = aLR[countLR-((countLR > delayL)?delayL+1:0)]; + double outQR = aQR[countQR-((countQR > delayQ)?delayQ+1:0)]; + double outVR = aVR[countVR-((countVR > delayV)?delayV+1:0)]; + + outSample = (outQL + prevMulchDL)*0.5; + prevMulchDL = outQL; outQL = outSample; + + outSample = (outGR + prevMulchDR)*0.5; + prevMulchDR = outGR; outGR = outSample; + + //-------- four + + aUL[countUL] = ((outPL*3.0) - ((outQL + outRL + outSL + outTL)*2.0)); + aVL[countVL] = ((outQL*3.0) - ((outPL + outRL + outSL + outTL)*2.0)); + aWL[countWL] = ((outRL*3.0) - ((outPL + outQL + outSL + outTL)*2.0)); + aXL[countXL] = ((outSL*3.0) - ((outPL + outQL + outRL + outTL)*2.0)); + aYL[countYL] = ((outTL*3.0) - ((outPL + outQL + outRL + outSL)*2.0)); + + aAR[countAR] = ((outBR*3.0) - ((outGR + outLR + outQR + outVR)*2.0)); + aFR[countFR] = ((outGR*3.0) - ((outBR + outLR + outQR + outVR)*2.0)); + aKR[countKR] = ((outLR*3.0) - ((outBR + outGR + outQR + outVR)*2.0)); + aPR[countPR] = ((outQR*3.0) - ((outBR + outGR + outLR + outVR)*2.0)); + aUR[countUR] = ((outVR*3.0) - ((outBR + outGR + outLR + outQR)*2.0)); + + countUL++; if (countUL < 0 || countUL > delayU) countUL = 0; + countVL++; if (countVL < 0 || countVL > delayV) countVL = 0; + countWL++; if (countWL < 0 || countWL > delayW) countWL = 0; + countXL++; if (countXL < 0 || countXL > delayX) countXL = 0; + countYL++; if (countYL < 0 || countYL > delayY) countYL = 0; + + countAR++; if (countAR < 0 || countAR > delayA) countAR = 0; + countFR++; if (countFR < 0 || countFR > delayF) countFR = 0; + countKR++; if (countKR < 0 || countKR > delayK) countKR = 0; + countPR++; if (countPR < 0 || countPR > delayP) countPR = 0; + countUR++; if (countUR < 0 || countUR > delayU) countUR = 0; + + double outUL = aUL[countUL-((countUL > delayU)?delayU+1:0)]; + double outVL = aVL[countVL-((countVL > delayV)?delayV+1:0)]; + double outWL = aWL[countWL-((countWL > delayW)?delayW+1:0)]; + double outXL = aXL[countXL-((countXL > delayX)?delayX+1:0)]; + double outYL = aYL[countYL-((countYL > delayY)?delayY+1:0)]; + + double outAR = aAR[countAR-((countAR > delayA)?delayA+1:0)]; + double outFR = aFR[countFR-((countFR > delayF)?delayF+1:0)]; + double outKR = aKR[countKR-((countKR > delayK)?delayK+1:0)]; + double outPR = aPR[countPR-((countPR > delayP)?delayP+1:0)]; + double outUR = aUR[countUR-((countUR > delayU)?delayU+1:0)]; + + //-------- mulch + + outSample = (outVL + prevMulchEL)*0.5; + prevMulchEL = outVL; outVL = outSample; + + outSample = (outFR + prevMulchER)*0.5; + prevMulchER = outFR; outFR = outSample; + + //-------- five + + feedbackER = ((outUL*3.0) - ((outVL + outWL + outXL + outYL)*2.0)); + feedbackAL = ((outAR*3.0) - ((outFR + outKR + outPR + outUR)*2.0)); + feedbackJR = ((outVL*3.0) - ((outUL + outWL + outXL + outYL)*2.0)); + feedbackBL = ((outFR*3.0) - ((outAR + outKR + outPR + outUR)*2.0)); + feedbackCL = ((outWL*3.0) - ((outUL + outVL + outXL + outYL)*2.0)); + feedbackOR = ((outKR*3.0) - ((outAR + outFR + outPR + outUR)*2.0)); + feedbackDL = ((outXL*3.0) - ((outUL + outVL + outWL + outYL)*2.0)); + feedbackTR = ((outPR*3.0) - ((outAR + outFR + outKR + outUR)*2.0)); + feedbackEL = ((outYL*3.0) - ((outUL + outVL + outWL + outXL)*2.0)); + feedbackYR = ((outUR*3.0) - ((outAR + outFR + outKR + outPR)*2.0)); + //which we need to feed back into the input again, a bit + + inputSampleL = (outUL + outVL + outWL + outXL + outYL)*0.0016; + inputSampleR = (outAR + outFR + outKR + outPR + outUR)*0.0016; + //and take the final combined sum of outputs, corrected for Householder gain + + inputSampleL += (earlyReflectionsL*0.2); + inputSampleR += (earlyReflectionsR*0.2); + + inputSampleL *= 0.25; inputSampleR *= 0.25; + if (gainOutL < 0.0078125) gainOutL = 0.0078125; if (gainOutL > 1.0) gainOutL = 1.0; + if (gainOutR < 0.0078125) gainOutR = 0.0078125; if (gainOutR > 1.0) gainOutR = 1.0; + //gain of 1,0 gives you a super-clean one, gain of 2 is obviously compressing + //smaller number is maximum clamping, if too small it'll take a while to bounce back + inputSampleL *= gainOutL; inputSampleR *= gainOutR; + gainOutL += sin((fabs(inputSampleL*4)>1)?4:fabs(inputSampleL*4))*pow(inputSampleL,4); + gainOutR += sin((fabs(inputSampleR*4)>1)?4:fabs(inputSampleR*4))*pow(inputSampleR,4); + //4.71239 radians sined will turn to -1 which is the maximum gain reduction speed + inputSampleL *= 4.0; inputSampleR *= 4.0; + //curve! To get a compressed effect that matches a certain other plugin + //that is too overprocessed for its own good :) + + outSample = (inputSampleL + prevOutEL)*0.5; + prevOutEL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + prevOutER)*0.5; + prevOutER = inputSampleR; inputSampleR = outSample; + + if (cycleEnd == 4) { + lastRefL[0] = lastRefL[4]; //start from previous last + lastRefL[2] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[1] = (lastRefL[0] + lastRefL[2])/2; //one quarter + lastRefL[3] = (lastRefL[2] + inputSampleL)/2; //three quarters + lastRefL[4] = inputSampleL; //full + lastRefR[0] = lastRefR[4]; //start from previous last + lastRefR[2] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[1] = (lastRefR[0] + lastRefR[2])/2; //one quarter + lastRefR[3] = (lastRefR[2] + inputSampleR)/2; //three quarters + lastRefR[4] = inputSampleR; //full + } + if (cycleEnd == 3) { + lastRefL[0] = lastRefL[3]; //start from previous last + lastRefL[2] = (lastRefL[0]+lastRefL[0]+inputSampleL)/3; //third + lastRefL[1] = (lastRefL[0]+inputSampleL+inputSampleL)/3; //two thirds + lastRefL[3] = inputSampleL; //full + lastRefR[0] = lastRefR[3]; //start from previous last + lastRefR[2] = (lastRefR[0]+lastRefR[0]+inputSampleR)/3; //third + lastRefR[1] = (lastRefR[0]+inputSampleR+inputSampleR)/3; //two thirds + lastRefR[3] = inputSampleR; //full + } + if (cycleEnd == 2) { + lastRefL[0] = lastRefL[2]; //start from previous last + lastRefL[1] = (lastRefL[0] + inputSampleL)/2; //half + lastRefL[2] = inputSampleL; //full + lastRefR[0] = lastRefR[2]; //start from previous last + lastRefR[1] = (lastRefR[0] + inputSampleR)/2; //half + lastRefR[2] = inputSampleR; //full + } + if (cycleEnd == 1) { + lastRefL[0] = inputSampleL; + lastRefR[0] = inputSampleR; + } + cycle = 0; //reset + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + } else { + inputSampleL = lastRefL[cycle]; + inputSampleR = lastRefR[cycle]; + //we are going through our references now + } + + inputSampleL *= 0.25; inputSampleR *= 0.25; + if (inputSampleL > 2.8) inputSampleL = 2.8; + if (inputSampleL < -2.8) inputSampleL = -2.8; + if (inputSampleR > 2.8) inputSampleR = 2.8; + if (inputSampleR < -2.8) inputSampleR = -2.8;//clip BigFastArcSin harder + if (inputSampleL > 0.0) inputSampleL = (inputSampleL*2.0)/(2.8274333882308-inputSampleL); + else inputSampleL = -(inputSampleL*-2.0)/(2.8274333882308+inputSampleL); + if (inputSampleR > 0.0) inputSampleR = (inputSampleR*2.0)/(2.8274333882308-inputSampleR); + else inputSampleR = -(inputSampleR*-2.0)/(2.8274333882308+inputSampleR); + //BigFastArcSin output stage + + if (cycleEnd > 1) { + double outSample = (inputSampleL + tailL)*0.5; + tailL = inputSampleL; inputSampleL = outSample; + outSample = (inputSampleR + tailR)*0.5; + tailR = inputSampleR; inputSampleR = outSample; + } //let's average only at elevated sample rates + + if (wet < 1.0) {inputSampleL *= wet; inputSampleR *= wet;} + if (dry < 1.0) {drySampleL *= dry; drySampleR *= dry;} + inputSampleL += drySampleL; inputSampleR += drySampleR; + //this is our submix verb dry/wet: 0.5 is BOTH at FULL VOLUME + //purpose is that, if you're adding verb, you're not altering other balances + + //begin 64 bit stereo floating point dither + //int expon; frexp((double)inputSampleL, &expon); + fpdL ^= fpdL << 13; fpdL ^= fpdL >> 17; fpdL ^= fpdL << 5; + //inputSampleL += ((double(fpdL)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //frexp((double)inputSampleR, &expon); + fpdR ^= fpdR << 13; fpdR ^= fpdR >> 17; fpdR ^= fpdR << 5; + //inputSampleR += ((double(fpdR)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62)); + //end 64 bit stereo floating point dither + + *out1 = inputSampleL; + *out2 = inputSampleR; + + in1++; + in2++; + out1++; + out2++; + } +} +} // end namespace