The drum-sequencer makes use of a bank of 64 different drum-sequences of 16 steps each. But I added lots of goodies to spice up these 16 steps:
-a count&phase "re-measure" that can turn the 16-step counter from a normal 4x 4/4 measure into a swinged 4/4 measure, a combined 2/2 and 3/3 measure, two versions for tripplets and even 5/5 and 6/6 measures, where the two 3/3 version just skip one of the counter-beat steps and the 5/5 and 6/6 re-use some steps. So the 0, 4, 8 and 12 steps are always used and the others are played in an order to get the measure being selected. eg one of the 5/5 versions: 0,1,3,2,1,3 for every 4 steps of the normal count.
-then the sequencer adds even more variations with settings like the chance of steps being actually triggered and adding pre-rolls and post-rolls by pre-viewing where triggers will land and calculating the timing/rate that a random amount of pre-triggers will need to land on that trigger. As it uses both the counter as well as the phase-position of the LFO that drives the counter Ɣnd the manipulation of the "re-measure" module, this can create loads of different variations on just a simple 16-step sequence.
-the drum-voices have special envelope generators that will calculate the level of the envelope based on the velocity of the trigger and where the envelope currently is. Then it uses this velocity to calculate the new maximum level based on how much is left between the current envelope position and maximum amplitude. So a roll of soft velocity triggers will create a drumroll with increasing amplitude. Also several parameters of the drum-voices are controlled by the velocity of the triggers to make sure they also sound differently at different velocities, just like a real drum.
-the cymbal is made with a fdn-feedback network and several modulations to emululate a real cymbal at any size, thickness and being broken or not.
-the bass is created with those oscillators I posted awhile ago, which will make sure the bass always stays in the bass region, no matter what octave is being played. Also here, I added several different version for layering the bass sound in specific regions.
-the violin-kind-of-sound is a live-ifft oscillator with a bank of 1024 fft-presets and 8 "fft-window" presets. Those 1024 presets will build up a waveform in the "normal" way, so the root-frequency of the fft will follow the root-note that is being played. But the window-fft is used as a static EQ-type of window, where it uses the pitch-information to look up in the table to see what volume each partial might be when playing a certain note. So the 1024 presets could be seen as 1024 different strings and the 8 window-presets could be seen as 8 different guitar-bodies that have different characteristics.
Though, it seems there is something wrong in this patch as I know this shĆ³uld create a lot more different sounds than it is currently making..
-the melody voice is a 3x phase-modulation oscillator with just a single phase generator. The 3 phase modulating sines are calculated as harmonics on this phase and then added before sending it through a sine-shaper. Also, each of these 3 can morph through independent ranges of harmonics in any order and independent amount of steps for the range of a phasor, where also the level of each of the 3 modulations is independently controlled by envelopes.
-the melody and bass note-sequences are being randomly pre-generated, where the calculation of each change is started at the end of the sequence, starting from 0 (root note), then, with random chance, going 1 or 2 notes up or down in the steps before it. This way, it always ends the sequence in root note and "comes home". This is being used 3 times in 3 different timings: a very slow one for root-key, a bit faster one for selecting a chord/scale in that key and a third, fast one, to select which notes in that key and scale/chord will actually be played. As they keep track of where they are from the counter and maximum count, they can also transpose the sequence to the next chord or key at the end of the sequence, so they always line up and make sense.
-All the sound sources are monophonic. In the last board I used several mid/side&comb-filter stages to see which frequencies are still in the center and then use comb filters to stereo-spread those frequencies. Only the bass is filtered out of this, to make sure it stays in the center.
SirSickSik Contributions
Awesome. I forget which one it was but one of your objects has a help patch with self generating audio and I like to just let it ride because it sounds great.
yes, I just love the idea of a patch that functions like a track. It's like a song that's always a little bit different from the previous time you played it, although you still recognize the sound/feel. Would be a nice twist on the normal albums that come out: a self-contained music-generating patch that runs from a flashdrive or a usb and perhaps some minimalistic control over midi/computer-GUI to personalise the music, eg. tempo, genre, key, scale and type of sounds (clear, bassy, distorted)
inversed note counter0.5.axp (127.5 KB)
a patch using a melody/chord-base/key generator (several different versions that can work together).
The melodies that are generated start from 0 and just randomly go up or down. But instead of reading them normally, they are read "last to first", to make sure that at the last count of the counter will always go back to "root"/"0". Several toggle switches are added to add some maximum-offset pendulum movement or limitations on the range (also creating pendulum movement). If a change in the sequence falls at a counter-beat, it checks whether it could be a pre-roll for the step after it that will also change, otherwise it will force the step before it to change. This will "remove" those odd feeling off-beat triggers you might have with "normal" randomisation.
This is done for 2 sequences, an "arp" and a "base" (eg. chord root). I allowed two different counter inputs for these, so you can use polyrhitmic variations in counting, but in a "normal" sense, the arp would at least reset to the first count when the base goes to the next step.
The "end" parameter divides the length of the counter by powers of 2 and uses this length at the end of the count to "walk" to the next "base" note. The arp is added to this base note as a note offset within the chosen scale, the key input is added to both base and note outputs.
A third output outputs the current "position" within the scale (always use 7 notes in this scale for these modules! I couldn't add any code anymore because of size limitations, but the modules' codes are quite easily modified to allow for less or more notes per octave)
well, anyways.. there's actually a bit too much to explain in this patch haha
I tried to make it at least oversee-able and seperated the voices. The patch is on the brink of using to much memory, so I even needed to change the order of modules to be able to get the patch to run, so be careful to not just drag modules around.. this might overflow the memory..
Some extra goodies are a tripple morphing PM oscillator, a random tremelo for sweeping between notes within the table, a randoming attack/decay envelope and an allpass-based reverb.
If you want to know what a module does exactly, just create a new patch, hook up the bare essentials and use displays to read out what it's spitting out.
earlier version which was used with external audio, use this to see the setup for layering with incoming audio.
sampling oscillator.axp (38.0 KB)
second version
sampling osc0.1.axp (34.2 KB)
and a version where I combined the two as external audio fx:
sampling oscillator0.2.axp (55.2 KB)
and a third version with inbuild speed controller. Speed at 0 plays the audio at recording rate. Great to alter speech recordings! Still working on this module, so more revisions will show up. These will also probably add some more cpu, that's why I keep these older versions here in case you don't need all the special things..
sampling oscillator0.3.axp (16.2 KB)
This is a granular oscillator that generates one big continuous wavetable with stacked randomly modulated sines.
Two readout positions and grain-length control how the oscillator reads from the table.
It has the option to just record any incoming sound into the table and use it instantly.
Using a feedback loop, the wavetable can feed back on itself, creating freaked up wavetables for lots of sonic exploration. Very industrial sounding.
When used with external audio, try out some envelope followers to trigger recordings, randomisations and opening up/closing down the volume and mix it with the original audio. I found that the tracks with drums of aphex twin's cd "drukqs" worked very nice to add even more grit to his often already freaked out drums.
finally got something intesting going on with the FIR filter code.
This filter isn't meant as a normal lowpass/highpass/bandpass filter, but more like an end-of-chain filter to shape the sound character of your synth. More like a complicated EQ.
Continuous modulation inputs for pitch, Q (more or less that is..) and filter variation are added, but will also mean quite an increase in cpu use. These can be switched on/off using an "update" input.
To make it more usable, I've added the possibility to save the shapes to your sd-card, to use later on in other patches with a trimmed down version of the module (see code which parts can be deleted for this).
Two "modes" are used to generate the coƫfficients: one based on a sinewave to create lowpass/bandpass/highpass/notch type of filters (certainly not perfect!) and the other just randomly fills the coƫfficients with values. These can then be mixed together to create the overall character.
Pitch and Q controls are more or less "logical", variation also in the 1st mode (mode set to 0), the others are a bit more "lets see what happens if I turn this dial".
This FIR filter also allows bigger coƫfficient tables (max 256) than the factory FIR filter (16). Increased size allows for filtering lower frequencies, but also adds lots of cpu use (that's why you better just build a bank of presets and load these, instead of live modulating them, and then use normal IR filters for live filtering)
FIR filter coƫfficients controller.axp (27.3 KB)
NEW MODULE
-multi-stage envelope
-up to 64 stages (though that would be a LOT of editing..LOL... or just press the randomise button I just added 
)
-3 modes for auto attack/release, sustained, or looping several stages for a set amount of loops (after which it can either hold or release).
-different set of stages for gate and release parts
-stages can independently change with fixed-time, fixed-rate or exponential rate
-a "common" time-scaling knob to quickly set the timing range of all stages faster or slower (log, so +12 would slow it by 1 octave/double the normal time)
-several useful outputs for some internal values (end of envelope, stage, loop count, currently looping off/on)
-I added some functionality around it to get it automatically going with example envelopes
multistage envelope 0.1.axp (31.1 KB)
To make it a bit better controllable I've added independent randomisation-inputs for "main" settings and "timing&litude" settings plus an extra input to control the main timing and independent "main timing" controls for when gate is on and release times when gate is off.
multistage envelope 0.2.axp (43.8 KB)
Finally got to sit down and try this out. This is a whole envelope suite! Was just reading about the MFOS Wave Former and this is like the big brother of it. Have you ever made any eurorack units? Considering your catalogue of objects, I think you'd make some mean modules.