because steinberg is an incredibly nice company, i can't actually distribute vst2 plugin binaries without a license, which they don't give out anymore :)
so you're gonna have to build the plugins yourself, but don't worry cause it's relatively easy! (i think)
no idea what you have to do for other platforms, refer to the `vst-rs` [docs](https://github.com/rustaudio/vst-rs). i think you can just build with `cargo b --package package_name --release` and take the `.so` or `.dll`, but don't quote me on that
there's a bit of an explanation of each of the plugins below, but it's not a thorough documentation or a manual, it's just a bunch of notes i've written and a short description of the parameters
it listens for incoming midi, and while a note is on, it triggers it every `tempo` beats. if `tempo` is one, it will trigger once per beat, if it's `0.5`, it'll play half notes, etc.
it's useful when you want to play a note super fast (over 1/64 tempo) but don't want to have a section full of tiny midi notes. just add the plugin, set the tempo to how often you want it to play, and add a midi note that lasts however long you want the notes to play for
to use this plugin, add an automation for `enable` and set the value to `1.0` wherever you want the sustain to happen. as soon as that happens, it'll start looping the last `length` samples
if set to manual, it uses the provided length for the looped grain. if pitch detection is enabled, it will use the detected pitch to calculate the period of the input, and it'll use that for the length of the grain. this should cause the sound to be sustained seamlessly
dissipation is a weird thingy. it smooths out the sound, and i think it's a lowpass filter? not sure. makes cool sounds though. what it does is roughly `x[n] = dissipation * x[n] + (1 - dissipation) * x[n + 1]` after each time it plays a sample, so `dissipation = 1` will leave the audio untouched, and setting it to `0.5` provides the greatest effect
-`[0.4, 0.6)`: the grain will cycle through forwards and backwards
-`[0.6, 1.0]`: the grain will play forwards
my three main uses are:
- sustaining a note, which you can do with `manual/pitch detection = 1`, `direction = 1`, and any amount of dissipation
- wavetable-ish kinda thing, by setting `manual = 0` and a really low length, you can play notes of frequency `1 / length`
- glitch repetition effect, by setting `manual = 0`, any direction (but usually forward), any dissipation, and a medium length. enable at the end of a bar or smth
but you can probably use it for more stuff! idk! this are just my suggestions
-`frequency`: cutoff frequency. it's not in hz, so move it around until it does what you want it to
-`nuke`: amount of distortion
i haven't checked correctly, but there's probably some mistakes and it might not sound exactly the same. it does what i want it to, so that's good enough for me. also i have absolutely no idea what the code does, it's just a direct translation
you might need to play with the parameters around a bit to get it to sound good
### multidim
multidim simulates a ball bouncing around in a 16-dimensional cube. each time the ball bounces off of a wall, a midi note is sent out
parameters:
-`speed`: speed at which the ball moves. around 1 should cause approximately one bounce per beat
-`root`: the lowest note that will be generated (in midi number). the rest of the notes will be from `root` to `root + 16`
this plugin is a weird thingy i made to generate midi notes pseudo-randomly. i didn't want it to be actually random, cause that doesn't make many patterns, so what i ended up doing is simulating a ball bouncing around a cube, and sending out a note every time it bounces off a wall. this works well, but a cube only has three dimensions, which is pretty low! so through the magic of computers not giving a shit about physical reality, i made the cube be 16 dimensional, and yeah that's basically it
the bounces are all perfect and maintain all the energy, so each note ends up playing at a regular interval but they're all playing at different tempos
works well if you put it in front of a sampler
the only way to reset the pattern is to reset the plugin. if your daw has a way of doing that, do that, otherwise you're gonna have to remove it and re-add it, or close and open your daw
WIP automatic pitch correction and pitch shifting. the intention is to use it to make hyperpop-style high-pitched vocals
it kinda works, but not really. since the pitch shifting part is too slow using a phase vocoder, it doesn't run in real time, and there's some clicking noises. i need to rework that whole thing so it can run in real time. i'll probably change the whole thing completely instead of optimizing it cause yeah
### hysteria
hysteria is a hysteresis nonlinear effect, which compresses and distorts the input audio
parameters:
-`drive`
-`saturation`
-`width`: width of the hysteresis loop
original source [here](https://ccrma.stanford.edu/~jatin/ComplexNonlinearities/Hysteresis.html)
hard limiter followed by a soft limiter with distortion
parameters:
-`pregain`: pregain for the hard limiter
-`drive`: drive for the soft limiter
-`distortion`: amount of distortion on the soft limiter
distortion affects lower volumes more than higher volumes, so if you crank up `drive` a lot, there will be less distortion (this is a good thing for high values of `distortion`!). if you leave `drive` low and set `distortion` to max, your audio will turn to almost white noise
bands work as they do in `threebandeq`. the `folding freq` parameters control the frequency of the wavefolder. higher is more distortion. use values over 40 if you want to have basically white noise
yeah there's not many params in this one, the implementation is pretty straightforward
it does weird things: a square wave of amplitude 1 will just be completely eliminated, while sine waves are distorted. since it can't be really controlled, use the `dry/wet` to lower the effect if you don't want to go overboard
the effect is reversible (it's an [involution](https://en.wikipedia.org/wiki/Involution_(mathematics))), so if you add this plugin twice in a row you get the original signal back. this means you can apply drdi to your audio, apply some other effect, and apply drdi again to get some fun stuff
### transmute midi
analyzes pitch of incoming audio and sends out the corresponding midi note
params:
-`passthrough`: how much of the original audio to be let through
latency should be close to 1024 samples, which is around 20ms at 48k i think. the pitch detection is not excellent and it's monophonic, so if you have a noisy input or a bunch of notes at the same time, it's anyone's guess what the detected note will be. there's also no pitch bending or anything fancy like that, so it'll jump around notes even if the input has portamento
issues and prs are welcome, but please open an issue before making any big pr, i don't wanna have to reject a pr where you have put a lot of effort on. if you are fine with that, ig go ahead i'm not your mum
