// modular synth prototype
// copyright 2008 Les Hall
// This software is protected by the GNU General Public License


// parameters
10 => int num_nodes;  // number of nodes available for connection
3 => int num_osc;  // number of oscillators
3 => int num_filters;  // number of filters
3 => int num_delays;  // number of delay lines
150 => int slot_width;  // width in pixels of each card slot
int mic_out;  // output node of microphone
int osc_sel[num_osc];  // the selected oscillators
int osc_in[num_osc];  // the previous value of input node
int osc_out[num_osc];  // the previous value of output node
int filter_sel[num_filters];  // the selected filters
int filter_in[num_filters];  // the previous value of input node
int filter_out[num_filters];  // the previous value of output node
int delay_sel[num_delays];  // the selected delays
int delay_in[num_delays];  // the previous value of input node
int delay_out[num_delays];  // the previous value of output node


// define the pages
MAUI_View main_view;
main_view.size (slot_width, 200);
main_view.name ("Synth Lab - Main Panel");
MAUI_View node_view;
node_view.size (3 * slot_width, 50 * (num_nodes + 1));
node_view.name ("Synth Lab - Nodes");
MAUI_View osc_view;
osc_view.size (num_osc * slot_width, 475);
osc_view.name ("Synth Lab - Oscillators");
MAUI_View filter_view;
filter_view.size (num_filters * slot_width, 400);
filter_view.name ("Synth Lab - Filters");
MAUI_View delay_view;
delay_view.size (num_delays * slot_width, 275);
delay_view.name ("Synth Lab - Delays");



// control declarations
// main panel controls
MAUI_Button main_record;
MAUI_Slider main_volume;
MAUI_Slider main_mic_output;
// node controls
MAUI_Slider node_gain[num_nodes+1];
MAUI_Button node_boost[num_nodes+1];
MAUI_Slider node_op[num_nodes+1];
// oscillator controls
MAUI_Button osc_label[num_osc];
MAUI_Slider osc_input[num_osc];
MAUI_Slider osc_output[num_osc];
MAUI_Slider osc_gain[num_osc];
MAUI_Slider osc_freq1[num_osc];
MAUI_Slider osc_freq2[num_osc];
MAUI_Slider osc_phase[num_osc];
MAUI_Slider osc_width[num_osc];
MAUI_Slider osc_sync[num_osc];
// filter panel controls
MAUI_Button filter_label[num_filters];
MAUI_Slider filter_input[num_filters];
MAUI_Slider filter_output[num_filters];
MAUI_Slider filter_gain[num_filters];
MAUI_Slider filter_freq1[num_filters];
MAUI_Slider filter_freq2[num_filters];
MAUI_Slider filter_q[num_filters];
// delay panel controls
MAUI_Button delay_label[num_delays];
MAUI_Slider delay_input[num_delays];
MAUI_Slider delay_output[num_delays];
MAUI_Slider delay_gain[num_delays];
MAUI_Slider delay_dur[num_delays];



// main panel controls
// main record button
main_record.toggleType ();
main_record.size (slot_width, 60);
main_record.position (0, 0);
main_record.name ("Record");
main_view.addElement (main_record);
// main volume slider
main_volume.name ("Volume");
main_volume.range (0, 1);
main_volume.value (0.5);
main_volume.size (slot_width, 75);
main_volume.position (0, 35);
main_view.addElement (main_volume);
// main mic output node slider
main_mic_output.name ("Mic Node");
main_mic_output.range (0, num_nodes);
main_mic_output.value (0);
main_mic_output.size (slot_width, 75);
main_mic_output.position (0, 100);
main_mic_output.displayFormat (main_mic_output.integerFormat);
main_view.addElement (main_mic_output);


// nodes
for (1 => int n; n <= num_nodes; n++) {
    // node gain slider
    node_gain[n].name ("Gain " + n);
    node_gain[n].range (0, 1);
    node_gain[n].value (1);
    node_gain[n].size (slot_width, 75);
    node_gain[n].position (0, 50 * (n - 1));
    node_view.addElement (node_gain[n]);
    // node boost button
    node_boost[n].toggleType ();
    node_boost[n].size (slot_width, 60);
    node_boost[n].position (slot_width, 50 * (n -1) + 10);
    node_boost[n].name ("Boost " + n);
    node_view.addElement (node_boost[n]);
    // node op slider
    node_op[n].name ("op " + n);
    node_op[n].range (-1, 4);
    node_op[n].value (1);
    node_op[n].size (slot_width, 75);
    node_op[n].position (2 * slot_width, 50 * (n - 1));
    node_op[n].displayFormat (node_op[n].integerFormat);
    node_view.addElement (node_op[n]);
}


// oscillators
for (0 => int o; o < num_osc; o++) {
    // initialize oscillator selection
    1 => osc_sel[o];
    // osc label button
    osc_label[o].pushType ();
    osc_label[o].size (slot_width, 60);
    osc_label[o].position (slot_width*o, 0);
    osc_label[o].name ("SinOsc " + o);
    osc_view.addElement (osc_label[o]);
    // osc input node slider
    osc_input[o].name ("Input Node");
    osc_input[o].range (0, num_nodes);
    osc_input[o].value (0);
    osc_input[o].size (slot_width, 75);
    osc_input[o].position (slot_width*o, 50);
    osc_input[o].displayFormat (osc_input[o].integerFormat);
    osc_view.addElement (osc_input[o]);
    // osc output node slider
    osc_output[o].name ("Output Node");
    osc_output[o].range (0, num_nodes);
    osc_output[o].value (0);
    osc_output[o].size (slot_width, 75);
    osc_output[o].position (slot_width*o, 100);
    osc_output[o].displayFormat (osc_output[o].integerFormat);
    osc_view.addElement (osc_output[o]);
    // osc gain slider
    osc_gain[o].name ("Gain");
    osc_gain[o].range (0, 1);
    osc_gain[o].value (0);
    osc_gain[o].size (slot_width, 75);
    osc_gain[o].position (slot_width*o, 150);
    osc_view.addElement (osc_gain[o]);
    // osc freq1 slider
    osc_freq1[o].name ("Freq, kHz");
    osc_freq1[o].range (0, 20);
    osc_freq1[o].value (0);
    osc_freq1[o].size (slot_width, 75);
    osc_freq1[o].position (slot_width*o, 200);
    osc_freq1[o].displayFormat (osc_freq1[o].integerFormat);
    osc_view.addElement (osc_freq1[o]);
    // osc freq2 slider
    osc_freq2[o].name ("Freq, Hz");
    osc_freq2[o].range (0, 1000);
    osc_freq2[o].value (500);
    osc_freq2[o].size (slot_width, 75);
    osc_freq2[o].position (slot_width*o, 250);
    osc_freq2[o].displayFormat (osc_freq2[o].integerFormat);
    osc_view.addElement (osc_freq2[o]);
    // osc phase slider
    osc_phase[o].name ("Phase");
    osc_phase[o].range (0, 2*pi);
    osc_phase[o].value (pi);
    osc_phase[o].size (slot_width, 75);
    osc_phase[o].position (slot_width*o, 300);
    osc_view.addElement (osc_phase[o]);
    // osc width slider
    osc_width[o].name ("Width");
    osc_width[o].range (0, 1);
    osc_width[o].value (0.5);
    osc_width[o].size (slot_width, 75);
    osc_width[o].position (slot_width*o, 350);
    osc_view.addElement (osc_width[o]);
    // osc synch slider
    osc_sync[o].name ("Sync");
    osc_sync[o].range (0, 2);
    osc_sync[o].value (0);
    osc_sync[o].size (slot_width, 75);
    osc_sync[o].position (slot_width*o, 400);
    osc_sync[o].displayFormat (osc_sync[o].integerFormat);
    osc_view.addElement (osc_sync[o]);
}


// filters
for (0 => int f; f < num_filters; f++) {
    // initialize filter selection
    0 => filter_sel[f];
    // filter label button
    filter_label[f].pushType ();
    filter_label[f].size (slot_width, 60);
    filter_label[f].position (slot_width*f, 0);
    filter_label[f].name ("LPF " + f);
    filter_view.addElement (filter_label[f]);
    // filter input node slider
    filter_input[f].name ("Input Node");
    filter_input[f].range (0, num_nodes);
    filter_input[f].value (0);
    filter_input[f].size (slot_width, 75);
    filter_input[f].position (slot_width*f, 50);
    filter_input[f].displayFormat (filter_input[f].integerFormat);
    filter_view.addElement (filter_input[f]);
    // filter output node slider
    filter_output[f].name ("Output Node");
    filter_output[f].range (0, num_nodes);
    filter_output[f].value (0);
    filter_output[f].size (slot_width, 75);
    filter_output[f].position (slot_width*f, 100);
    filter_output[f].displayFormat (filter_output[f].integerFormat);
    filter_view.addElement (filter_output[f]);
    // filter gain slider
    filter_gain[f].name ("Gain");
    filter_gain[f].range (0, 1);
    filter_gain[f].value (0);
    filter_gain[f].size (slot_width, 75);
    filter_gain[f].position (slot_width*f, 150);
    filter_view.addElement (filter_gain[f]);
    // filter freq1 slider
    filter_freq1[f].name ("Freq, kHz");
    filter_freq1[f].range (0, 20);
    filter_freq1[f].value (0);
    filter_freq1[f].size (slot_width, 75);
    filter_freq1[f].position (slot_width*f, 200);
    filter_freq1[f].displayFormat (filter_freq1[f].integerFormat);
    filter_view.addElement (filter_freq1[f]);
    // filter freq2 slider
    filter_freq2[f].name ("Freq, Hz");
    filter_freq2[f].range (0, 1000);
    filter_freq2[f].value (500);
    filter_freq2[f].size (slot_width, 75);
    filter_freq2[f].position (slot_width*f, 250);
    filter_freq2[f].displayFormat (filter_freq2[f].integerFormat);
    filter_view.addElement (filter_freq2[f]);
    // filter Q slider
    filter_q[f].name ("Q");
    filter_q[f].range (0, 50);
    filter_q[f].value (4);
    filter_q[f].size (slot_width, 75);
    filter_q[f].position (slot_width*f, 300);
    filter_q[f].displayFormat (filter_q[f].integerFormat);
    filter_view.addElement (filter_q[f]);
}


// delays
for (0 => int d; d < num_delays; d++) {
    // initialize delay selection
    0 => delay_sel[d];
    // delay label button
    delay_label[d].pushType ();
    delay_label[d].size (slot_width, 60);
    delay_label[d].position (slot_width*d, 0);
    delay_label[d].name ("Delay " + d);
    delay_view.addElement (delay_label[d]);
    // delay input node slider
    delay_input[d].name ("Input Node");
    delay_input[d].range (0, num_nodes);
    delay_input[d].value (0);
    delay_input[d].size (slot_width, 75);
    delay_input[d].position (slot_width*d, 50);
    delay_input[d].displayFormat (delay_input[d].integerFormat);
    delay_view.addElement (delay_input[d]);
    // delay output node slider
    delay_output[d].name ("Output Node");
    delay_output[d].range (0, num_nodes);
    delay_output[d].value (0);
    delay_output[d].size (slot_width, 75);
    delay_output[d].position (slot_width*d, 100);
    delay_output[d].displayFormat (delay_output[d].integerFormat);
    delay_view.addElement (delay_output[d]);
    // delay gain slider
    delay_gain[d].name ("Gain");
    delay_gain[d].range (0, 1);
    delay_gain[d].value (0);
    delay_gain[d].size (slot_width, 75);
    delay_gain[d].position (slot_width*d, 150);
    delay_view.addElement (delay_gain[d]);
    // delay duration slider
    delay_dur[d].name ("Delay, ms");
    delay_dur[d].range (0, 10);
    delay_dur[d].value (0);
    delay_dur[d].size (slot_width, 75);
    delay_dur[d].position (slot_width*d, 200);
    delay_view.addElement (delay_dur[d]);
}


// display the pages
delay_view.display ();
filter_view.display ();
osc_view.display ();
node_view.display ();
main_view.display ();


// instantiate the oscillators
Phasor phasor[num_osc];
SinOsc sinosc[num_osc];
PulseOsc pulseosc[num_osc];
SqrOsc sqrosc[num_osc];
TriOsc triosc[num_osc];
SawOsc sawosc[num_osc];

// instantiate the filters
LPF lpf[num_filters];
BPF bpf[num_filters];
HPF hpf[num_filters];

// instantiate delays
Delay delay[num_delays];
DelayA delaya[num_delays];
DelayL delayl[num_delays];

// the nodes are implemented as Gain ugens
Gain g[num_nodes+1];
// initialize nodes
for (0 => int n; n <= num_nodes; n++) {
    g[n].gain (1);
}
// initialize all connections to node zero
for (0 => int o; o < num_osc; o++) {
    sinosc[o] => g[0];
    0 => osc_in[o];
    0 => osc_out[o];
}

// hook up the highest node to the dac
g[1] => Gain master => WvOut wave_out => dac;


// shred for record button on main panel
function void main_record_adj () {
    while (true) {
        main_record => now;
        if (main_record.state ()) {
            "Synth_Lab.wav" => wave_out.wavFilename;
        } else {
            wave_out.closeFile ();
        }
    }
}
spork ~ main_record_adj ();
// shred for volume button on main panel
function void main_volume_adj () {
    while (true) {
        main_volume => now;
        master.gain (main_volume.value ());
    }
}
spork ~ main_volume_adj ();
// shred for output node slider on mic
function void main_mic_output_adj () {
    while (true) {
        main_mic_output => now;
        adc =< g[mic_out];
        adc => g[main_mic_output.value () $ int];
        main_mic_output.value () $ int => mic_out;
    }
}
spork ~ main_mic_output_adj ();


// shreds to watch the ugen buttons and sliders of nodes
// shred for gain slider on nodes
function void node_gain_adj (int n) {
    while (true) {
        node_gain[n] => now;
        if (node_boost[n].state ()) {
            g[n].gain (1000 * node_gain[n].value ());
        } else {
            g[n].gain (node_gain[n].value ());
        }
    }
}
for (1 => int n; n <= num_nodes; n++) {
    spork ~ node_gain_adj (n);
}
// gain boost button
function void node_boost_adj (int n) {
    while (true) {
        node_boost[n] => now;
        if (node_boost[n].state ()) {
            g[n].gain (1000 * node_gain[n].value ());
        } else {
            g[n].gain (node_gain[n].value ());
        }
    }
}
for (1 => int n; n <= num_nodes; n++) {
    spork ~ node_boost_adj (n);
}
// shred for op slider on nodes
function void node_op_adj (int n) {
    while (true) {
        node_op[n] => now;
        g[n].op (node_op[n].value () $ int);
    }
}
for (1 => int n; n <= num_nodes; n++) {
    spork ~ node_op_adj (n);
}



// shreds to watch the ugen buttons and sliders of oscillators
// osc label button
function void osc_label_adj (int o) {
    while (true) {
        osc_label[o] => now;
        if (osc_label[o].state ()) {
            (osc_sel[o] + 1) % 6 => osc_sel[o];
            if (osc_sel[o] == 0) {
                g[osc_in[o]] =< sawosc[o];
                if (osc_input[0].value ()) {
                    g[osc_input[o].value () $ int] => phasor[o];
                }
                sawosc[o] =< g[osc_out[o]];
                phasor[o] => g[osc_output[o].value () $ int];
                osc_label[o].name ("Phasor " + o);
            }
            if (osc_sel[o] == 1) {
                g[osc_in[o]] =< phasor[o];
                if (osc_input[0].value ()) {
                    g[osc_input[o].value () $ int] => sinosc[o];
                }
                phasor[o] =< g[osc_out[o]];
                sinosc[o] => g[osc_output[o].value () $ int];
                osc_label[o].name ("SinOsc " + o);
            }
            if (osc_sel[o] == 2) {
                g[osc_in[o]] =< sinosc[o];
                if (osc_input[0].value ()) {
                    g[osc_input[o].value () $ int] => pulseosc[o];
                }
                sinosc[o] =< g[osc_out[o]];
                pulseosc[o] => g[osc_output[o].value () $ int];
                osc_label[o].name ("PulseOsc " + o);
            }
            if (osc_sel[o] == 3) {
                g[osc_in[o]] =< pulseosc[o];
                if (osc_input[0].value ()) {
                    g[osc_input[o].value () $ int] => sqrosc[o];
                }
                pulseosc[o] =< g[osc_out[o]];
                sqrosc[o] => g[osc_output[o].value () $ int];
                osc_label[o].name ("SqrOsc " + o);
            }
            if (osc_sel[o] == 4) {
                g[osc_in[o]] =< sqrosc[o];
                if (osc_input[0].value ()) {
                    g[osc_input[o].value () $ int] => triosc[o];
                }
                sqrosc[o] =< g[osc_out[o]];
                triosc[o] => g[osc_output[o].value () $ int];
                osc_label[o].name ("TriOsc " + o);
            }
            if (osc_sel[o] == 5) {
                g[osc_in[o]] =< triosc[o];
                if (osc_input[0].value ()) {
                    g[osc_input[o].value () $ int] => sawosc[o];
                }
                triosc[o] =< g[osc_out[o]];
                sawosc[o] => g[osc_output[o].value () $ int];
                osc_label[o].name ("SawOsc " + o);
            }
        }
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_label_adj (o);
}
// shred for input node slider on oscillators
function void osc_input_adj (int o) {
    while (true) {
        osc_input[o] => now;
        if (osc_sel[o] == 0) {
            g[osc_in[o]] =< phasor[o];
            if (osc_input[0].value ()) {
                g[osc_input[o].value () $ int] => phasor[o];
            }
        }
        if (osc_sel[o] == 1) {
            g[osc_in[o]] =< sinosc[o];
            if (osc_input[0].value ()) {
                g[osc_input[o].value () $ int] => sinosc[o];
            }
        }
        if (osc_sel[o] == 2) {
            g[osc_in[o]] =< pulseosc[o];
            if (osc_input[0].value ()) {
                g[osc_input[o].value () $ int] => pulseosc[o];
            }
        }
        if (osc_sel[o] == 3) {
            g[osc_in[o]] =< sqrosc[o];
            if (osc_input[0].value ()) {
                g[osc_input[o].value () $ int] => sqrosc[o];
            }
        }
        if (osc_sel[o] == 4) {
            g[osc_in[o]] =< triosc[o];
            if (osc_input[0].value ()) {
                g[osc_input[o].value () $ int] => triosc[o];
            }
        }
        if (osc_sel[o] == 5) {
            g[osc_in[o]] =< sawosc[o];
            if (osc_input[0].value ()) {
                g[osc_input[o].value () $ int] => sawosc[o];
            }
        }
        osc_input[o].value () $ int => osc_in[o];
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_input_adj (o);
}
// shred for output node slider on oscillators
function void osc_output_adj (int o) {
    while (true) {
        osc_output[o] => now;
        if (osc_sel[o] == 0) {
            phasor[o] =< g[osc_out[o]];
            phasor[o] => g[osc_output[o].value () $ int];
        }
        if (osc_sel[o] == 1) {
            sinosc[o] =< g[osc_out[o]];
            sinosc[o] => g[osc_output[o].value () $ int];
        }
        if (osc_sel[o] == 2) {
            pulseosc[o] =< g[osc_out[o]];
            pulseosc[o] => g[osc_output[o].value () $ int];
        }
        if (osc_sel[o] == 3) {
            sqrosc[o] =< g[osc_out[o]];
            sqrosc[o] => g[osc_output[o].value () $ int];
        }
        if (osc_sel[o] == 4) {
            triosc[o] =< g[osc_out[o]];
            triosc[o] => g[osc_output[o].value () $ int];
        }
        if (osc_sel[o] == 5) {
            sawosc[o] =< g[osc_out[o]];
            sawosc[o] => g[osc_output[o].value () $ int];
        }
        osc_output[o].value () $ int => osc_out[o];
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_output_adj (o);
}
// shred for gain slider on oscillators
function void osc_gain_adj (int o) {
    while (true) {
        osc_gain[o] => now;
        phasor[o].gain (osc_gain[o].value ());
        sinosc[o].gain (osc_gain[o].value ());
        pulseosc[o].gain (osc_gain[o].value ());
        sqrosc[o].gain (osc_gain[o].value ());
        triosc[o].gain (osc_gain[o].value ());
        sawosc[o].gain (osc_gain[o].value ());
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_gain_adj (o);
}
// shred for freq1 slider on oscillators
function void osc_freq1_adj (int o) {
    while (true) {
        osc_freq1[o] => now;
        phasor[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sinosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        pulseosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sqrosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        triosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sawosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_freq1_adj (o);
}
// shred for freq2 slider on oscillators
function void osc_freq2_adj (int o) {
    while (true) {
        osc_freq2[o] => now;
        phasor[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sinosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        pulseosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sqrosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        triosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sawosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_freq2_adj (o);
}
// shred for phase slider on oscillators
function void osc_phase_adj (int o) {
    while (true) {
        osc_phase[o] => now;
        phasor[o].phase (osc_phase[o].value ());
        sinosc[o].phase (osc_phase[o].value ());
        pulseosc[o].phase (osc_phase[o].value ());
        sqrosc[o].phase (osc_phase[o].value ());
        triosc[o].phase (osc_phase[o].value ());
        sawosc[o].phase (osc_phase[o].value ());
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_phase_adj (o);
}
// shred for width slider on oscillators
function void osc_width_adj (int o) {
    while (true) {
        osc_width[o] => now;
        pulseosc[o].width (osc_width[o].value ());
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_width_adj (o);
}
// shred for sync slider on oscillators
function void osc_sync_adj (int o) {
    while (true) {
        osc_sync[o] => now;
        phasor[o].sync (osc_sync[o].value () $ int);
        sinosc[o].sync (osc_sync[o].value () $ int);
        pulseosc[o].sync (osc_sync[o].value () $ int);
        sqrosc[o].sync (osc_sync[o].value () $ int);
        triosc[o].sync (osc_sync[o].value () $ int);
        sawosc[o].sync (osc_sync[o].value () $ int);
    }
}
for (0 => int o; o < num_osc; o++) {
    spork ~ osc_sync_adj (o);
}


// shreds to watch the ugen buttons and sliders of filters
// filter label button
function void filter_label_adj (int f) {
    while (true) {
        filter_label[f] => now;
        if (filter_label[f].state ()) {
            (filter_sel[f] + 1) % 3 => filter_sel[f];
            if (filter_sel[f] == 0) {
                g[filter_in[f]] =< hpf[f];
                if (filter_input[0].value ()) {
                    g[filter_input[f].value () $ int] => lpf[f];
                }
                hpf[f] =< g[filter_out[f]];
                lpf[f] => g[filter_output[f].value () $ int];
                filter_label[f].name ("LPF " + f);
            }
            if (filter_sel[f] == 1) {
                g[filter_in[f]] =< lpf[f];
                if (filter_input[0].value ()) {
                    g[filter_input[f].value () $ int] => bpf[f];
                }
                lpf[f] =< g[filter_out[f]];
                bpf[f] => g[filter_output[f].value () $ int];
                filter_label[f].name ("BPF " + f);
            }
            if (filter_sel[f] == 2) {
                g[filter_in[f]] =< bpf[f];
                if (filter_input[0].value ()) {
                    g[filter_input[f].value () $ int] => hpf[f];
                }
                bpf[f] =< g[filter_out[f]];
                hpf[f] => g[filter_output[f].value () $ int];
                filter_label[f].name ("HPF " + f);
            }
        }
    }
}
for (0 => int f; f < num_filters; f++) {
    spork ~ filter_label_adj (f);
}
// shred for input node slider on filters
function void filter_input_adj (int f) {
    while (true) {
        filter_input[f] => now;
        if (filter_sel[f] == 0) {
            g[filter_in[f]] =< lpf[f];
            if (filter_input[0].value ()) {
                g[filter_input[f].value () $ int] => lpf[f];
            }
        }
        if (filter_sel[f] == 1) {
            g[filter_in[f]] =< bpf[f];
            if (filter_input[0].value ()) {
                g[filter_input[f].value () $ int] => bpf[f];
            }
        }
        if (filter_sel[f] == 2) {
            g[filter_in[f]] =< hpf[f];
            if (filter_input[0].value ()) {
                g[filter_input[f].value () $ int] => hpf[f];
            }
        }
        filter_input[f].value () $ int => filter_in[f];
    }
}
for (0 => int f; f < num_filters; f++) {
    spork ~ filter_input_adj (f);
}
// shred for output node slider on filters
function void filter_output_adj (int f) {
    while (true) {
        filter_output[f] => now;
        if (filter_sel[f] == 0) {
            lpf[f] =< g[filter_out[f]];
            lpf[f] => g[filter_output[f].value () $ int];
        }
        if (filter_sel[f] == 1) {
            bpf[f] =< g[filter_out[f]];
            bpf[f] => g[filter_output[f].value () $ int];
        }
        if (filter_sel[f] == 2) {
            hpf[f] =< g[filter_out[f]];
            hpf[f] => g[filter_output[f].value () $ int];
        }
        filter_output[f].value () $ int => filter_out[f];
    }
}
for (0 => int f; f < num_filters; f++) {
    spork ~ filter_output_adj (f);
}
// shred for gain slider on filters
function void filter_gain_adj (int f) {
    while (true) {
        filter_gain[f] => now;
        lpf[f].gain (filter_gain[f].value ());
        bpf[f].gain (filter_gain[f].value ());
        hpf[f].gain (filter_gain[f].value ());
    }
}
for (0 => int f; f < num_filters; f++) {
    spork ~ filter_gain_adj (f);
}
// shred for freq1 slider on filters
function void filter_freq1_adj (int f) {
    while (true) {
        filter_freq1[f] => now;
        lpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
        bpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
        hpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
    }
}
for (0 => int f; f < num_filters; f++) {
    spork ~ filter_freq1_adj (f);
}
// shred for freq2 slider on filters
function void filter_freq2_adj (int f) {
    while (true) {
        filter_freq2[f] => now;
        lpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
        bpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
        hpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
    }
}
for (0 => int f; f < num_filters; f++) {
    spork ~ filter_freq2_adj (f);
}
// shred for Q slider on filters
function void filter_q_adj (int f) {
    while (true) {
        filter_q[f] => now;
        lpf[f].Q (filter_q[f].value ());
        bpf[f].Q (filter_q[f].value ());
        hpf[f].Q (filter_q[f].value ());
    }
}
for (0 => int f; f < num_filters; f++) {
    spork ~ filter_q_adj (f);
}


// shreds to watch the ugen buttons and sliders of delays
// delay label button
function void delay_label_adj (int d) {
    while (true) {
        delay_label[d] => now;
        if (delay_label[d].state ()) {
            (delay_sel[d] + 1) % 3 => delay_sel[d];
            if (delay_sel[d] == 0) {
                g[delay_in[d]] =< delayl[d];
                if (delay_input[0].value ()) {
                    g[delay_input[d].value () $ int] => delay[d];
                }
                delayl[d] =< g[delay_out[d]];
                delay[d] => g[delay_output[d].value () $ int];
                delay_label[d].name ("Delay " + d);
            }
            if (delay_sel[d] == 1) {
                g[delay_in[d]] =< delay[d];
                if (delay_input[0].value ()) {
                    g[delay_input[d].value () $ int] => delaya[d];
                }
                delay[d] =< g[delay_out[d]];
                delaya[d] => g[delay_output[d].value () $ int];
                delay_label[d].name ("DelayA " + d);
            }
            if (delay_sel[d] == 2) {
                g[delay_in[d]] =< delaya[d];
                if (delay_input[0].value ()) {
                    g[delay_input[d].value () $ int] => delayl[d];
                }
                delaya[d] =< g[delay_out[d]];
                delayl[d] => g[delay_output[d].value () $ int];
                delay_label[d].name ("DelayL " + d);
            }
        }
    }
}
for (0 => int d; d < num_delays; d++) {
    spork ~ delay_label_adj (d);
}
// shred for input node slider on delays
function void delay_input_adj (int d) {
    while (true) {
        delay_input[d] => now;
        if (delay_sel[d] == 0) {
            g[delay_in[d]] =< delay[d];
            if (delay_input[0].value ()) {
                g[delay_input[d].value () $ int] => delay[d];
            }
        }
        if (delay_sel[d] == 1) {
            g[delay_in[d]] =< delaya[d];
            if (delay_input[0].value ()) {
                g[delay_input[d].value () $ int] => delaya[d];
            }
        }
        if (delay_sel[d] == 2) {
            g[delay_in[d]] =< delayl[d];
            if (delay_input[0].value ()) {
                g[delay_input[d].value () $ int] => delayl[d];
            }
        }
        delay_input[d].value () $ int => delay_in[d];
    }
}
for (0 => int d; d < num_delays; d++) {
    spork ~ delay_input_adj (d);
}
// shred for output node slider on delays
function void delay_output_adj (int d) {
    while (true) {
        delay_output[d] => now;
        if (delay_sel[d] == 0) {
            delay[d] =< g[delay_out[d]];
            delay[d] => g[delay_output[d].value () $ int];
        }
        if (delay_sel[d] == 1) {
            delaya[d] =< g[delay_out[d]];
            delaya[d] => g[delay_output[d].value () $ int];
        }
        if (delay_sel[d] == 2) {
            delayl[d] =< g[delay_out[d]];
            delayl[d] => g[delay_output[d].value () $ int];
        }
        delay_output[d].value () $ int => delay_out[d];
    }
}
for (0 => int d; d < num_delays; d++) {
    spork ~ delay_output_adj (d);
}
// shred dor gain slider on delays
function void delay_gain_adj (int d) {
    while (true) {
        delay_gain[d] => now;
        delay[d].gain (delay_gain[d].value ());
        delaya[d].gain (delay_gain[d].value ());
        delayl[d].gain (delay_gain[d].value ());
    }
}
for (0 => int d; d < num_delays; d++) {
    spork ~ delay_gain_adj (d);
}
// shred for duration slider on delays
function void delay_dur_adj (int d) {
    while (true) {
        delay_dur[d] => now;
        delay[d].delay (delay_dur[d].value () * ms);
        delay[d].max (delay_dur[d].value () * ms);
        delaya[d].delay (delay_dur[d].value () * ms);
        delaya[d].max (delay_dur[d].value () * ms);
        delayl[d].delay (delay_dur[d].value () * ms);
        delayl[d].max (delay_dur[d].value () * ms);
    }
}
for (0 => int d; d < num_delays; d++) {
    spork ~ delay_dur_adj (d);
}


// initialization of instruments
function void initialize () {
    // initialize nodes
    for (1 => int n; n <= num_nodes; n++) {
        g[n].gain (node_gain[n].value ());
    }
    // initialize oscillators
    for (0 => int o; o < num_osc; o++) {
        phasor[o].gain (osc_gain[o].value ());
        phasor[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        phasor[o].phase (osc_phase[o].value ());
        sinosc[o].gain (osc_gain[o].value ());
        sinosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sinosc[o].phase (osc_phase[o].value ());
        pulseosc[o].gain (osc_gain[o].value ());
        pulseosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        pulseosc[o].phase (osc_phase[o].value ());
        sqrosc[o].gain (osc_gain[o].value ());
        sqrosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sqrosc[o].phase (osc_phase[o].value ());
        triosc[o].gain (osc_gain[o].value ());
        triosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        triosc[o].phase (osc_phase[o].value ());
        sawosc[o].gain (osc_gain[o].value ());
        sawosc[o].freq (1000 * osc_freq1[o].value () + osc_freq2[o].value ());
        sawosc[o].phase (osc_phase[o].value ());
    }
    // initialize filters
    for (0 => int f; f < num_osc; f++) {
        lpf[f].gain (filter_gain[f].value ());
        lpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
        lpf[f].Q (filter_q[f].value ());
        bpf[f].gain (filter_gain[f].value ());
        bpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
        bpf[f].Q (filter_q[f].value ());
        hpf[f].gain (filter_gain[f].value ());
        hpf[f].freq (1000 * filter_freq1[f].value () + filter_freq2[f].value ());
        hpf[f].Q (filter_q[f].value ());
    }
}
initialize ();



// loop forever
while (true) {
    day => now;
}