For this note generator to work I need to be able to reliably output notes on specified time divisions... but before I can output notes on certain time divisions, I have to output notes on every time division. It would've been convenient if I could detect beats by simply going:
Code:
floor(beat_position) == beat_position
...but alas, this isn't accurate enough, nor reliable enough. samplesblock's size changes, and even if you were just to look for crossings, in a worstcase scenario of 2048 samples per block this could be a very ugly 46ms at 44.1kHz. So, the long way around then. This is the abridged version:
Code:
...
slider4:1<1,6,{1/16, 1/8, 1/8D, 1/4, 1/4D, 1/2}1> RhythmicUnits
...
@init
blockSize = samplesblock / srate; //seconds per block
bps = tempo/60; //beats per second
function getBeatDiv(x) local(div)
(
div = 1; // if anything goes wrong, don't divide by zero later
x == 0 ? div = 0.25; // 1/16
x == 1 ? div = 0.5; // 1/8
x == 2 ? div = 0.75; // 1/8D
x == 3 ? div = 1; // 1/4
x == 4 ? div = 1.5; // 1/4D
x == 5 ? div = 2; // 1/2
div;
);
------------------------------------
The basic idea is to see how many seconds per sampleblock there are, and if we get close enough to a beat that the next beat division of interest lies within the current sample block, we can dispatch a note in that sample block (or not, depending on the pattern we are following).
To make life easier for ourselves we will adjust the beat_position global variable so that all whole divisions of the adjusted beat_position fall on the rhythmic units we are interested in, eg. beat_position = 1/4 beats; if the unit of choice is 1/2 we know 1/2's occur where beat_position/2 is a whole number ([1/2] / [1/4] = 2).
-----------------------------------
Code:
@block
beat = beat_position;
beatadj = beat / beatDiv; // whole beatadj's correspond to our note divisions
frac = ceil(beatadj) - beatadj; //fractional adjusted beats left to next tick
beatsLeft = (frac * beatDiv); // beats till next tick
secondsLeft = (beatsLeft/bps); //bps is beats per second
secondsLeft < blockSize ? ( //shit happening in this block
secondsTillEvent = secondsLeft/blockSize;
samplesTillEvent = secondsTillEvent*samplesblock;
ding += ceil(samplesTillEvent);
//do the stuff
1;
); //else do nothing
@sample
ding > 0 ? ding -= 1; //count out "ding" number of samples
ding == 0 ? (dong = 1; ding = -1); //after "ding" samples, dong.
------------------------------------
So, when the note is in the current sample block, a sample-timer is started which counts down until the appropriate moment, and does something. In the case of my program, it drew a little white line. To verify that this was indeed on my divisions of interest I also drew lines on every 1/4. I only drew tiny lines, so I couldn't reeeaallly see if it was lining up on a sample accurate basis (and I expect it didn't, I did ceil afterall instead of round to nearest neighbor on the samplesTillEvent), but what's 23 microseconds between friends
If things ever need to be rounded however, this is a reasonable way to do it:
Code:
function round(i) local(flo, ans)
(
flo = floor(i);
ans = (i - flo) < 0.5 ? flo : ceil(i);
ans
);
Next step is to compile the pattern and use that pattern to choose which notes to send and which not to.
teatimes Log - Star Date -306358.2
Hybrid Mode
