Re: big picture stuff (long message)

[Matthew Itkin]

> I find the idea of having a scriptable tracker gui (ala emacs) very
> interesting. 
> you want parameter interpolation with a strange function? just code it and
> voila, 
> you have your exp, sinus function inserting parameters in the track...
> That's 
> the obvious application i would have for such things. 
> 
> or you could be able to manipulate the dynamic of parameters ... dilate
> them, 
> translate them... whatever.
> 
> -Nicolas Léveillé (Knos)

OK, so you are saying you want to be able to script LFOs and wierd functions 
and such into patterns and have them give commands to machines arbitrary of 
whats in the patterns.  Its pretty easy to do a triangle LFO in Buzz just by 
interpolating between values in the pattern editor, but if you are going for 
sines and stuff I can see how you might want some code behind it.

Lets take a volume sweep for example.  You want to control the volume of 
machine X with a python script.  You have a machine somewhere that loads the 
python script, and makes a volume sweep using a sine LFO that is triggered 
within the pattern editor of your python octal machine.

What makes the most sense is LFOs inside of machines cuz then you only have to 
communicate the LFO values to the machine instead of having a whole seperate 
LFO just to control machine paramaters.  The less you have to communicate to 
the machines, the better.  They should do as much for themselves as they can.  
Its more efficient that way. 

Now, if you really want some LFO modulated paramaters, hack the pattern editor 
and let everyone join in the fun.  OCTAL is not as tick-centric as Buzz, and so 
theoreticaally the pattern editor could use functions in it that are more 
precise than the ticks of a pattern.  You could interpolate between 80 and 0 in 
the the space of only a few ticks and have it actually interpolate between 80 
and 0 instead of just being "80, 60, 40, 20, 0" in the patterns.  OCTAL could 
also have the option to make paramter fields into LFO fields.  you could have 
it take selected areas and make them into LFO fields by hitting ^L over 
selected areas, or you could hit ^P or something and have it permanently turn 
that column into an LFO column.  LFO columns could be differntiated by having a 
different background color.  Also, it would still store any information you had 
in the regular pattern field incase you decided to hit ^P or ^L again and 
switch back.  In the LFO field, you would have a hex column to select the LFO 
type, and then 3 more hex colums to select the paramaters for that LFO.  That 
LFO engine would understand the max and min fields given to the pattern editor, 
and would allow you to choose min and max fields for the LFO that are anywhere 
between those.  that takes up 2 of those hex fields.  the 3rd hex field would 
be for the phase of the LFO.  there should also be a trigger field for "restart 
LFO" so you can make sure the LFO begins where you want it to.  this LFO engine 
could get pretty complex if you wanted, and I think is something that should 
eventually be built into OCTAL.  I dont want to have to code a python script up 
everytime I want to use a simple LFO, do you?

If you wanted to control patterns using wierd-ass functions other than LFOs, a 
python script might make sense for that, but I still think you are better off 
putting those wierd ass functions into the machines themselves and then 
triggering them and modulating them with patterns.  Its a lot cleaner that way, 
and its good fun everyone can share.  The machines should all be as open source 
as OCTAL, so everyone can hack and have fun.  :)

-Matthew Itkin