├── .gitmodules ├── .gitignore ├── README.md ├── package-info.json.in ├── source └── objects │ ├── filter │ ├── airfx.eq_tilde │ │ └── airfx.eq_tilde.cpp │ ├── airfx.holt_tilde │ │ └── airfx.holt_tilde.cpp │ ├── airfx.hull_tilde │ │ └── airfx.hull_tilde.cpp │ ├── airfx.pear_tilde │ │ └── airfx.pear_tilde.cpp │ ├── airfx.holt2_tilde │ │ └── airfx.holt2_tilde.cpp │ ├── airfx.hull2_tilde │ │ └── airfx.hull2_tilde.cpp │ ├── airfx.pear2_tilde │ │ └── airfx.pear2_tilde.cpp │ ├── airfx.reseq_tilde │ │ └── airfx.reseq_tilde.cpp │ ├── airfx.kalman_tilde │ │ └── airfx.kalman_tilde.cpp │ ├── airfx.mackeq_tilde │ │ └── airfx.mackeq_tilde.cpp │ ├── airfx.reseq2_tilde │ │ └── airfx.reseq2_tilde.cpp │ ├── airfx.weight_tilde │ │ └── airfx.weight_tilde.cpp │ ├── airfx.average_tilde │ │ └── airfx.average_tilde.cpp │ ├── airfx.cstrip2_tilde │ │ └── airfx.cstrip2_tilde.cpp │ ├── airfx.lowpass_tilde │ │ └── airfx.lowpass_tilde.cpp │ ├── airfx.tapefat_tilde │ │ └── airfx.tapefat_tilde.cpp │ ├── airfx.distance_tilde │ │ └── airfx.distance_tilde.cpp │ ├── airfx.highpass_tilde │ │ └── airfx.highpass_tilde.cpp │ ├── airfx.isolator_tilde │ │ └── airfx.isolator_tilde.cpp │ ├── airfx.lowpass2_tilde │ │ └── airfx.lowpass2_tilde.cpp │ ├── airfx.subtight_tilde │ │ └── airfx.subtight_tilde.cpp │ ├── airfx.baxandall_tilde │ │ └── airfx.baxandall_tilde.cpp │ ├── airfx.capacitor_tilde │ │ └── airfx.capacitor_tilde.cpp │ ├── airfx.distance2_tilde │ │ └── airfx.distance2_tilde.cpp │ ├── airfx.distance3_tilde │ │ └── airfx.distance3_tilde.cpp │ ├── airfx.highpass2_tilde │ │ └── airfx.highpass2_tilde.cpp │ ├── airfx.isolator2_tilde │ │ └── airfx.isolator2_tilde.cpp │ ├── airfx.stonefire_tilde │ │ └── airfx.stonefire_tilde.cpp │ └── airfx.toneslant_tilde │ │ └── airfx.toneslant_tilde.cpp │ ├── ambience │ ├── airfx.mv_tilde │ │ └── airfx.mv_tilde.cpp │ ├── airfx.mv2_tilde │ │ └── airfx.mv2_tilde.cpp │ ├── airfx.melt_tilde │ │ └── airfx.melt_tilde.cpp │ ├── airfx.hombre_tilde │ │ └── airfx.hombre_tilde.cpp │ ├── airfx.ensemble_tilde │ │ └── airfx.ensemble_tilde.cpp │ ├── airfx.clearcoat_tilde │ │ └── airfx.clearcoat_tilde.cpp │ ├── airfx.doublelay_tilde │ │ └── airfx.doublelay_tilde.cpp │ ├── airfx.starchild_tilde │ │ └── airfx.starchild_tilde.cpp │ └── airfx.tapedelay_tilde │ │ └── airfx.tapedelay_tilde.cpp │ ├── dynamics │ ├── airfx.pop_tilde │ │ └── airfx.pop_tilde.cpp │ ├── airfx.pop2_tilde │ │ └── airfx.pop2_tilde.cpp │ ├── airfx.curve_tilde │ │ └── airfx.curve_tilde.cpp │ ├── airfx.point_tilde │ │ └── airfx.point_tilde.cpp │ ├── airfx.surge_tilde │ │ └── airfx.surge_tilde.cpp │ ├── airfx.swell_tilde │ │ └── airfx.swell_tilde.cpp │ ├── airfx.varimu_tilde │ │ └── airfx.varimu_tilde.cpp │ ├── airfx.podcast_tilde │ │ └── airfx.podcast_tilde.cpp │ ├── airfx.recurve_tilde │ │ └── airfx.recurve_tilde.cpp │ ├── airfx.thunder_tilde │ │ └── airfx.thunder_tilde.cpp │ ├── airfx.drumslam_tilde │ │ └── airfx.drumslam_tilde.cpp │ ├── airfx.dynamics_tilde │ │ └── airfx.dynamics_tilde.cpp │ ├── airfx.gatelope_tilde │ │ └── airfx.gatelope_tilde.cpp │ ├── airfx.logical4_tilde │ │ └── airfx.logical4_tilde.cpp │ └── airfx.softgate_tilde │ │ └── airfx.softgate_tilde.cpp │ ├── brightness │ ├── airfx.air_tilde │ │ └── airfx.air_tilde.cpp │ ├── airfx.air2_tilde │ │ └── airfx.air2_tilde.cpp │ ├── airfx.air3_tilde │ │ └── airfx.air3_tilde.cpp │ ├── airfx.deess_tilde │ │ └── airfx.deess_tilde.cpp │ ├── airfx.sinew_tilde │ │ └── airfx.sinew_tilde.cpp │ ├── airfx.slew2_tilde │ │ └── airfx.slew2_tilde.cpp │ ├── airfx.slew3_tilde │ │ └── airfx.slew3_tilde.cpp │ ├── airfx.debess_tilde │ │ └── airfx.debess_tilde.cpp │ ├── airfx.dehiss_tilde │ │ └── airfx.dehiss_tilde.cpp │ ├── airfx.smooth_tilde │ │ └── airfx.smooth_tilde.cpp │ ├── airfx.everyslew_tilde │ │ └── airfx.everyslew_tilde.cpp │ └── airfx.hypersonx_tilde │ │ └── airfx.hypersonx_tilde.cpp │ ├── lo-fi │ ├── airfx.bite_tilde │ │ └── airfx.bite_tilde.cpp │ ├── airfx.derez_tilde │ │ └── airfx.derez_tilde.cpp │ ├── airfx.derez2_tilde │ │ └── airfx.derez2_tilde.cpp │ ├── airfx.pockey_tilde │ │ └── airfx.pockey_tilde.cpp │ ├── airfx.cojones_tilde │ │ └── airfx.cojones_tilde.cpp │ ├── airfx.flutter_tilde │ │ └── airfx.flutter_tilde.cpp │ ├── airfx.pockey2_tilde │ │ └── airfx.pockey2_tilde.cpp │ ├── airfx.vibrato_tilde │ │ └── airfx.vibrato_tilde.cpp │ └── airfx.dustbunny_tilde │ │ └── airfx.dustbunny_tilde.cpp │ ├── tape │ ├── airfx.tape_tilde │ │ └── airfx.tape_tilde.cpp │ ├── airfx.totape5_tilde │ │ └── airfx.totape5_tilde.cpp │ ├── airfx.totape6_tilde │ │ └── airfx.totape6_tilde.cpp │ └── airfx.fromtape_tilde │ │ └── airfx.fromtape_tilde.cpp │ ├── dithers │ ├── airfx.beam_tilde │ │ └── airfx.beam_tilde.cpp │ ├── airfx.dark_tilde │ │ └── airfx.dark_tilde.cpp │ ├── airfx.paulwide_tilde │ │ └── airfx.paulwide_tilde.cpp │ ├── airfx.tpdfwide_tilde │ │ └── airfx.tpdfwide_tilde.cpp │ ├── airfx.ditherbox_tilde │ │ └── airfx.ditherbox_tilde.cpp │ └── airfx.studiotan_tilde │ │ └── airfx.studiotan_tilde.cpp │ ├── effects │ ├── airfx.aura_tilde │ │ └── airfx.aura_tilde.cpp │ ├── airfx.dubly_tilde │ │ └── airfx.dubly_tilde.cpp │ ├── airfx.facet_tilde │ │ └── airfx.facet_tilde.cpp │ ├── airfx.energy_tilde │ │ └── airfx.energy_tilde.cpp │ ├── airfx.nikola_tilde │ │ └── airfx.nikola_tilde.cpp │ ├── airfx.energy2_tilde │ │ └── airfx.energy2_tilde.cpp │ ├── airfx.exciter_tilde │ │ └── airfx.exciter_tilde.cpp │ ├── airfx.gringer_tilde │ │ └── airfx.gringer_tilde.cpp │ ├── airfx.tremolo_tilde │ │ └── airfx.tremolo_tilde.cpp │ ├── airfx.fracture_tilde │ │ └── airfx.fracture_tilde.cpp │ ├── airfx.powersag_tilde │ │ └── airfx.powersag_tilde.cpp │ ├── airfx.cloudcoat_tilde │ │ └── airfx.cloudcoat_tilde.cpp │ ├── airfx.fracture2_tilde │ │ └── airfx.fracture2_tilde.cpp │ ├── airfx.powersag2_tilde │ │ └── airfx.powersag2_tilde.cpp │ └── airfx.shortbuss_tilde │ │ └── airfx.shortbuss_tilde.cpp │ ├── amp-sims │ ├── airfx.cabs_tilde │ │ └── airfx.cabs_tilde.cpp │ ├── airfx.bigamp_tilde │ │ └── airfx.bigamp_tilde.cpp │ ├── airfx.lilamp_tilde │ │ └── airfx.lilamp_tilde.cpp │ ├── airfx.midamp_tilde │ │ └── airfx.midamp_tilde.cpp │ ├── airfx.bassamp_tilde │ │ └── airfx.bassamp_tilde.cpp │ ├── airfx.fireamp_tilde │ │ └── airfx.fireamp_tilde.cpp │ ├── airfx.leadamp_tilde │ │ └── airfx.leadamp_tilde.cpp │ ├── airfx.grindamp_tilde │ │ └── airfx.grindamp_tilde.cpp │ ├── airfx.bassdrive_tilde │ │ └── airfx.bassdrive_tilde.cpp │ └── airfx.crickbass_tilde │ │ └── airfx.crickbass_tilde.cpp │ ├── bass │ ├── airfx.floor_tilde │ │ └── airfx.floor_tilde.cpp │ ├── airfx.dubsub_tilde │ │ └── airfx.dubsub_tilde.cpp │ ├── airfx.basskit_tilde │ │ └── airfx.basskit_tilde.cpp │ ├── airfx.dubcenter_tilde │ │ └── airfx.dubcenter_tilde.cpp │ ├── airfx.hermepass_tilde │ │ └── airfx.hermepass_tilde.cpp │ ├── airfx.orbitkick_tilde │ │ └── airfx.orbitkick_tilde.cpp │ ├── airfx.fathomfive_tilde │ │ └── airfx.fathomfive_tilde.cpp │ └── airfx.infrasonic_tilde │ │ └── airfx.infrasonic_tilde.cpp │ ├── distortion │ ├── airfx.dirt_tilde │ │ └── airfx.dirt_tilde.cpp │ ├── airfx.edge_tilde │ │ └── airfx.edge_tilde.cpp │ ├── airfx.loud_tilde │ │ └── airfx.loud_tilde.cpp │ ├── airfx.drive_tilde │ │ └── airfx.drive_tilde.cpp │ ├── airfx.density_tilde │ │ └── airfx.density_tilde.cpp │ ├── airfx.mackity_tilde │ │ └── airfx.mackity_tilde.cpp │ └── airfx.density2_tilde │ │ └── airfx.density2_tilde.cpp │ ├── saturation │ ├── airfx.dyno_tilde │ │ └── airfx.dyno_tilde.cpp │ ├── airfx.huge_tilde │ │ └── airfx.huge_tilde.cpp │ ├── airfx.mojo_tilde │ │ └── airfx.mojo_tilde.cpp │ ├── airfx.tube_tilde │ │ └── airfx.tube_tilde.cpp │ ├── airfx.desk4_tilde │ │ └── airfx.desk4_tilde.cpp │ ├── airfx.focus_tilde │ │ └── airfx.focus_tilde.cpp │ ├── airfx.tube2_tilde │ │ └── airfx.tube2_tilde.cpp │ ├── airfx.unbox_tilde │ │ └── airfx.unbox_tilde.cpp │ ├── airfx.spiral_tilde │ │ └── airfx.spiral_tilde.cpp │ ├── airfx.spiral2_tilde │ │ └── airfx.spiral2_tilde.cpp │ └── airfx.creature_tilde │ │ └── airfx.creature_tilde.cpp │ ├── subtlety │ ├── airfx.desk_tilde │ │ └── airfx.desk_tilde.cpp │ ├── airfx.hype_tilde │ │ └── airfx.hype_tilde.cpp │ ├── airfx.coils_tilde │ │ └── airfx.coils_tilde.cpp │ ├── airfx.remap_tilde │ │ └── airfx.remap_tilde.cpp │ ├── airfx.shape_tilde │ │ └── airfx.shape_tilde.cpp │ ├── airfx.coils2_tilde │ │ └── airfx.coils2_tilde.cpp │ ├── airfx.sweeten_tilde │ │ └── airfx.sweeten_tilde.cpp │ ├── airfx.inflamer_tilde │ │ └── airfx.inflamer_tilde.cpp │ └── airfx.tubedesk_tilde │ │ └── airfx.tubedesk_tilde.cpp │ ├── noise │ ├── airfx.noise_tilde │ │ └── airfx.noise_tilde.cpp │ ├── airfx.tapedust_tilde │ │ └── airfx.tapedust_tilde.cpp │ ├── airfx.darknoise_tilde │ │ └── airfx.darknoise_tilde.cpp │ └── airfx.texturize_tilde │ │ └── airfx.texturize_tilde.cpp │ ├── stereo │ ├── airfx.srsly_tilde │ │ └── airfx.srsly_tilde.cpp │ ├── airfx.wider_tilde │ │ └── airfx.wider_tilde.cpp │ ├── airfx.srsly2_tilde │ │ └── airfx.srsly2_tilde.cpp │ ├── airfx.autopan_tilde │ │ └── airfx.autopan_tilde.cpp │ ├── airfx.sidedull_tilde │ │ └── airfx.sidedull_tilde.cpp │ ├── airfx.sidepass_tilde │ │ └── airfx.sidepass_tilde.cpp │ ├── airfx.stereofx_tilde │ │ └── airfx.stereofx_tilde.cpp │ └── airfx.tovinyl4_tilde │ │ └── airfx.tovinyl4_tilde.cpp │ ├── utility │ ├── airfx.golem_tilde │ │ └── airfx.golem_tilde.cpp │ ├── airfx.monoam_tilde │ │ └── airfx.monoam_tilde.cpp │ ├── airfx.edisdim_tilde │ │ └── airfx.edisdim_tilde.cpp │ ├── airfx.flipity_tilde │ │ └── airfx.flipity_tilde.cpp │ ├── airfx.midside_tilde │ │ └── airfx.midside_tilde.cpp │ ├── airfx.balanced_tilde │ │ └── airfx.balanced_tilde.cpp │ ├── airfx.slewonly_tilde │ │ └── airfx.slewonly_tilde.cpp │ ├── airfx.subsonly_tilde │ │ └── airfx.subsonly_tilde.cpp │ ├── airfx.dcvoltage_tilde │ │ └── airfx.dcvoltage_tilde.cpp │ ├── airfx.everytrim_tilde │ │ └── airfx.everytrim_tilde.cpp │ ├── airfx.hermetrim_tilde │ │ └── airfx.hermetrim_tilde.cpp │ ├── airfx.leftomono_tilde │ │ └── airfx.leftomono_tilde.cpp │ └── airfx.peaksonly_tilde │ │ └── airfx.peaksonly_tilde.cpp │ ├── tone-color │ ├── airfx.cider_tilde │ │ └── airfx.cider_tilde.cpp │ ├── airfx.luxor_tilde │ │ └── airfx.luxor_tilde.cpp │ ├── airfx.calibre_tilde │ │ └── airfx.calibre_tilde.cpp │ ├── airfx.crystal_tilde │ │ └── airfx.crystal_tilde.cpp │ ├── airfx.elation_tilde │ │ └── airfx.elation_tilde.cpp │ ├── airfx.channel4_tilde │ │ └── airfx.channel4_tilde.cpp │ ├── airfx.channel9_tilde │ │ └── airfx.channel9_tilde.cpp │ └── airfx.precious_tilde │ │ └── airfx.precious_tilde.cpp │ ├── biquads │ ├── airfx.biquad_tilde │ │ └── airfx.biquad_tilde.cpp │ └── airfx.biquad2_tilde │ │ └── airfx.biquad2_tilde.cpp │ ├── reverb │ ├── airfx.reverb_tilde │ │ └── airfx.reverb_tilde.cpp │ ├── airfx.chamber_tilde │ │ └── airfx.chamber_tilde.cpp │ ├── airfx.kplatea_tilde │ │ └── airfx.kplatea_tilde.cpp │ ├── airfx.kplateb_tilde │ │ └── airfx.kplateb_tilde.cpp │ ├── airfx.kplatec_tilde │ │ └── airfx.kplatec_tilde.cpp │ ├── airfx.kplated_tilde │ │ └── airfx.kplated_tilde.cpp │ ├── airfx.verbity_tilde │ │ └── airfx.verbity_tilde.cpp │ ├── airfx.chamber2_tilde │ │ └── airfx.chamber2_tilde.cpp │ ├── airfx.galactic_tilde │ │ └── airfx.galactic_tilde.cpp │ ├── airfx.infinity_tilde │ │ └── airfx.infinity_tilde.cpp │ ├── airfx.verbity2_tilde │ │ └── airfx.verbity2_tilde.cpp │ ├── airfx.galactic2_tilde │ │ └── airfx.galactic2_tilde.cpp │ └── airfx.infinity2_tilde │ │ └── airfx.infinity2_tilde.cpp │ ├── xyz-filters │ ├── airfx.xnotch_tilde │ │ └── airfx.xnotch_tilde.cpp │ ├── airfx.ynotch_tilde │ │ └── airfx.ynotch_tilde.cpp │ ├── airfx.znotch_tilde │ │ └── airfx.znotch_tilde.cpp │ ├── airfx.xregion_tilde │ │ └── airfx.xregion_tilde.cpp │ ├── airfx.znotch2_tilde │ │ └── airfx.znotch2_tilde.cpp │ ├── airfx.zregion_tilde │ │ └── airfx.zregion_tilde.cpp │ ├── airfx.xlowpass_tilde │ │ └── airfx.xlowpass_tilde.cpp │ ├── airfx.ylowpass_tilde │ │ └── airfx.ylowpass_tilde.cpp │ ├── airfx.zlowpass_tilde │ │ └── airfx.zlowpass_tilde.cpp │ └── airfx.zregion2_tilde │ │ └── airfx.zregion2_tilde.cpp │ └── clipping │ ├── airfx.adclip7_tilde │ └── airfx.adclip7_tilde.cpp │ ├── airfx.adclip8_tilde │ └── airfx.adclip8_tilde.cpp │ └── airfx.cliponly_tilde │ └── airfx.cliponly_tilde.cpp └── scripts ├── example.cpp └── example.CMakeLists.txt /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "source/min-api"] 2 | path = source/min-api 3 | url = git@github.com:Cycling74/min-api.git 4 | [submodule "source/airwindohhs"] 5 | path = source/airwindohhs 6 | url = git@github.com:isabelgk/airwindohhs.git 7 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | __* 2 | sysbuild 3 | *.sdf 4 | *.suo 5 | *.sln 6 | *.opensdf 7 | log.txt 8 | externals 9 | extensions 10 | support 11 | build 12 | tests 13 | *.o 14 | *.dylib 15 | tmp 16 | .DS_Store 17 | .vs 18 | package-info.json 19 | .vscode 20 | .idea 21 | .cache 22 | cmake-build-*/ 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # airfx 2 | Max objects ported from the open source VST2 [airwindows](https://github.com/airwindows/airwindows/) plugins by Chris Johnson. 3 | 4 | Releases and pre-release packages for all platforms are available from the GitHub releases page. Download and unzip into your Max Packages directory. 5 | 6 | 7 | # License 8 | 9 | This project and the Airwindows VSTs are licenced under the MIT license. 10 | -------------------------------------------------------------------------------- /package-info.json.in: -------------------------------------------------------------------------------- 1 | { 2 | "author" : "Isabel Kaspriskie", 3 | "description" : "Max objects ported from the open source airwindows VST plugins.", 4 | "homepatcher" : "", 5 | "max_version_min" : "8.0", "max_version_max" : "none", 6 | "name" : "@C74_PACKAGE_NAME@", 7 | "os" : { 8 | "macintosh" : { 9 | "platform" : [ "x64", "aarch64" ], 10 | "min_version" : "none" 11 | }, 12 | "windows" : { 13 | "platform" : [ "x64" ], 14 | "min_version" : "none" 15 | } 16 | }, 17 | "package_extra" : { 18 | "reverse_domain" : "com.isabelgk" 19 | }, 20 | "tags" : [ "effects", "audio" ], 21 | "version" : "@GIT_VERSION_MAJ@.@GIT_VERSION_MIN@.@GIT_VERSION_SUB@", 22 | "website" : "http://www.github.com/isabelgk/airfx" 23 | } 24 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.eq_tilde/airfx.eq_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/eq.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class eq_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::eq::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::eq::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::eq::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | eq_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(eq_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.mv_tilde/airfx.mv_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/mv.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class mv_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::mv::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::mv::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::mv::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | mv_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(mv_tilde); 32 | -------------------------------------------------------------------------------- /scripts/example.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "category/example.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class example_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::example::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::example::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::example::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | example_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(example_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.mv2_tilde/airfx.mv2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/mv2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class mv2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::mv2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::mv2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::mv2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | mv2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(mv2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.pop_tilde/airfx.pop_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/pop.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class pop_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::pop::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::pop::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::pop::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | pop_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(pop_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.air_tilde/airfx.air_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/air.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class air_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::air::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::air::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::air::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | air_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(air_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.bite_tilde/airfx.bite_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/bite.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class bite_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::bite::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::bite::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::bite::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | bite_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(bite_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tape/airfx.tape_tilde/airfx.tape_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tape/tape.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tape_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tape::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tape::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tape::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tape_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tape_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dithers/airfx.beam_tilde/airfx.beam_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dithers/beam.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class beam_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::beam::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::beam::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::beam::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | beam_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(beam_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dithers/airfx.dark_tilde/airfx.dark_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dithers/dark.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dark_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dark::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dark::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dark::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dark_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dark_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.aura_tilde/airfx.aura_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/aura.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class aura_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::aura::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::aura::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::aura::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | aura_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(aura_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.holt_tilde/airfx.holt_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/holt.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class holt_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::holt::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::holt::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::holt::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | holt_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(holt_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.hull_tilde/airfx.hull_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/hull.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class hull_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::hull::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::hull::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::hull::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | hull_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(hull_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.pear_tilde/airfx.pear_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/pear.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class pear_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::pear::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::pear::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::pear::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | pear_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(pear_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.melt_tilde/airfx.melt_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/melt.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class melt_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::melt::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::melt::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::melt::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | melt_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(melt_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.cabs_tilde/airfx.cabs_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/cabs.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class cabs_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::cabs::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::cabs::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::cabs::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | cabs_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(cabs_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.floor_tilde/airfx.floor_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/floor.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class floor_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::floor::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::floor::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::floor::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | floor_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(floor_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.air2_tilde/airfx.air2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/air2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class air2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::air2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::air2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::air2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | air2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(air2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.air3_tilde/airfx.air3_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/air3.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class air3_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::air3::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::air3::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::air3::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | air3_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(air3_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/distortion/airfx.dirt_tilde/airfx.dirt_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "distortion/dirt.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dirt_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dirt::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dirt::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dirt::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dirt_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dirt_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/distortion/airfx.edge_tilde/airfx.edge_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "distortion/edge.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class edge_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::edge::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::edge::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::edge::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | edge_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(edge_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/distortion/airfx.loud_tilde/airfx.loud_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "distortion/loud.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class loud_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::loud::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::loud::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::loud::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | loud_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(loud_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.pop2_tilde/airfx.pop2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/pop2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class pop2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::pop2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::pop2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::pop2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | pop2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(pop2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.dyno_tilde/airfx.dyno_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/dyno.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dyno_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dyno::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dyno::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dyno::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dyno_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dyno_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.huge_tilde/airfx.huge_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/huge.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class huge_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::huge::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::huge::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::huge::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | huge_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(huge_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.mojo_tilde/airfx.mojo_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/mojo.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class mojo_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::mojo::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::mojo::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::mojo::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | mojo_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(mojo_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.tube_tilde/airfx.tube_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/tube.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tube_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tube::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tube::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tube::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tube_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tube_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.desk_tilde/airfx.desk_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/desk.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class desk_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::desk::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::desk::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::desk::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | desk_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(desk_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.hype_tilde/airfx.hype_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/hype.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class hype_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::hype::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::hype::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::hype::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | hype_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(hype_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.holt2_tilde/airfx.holt2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/holt2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class holt2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::holt2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::holt2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::holt2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | holt2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(holt2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.hull2_tilde/airfx.hull2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/hull2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class hull2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::hull2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::hull2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::hull2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | hull2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(hull2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.pear2_tilde/airfx.pear2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/pear2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class pear2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::pear2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::pear2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::pear2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | pear2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(pear2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.reseq_tilde/airfx.reseq_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/reseq.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class reseq_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::reseq::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::reseq::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::reseq::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | reseq_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(reseq_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.derez_tilde/airfx.derez_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/derez.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class derez_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::derez::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::derez::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::derez::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | derez_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(derez_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/noise/airfx.noise_tilde/airfx.noise_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "noise/noise.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class noise_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::noise::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::noise::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::noise::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | noise_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(noise_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.srsly_tilde/airfx.srsly_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/srsly.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class srsly_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::srsly::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::srsly::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::srsly::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | srsly_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(srsly_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.wider_tilde/airfx.wider_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/wider.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class wider_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::wider::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::wider::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::wider::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | wider_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(wider_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.curve_tilde/airfx.curve_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/curve.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class curve_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::curve::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::curve::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::curve::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | curve_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(curve_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.point_tilde/airfx.point_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/point.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class point_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::point::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::point::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::point::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | point_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(point_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.surge_tilde/airfx.surge_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/surge.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class surge_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::surge::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::surge::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::surge::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | surge_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(surge_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.swell_tilde/airfx.swell_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/swell.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class swell_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::swell::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::swell::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::swell::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | swell_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(swell_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.dubly_tilde/airfx.dubly_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/dubly.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dubly_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dubly::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dubly::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dubly::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dubly_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dubly_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.facet_tilde/airfx.facet_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/facet.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class facet_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::facet::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::facet::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::facet::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | facet_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(facet_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.coils_tilde/airfx.coils_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/coils.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class coils_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::coils::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::coils::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::coils::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | coils_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(coils_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.remap_tilde/airfx.remap_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/remap.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class remap_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::remap::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::remap::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::remap::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | remap_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(remap_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.shape_tilde/airfx.shape_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/shape.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class shape_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::shape::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::shape::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::shape::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | shape_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(shape_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.golem_tilde/airfx.golem_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/golem.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class golem_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::golem::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::golem::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::golem::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | golem_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(golem_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.dubsub_tilde/airfx.dubsub_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/dubsub.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dubsub_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dubsub::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dubsub::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dubsub::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dubsub_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dubsub_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.deess_tilde/airfx.deess_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/deess.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class deess_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::deess::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::deess::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::deess::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | deess_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(deess_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.sinew_tilde/airfx.sinew_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/sinew.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class sinew_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::sinew::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::sinew::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::sinew::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | sinew_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(sinew_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.slew2_tilde/airfx.slew2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/slew2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class slew2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::slew2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::slew2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::slew2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | slew2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(slew2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.slew3_tilde/airfx.slew3_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/slew3.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class slew3_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::slew3::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::slew3::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::slew3::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | slew3_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(slew3_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/distortion/airfx.drive_tilde/airfx.drive_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "distortion/drive.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class drive_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::drive::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::drive::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::drive::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | drive_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(drive_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.derez2_tilde/airfx.derez2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/derez2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class derez2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::derez2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::derez2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::derez2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | derez2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(derez2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.pockey_tilde/airfx.pockey_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/pockey.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class pockey_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::pockey::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::pockey::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::pockey::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | pockey_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(pockey_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.desk4_tilde/airfx.desk4_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/desk4.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class desk4_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::desk4::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::desk4::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::desk4::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | desk4_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(desk4_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.focus_tilde/airfx.focus_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/focus.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class focus_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::focus::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::focus::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::focus::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | focus_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(focus_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.tube2_tilde/airfx.tube2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/tube2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tube2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tube2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tube2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tube2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tube2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tube2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.unbox_tilde/airfx.unbox_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/unbox.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class unbox_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::unbox::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::unbox::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::unbox::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | unbox_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(unbox_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.cider_tilde/airfx.cider_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/cider.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class cider_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::cider::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::cider::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::cider::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | cider_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(cider_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.luxor_tilde/airfx.luxor_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/luxor.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class luxor_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::luxor::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::luxor::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::luxor::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | luxor_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(luxor_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.hombre_tilde/airfx.hombre_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/hombre.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class hombre_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::hombre::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::hombre::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::hombre::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | hombre_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(hombre_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.bigamp_tilde/airfx.bigamp_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/bigamp.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class bigamp_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::bigamp::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::bigamp::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::bigamp::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | bigamp_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(bigamp_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.lilamp_tilde/airfx.lilamp_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/lilamp.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class lilamp_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::lilamp::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::lilamp::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::lilamp::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | lilamp_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(lilamp_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.midamp_tilde/airfx.midamp_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/midamp.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class midamp_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::midamp::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::midamp::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::midamp::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | midamp_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(midamp_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/biquads/airfx.biquad_tilde/airfx.biquad_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "biquads/biquad.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class biquad_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::biquad::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::biquad::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::biquad::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | biquad_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(biquad_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.varimu_tilde/airfx.varimu_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/varimu.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class varimu_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::varimu::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::varimu::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::varimu::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | varimu_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(varimu_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.energy_tilde/airfx.energy_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/energy.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class energy_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::energy::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::energy::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::energy::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | energy_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(energy_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.nikola_tilde/airfx.nikola_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/nikola.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class nikola_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::nikola::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::nikola::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::nikola::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | nikola_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(nikola_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.kalman_tilde/airfx.kalman_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/kalman.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class kalman_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::kalman::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::kalman::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::kalman::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | kalman_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(kalman_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.mackeq_tilde/airfx.mackeq_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/mackeq.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class mackeq_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::mackeq::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::mackeq::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::mackeq::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | mackeq_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(mackeq_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.reseq2_tilde/airfx.reseq2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/reseq2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class reseq2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::reseq2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::reseq2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::reseq2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | reseq2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(reseq2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.weight_tilde/airfx.weight_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/weight.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class weight_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::weight::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::weight::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::weight::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | weight_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(weight_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.reverb_tilde/airfx.reverb_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/reverb.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class reverb_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::reverb::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::reverb::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::reverb::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | reverb_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(reverb_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.srsly2_tilde/airfx.srsly2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/srsly2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class srsly2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::srsly2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::srsly2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::srsly2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | srsly2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(srsly2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.coils2_tilde/airfx.coils2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/coils2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class coils2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::coils2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::coils2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::coils2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | coils2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(coils2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.monoam_tilde/airfx.monoam_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/monoam.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class monoam_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::monoam::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::monoam::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::monoam::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | monoam_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(monoam_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.basskit_tilde/airfx.basskit_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/basskit.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class basskit_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::basskit::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::basskit::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::basskit::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | basskit_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(basskit_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.debess_tilde/airfx.debess_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/debess.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class debess_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::debess::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::debess::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::debess::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | debess_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(debess_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.dehiss_tilde/airfx.dehiss_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/dehiss.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dehiss_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dehiss::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dehiss::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dehiss::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dehiss_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dehiss_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.smooth_tilde/airfx.smooth_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/smooth.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class smooth_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::smooth::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::smooth::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::smooth::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | smooth_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(smooth_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.spiral_tilde/airfx.spiral_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/spiral.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class spiral_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::spiral::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::spiral::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::spiral::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | spiral_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(spiral_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tape/airfx.totape5_tilde/airfx.totape5_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tape/totape5.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class totape5_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::totape5::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::totape5::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::totape5::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | totape5_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(totape5_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tape/airfx.totape6_tilde/airfx.totape6_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tape/totape6.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class totape6_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::totape6::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::totape6::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::totape6::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | totape6_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(totape6_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/biquads/airfx.biquad2_tilde/airfx.biquad2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "biquads/biquad2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class biquad2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::biquad2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::biquad2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::biquad2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | biquad2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(biquad2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.energy2_tilde/airfx.energy2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/energy2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class energy2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::energy2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::energy2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::energy2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | energy2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(energy2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.exciter_tilde/airfx.exciter_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/exciter.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class exciter_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::exciter::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::exciter::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::exciter::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | exciter_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(exciter_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.gringer_tilde/airfx.gringer_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/gringer.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class gringer_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::gringer::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::gringer::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::gringer::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | gringer_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(gringer_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.tremolo_tilde/airfx.tremolo_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/tremolo.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tremolo_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tremolo::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tremolo::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tremolo::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tremolo_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tremolo_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.average_tilde/airfx.average_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/average.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class average_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::average::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::average::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::average::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | average_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(average_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.cstrip2_tilde/airfx.cstrip2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/cstrip2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class cstrip2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::cstrip2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::cstrip2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::cstrip2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | cstrip2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(cstrip2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.lowpass_tilde/airfx.lowpass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/lowpass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class lowpass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::lowpass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::lowpass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::lowpass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | lowpass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(lowpass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.tapefat_tilde/airfx.tapefat_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/tapefat.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tapefat_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tapefat::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tapefat::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tapefat::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tapefat_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tapefat_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.cojones_tilde/airfx.cojones_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/cojones.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class cojones_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::cojones::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::cojones::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::cojones::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | cojones_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(cojones_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.flutter_tilde/airfx.flutter_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/flutter.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class flutter_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::flutter::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::flutter::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::flutter::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | flutter_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(flutter_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.pockey2_tilde/airfx.pockey2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/pockey2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class pockey2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::pockey2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::pockey2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::pockey2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | pockey2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(pockey2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.vibrato_tilde/airfx.vibrato_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/vibrato.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class vibrato_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::vibrato::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::vibrato::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::vibrato::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | vibrato_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(vibrato_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.chamber_tilde/airfx.chamber_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/chamber.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class chamber_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::chamber::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::chamber::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::chamber::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | chamber_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(chamber_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.kplatea_tilde/airfx.kplatea_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/kplatea.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class kplatea_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::kplatea::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::kplatea::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::kplatea::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | kplatea_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(kplatea_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.kplateb_tilde/airfx.kplateb_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/kplateb.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class kplateb_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::kplateb::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::kplateb::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::kplateb::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | kplateb_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(kplateb_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.kplatec_tilde/airfx.kplatec_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/kplatec.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class kplatec_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::kplatec::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::kplatec::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::kplatec::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | kplatec_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(kplatec_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.kplated_tilde/airfx.kplated_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/kplated.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class kplated_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::kplated::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::kplated::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::kplated::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | kplated_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(kplated_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.verbity_tilde/airfx.verbity_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/verbity.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class verbity_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::verbity::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::verbity::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::verbity::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | verbity_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(verbity_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.autopan_tilde/airfx.autopan_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/autopan.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class autopan_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::autopan::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::autopan::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::autopan::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | autopan_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(autopan_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.edisdim_tilde/airfx.edisdim_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/edisdim.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class edisdim_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::edisdim::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::edisdim::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::edisdim::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | edisdim_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(edisdim_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.flipity_tilde/airfx.flipity_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/flipity.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class flipity_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::flipity::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::flipity::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::flipity::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | flipity_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(flipity_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.midside_tilde/airfx.midside_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/midside.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class midside_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::midside::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::midside::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::midside::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | midside_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(midside_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.xnotch_tilde/airfx.xnotch_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/xnotch.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class xnotch_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::xnotch::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::xnotch::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::xnotch::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | xnotch_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(xnotch_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.ynotch_tilde/airfx.ynotch_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/ynotch.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class ynotch_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::ynotch::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::ynotch::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::ynotch::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | ynotch_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(ynotch_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.znotch_tilde/airfx.znotch_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/znotch.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class znotch_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::znotch::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::znotch::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::znotch::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | znotch_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(znotch_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.bassamp_tilde/airfx.bassamp_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/bassamp.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class bassamp_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::bassamp::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::bassamp::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::bassamp::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | bassamp_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(bassamp_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.fireamp_tilde/airfx.fireamp_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/fireamp.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class fireamp_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::fireamp::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::fireamp::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::fireamp::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | fireamp_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(fireamp_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.leadamp_tilde/airfx.leadamp_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/leadamp.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class leadamp_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::leadamp::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::leadamp::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::leadamp::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | leadamp_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(leadamp_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/clipping/airfx.adclip7_tilde/airfx.adclip7_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "clipping/adclip7.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class adclip7_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::adclip7::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::adclip7::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::adclip7::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | adclip7_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(adclip7_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/clipping/airfx.adclip8_tilde/airfx.adclip8_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "clipping/adclip8.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class adclip8_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::adclip8::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::adclip8::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::adclip8::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | adclip8_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(adclip8_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.podcast_tilde/airfx.podcast_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/podcast.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class podcast_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::podcast::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::podcast::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::podcast::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | podcast_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(podcast_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.recurve_tilde/airfx.recurve_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/recurve.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class recurve_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::recurve::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::recurve::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::recurve::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | recurve_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(recurve_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.thunder_tilde/airfx.thunder_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/thunder.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class thunder_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::thunder::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::thunder::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::thunder::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | thunder_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(thunder_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.sweeten_tilde/airfx.sweeten_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/sweeten.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class sweeten_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::sweeten::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::sweeten::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::sweeten::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | sweeten_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(sweeten_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/distortion/airfx.density_tilde/airfx.density_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "distortion/density.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class density_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::density::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::density::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::density::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | density_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(density_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/distortion/airfx.mackity_tilde/airfx.mackity_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "distortion/mackity.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class mackity_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::mackity::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::mackity::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::mackity::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | mackity_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(mackity_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.distance_tilde/airfx.distance_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/distance.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class distance_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::distance::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::distance::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::distance::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | distance_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(distance_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.highpass_tilde/airfx.highpass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/highpass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class highpass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::highpass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::highpass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::highpass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | highpass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(highpass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.isolator_tilde/airfx.isolator_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/isolator.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class isolator_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::isolator::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::isolator::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::isolator::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | isolator_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(isolator_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.lowpass2_tilde/airfx.lowpass2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/lowpass2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class lowpass2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::lowpass2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::lowpass2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::lowpass2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | lowpass2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(lowpass2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.subtight_tilde/airfx.subtight_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/subtight.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class subtight_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::subtight::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::subtight::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::subtight::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | subtight_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(subtight_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/noise/airfx.tapedust_tilde/airfx.tapedust_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "noise/tapedust.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tapedust_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tapedust::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tapedust::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tapedust::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tapedust_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tapedust_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.chamber2_tilde/airfx.chamber2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/chamber2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class chamber2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::chamber2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::chamber2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::chamber2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | chamber2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(chamber2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.galactic_tilde/airfx.galactic_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/galactic.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class galactic_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::galactic::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::galactic::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::galactic::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | galactic_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(galactic_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.infinity_tilde/airfx.infinity_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/infinity.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class infinity_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::infinity::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::infinity::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::infinity::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | infinity_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(infinity_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.verbity2_tilde/airfx.verbity2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/verbity2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class verbity2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::verbity2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::verbity2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::verbity2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | verbity2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(verbity2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.spiral2_tilde/airfx.spiral2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/spiral2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class spiral2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::spiral2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::spiral2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::spiral2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | spiral2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(spiral2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.sidedull_tilde/airfx.sidedull_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/sidedull.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class sidedull_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::sidedull::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::sidedull::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::sidedull::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | sidedull_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(sidedull_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.sidepass_tilde/airfx.sidepass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/sidepass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class sidepass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::sidepass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::sidepass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::sidepass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | sidepass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(sidepass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.stereofx_tilde/airfx.stereofx_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/stereofx.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class stereofx_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::stereofx::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::stereofx::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::stereofx::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | stereofx_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(stereofx_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/stereo/airfx.tovinyl4_tilde/airfx.tovinyl4_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "stereo/tovinyl4.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tovinyl4_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tovinyl4::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tovinyl4::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tovinyl4::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tovinyl4_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tovinyl4_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tape/airfx.fromtape_tilde/airfx.fromtape_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tape/fromtape.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class fromtape_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::fromtape::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::fromtape::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::fromtape::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | fromtape_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(fromtape_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.calibre_tilde/airfx.calibre_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/calibre.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class calibre_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::calibre::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::calibre::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::calibre::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | calibre_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(calibre_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.crystal_tilde/airfx.crystal_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/crystal.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class crystal_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::crystal::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::crystal::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::crystal::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | crystal_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(crystal_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.elation_tilde/airfx.elation_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/elation.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class elation_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::elation::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::elation::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::elation::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | elation_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(elation_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.xregion_tilde/airfx.xregion_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/xregion.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class xregion_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::xregion::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::xregion::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::xregion::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | xregion_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(xregion_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.znotch2_tilde/airfx.znotch2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/znotch2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class znotch2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::znotch2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::znotch2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::znotch2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | znotch2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(znotch2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.zregion_tilde/airfx.zregion_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/zregion.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class zregion_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::zregion::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::zregion::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::zregion::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | zregion_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(zregion_tilde); 32 | -------------------------------------------------------------------------------- /scripts/example.CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.20) 2 | 3 | set(C74_MIN_API_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../../min-api) 4 | include(${C74_MIN_API_DIR}/script/min-pretarget.cmake) 5 | 6 | include_directories( 7 | "${C74_INCLUDES}" 8 | "${CMAKE_CURRENT_LIST_DIR}/../../../airfx" 9 | ) 10 | 11 | set(SOURCE_FILES 12 | ${PROJECT_NAME}.cpp 13 | ) 14 | 15 | add_library( 16 | ${PROJECT_NAME} 17 | MODULE 18 | ${SOURCE_FILES} 19 | ) 20 | 21 | # Use the system flag in order to suppress warnings from the external library code 22 | # (in particular, the unused-variable warning for airwindohhs) 23 | target_include_directories(${PROJECT_NAME} SYSTEM PRIVATE 24 | "${CMAKE_CURRENT_LIST_DIR}/../../../airwindohhs/include/" 25 | ) 26 | 27 | if (${CMAKE_BUILD_TYPE} STREQUAL "Release") 28 | target_compile_definitions(${PROJECT_NAME} PRIVATE -DAIRFX_NO_DOC_GEN=1) 29 | endif () 30 | 31 | include(${C74_MIN_API_DIR}/script/min-posttarget.cmake) 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.ensemble_tilde/airfx.ensemble_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/ensemble.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class ensemble_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::ensemble::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::ensemble::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::ensemble::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | ensemble_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(ensemble_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.grindamp_tilde/airfx.grindamp_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/grindamp.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class grindamp_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::grindamp::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::grindamp::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::grindamp::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | grindamp_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(grindamp_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/clipping/airfx.cliponly_tilde/airfx.cliponly_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "clipping/cliponly.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class cliponly_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::cliponly::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::cliponly::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::cliponly::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | cliponly_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(cliponly_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dithers/airfx.paulwide_tilde/airfx.paulwide_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dithers/paulwide.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class paulwide_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::paulwide::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::paulwide::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::paulwide::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | paulwide_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(paulwide_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dithers/airfx.tpdfwide_tilde/airfx.tpdfwide_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dithers/tpdfwide.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tpdfwide_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tpdfwide::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tpdfwide::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tpdfwide::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tpdfwide_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tpdfwide_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.drumslam_tilde/airfx.drumslam_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/drumslam.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class drumslam_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::drumslam::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::drumslam::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::drumslam::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | drumslam_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(drumslam_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.dynamics_tilde/airfx.dynamics_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/dynamics.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dynamics_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dynamics::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dynamics::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dynamics::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dynamics_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dynamics_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.gatelope_tilde/airfx.gatelope_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/gatelope.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class gatelope_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::gatelope::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::gatelope::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::gatelope::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | gatelope_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(gatelope_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.logical4_tilde/airfx.logical4_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/logical4.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class logical4_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::logical4::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::logical4::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::logical4::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | logical4_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(logical4_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dynamics/airfx.softgate_tilde/airfx.softgate_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dynamics/softgate.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class softgate_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::softgate::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::softgate::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::softgate::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | softgate_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(softgate_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.fracture_tilde/airfx.fracture_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/fracture.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class fracture_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::fracture::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::fracture::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::fracture::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | fracture_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(fracture_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.powersag_tilde/airfx.powersag_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/powersag.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class powersag_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::powersag::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::powersag::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::powersag::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | powersag_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(powersag_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.inflamer_tilde/airfx.inflamer_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/inflamer.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class inflamer_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::inflamer::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::inflamer::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::inflamer::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | inflamer_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(inflamer_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/subtlety/airfx.tubedesk_tilde/airfx.tubedesk_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "subtlety/tubedesk.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tubedesk_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tubedesk::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tubedesk::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tubedesk::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tubedesk_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tubedesk_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.balanced_tilde/airfx.balanced_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/balanced.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class balanced_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::balanced::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::balanced::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::balanced::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | balanced_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(balanced_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.slewonly_tilde/airfx.slewonly_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/slewonly.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class slewonly_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::slewonly::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::slewonly::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::slewonly::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | slewonly_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(slewonly_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.subsonly_tilde/airfx.subsonly_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/subsonly.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class subsonly_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::subsonly::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::subsonly::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::subsonly::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | subsonly_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(subsonly_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.dubcenter_tilde/airfx.dubcenter_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/dubcenter.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dubcenter_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dubcenter::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dubcenter::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dubcenter::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dubcenter_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dubcenter_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.hermepass_tilde/airfx.hermepass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/hermepass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class hermepass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::hermepass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::hermepass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::hermepass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | hermepass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(hermepass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.orbitkick_tilde/airfx.orbitkick_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/orbitkick.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class orbitkick_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::orbitkick::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::orbitkick::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::orbitkick::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | orbitkick_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(orbitkick_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/distortion/airfx.density2_tilde/airfx.density2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "distortion/density2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class density2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::density2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::density2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::density2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | density2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(density2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/lo-fi/airfx.dustbunny_tilde/airfx.dustbunny_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "lo-fi/dustbunny.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dustbunny_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dustbunny::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dustbunny::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dustbunny::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dustbunny_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dustbunny_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/noise/airfx.darknoise_tilde/airfx.darknoise_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "noise/darknoise.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class darknoise_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::darknoise::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::darknoise::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::darknoise::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | darknoise_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(darknoise_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/noise/airfx.texturize_tilde/airfx.texturize_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "noise/texturize.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class texturize_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::texturize::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::texturize::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::texturize::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | texturize_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(texturize_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/saturation/airfx.creature_tilde/airfx.creature_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "saturation/creature.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class creature_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::creature::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::creature::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::creature::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | creature_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(creature_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.channel4_tilde/airfx.channel4_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/channel4.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class channel4_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::channel4::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::channel4::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::channel4::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | channel4_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(channel4_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.channel9_tilde/airfx.channel9_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/channel9.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class channel9_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::channel9::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::channel9::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::channel9::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | channel9_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(channel9_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/tone-color/airfx.precious_tilde/airfx.precious_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "tone-color/precious.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class precious_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::precious::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::precious::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::precious::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | precious_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(precious_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.xlowpass_tilde/airfx.xlowpass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/xlowpass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class xlowpass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::xlowpass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::xlowpass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::xlowpass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | xlowpass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(xlowpass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.ylowpass_tilde/airfx.ylowpass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/ylowpass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class ylowpass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::ylowpass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::ylowpass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::ylowpass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | ylowpass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(ylowpass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.zlowpass_tilde/airfx.zlowpass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/zlowpass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class zlowpass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::zlowpass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::zlowpass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::zlowpass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | zlowpass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(zlowpass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/xyz-filters/airfx.zregion2_tilde/airfx.zregion2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "xyz-filters/zregion2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class zregion2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::zregion2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::zregion2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::zregion2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | zregion2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(zregion2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dithers/airfx.ditherbox_tilde/airfx.ditherbox_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dithers/ditherbox.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class ditherbox_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::ditherbox::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::ditherbox::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::ditherbox::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | ditherbox_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(ditherbox_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/dithers/airfx.studiotan_tilde/airfx.studiotan_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "dithers/studiotan.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class studiotan_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::studiotan::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::studiotan::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::studiotan::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | studiotan_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(studiotan_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.cloudcoat_tilde/airfx.cloudcoat_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/cloudcoat.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class cloudcoat_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::cloudcoat::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::cloudcoat::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::cloudcoat::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | cloudcoat_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(cloudcoat_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.fracture2_tilde/airfx.fracture2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/fracture2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class fracture2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::fracture2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::fracture2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::fracture2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | fracture2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(fracture2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.powersag2_tilde/airfx.powersag2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/powersag2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class powersag2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::powersag2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::powersag2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::powersag2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | powersag2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(powersag2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/effects/airfx.shortbuss_tilde/airfx.shortbuss_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "effects/shortbuss.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class shortbuss_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::shortbuss::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::shortbuss::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::shortbuss::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | shortbuss_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(shortbuss_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.baxandall_tilde/airfx.baxandall_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/baxandall.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class baxandall_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::baxandall::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::baxandall::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::baxandall::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | baxandall_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(baxandall_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.capacitor_tilde/airfx.capacitor_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/capacitor.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class capacitor_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::capacitor::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::capacitor::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::capacitor::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | capacitor_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(capacitor_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.distance2_tilde/airfx.distance2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/distance2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class distance2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::distance2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::distance2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::distance2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | distance2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(distance2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.distance3_tilde/airfx.distance3_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/distance3.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class distance3_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::distance3::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::distance3::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::distance3::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | distance3_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(distance3_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.highpass2_tilde/airfx.highpass2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/highpass2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class highpass2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::highpass2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::highpass2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::highpass2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | highpass2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(highpass2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.isolator2_tilde/airfx.isolator2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/isolator2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class isolator2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::isolator2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::isolator2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::isolator2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | isolator2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(isolator2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.stonefire_tilde/airfx.stonefire_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/stonefire.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class stonefire_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::stonefire::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::stonefire::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::stonefire::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | stonefire_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(stonefire_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/filter/airfx.toneslant_tilde/airfx.toneslant_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "filter/toneslant.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class toneslant_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::toneslant::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::toneslant::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::toneslant::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | toneslant_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(toneslant_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.galactic2_tilde/airfx.galactic2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/galactic2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class galactic2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::galactic2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::galactic2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::galactic2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | galactic2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(galactic2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/reverb/airfx.infinity2_tilde/airfx.infinity2_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "reverb/infinity2.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class infinity2_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::infinity2::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::infinity2::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::infinity2::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | infinity2_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(infinity2_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.dcvoltage_tilde/airfx.dcvoltage_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/dcvoltage.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class dcvoltage_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::dcvoltage::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::dcvoltage::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::dcvoltage::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | dcvoltage_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(dcvoltage_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.everytrim_tilde/airfx.everytrim_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/everytrim.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class everytrim_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::everytrim::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::everytrim::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::everytrim::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | everytrim_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(everytrim_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.hermetrim_tilde/airfx.hermetrim_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/hermetrim.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class hermetrim_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::hermetrim::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::hermetrim::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::hermetrim::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | hermetrim_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(hermetrim_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.leftomono_tilde/airfx.leftomono_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/leftomono.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class leftomono_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::leftomono::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::leftomono::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::leftomono::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | leftomono_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(leftomono_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/utility/airfx.peaksonly_tilde/airfx.peaksonly_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "utility/peaksonly.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class peaksonly_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::peaksonly::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::peaksonly::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::peaksonly::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | peaksonly_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(peaksonly_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.clearcoat_tilde/airfx.clearcoat_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/clearcoat.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class clearcoat_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::clearcoat::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::clearcoat::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::clearcoat::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | clearcoat_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(clearcoat_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.doublelay_tilde/airfx.doublelay_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/doublelay.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class doublelay_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::doublelay::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::doublelay::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::doublelay::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | doublelay_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(doublelay_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.starchild_tilde/airfx.starchild_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/starchild.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class starchild_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::starchild::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::starchild::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::starchild::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | starchild_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(starchild_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/ambience/airfx.tapedelay_tilde/airfx.tapedelay_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "ambience/tapedelay.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class tapedelay_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::tapedelay::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::tapedelay::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::tapedelay::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | tapedelay_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(tapedelay_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.bassdrive_tilde/airfx.bassdrive_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/bassdrive.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class bassdrive_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::bassdrive::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::bassdrive::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::bassdrive::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | bassdrive_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(bassdrive_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/amp-sims/airfx.crickbass_tilde/airfx.crickbass_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "amp-sims/crickbass.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class crickbass_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::crickbass::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::crickbass::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::crickbass::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | crickbass_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(crickbass_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.fathomfive_tilde/airfx.fathomfive_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/fathomfive.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class fathomfive_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::fathomfive::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::fathomfive::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::fathomfive::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | fathomfive_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(fathomfive_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/bass/airfx.infrasonic_tilde/airfx.infrasonic_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "bass/infrasonic.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class infrasonic_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::infrasonic::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::infrasonic::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::infrasonic::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | infrasonic_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(infrasonic_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.everyslew_tilde/airfx.everyslew_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/everyslew.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class everyslew_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::everyslew::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::everyslew::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::everyslew::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | everyslew_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(everyslew_tilde); 32 | -------------------------------------------------------------------------------- /source/objects/brightness/airfx.hypersonx_tilde/airfx.hypersonx_tilde.cpp: -------------------------------------------------------------------------------- 1 | #include "c74_min.h" 2 | #include "airfx.hpp" 3 | #include "brightness/hypersonx.hpp" 4 | 5 | using namespace c74::min; 6 | 7 | class hypersonx_tilde : public airfx> 8 | { 9 | atom m_about_text = symbol{ airwindohhs::hypersonx::k_long_description.data() }; 10 | 11 | public: 12 | MIN_DESCRIPTION{ airwindohhs::hypersonx::k_name.data() }; 13 | MIN_TAGS{ airwindohhs::hypersonx::k_tags.data() }; 14 | 15 | message<> m_about{ 16 | this, 17 | "about", 18 | description{ "Get the original Airwindows 'about' text for this object" }, 19 | [this](const atoms& args, const int inlet) -> atoms { 20 | dump_out.send({"about", m_about_text}); 21 | return {}; 22 | } 23 | }; 24 | 25 | hypersonx_tilde(const atoms& args = {}) 26 | : airfx(args) 27 | { 28 | } 29 | }; 30 | 31 | MIN_EXTERNAL(hypersonx_tilde); 32 | --------------------------------------------------------------------------------