// Synth Lab // copyright 2008 Les Hall // This software is protected by the GNU General Public License // parameter default values for introductory configuration screen controls 20 => int num_nodes; // number of nodes available for connection 9 => int num_gains; // number of gains 3 => int num_osc; // number of oscillators 3 => int num_filters; // number of filters 3 => int num_delays; // number of delay lines 3 => int num_reverbs; // number of reverbs 2 => int num_counters; // number of counters 6 => int num_bits; // number of bits in each counter 1 => int num_rects; // number of rectifiers 1 => int num_zerox; // number of zero crossing detectors 3 => int num_envelopes; // number of envelope generators 8 => int num_logic_gates; // number of logic gates 3 => int num_logic_inputs; // number of inputs to each logic gate 3 => int num_dynos; // number of dynos 3 => int num_echos; // number of echos 140 => int slot_width; // width in pixels of each card slot, increase for better slider resolution 1280 => int screen_width; // horizontal size of screen 960 => int screen_height; // vertical size of screen 1 => int misc_view_select; // enable/disable misc view 1 => int patch_view_select; // enable/disable patch view 1 => int kbd_view_select; // enable/disable kbd view 1 => int lisa_view_select; // enable/disable lisa view // variables int exit; // 1 to indicate an exit when self-destruct is pressed dur clock_period; // system clock, for shreds that run continuously dur note_period; // 1 / notes per second, for note playing delays float node_boost_val[num_nodes+1]; // boost value for nodes int mic_out; // output node of microphone int dac_left_in; // left input node of dac int dac_right_in; // right input node of dac int gain_boost_val[num_gains]; // boost value for gains int gain_in[num_gains]; // the previous value of input node int gain_out[num_gains]; // the previous value of output node 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 filter_wah[num_filters]; // the previous value of wahwah 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 int reverb_sel[num_reverbs]; // the selected reverbs int reverb_in[num_reverbs]; // the previous value of input node int reverb_out[num_reverbs]; // the previous value of output node int counter_in[num_counters]; // the previous value of the input node int counter_out[num_counters][num_bits]; // the previous value of the output node int envelope_in[num_envelopes]; // the previous value of input node int envelope_out[num_envelopes]; // the previous value of output node int envelope_trig[num_envelopes]; // the previous value of trigger node int noise_out; // the previous value of output node int pitshift_in; // the previous value of input node int pitshift_out; // the previous value of output node int rect_sel[num_rects]; // the selected rectifiers int rect_in[num_rects]; // the previous value of input node int rect_out[num_rects]; // the previous value of output node int zerox_in[num_zerox]; // the previous value of input node int zerox_out[num_zerox]; // the previous value of output node int kbd_out; // the previous value of output node 0 => int kbd_device; // device number of the keyboard 10::ms => dur kbd_env_dur; // keyboard envelope duration int logic_gate_sel[num_logic_gates]; // the selected logic gates int logic_gate_in[num_logic_gates][num_logic_inputs]; // the previous value of input node int logic_gate_out[num_logic_gates]; // the previous value of output node int dyno_sel[num_dynos]; // the selected dynos int dyno_in[num_dynos]; // the previous value of input node int dyno_out[num_dynos]; // the previous value of output node int echo_in[num_echos]; // the previous value of input node int echo_out[num_echos]; // the previous value of output node int lisa_voice_in; // the previous value of input node int lisa_rate_in; // the previous value of input node int lisa_clear_in; // the previous value of input node int lisa_record_in; // the previous value of input node int lisa_play_in; // the previous value of input node int lisa_backward_in; // the previous value of input node int lisa_in; // the previous value of input node int lisa_out; // the previous value of output node 100::ms => dur lisa_ramp_duration; // duration of rampUp and rampDown 1::minute => dur lisa_buffer_duration; // lisa buffer size 10 => int lisa_max_voices; // number of voices to use in lisa (hard limit 200) int guitar_lab_out; // the previous value of output node // define the intro screen page MAUI_View intro_view; intro_view.size (3 * slot_width, 525); intro_view.position (screen_width / 2 - 3 * slot_width / 2, screen_height / 2 - 525 / 2); intro_view.name ("Synth Lab Configuration"); // define the intro controls MAUI_Slider intro_num_nodes; MAUI_Slider intro_num_gains; MAUI_Slider intro_misc_view; MAUI_Slider intro_num_osc; MAUI_Slider intro_num_filters; MAUI_Slider intro_patch_view; MAUI_Slider intro_num_delays; MAUI_Slider intro_num_reverbs; MAUI_Slider intro_kbd_view; MAUI_Slider intro_num_counters; MAUI_Slider intro_num_bits; MAUI_Slider intro_lisa_view; MAUI_Slider intro_num_rects; MAUI_Slider intro_num_zerox; MAUI_Slider intro_num_envelopes; MAUI_Slider intro_num_dynos; MAUI_Slider intro_num_logic_gates; MAUI_Slider intro_num_logic_inputs; MAUI_Slider intro_num_echos; MAUI_Slider intro_slot_width; MAUI_Slider intro_screen_height; MAUI_Slider intro_screen_width; MAUI_Button intro_begin; // Set up the intro controls // num_nodes intro_num_nodes.name ("Nodes"); intro_num_nodes.range (0, 40); intro_num_nodes.value (num_nodes); intro_num_nodes.size (slot_width, 75); intro_num_nodes.position (0, 0); intro_num_nodes.displayFormat (intro_num_nodes.integerFormat); intro_view.addElement (intro_num_nodes); // num_gains intro_num_gains.name ("Gains"); intro_num_gains.range (0, 20); intro_num_gains.value (num_gains); intro_num_gains.size (slot_width, 75); intro_num_gains.position (slot_width, 0); intro_num_gains.displayFormat (intro_num_gains.integerFormat); intro_view.addElement (intro_num_gains); // misc_view_select intro_misc_view.name ("Misc View"); intro_misc_view.range (0, 1); intro_misc_view.value (misc_view_select); intro_misc_view.size (slot_width, 75); intro_misc_view.position (2 * slot_width, 0); intro_misc_view.displayFormat (intro_misc_view.integerFormat); intro_view.addElement (intro_misc_view); // num_osc intro_num_osc.name ("Oscillators"); intro_num_osc.range (0, 10); intro_num_osc.value (num_osc); intro_num_osc.size (slot_width, 75); intro_num_osc.position (0, 50); intro_num_osc.displayFormat (intro_num_osc.integerFormat); intro_view.addElement (intro_num_osc); // num_filters intro_num_filters.name ("Filters"); intro_num_filters.range (0, 10); intro_num_filters.value (num_filters); intro_num_filters.size (slot_width, 75); intro_num_filters.position (slot_width, 50); intro_num_filters.displayFormat (intro_num_filters.integerFormat); intro_view.addElement (intro_num_filters); // patch_view_select intro_patch_view.name ("Patch View"); intro_patch_view.range (0, 1); intro_patch_view.value (patch_view_select); intro_patch_view.size (slot_width, 75); intro_patch_view.position (2 * slot_width, 50); intro_patch_view.displayFormat (intro_patch_view.integerFormat); intro_view.addElement (intro_patch_view); // num_delays intro_num_delays.name ("Delays"); intro_num_delays.range (0, 10); intro_num_delays.value (num_delays); intro_num_delays.size (slot_width, 75); intro_num_delays.position (0, 100); intro_num_delays.displayFormat (intro_num_delays.integerFormat); intro_view.addElement (intro_num_delays); // num_reverbs intro_num_reverbs.name ("Reverbs"); intro_num_reverbs.range (0, 10); intro_num_reverbs.value (num_reverbs); intro_num_reverbs.size (slot_width, 75); intro_num_reverbs.position (slot_width, 100); intro_num_reverbs.displayFormat (intro_num_reverbs.integerFormat); intro_view.addElement (intro_num_reverbs); // kbd_view_select intro_kbd_view.name ("Keyboard View"); intro_kbd_view.range (0, 1); intro_kbd_view.value (kbd_view_select); intro_kbd_view.size (slot_width, 75); intro_kbd_view.position (2 * slot_width, 100); intro_kbd_view.displayFormat (intro_kbd_view.integerFormat); intro_view.addElement (intro_kbd_view); // num_counters intro_num_counters.name ("Counters"); intro_num_counters.range (0, 10); intro_num_counters.value (num_counters); intro_num_counters.size (slot_width, 75); intro_num_counters.position (0, 150); intro_num_counters.displayFormat (intro_num_counters.integerFormat); intro_view.addElement (intro_num_counters); // num_bits intro_num_bits.name ("Counter Bits"); intro_num_bits.range (1, 16); intro_num_bits.value (num_bits); intro_num_bits.size (slot_width, 75); intro_num_bits.position (slot_width, 150); intro_num_bits.displayFormat (intro_num_bits.integerFormat); intro_view.addElement (intro_num_bits); // lisa_view_select intro_lisa_view.name ("LiSa View"); intro_lisa_view.range (0, 1); intro_lisa_view.value (kbd_view_select); intro_lisa_view.size (slot_width, 75); intro_lisa_view.position (2 * slot_width, 150); intro_lisa_view.displayFormat (intro_lisa_view.integerFormat); intro_view.addElement (intro_lisa_view); // num_rects intro_num_rects.name ("Rectifiers"); intro_num_rects.range (0, 10); intro_num_rects.value (num_rects); intro_num_rects.size (slot_width, 75); intro_num_rects.position (0, 200); intro_num_rects.displayFormat (intro_num_rects.integerFormat); intro_view.addElement (intro_num_rects); // num_zerox intro_num_zerox.name ("ZeroX"); intro_num_zerox.range (0, 10); intro_num_zerox.value (num_zerox); intro_num_zerox.size (slot_width, 75); intro_num_zerox.position (slot_width, 200); intro_num_zerox.displayFormat (intro_num_zerox.integerFormat); intro_view.addElement (intro_num_zerox); // num_envelopes intro_num_envelopes.name ("Envelopes"); intro_num_envelopes.range (0, 10); intro_num_envelopes.value (num_envelopes); intro_num_envelopes.size (slot_width, 75); intro_num_envelopes.position (0, 250); intro_num_envelopes.displayFormat (intro_num_envelopes.integerFormat); intro_view.addElement (intro_num_envelopes); // num_dynos intro_num_dynos.name ("Dynos"); intro_num_dynos.range (0, 10); intro_num_dynos.value (num_dynos); intro_num_dynos.size (slot_width, 75); intro_num_dynos.position (slot_width, 250); intro_num_dynos.displayFormat (intro_num_dynos.integerFormat); intro_view.addElement (intro_num_dynos); // num_logic_gates intro_num_logic_gates.name ("Logic Gates"); intro_num_logic_gates.range (0, 10); intro_num_logic_gates.value (num_logic_gates); intro_num_logic_gates.size (slot_width, 75); intro_num_logic_gates.position (0, 300); intro_num_logic_gates.displayFormat (intro_num_logic_gates.integerFormat); intro_view.addElement (intro_num_logic_gates); // num_logic_inputs intro_num_logic_inputs.name ("Logic Inputs"); intro_num_logic_inputs.range (1, 10); intro_num_logic_inputs.value (num_logic_inputs); intro_num_logic_inputs.size (slot_width, 75); intro_num_logic_inputs.position (slot_width, 300); intro_num_logic_inputs.displayFormat (intro_num_logic_inputs.integerFormat); intro_view.addElement (intro_num_logic_inputs); // num_echos intro_num_echos.name ("Echos"); intro_num_echos.range (0, 10); intro_num_echos.value (num_echos); intro_num_echos.size (slot_width, 75); intro_num_echos.position (0, 350); intro_num_echos.displayFormat (intro_num_echos.integerFormat); intro_view.addElement (intro_num_echos); // slot_width intro_slot_width.name ("Slot Width"); intro_slot_width.range (140, 300); intro_slot_width.value (slot_width); intro_slot_width.size (slot_width, 75); intro_slot_width.position (slot_width, 350); intro_slot_width.displayFormat (intro_slot_width.integerFormat); intro_view.addElement (intro_slot_width); // screen_width intro_screen_width.name ("Screen W"); intro_screen_width.range (1000, 4000); intro_screen_width.value (screen_width); intro_screen_width.size (slot_width, 75); intro_screen_width.position (0, 400); intro_screen_width.displayFormat (intro_screen_width.integerFormat); intro_view.addElement (intro_screen_width); // screen_height intro_screen_height.name ("Screen H"); intro_screen_height.range (800, 2000); intro_screen_height.value (screen_height); intro_screen_height.size (slot_width, 75); intro_screen_height.position (slot_width, 400); intro_screen_height.displayFormat (intro_screen_height.integerFormat); intro_view.addElement (intro_screen_height); // begin button intro_begin.pushType (); intro_begin.size (3 * slot_width, 60); intro_begin.position (0, 460); intro_begin.name ("Begin Synth Lab"); intro_view.addElement (intro_begin); // display the intro panel intro_view.display (); // wait for the user to press the begin button, then record variables intro_begin => now; intro_num_nodes.value () $ int => num_nodes; intro_num_gains.value () $ int => num_gains; intro_misc_view.value () $ int => misc_view_select; intro_num_osc.value () $ int => num_osc; intro_num_filters.value () $ int => num_filters; intro_patch_view.value () $ int => patch_view_select; intro_num_delays.value () $ int => num_delays; intro_num_reverbs.value () $ int => num_reverbs; intro_kbd_view.value () $ int => kbd_view_select; intro_num_counters.value () $ int => num_counters; intro_num_bits.value () $ int => num_bits; intro_lisa_view.value () $ int => lisa_view_select; intro_num_rects.value () $ int => num_rects; intro_num_zerox.value () $ int => num_zerox; intro_num_envelopes.value () $ int => num_envelopes; intro_num_dynos.value () $ int => num_dynos; intro_num_logic_gates.value () $ int => num_logic_gates; intro_num_logic_inputs.value () $ int => num_logic_inputs; intro_num_echos.value () $ int => num_echos; intro_slot_width.value () $ int => slot_width; intro_screen_height.value () $ int => screen_height; intro_screen_width.value () $ int => screen_width; // destroy the intro screen; intro_view.destroy (); // define the pages MAUI_View main_view; main_view.size (2 * slot_width, 500); main_view.position (0, screen_height - 500); main_view.name ("Synth Lab"); MAUI_View node_view; node_view.size (3 * slot_width, 50 * num_nodes + 25); node_view.position (screen_width - 3 * slot_width - 50, screen_height - (50 * num_nodes + 25)); node_view.name ("Nodes"); MAUI_View gain_view; gain_view.size (num_gains * slot_width, 175); gain_view.position (0, 50); gain_view.name ("Gains"); MAUI_View osc_view; osc_view.size (num_osc * slot_width, 475); osc_view.position (screen_width - (num_osc +3) * slot_width, screen_height - 475 - 100); osc_view.name ("Oscillators"); MAUI_View filter_view; filter_view.size (num_filters * slot_width, 475); filter_view.position (2 * slot_width, screen_height - 475 - 300); filter_view.name ("Filters"); MAUI_View delay_view; delay_view.size (num_delays * slot_width, 275); delay_view.position (50, screen_height - 300 - 275); delay_view.name ("Delays"); MAUI_View reverb_view; reverb_view.size (num_reverbs * slot_width, 225); reverb_view.position (0, screen_height - 300 - 275 - 225); reverb_view.name ("Reverbs"); MAUI_View counter_view; counter_view.size (num_counters * slot_width, (3 + num_bits) * 50 + 10); counter_view.position (screen_width - (num_counters + 3) * slot_width, 50); counter_view.name ("Counters"); MAUI_View envelope_view; envelope_view.size (num_envelopes * slot_width, 275); envelope_view.position (slot_width, screen_height - 300 - 275); envelope_view.name ("Envelopes"); MAUI_View misc_view; misc_view.size ((2 + num_rects + num_zerox) * slot_width, 275); misc_view.position (2 * slot_width, screen_height - 275 - 100); misc_view.name ("Misc."); MAUI_View kbd_view; kbd_view.size (slot_width, 175); kbd_view.position (slot_width, 200); kbd_view.name ("Keyboard"); MAUI_View logic_gate_view; logic_gate_view.size (num_logic_gates * slot_width, (2 + num_logic_inputs) * 50 + 25); logic_gate_view.position (screen_width - num_logic_gates * slot_width, 50); logic_gate_view.name ("Logic Gates"); MAUI_View dyno_view; dyno_view.size (num_dynos * slot_width, 175); dyno_view.position (screen_width - num_dynos * slot_width, screen_height - 175); dyno_view.name ("Dynos"); MAUI_View echo_view; echo_view.size (num_echos * slot_width, 275); echo_view.position (screen_width - (num_dynos + num_echos) * slot_width, screen_height - 275); echo_view.name ("Echos"); MAUI_View led_view; led_view.size (num_nodes * 50 + 25, 100); led_view.position (screen_width / 2 - (num_nodes * 50 + 25) / 2, screen_height - 100); led_view.name ("Node Logic Values"); MAUI_View patch_view; patch_view.size ((2 + num_nodes) * 35, (2 + num_nodes) * 35 + 20); patch_view.position (0, screen_height / 2 - ((2 + num_nodes) * 35 + 20) / 2); patch_view.name ("Patch Matrix"); MAUI_View lisa_view; lisa_view.size (2 * slot_width, 425); lisa_view.position (screen_width - 2 * slot_width, screen_height/2 - 425 / 2); lisa_view.name ("LiSa Live Sampling Utility"); // control declarations // main panel controls MAUI_Slider main_volume; MAUI_Button main_record; MAUI_Button main_playback; MAUI_Slider main_clock_freq; MAUI_Slider main_note_freq; MAUI_Button main_copyright; MAUI_Button main_credits; MAUI_Button main_self_destruct; MAUI_Slider main_mic_output; MAUI_Slider main_dac_left_input; MAUI_Slider main_dac_right_input; MAUI_Button main_fortune_cookie; MAUI_Slider guitar_lab_output; // node controls MAUI_Slider node_gain[num_nodes+1]; MAUI_Button node_boost[num_nodes+1]; MAUI_Slider node_op[num_nodes+1]; // gain controls MAUI_Slider gain_input[num_gains]; MAUI_Slider gain_output[num_gains]; MAUI_Slider gain_gain[num_gains]; // 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_wahwah[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]; MAUI_Button filter_reset; // 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]; // reverb panel controls MAUI_Button reverb_label[num_reverbs]; MAUI_Slider reverb_input[num_reverbs]; MAUI_Slider reverb_output[num_reverbs]; MAUI_Slider reverb_mix[num_reverbs]; // counter panel controls MAUI_Button counter_label[num_counters]; MAUI_Slider counter_input[num_counters]; MAUI_Slider counter_output[num_counters][num_bits]; MAUI_Button counter_pk2pk[num_counters]; // envelope panel controls MAUI_Button envelope_label[num_envelopes]; MAUI_Slider envelope_input[num_envelopes]; MAUI_Slider envelope_output[num_envelopes]; MAUI_Slider envelope_trigger[num_envelopes]; MAUI_Slider envelope_duration[num_envelopes]; // misc panel controls MAUI_Button noise_label; MAUI_Slider noise_output; MAUI_Slider noise_gain; MAUI_Button pitshift_label; MAUI_Slider pitshift_input; MAUI_Slider pitshift_output; MAUI_Slider pitshift_mix; MAUI_Slider pitshift_shift; MAUI_Button rect_label[num_rects]; MAUI_Slider rect_input[num_rects]; MAUI_Slider rect_output[num_rects]; MAUI_Button zerox_label[num_zerox]; MAUI_Slider zerox_input[num_zerox]; MAUI_Slider zerox_output[num_zerox]; // keyboard panel controls MAUI_Button kbd_label; MAUI_Slider kbd_output; MAUI_Slider kbd_base_note; // logic gate panel controls MAUI_Button logic_gate_label[num_logic_gates]; MAUI_Slider logic_gate_input[num_logic_gates][num_logic_inputs]; MAUI_Slider logic_gate_output[num_logic_gates]; // dyno panel controls MAUI_Button dyno_label[num_dynos]; MAUI_Slider dyno_input[num_dynos]; MAUI_Slider dyno_output[num_dynos]; // echo panel controls MAUI_Button echo_label[num_echos]; MAUI_Slider echo_input[num_echos]; MAUI_Slider echo_output[num_echos]; MAUI_Slider echo_delay[num_echos]; MAUI_Slider echo_mix[num_echos]; // led panel controls MAUI_Button led_label[num_nodes]; MAUI_LED led_led[num_nodes]; // patch panel controls MAUI_Button patch_dot[num_nodes][num_nodes]; MAUI_Button patch_x_label[num_nodes]; MAUI_Button patch_y_label[num_nodes]; MAUI_Button patch_connect; // lisa panel controls MAUI_Slider lisa_voice; MAUI_Slider lisa_voice_input; MAUI_Slider lisa_rate; MAUI_Slider lisa_rate_input; MAUI_Button lisa_clear; MAUI_Slider lisa_clear_input; MAUI_Button lisa_record; MAUI_Slider lisa_record_input; MAUI_Button lisa_play; MAUI_Slider lisa_play_input; MAUI_Button lisa_backward; MAUI_Slider lisa_backward_input; MAUI_Slider lisa_input; MAUI_Slider lisa_output; // main panel controls // 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, 0); main_view.addElement (main_volume); // main clock frequency slider main_clock_freq.name ("Clock, Hz"); main_clock_freq.range (1, 1000); main_clock_freq.value (100); main_clock_freq.size (slot_width, 75); main_clock_freq.position (0, 50); main_clock_freq.displayFormat (main_clock_freq.integerFormat); main_view.addElement (main_clock_freq); // main note frequency slider main_note_freq.name ("Notes/Sec"); main_note_freq.range (1, 10); main_note_freq.value (4); main_note_freq.size (slot_width, 75); main_note_freq.position (0, 100); main_note_freq.displayFormat (main_note_freq.integerFormat); main_view.addElement (main_note_freq); // main record button main_record.toggleType (); main_record.size (slot_width, 60); main_record.position (0, 170); main_record.name ("Record"); main_view.addElement (main_record); // main playback button main_playback.pushType (); main_playback.size (slot_width, 60); main_playback.position (slot_width, 170); main_playback.name ("Playback"); main_view.addElement (main_playback); // main copyright button main_copyright.toggleType (); main_copyright.size (2*slot_width, 60); main_copyright.position (0, 220); main_copyright.name ("Copyright 2008 Les Hall"); main_view.addElement (main_copyright); // main credits button main_credits.toggleType (); main_credits.size (2*slot_width, 60); main_credits.position (0, 270); main_credits.name ("Thanks to www.electro-music.com"); main_view.addElement (main_credits); // main fortune cookie button main_fortune_cookie.toggleType (); main_fortune_cookie.size (2*slot_width, 60); main_fortune_cookie.position (0, 320); main_fortune_cookie.name ("Fortune Cookie"); main_view.addElement (main_fortune_cookie); // main self-destruct button main_self_destruct.pushType (); main_self_destruct.size (2 * slot_width, 60); main_self_destruct.position (0, 370); main_self_destruct.name ("Self Destruct"); main_view.addElement (main_self_destruct); // main mic output node slider main_mic_output.name ("Mic Output"); main_mic_output.range (0, num_nodes); main_mic_output.value (0); main_mic_output.size (slot_width, 75); main_mic_output.position (slot_width, 0); main_mic_output.displayFormat (main_mic_output.integerFormat); main_view.addElement (main_mic_output); // main dac left output node slider main_dac_left_input.name ("DAC Left"); main_dac_left_input.range (0, num_nodes); main_dac_left_input.value (num_nodes); main_dac_left_input.size (slot_width, 75); main_dac_left_input.position (slot_width, 50); main_dac_left_input.displayFormat (main_dac_left_input.integerFormat); main_view.addElement (main_dac_left_input); // main dac right output node slider main_dac_right_input.name ("DAC Right"); main_dac_right_input.range (0, num_nodes); main_dac_right_input.value (num_nodes); main_dac_right_input.size (slot_width, 75); main_dac_right_input.position (slot_width, 100); main_dac_right_input.displayFormat (main_dac_right_input.integerFormat); main_view.addElement (main_dac_right_input); // guitar lab output node slider guitar_lab_output.name ("Guitar Lab Output Node"); guitar_lab_output.range (0, num_nodes); guitar_lab_output.value (0); guitar_lab_output.size (2 * slot_width, 75); guitar_lab_output.position (0, 420); guitar_lab_output.displayFormat (guitar_lab_output.integerFormat); main_view.addElement (guitar_lab_output); // nodes for (1 => int n; n <= num_nodes; n++) { // node gain slider node_gain[n].name ("Gain " + n); node_gain[n].range (-1, 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].pushType (); node_boost[n].size (slot_width, 60); node_boost[n].position (slot_width, 50 * (n -1) + 10); node_boost[n].name ("x1"); 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]); } // gains for (0 => int g; g < num_gains; g++) { // gain input node slider gain_input[g].name ("Input Node"); gain_input[g].range (0, num_nodes); gain_input[g].value (0); gain_input[g].size (slot_width, 75); gain_input[g].position (slot_width * g, 0); gain_input[g].displayFormat (gain_input[g].integerFormat); gain_view.addElement (gain_input[g]); // gain output node slider gain_output[g].name ("Output Node"); gain_output[g].range (0, num_nodes); gain_output[g].value (0); gain_output[g].size (slot_width, 75); gain_output[g].position (slot_width * g, 50); gain_output[g].displayFormat (gain_output[g].integerFormat); gain_view.addElement (gain_output[g]); // gain gain slider gain_gain[g].name ("Gain " + g); gain_gain[g].range (-1, 1); gain_gain[g].value (1); gain_gain[g].size (slot_width, 75); gain_gain[g].position (slot_width * g, 100); gain_view.addElement (gain_gain[g]); } // 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 (-1, 1); osc_gain[o].value (1); 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"); osc_freq1[o].range (0, 10); osc_freq1[o].value (5); osc_freq1[o].size (slot_width, 75); osc_freq1[o].position (slot_width*o, 200); osc_view.addElement (osc_freq1[o]); // osc freq2 slider osc_freq2[o].name ("Freq Exp"); osc_freq2[o].range (-2, 4); osc_freq2[o].value (2); 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 (0); 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 output node slider filter_wahwah[f].name ("WahWah Node"); filter_wahwah[f].range (0, num_nodes); filter_wahwah[f].value (0); filter_wahwah[f].size (slot_width, 75); filter_wahwah[f].position (slot_width*f, 150); filter_wahwah[f].displayFormat (filter_wahwah[f].integerFormat); filter_view.addElement (filter_wahwah[f]); // filter gain slider filter_gain[f].name ("Gain"); filter_gain[f].range (-1, 1); filter_gain[f].value (1); filter_gain[f].size (slot_width, 75); filter_gain[f].position (slot_width*f, 200); filter_view.addElement (filter_gain[f]); // filter freq1 slider filter_freq1[f].name ("Freq"); filter_freq1[f].range (0, 10); filter_freq1[f].value (5); filter_freq1[f].size (slot_width, 75); filter_freq1[f].position (slot_width*f, 250); filter_view.addElement (filter_freq1[f]); // filter freq2 slider filter_freq2[f].name ("Freq Exp"); filter_freq2[f].range (-2, 4); filter_freq2[f].value (2); filter_freq2[f].size (slot_width, 75); filter_freq2[f].position (slot_width*f, 300); 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, 350); filter_q[f].displayFormat (filter_q[f].integerFormat); filter_view.addElement (filter_q[f]); } // filter reset button filter_reset.pushType (); filter_reset.size (num_filters * slot_width, 60); filter_reset.position (0, 410); filter_reset.name ("Reset Q's"); filter_view.addElement (filter_reset); // 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 (-1, 1); delay_gain[d].value (1); 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.01, 100); delay_dur[d].value (10); delay_dur[d].size (slot_width, 75); delay_dur[d].position (slot_width*d, 200); delay_view.addElement (delay_dur[d]); } // reverbs for (0 => int r; r < num_reverbs; r++) { // initialize reverb selection 0 => reverb_sel[r]; // reverb label button reverb_label[r].pushType (); reverb_label[r].size (slot_width, 60); reverb_label[r].position (slot_width*r, 0); reverb_label[r].name ("JCRev " + r); reverb_view.addElement (reverb_label[r]); // reverb input node slider reverb_input[r].name ("Input Node"); reverb_input[r].range (0, num_nodes); reverb_input[r].value (0); reverb_input[r].size (slot_width, 75); reverb_input[r].position (slot_width*r, 50); reverb_input[r].displayFormat (reverb_input[r].integerFormat); reverb_view.addElement (reverb_input[r]); // reverb output node slider reverb_output[r].name ("Output Node"); reverb_output[r].range (0, num_nodes); reverb_output[r].value (0); reverb_output[r].size (slot_width, 75); reverb_output[r].position (slot_width*r, 100); reverb_output[r].displayFormat (reverb_output[r].integerFormat); reverb_view.addElement (reverb_output[r]); // reverb mix slider reverb_mix[r].name ("Mix"); reverb_mix[r].range (0, 1); reverb_mix[r].value (0.1); reverb_mix[r].size (slot_width, 75); reverb_mix[r].position (slot_width*r, 150); reverb_view.addElement (reverb_mix[r]); } // counters for (0 => int c; c < num_counters; c++) { // counter label buttons counter_label[c].pushType (); counter_label[c].size (slot_width, 60); counter_label[c].position (c * slot_width, 0); counter_label[c].name ("Counter " + c); counter_view.addElement (counter_label[c]); // counter input node slider counter_input[c].name ("Input Node"); counter_input[c].range (0, num_nodes); counter_input[c].value (0); counter_input[c].size (slot_width, 75); counter_input[c].position (c * slot_width, 50); counter_input[c].displayFormat (counter_input[c].integerFormat); counter_view.addElement (counter_input[c]); for (0 => int b; b < num_bits; b++) { // counter output node slider counter_output[c][b].name ("Bit " + b + " Output"); counter_output[c][b].range (0, num_nodes); counter_output[c][b].value (0); counter_output[c][b].size (slot_width, 75); counter_output[c][b].position (c * slot_width, (2 + b) * 50); counter_output[c][b].displayFormat (counter_output[c][b].integerFormat); counter_view.addElement (counter_output[c][b]); } // counter peak to peak select button counter_pk2pk[c].toggleType (); counter_pk2pk[c].size (slot_width, 60); counter_pk2pk[c].position (c * slot_width, (2 + num_bits) * 50); counter_pk2pk[c].name ("0 to 1"); counter_view.addElement (counter_pk2pk[c]); } // envelopes for (0 => int e; e < num_envelopes; e++) { // envelope label button envelope_label[e].pushType (); envelope_label[e].size (slot_width, 60); envelope_label[e].position (e * slot_width, 0); envelope_label[e].name ("Envelope " + e); envelope_view.addElement (envelope_label[e]); // envelope input node slider envelope_input[e].name ("Input Node"); envelope_input[e].range (0, num_nodes); envelope_input[e].value (0); envelope_input[e].size (slot_width, 75); envelope_input[e].position (e * slot_width, 50); envelope_input[e].displayFormat (envelope_input[e].integerFormat); envelope_view.addElement (envelope_input[e]); // envelope output node slider envelope_output[e].name ("Output Node"); envelope_output[e].range (0, num_nodes); envelope_output[e].value (0); envelope_output[e].size (slot_width, 75); envelope_output[e].position (e * slot_width, 100); envelope_output[e].displayFormat (envelope_output[e].integerFormat); envelope_view.addElement (envelope_output[e]); // envelope trigger node slider envelope_trigger[e].name ("Trigger Node"); envelope_trigger[e].range (0, num_nodes); envelope_trigger[e].value (0); envelope_trigger[e].size (slot_width, 75); envelope_trigger[e].position (e * slot_width, 150); envelope_trigger[e].displayFormat (envelope_trigger[e].integerFormat); envelope_view.addElement (envelope_trigger[e]); // envelope rate slider envelope_duration[e].name ("Dur, Sec"); envelope_duration[e].range (0, 1); envelope_duration[e].value (0.1); envelope_duration[e].size (slot_width, 75); envelope_duration[e].position (e * slot_width, 200); envelope_view.addElement (envelope_duration[e]); } // misc if (misc_view_select) { // misc noise label button noise_label.pushType (); noise_label.size (slot_width, 60); noise_label.position (0, 0); noise_label.name ("Noise"); misc_view.addElement (noise_label); // misc noise output node slider noise_output.name ("Output Node"); noise_output.range (0, num_nodes); noise_output.value (0); noise_output.size (slot_width, 75); noise_output.position (0, 50); noise_output.displayFormat (noise_output.integerFormat); misc_view.addElement (noise_output); // misc noise gain slider noise_gain.name ("Gain"); noise_gain.range (0, 1); noise_gain.value (1); noise_gain.size (slot_width, 75); noise_gain.position (0, 100); misc_view.addElement (noise_gain); // pitshift label button pitshift_label.pushType (); pitshift_label.size (slot_width, 60); pitshift_label.position (slot_width, 0); pitshift_label.name ("Pitch Shifter"); misc_view.addElement (pitshift_label); // pitshift input node slider pitshift_input.name ("Input Node"); pitshift_input.range (0, num_nodes); pitshift_input.value (0); pitshift_input.size (slot_width, 75); pitshift_input.position (slot_width, 50); pitshift_input.displayFormat (pitshift_input.integerFormat); misc_view.addElement (pitshift_input); // pitshift output node slider pitshift_output.name ("Output Node"); pitshift_output.range (0, num_nodes); pitshift_output.value (0); pitshift_output.size (slot_width, 75); pitshift_output.position (slot_width, 100); pitshift_output.displayFormat (pitshift_output.integerFormat); misc_view.addElement (pitshift_output); // pitshift mix slider pitshift_mix.name ("Mix"); pitshift_mix.range (0, 1); pitshift_mix.value (0.5); pitshift_mix.size (slot_width, 75); pitshift_mix.position (slot_width, 150); misc_view.addElement (pitshift_mix); // pitshift shift slider pitshift_shift.name ("Shift"); pitshift_shift.range (0, 1); pitshift_shift.value (0.5); pitshift_shift.size (slot_width, 75); pitshift_shift.position (slot_width, 200); misc_view.addElement (pitshift_shift); // rectifiers for (0 => int r; r < num_rects; r++) { // initialize rectifier selection 0 => rect_sel[r]; // rect label button rect_label[r].pushType (); rect_label[r].size (slot_width, 60); rect_label[r].position ((2 + r) * slot_width, 0); rect_label[r].name ("Half Rect " + r); misc_view.addElement (rect_label[r]); // rect input node slider rect_input[r].name ("Input Node"); rect_input[r].range (0, num_nodes); rect_input[r].value (0); rect_input[r].size (slot_width, 75); rect_input[r].position ((2 + r) * slot_width, 50); rect_input[r].displayFormat (rect_input[r].integerFormat); misc_view.addElement (rect_input[r]); // rect output node slider rect_output[r].name ("Output Node"); rect_output[r].range (0, num_nodes); rect_output[r].value (0); rect_output[r].size (slot_width, 75); rect_output[r].position ((2 + r) * slot_width, 100); rect_output[r].displayFormat (rect_output[r].integerFormat); misc_view.addElement (rect_output[r]); } // ZeroX zero crossing detectors for (0 => int z; z < num_zerox; z++) { // zerox label button zerox_label[z].pushType (); zerox_label[z].size (slot_width, 60); zerox_label[z].position ((2 + num_rects + z) * slot_width, 0); zerox_label[z].name ("ZeroX " + z); misc_view.addElement (zerox_label[z]); // zerox input node slider zerox_input[z].name ("Input Node"); zerox_input[z].range (0, num_nodes); zerox_input[z].value (0); zerox_input[z].size (slot_width, 75); zerox_input[z].position ((2 + num_rects + z) * slot_width, 50); zerox_input[z].displayFormat (zerox_input[z].integerFormat); misc_view.addElement (zerox_input[z]); // zerox output node slider zerox_output[z].name ("Output Node"); zerox_output[z].range (0, num_nodes); zerox_output[z].value (0); zerox_output[z].size (slot_width, 75); zerox_output[z].position ((2 + num_rects + z) * slot_width, 100); zerox_output[z].displayFormat (zerox_output[z].integerFormat); misc_view.addElement (zerox_output[z]); } } // keyboard if (kbd_view_select) { // keyboard label button kbd_label.pushType (); kbd_label.size (slot_width, 60); kbd_label.position (0, 0); kbd_label.name ("Keyboard"); kbd_view.addElement (kbd_label); // keyboard output node slider kbd_output.name ("Output Node"); kbd_output.range (0, num_nodes); kbd_output.value (0); kbd_output.size (slot_width, 75); kbd_output.position (0, 50); kbd_output.displayFormat (kbd_output.integerFormat); kbd_view.addElement (kbd_output); // keyboard base note node slider kbd_base_note.name ("Base Note"); kbd_base_note.range (0, 127); kbd_base_note.value (50); kbd_base_note.size (slot_width, 75); kbd_base_note.position (0, 100); kbd_base_note.displayFormat (kbd_base_note.integerFormat); kbd_view.addElement (kbd_base_note); } // logic gates for (0 => int g; g < num_logic_gates; g++) { // logic gate label buttons logic_gate_label[g].pushType (); logic_gate_label[g].size (slot_width, 60); logic_gate_label[g].position (g * slot_width, 0); logic_gate_label[g].name ("AND " + g); logic_gate_view.addElement (logic_gate_label[g]); for (0 => int i; i < num_logic_inputs; i++) { // logic gate input node slider logic_gate_input[g][i].name ("Input " + i); logic_gate_input[g][i].range (0, num_nodes); logic_gate_input[g][i].value (0); logic_gate_input[g][i].size (slot_width, 75); logic_gate_input[g][i].position (g * slot_width, (1 + i) * 50); logic_gate_input[g][i].displayFormat (logic_gate_input[g][i].integerFormat); logic_gate_view.addElement (logic_gate_input[g][i]); } // logic gate output node slider logic_gate_output[g].name ("Output"); logic_gate_output[g].range (0, num_nodes); logic_gate_output[g].value (0); logic_gate_output[g].size (slot_width, 75); logic_gate_output[g].position (g * slot_width, (1 + num_logic_inputs) * 50); logic_gate_output[g].displayFormat (logic_gate_output[g].integerFormat); logic_gate_view.addElement (logic_gate_output[g]); } // dynos for (0 => int d; d < num_dynos; d++) { // dyno label button dyno_label[d].pushType (); dyno_label[d].size (slot_width, 60); dyno_label[d].position (d * slot_width, 0); dyno_label[d].name ("Limiter " + d); dyno_view.addElement (dyno_label[d]); // dyno input node slider dyno_input[d].name ("Input Node"); dyno_input[d].range (0, num_nodes); dyno_input[d].value (0); dyno_input[d].size (slot_width, 75); dyno_input[d].position (d * slot_width, 50); dyno_input[d].displayFormat (dyno_input[d].integerFormat); dyno_view.addElement (dyno_input[d]); // dyno output node slider dyno_output[d].name ("Output Node"); dyno_output[d].range (0, num_nodes); dyno_output[d].value (0); dyno_output[d].size (slot_width, 75); dyno_output[d].position (d * slot_width, 100); dyno_output[d].displayFormat (dyno_output[d].integerFormat); dyno_view.addElement (dyno_output[d]); } // echos for (0 => int e; e < num_echos; e++) { // echo label button echo_label[e].pushType (); echo_label[e].size (slot_width, 60); echo_label[e].position (e * slot_width, 0); echo_label[e].name ("Echo " + e); echo_view.addElement (echo_label[e]); // echo input node slider echo_input[e].name ("Input Node"); echo_input[e].range (0, num_nodes); echo_input[e].value (0); echo_input[e].size (slot_width, 75); echo_input[e].position (e * slot_width, 50); echo_input[e].displayFormat (echo_input[e].integerFormat); echo_view.addElement (echo_input[e]); // echo output node slider echo_output[e].name ("Output Node"); echo_output[e].range (0, num_nodes); echo_output[e].value (0); echo_output[e].size (slot_width, 75); echo_output[e].position (e * slot_width, 100); echo_output[e].displayFormat (echo_output[e].integerFormat); echo_view.addElement (echo_output[e]); // echo delay slider echo_delay[e].name ("Delay, ms"); echo_delay[e].range (0, 1000); echo_delay[e].value (100); echo_delay[e].size (slot_width, 75); echo_delay[e].position (e * slot_width, 150); echo_view.addElement (echo_delay[e]); // echo mix slider echo_mix[e].name ("mix"); echo_mix[e].range (0, 1); echo_mix[e].value (0.5); echo_mix[e].size (slot_width, 75); echo_mix[e].position (e * slot_width, 200); echo_view.addElement (echo_mix[e]); } // LEDs if (num_nodes) { for (0 => int l; l < num_nodes; l++) { // led label button led_label[l].pushType (); led_label[l].size (70, 60); led_label[l].position (l * 50, 0); led_label[l].name ("" + (l + 1)); led_view.addElement (led_label[l]); // the LEDs led_led[l].position (l * 50, 40); led_led[l].color (led_led[l].blue); led_view.addElement (led_led[l]); } } // Patches if (patch_view_select) { // patch x label buttons for (0 => int nx; nx < num_nodes; nx++) { patch_x_label[nx].toggleType (); patch_x_label[nx].size (65, 65); patch_x_label[nx].position ((1 + nx) * 35, num_nodes * 35); patch_x_label[nx].name ("" + (nx + 1)); patch_view.addElement (patch_x_label[nx]); } // patch y label buttons for (0 => int ny; ny < num_nodes; ny++) { patch_y_label[ny].toggleType (); patch_y_label[ny].size (65, 65); patch_y_label[ny].position (0, (num_nodes - ny - 1) * 35); patch_y_label[ny].name ("" + (ny + 1)); patch_view.addElement (patch_y_label[ny]); } // patch dot buttons for (0 => int nx; nx < num_nodes; nx++) { for (0 => int ny; ny < num_nodes; ny++) { patch_dot[nx][ny].toggleType (); patch_dot[nx][ny].size (65, 65); patch_dot[nx][ny].position ((1 + nx) * 35, (num_nodes - ny -1) * 35); patch_dot[nx][ny].name (""); patch_view.addElement (patch_dot[nx][ny]); } } // patch connect button patch_connect.pushType (); patch_connect.size (2 * slot_width, 60); patch_connect.position (((1 + num_nodes) / 2) * 35 - slot_width, (1 + num_nodes) * 35); patch_connect.name ("Make Connections"); patch_view.addElement (patch_connect); } // lisa panel controls if (lisa_view_select) { // lisa voice input node slider lisa_voice_input.name ("Voice In Node"); lisa_voice_input.range (0, num_nodes); lisa_voice_input.value (0); lisa_voice_input.size (slot_width, 75); lisa_voice_input.position (0, 0); lisa_voice_input.displayFormat (lisa_voice_input.integerFormat); lisa_view.addElement (lisa_voice_input); // lisa voice input slider lisa_voice.name ("Voice"); lisa_voice.range (0, lisa_max_voices - 1); lisa_voice.value (0); lisa_voice.size (slot_width, 75); lisa_voice.position (slot_width, 0); lisa_voice.displayFormat (lisa_voice.integerFormat); lisa_view.addElement (lisa_voice); // lisa rate input node slider lisa_rate_input.name ("Rate In Node"); lisa_rate_input.range (0, num_nodes); lisa_rate_input.value (0); lisa_rate_input.size (slot_width, 75); lisa_rate_input.position (0, 50); lisa_rate_input.displayFormat (lisa_rate_input.integerFormat); lisa_view.addElement (lisa_rate_input); // lisa rate slider lisa_rate.name ("Rate"); lisa_rate.range (0, 4); lisa_rate.value (1); lisa_rate.size (slot_width, 75); lisa_rate.position (slot_width, 50); lisa_view.addElement (lisa_rate); // lisa clear input node slider lisa_clear_input.name ("Clear In Node"); lisa_clear_input.range (0, num_nodes); lisa_clear_input.value (0); lisa_clear_input.size (slot_width, 75); lisa_clear_input.position (0, 100); lisa_clear_input.displayFormat (lisa_clear_input.integerFormat); lisa_view.addElement (lisa_clear_input); // lisa clear button lisa_clear.pushType (); lisa_clear.size (slot_width, 60); lisa_clear.position (slot_width, 110); lisa_clear.name ("Clear"); lisa_view.addElement (lisa_clear); // lisa record input node slider lisa_record_input.name ("Record In Node"); lisa_record_input.range (0, num_nodes); lisa_record_input.value (0); lisa_record_input.size (slot_width, 75); lisa_record_input.position (0, 150); lisa_record_input.displayFormat (lisa_record_input.integerFormat); lisa_view.addElement (lisa_record_input); // lisa record button lisa_record.toggleType (); lisa_record.size (slot_width, 60); lisa_record.position (slot_width, 160); lisa_record.name ("Record"); lisa_view.addElement (lisa_record); // lisa play input node slider lisa_play_input.name ("Play In Node"); lisa_play_input.range (0, num_nodes); lisa_play_input.value (0); lisa_play_input.size (slot_width, 75); lisa_play_input.position (0, 200); lisa_play_input.displayFormat (lisa_play_input.integerFormat); lisa_view.addElement (lisa_play_input); // lisa play button lisa_play.toggleType (); lisa_play.size (slot_width, 60); lisa_play.position (slot_width, 210); lisa_play.name ("Play"); lisa_view.addElement (lisa_play); // lisa backward input node slider lisa_backward_input.name ("Fw/Rev In Node"); lisa_backward_input.range (0, num_nodes); lisa_backward_input.value (0); lisa_backward_input.size (slot_width, 75); lisa_backward_input.position (0, 250); lisa_backward_input.displayFormat (lisa_backward_input.integerFormat); lisa_view.addElement (lisa_backward_input); // lisa backward button lisa_backward.toggleType (); lisa_backward.size (slot_width, 60); lisa_backward.position (slot_width, 260); lisa_backward.name ("Fw/Rev"); lisa_view.addElement (lisa_backward); // lisa input node slider lisa_input.name ("Input Node"); lisa_input.range (0, num_nodes); lisa_input.value (0); lisa_input.size (slot_width, 75); lisa_input.position (0, 300); lisa_input.displayFormat (lisa_input.integerFormat); lisa_view.addElement (lisa_input); // lisa output node slider lisa_output.name ("Output Node"); lisa_output.range (0, num_nodes); lisa_output.value (0); lisa_output.size (slot_width, 75); lisa_output.position (0, 350); lisa_output.displayFormat (lisa_output.integerFormat); lisa_view.addElement (lisa_output); } // display the panels if (lisa_view_select) { lisa_view.display (); } if (patch_view_select) { patch_view.display (); } if (num_nodes) { led_view.display (); } echo_view.display (); dyno_view.display (); logic_gate_view.display (); if (kbd_view_select) { kbd_view.display (); } if (misc_view_select) { misc_view.display (); } envelope_view.display (); counter_view.display (); reverb_view.display (); delay_view.display (); filter_view.display (); osc_view.display (); gain_view.display (); if (num_nodes) { node_view.display (); } main_view.display (); // instantiate the nodes // the nodes are implemented as Gain ugens Gain node[num_nodes+1]; // make all nodes always active by sucking samples into blackhole for (1 => int n; n <= num_nodes; n++) { node[n] => blackhole; } // instantiate the gains Gain gain[num_gains]; // 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]; BRF brf[num_filters]; ResonZ resonz[num_filters]; // instantiate delays Delay delay[num_delays]; DelayA delaya[num_delays]; DelayL delayl[num_delays]; // instantiate reverbs JCRev jcrev[num_reverbs]; NRev nrev[num_reverbs]; PRCRev prcrev[num_reverbs]; // instantiate the counters Step counter_step[num_counters][num_bits]; // instantiate envelopes Envelope envelope[num_envelopes]; // instantiate misc view items Noise noise; PitShift pitshift; HalfRect halfrect[num_rects]; FullRect fullrect[num_rects]; ZeroX zerox[num_zerox]; // instantiate keyboard stuff Hid hid; HidMsg hidmsg; SinOsc kbd => Envelope kbd_env; // instantiate logic gate output drivers Step logic_gate[num_logic_gates]; // instantiate dynos Dyno dyno[num_dynos]; // instantiate echos Echo echo[num_echos]; // instantiate patch panel connections Gain patch[num_nodes][num_nodes]; // instantiate lisa LiSa lisa; // instantiate fun sound for copyright button Noise copyright_n1 => SinOsc copyright_s1 => SinOsc copyright_s2 => SinOsc copyright_s3; copyright_s3 => copyright_s1; copyright_s1.gain (10); copyright_s2.gain (500); copyright_s3.gain (1); // instantiate fun sound for credits button PulseOsc credits_s1 => BPF credits_f1 => JCRev credits_n1; PulseOsc credits_s2 => credits_f1; credits_s1.gain (25); credits_s1.freq (1.5); credits_s1.width (0.1); credits_s2.gain (50); credits_s2.freq (2); credits_s1.width (0.1); credits_f1.freq (440); credits_f1.Q (30); credits_n1.mix (0.1); // hook up the output nodes to the DAC and connect wave file ugens node[main_dac_left_input.value () $ int] => Gain master_left => Dyno dyno_left => dac.left; node[main_dac_right_input.value () $ int] => Gain master_right => Dyno dyno_right => dac.right; dyno_left.limit (); dyno_right.limit (); dac.gain (0.5); WvOut wvout; dac => wvout => blackhole; WvIn wvin; wvin => master_left; wvin => master_right; // receive audio from the public class Communication (in Communication.ck) Communication.buffer; // main panel shreds // shred for record button on main panel function void main_record_adj () { while (true) { main_record => now; if (main_record.state ()) { "Synth_Lab.wav" => wvout.wavFilename; } else { wvout.closeFile (); } } } spork ~ main_record_adj (); // shred for playback button on main panel function void main_playback_adj () { while (true) { main_playback => now; if (main_playback.state () & (!main_record.state ())) { 1 => wvin.rate; "Synth_Lab.wav" => wvin.path; } } } spork ~ main_playback_adj (); // shred for volume slider on main panel function void main_volume_adj () { while (true) { main_volume => now; master_left.gain (main_volume.value ()); master_right.gain (main_volume.value ()); } } spork ~ main_volume_adj (); // shred for clock freq slider on main panel function void main_clock_freq_adj () { while (true) { main_clock_freq => now; 1::second / main_clock_freq.value () => clock_period; } } spork ~ main_clock_freq_adj (); // shred for note freq slider on main panel function void main_note_freq_adj () { while (true) { main_note_freq => now; // save the note period 1::second / main_note_freq.value () => note_period; } } spork ~ main_note_freq_adj (); // shred for monitoring self-destruct button function void main_self_destruct_adj () { while (true) { main_self_destruct => now; if (main_self_destruct.state ()) { 1 => exit; main_self_destruct.name ("Self Destruct Initiated"); } } } spork ~ main_self_destruct_adj (); // shred for output node slider on mic function void main_mic_output_adj () { while (true) { main_mic_output => now; adc =< node[mic_out]; adc => node[main_mic_output.value () $ int]; main_mic_output.value () $ int => mic_out; } } spork ~ main_mic_output_adj (); // shred for input node slider on dac left function void main_dac_left_input_adj () { while (true) { main_dac_left_input => now; node[dac_left_in] =< master_left; node[main_dac_left_input.value () $ int] => master_left; main_dac_left_input.value () $ int => dac_left_in; } } spork ~ main_dac_left_input_adj (); // shred for input node slider on dac right function void main_dac_right_input_adj () { while (true) { main_dac_right_input => now; node[dac_right_in] =< master_right; node[main_dac_right_input.value () $ int] => master_right; main_dac_right_input.value () $ int => dac_right_in; } } spork ~ main_dac_right_input_adj (); // shred for copyright button fun noise function void main_copyright_adj () { while (true) { main_copyright => now; if (main_copyright.state ()) { copyright_s3 => master_left; main_copyright.name ("inventor-66@comcast.net"); } else { copyright_s3 =< master_left; main_copyright.name ("Copyright 2008 Les Hall"); } } } spork ~ main_copyright_adj (); // shred for credits button fun noise function void main_credits_adj () { while (true) { main_credits => now; if (main_credits.state ()) { credits_n1 => master_right; main_credits.name ("A Community of Music Lovers"); } else { credits_n1 =< master_right; main_credits.name ("Thanks to www.electromusic.com"); } } } spork ~ main_credits_adj (); // shred for fortune cooke button on main panel function void main_fortune_cookie_adj () { ["You have an ear for music", "Now is the time to synthesize", "Vote for a Democrat next time", "You aspire to greatness", "You are fond of synthesizers", "You dig retrograde", "Visit www.electro-music.com today", "Try synthesizing a love song", "Try Guitar Lab as well", "Your horoscope looks promising", "Judas Priest Rocks", "Your mama didn't raise no fools", "You are very popular", "Domo aregato Mr. Roboto", "You will create something wonderful", "Less is more", "Keep your passwords secret", "Kassen is very helpful", "kijjaz is a master ChucKist", "Frostburn is brilliant", "mosc is living synthesizer history", "Ge Wang is a friendly ChucKist", "Blue Hell likes music circuitry", "wppk made an great ChucK rain patch", "AC/DC rocks", "Joan Jett would like to meet you", "Use the force with confidence", "You will have long life", "You are entering a time of prosperity", "Jimmi Hendrix is a legend", "Remember this: oh, I forgot!", "You can be a good programmer if you try", "You are generous and kind", "The universe is analog", "God does not play dice with the universe", "A penny saved is a penny earned", "You will become a synthesizer wizard", "Never give up", "Visit www.freedomodds.com/music/", "Nostrodamus never saw Synth Lab coming", "Synth Lab is ChucK on steroids", "Synth Lab will bring you happiness", "You are healthy, wealthy, and wise", "Never eat kiwi fruit alone", "You will become a skilled ChucKist", "For sports, visit www.freedomodds.com", "You will master Perl programming", "Macs are the best computers", "Computers are getting smarter", "Captain Picard gave you a promotion", "The force is strong with you"] @=>string fortunes[]; while (true) { main_fortune_cookie => now; if (main_fortune_cookie.state ()) { main_fortune_cookie.name (fortunes[Std.rand2(0, 50)]); } else { main_fortune_cookie.name ("Fortune Cookie"); } } } spork ~ main_fortune_cookie_adj (); // shred for output node slider on guitar lab function void guitar_lab_output_adj () { while (true) { guitar_lab_output => now; if (guitar_lab_out > 0) { Communication.buffer =< node[guitar_lab_out]; } if (guitar_lab_output.value () > 0) { Communication.buffer => node[guitar_lab_output.value () $ int]; } guitar_lab_output.value () $ int => guitar_lab_out; } } spork ~ guitar_lab_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; node[n].gain (node_boost_val[n] * 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 ()) { 10 *=> node_boost_val[n]; if (node_boost_val[n] > 10000) { 0.1 => node_boost_val[n]; } node_boost[n].name ("x" + node_boost_val[n]); } node[n].gain (node_boost_val[n] * 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; node[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 gains // shred for input node slider on gains function void gain_input_adj (int g) { while (true) { gain_input[g] => now; node[gain_in[g]] =< gain[g]; node[gain_input[g].value () $ int] => gain[g]; gain_input[g].value () $ int => gain_in[g]; } } for (0 => int g; g < num_gains; g++) { spork ~ gain_input_adj (g); } // shred for output node slider on gains function void gain_output_adj (int g) { while (true) { gain_output[g] => now; gain[g] =< node[gain_out[g]]; gain[g] => node[gain_output[g].value () $ int]; gain_output[g].value () $ int => gain_out[g]; } } for (0 => int g; g < num_gains; g++) { spork ~ gain_output_adj (g); } // shred for gain slider on gains function void gain_gain_adj (int g) { while (true) { gain_gain[g] => now; node[g].gain (gain_gain[g].value ()); } } for (0 => int g; g < num_gains; g++) { spork ~ gain_gain_adj (g); } // 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) { node[osc_in[o]] =< sawosc[o]; if (osc_out[o] > 0) { node[osc_in[o]] => phasor[o]; sawosc[o] =< node[osc_out[o]]; phasor[o] => node[osc_out[o]]; } osc_label[o].name ("Phasor " + o); } if (osc_sel[o] == 1) { node[osc_in[o]] =< phasor[o]; if (osc_out[o] > 0) { node[osc_in[o]] => sinosc[o]; phasor[o] =< node[osc_out[o]]; sinosc[o] => node[osc_out[o]]; } osc_label[o].name ("SinOsc " + o); } if (osc_sel[o] == 2) { node[osc_in[o]] =< sinosc[o]; if (osc_out[o] > 0) { node[osc_in[o]] => pulseosc[o]; sinosc[o] =< node[osc_out[o]]; pulseosc[o] => node[osc_out[o]]; } osc_label[o].name ("PulseOsc " + o); } if (osc_sel[o] == 3) { node[osc_in[o]] =< pulseosc[o]; if (osc_out[o] > 0) { node[osc_in[o]] => sqrosc[o]; pulseosc[o] =< node[osc_out[o]]; sqrosc[o] => node[osc_out[o]]; } osc_label[o].name ("SqrOsc " + o); } if (osc_sel[o] == 4) { node[osc_in[o]] =< sqrosc[o]; if (osc_out[o] > 0) { node[osc_in[o]] => triosc[o]; sqrosc[o] =< node[osc_out[o]]; triosc[o] => node[osc_out[o]]; } osc_label[o].name ("TriOsc " + o); } if (osc_sel[o] == 5) { node[osc_in[o]] =< triosc[o]; if (osc_out[o] > 0) { node[osc_in[o]] => sawosc[o]; triosc[o] =< node[osc_out[o]]; sawosc[o] => node[osc_out[o]]; } osc_label[o].name ("SawOsc " + o); } phasor[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sinosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); pulseosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sqrosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); triosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sawosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); } } } 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) { node[osc_in[o]] =< phasor[o]; if (osc_input[o].value () > 0) { node[osc_input[o].value () $ int] => phasor[o]; } } if (osc_sel[o] == 1) { node[osc_in[o]] =< sinosc[o]; if (osc_input[o].value () > 0) { node[osc_input[o].value () $ int] => sinosc[o]; } } if (osc_sel[o] == 2) { node[osc_in[o]] =< pulseosc[o]; if (osc_input[o].value () > 0) { node[osc_input[o].value () $ int] => pulseosc[o]; } } if (osc_sel[o] == 3) { node[osc_in[o]] =< sqrosc[o]; if (osc_input[o].value () > 0) { node[osc_input[o].value () $ int] => sqrosc[o]; } } if (osc_sel[o] == 4) { node[osc_in[o]] =< triosc[o]; if (osc_input[o].value () > 0) { node[osc_input[o].value () $ int] => triosc[o]; } } if (osc_sel[o] == 5) { node[osc_in[o]] =< sawosc[o]; if (osc_input[o].value () > 0) { node[osc_input[o].value () $ int] => sawosc[o]; } } osc_input[o].value () $ int => osc_in[o]; phasor[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sinosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); pulseosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sqrosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); triosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sawosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); } } 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) { if (osc_out[o] > 0) { phasor[o] =< node[osc_out[o]]; } if (osc_output[o].value () > 0) { phasor[o] => node[osc_output[o].value () $ int]; } } if (osc_sel[o] == 1) { if (osc_out[o] > 0) { sinosc[o] =< node[osc_out[o]]; } if (osc_output[o].value () > 0) { sinosc[o] => node[osc_output[o].value () $ int]; } } if (osc_sel[o] == 2) { if (osc_out[o] > 0) { pulseosc[o] =< node[osc_out[o]]; } if (osc_output[o].value () > 0) { pulseosc[o] => node[osc_output[o].value () $ int]; } } if (osc_sel[o] == 3) { if (osc_out[o] > 0) { sqrosc[o] =< node[osc_out[o]]; } if (osc_output[o].value () > 0) { sqrosc[o] => node[osc_output[o].value () $ int]; } } if (osc_sel[o] == 4) { if (osc_out[o] > 0) { triosc[o] =< node[osc_out[o]]; } if (osc_output[o].value () > 0) { triosc[o] => node[osc_output[o].value () $ int]; } } if (osc_sel[o] == 5) { if (osc_out[o] > 0) { sawosc[o] =< node[osc_out[o]]; } if (osc_output[o].value () > 0) { sawosc[o] => node[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 (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sinosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); pulseosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sqrosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); triosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sawosc[o].freq (osc_freq1[o].value () * Math.pow(10, 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 (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sinosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); pulseosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sqrosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); triosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sawosc[o].freq (osc_freq1[o].value () * Math.pow(10, 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) % 5 => filter_sel[f]; if (filter_sel[f] == 0) { node[filter_in[f]] =< resonz[f]; node[filter_input[f].value () $ int] => lpf[f]; resonz[f] =< node[filter_out[f]]; lpf[f] => node[filter_output[f].value () $ int]; filter_label[f].name ("LPF " + f); } if (filter_sel[f] == 1) { node[filter_in[f]] =< lpf[f]; node[filter_input[f].value () $ int] => bpf[f]; lpf[f] =< node[filter_out[f]]; bpf[f] => node[filter_output[f].value () $ int]; filter_label[f].name ("BPF " + f); } if (filter_sel[f] == 2) { node[filter_in[f]] =< bpf[f]; node[filter_input[f].value () $ int] => hpf[f]; bpf[f] =< node[filter_out[f]]; hpf[f] => node[filter_output[f].value () $ int]; filter_label[f].name ("HPF " + f); } if (filter_sel[f] == 3) { node[filter_in[f]] =< hpf[f]; node[filter_input[f].value () $ int] => brf[f]; hpf[f] =< node[filter_out[f]]; brf[f] => node[filter_output[f].value () $ int]; filter_label[f].name ("BRF " + f); } if (filter_sel[f] == 4) { node[filter_in[f]] =< brf[f]; node[filter_input[f].value () $ int] => resonz[f]; brf[f] =< node[filter_out[f]]; resonz[f] => node[filter_output[f].value () $ int]; filter_label[f].name ("ResonZ " + 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) { node[filter_in[f]] =< lpf[f]; node[filter_input[f].value () $ int] => lpf[f]; } if (filter_sel[f] == 1) { node[filter_in[f]] =< bpf[f]; node[filter_input[f].value () $ int] => bpf[f]; } if (filter_sel[f] == 2) { node[filter_in[f]] =< hpf[f]; node[filter_input[f].value () $ int] => hpf[f]; } if (filter_sel[f] == 3) { node[filter_in[f]] =< brf[f]; node[filter_input[f].value () $ int] => brf[f]; } if (filter_sel[f] == 4) { node[filter_in[f]] =< resonz[f]; node[filter_input[f].value () $ int] => resonz[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] =< node[filter_out[f]]; lpf[f] => node[filter_output[f].value () $ int]; } if (filter_sel[f] == 1) { bpf[f] =< node[filter_out[f]]; bpf[f] => node[filter_output[f].value () $ int]; } if (filter_sel[f] == 2) { hpf[f] =< node[filter_out[f]]; hpf[f] => node[filter_output[f].value () $ int]; } if (filter_sel[f] == 3) { brf[f] =< node[filter_out[f]]; brf[f] => node[filter_output[f].value () $ int]; } if (filter_sel[f] == 4) { resonz[f] =< node[filter_out[f]]; resonz[f] => node[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 wahwah slider on filters function void filter_wahwah_adj (int f) { while (true) { filter_wahwah[f] => now; filter_wahwah[f].value () $ int => filter_wah[f]; } } for (0 => int f; f < num_filters; f++) { spork ~ filter_wahwah_adj (f); } // shred to constantly adjust wahwah frequency on filters function void filter_wahwah_freq_adj (int f) { while (true) { if (filter_wah[f] > 0) { lpf[f].freq (node[filter_wah[f]].last ()); bpf[f].freq (node[filter_wah[f]].last ()); hpf[f].freq (node[filter_wah[f]].last ()); brf[f].freq (node[filter_wah[f]].last ()); resonz[f].freq (node[filter_wah[f]].last ()); } else { lpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); bpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); hpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); brf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); resonz[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); } clock_period => now; } } for (0 => int f; f < num_filters; f++) { spork ~ filter_wahwah_freq_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 ()); brf[f].gain (filter_gain[f].value ()); resonz[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; if (filter_wah[f] == 0) { lpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); bpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); hpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); brf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); resonz[f].freq (filter_freq1[f].value () * Math.pow(10, 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; if (filter_wah[f] == 0) { lpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); bpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); hpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); brf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); resonz[f].freq (filter_freq1[f].value () * Math.pow(10, 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 ()); brf[f].Q (filter_q[f].value ()); resonz[f].Q (filter_q[f].value ()); } } for (0 => int f; f < num_filters; f++) { spork ~ filter_q_adj (f); } // shred for resetting the Q of the filters to kill noisy resonance function void filter_reset_adj () { while (true) { filter_reset => now; if (filter_reset.state ()) { for (0 => int f; f < num_filters; f++) { lpf[f].Q (0); bpf[f].Q (0); hpf[f].Q (0); brf[f].Q (0); } } else { for (0 => int f; f < num_filters; f++) { lpf[f].Q (filter_q[f].value ()); bpf[f].Q (filter_q[f].value ()); hpf[f].Q (filter_q[f].value ()); brf[f].Q (filter_q[f].value ()); } } } } spork ~ filter_reset_adj (); // 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) { node[delay_in[d]] =< delayl[d]; node[delay_input[d].value () $ int] => delay[d]; delayl[d] =< node[delay_out[d]]; delay[d] => node[delay_output[d].value () $ int]; delay_label[d].name ("Delay " + d); } if (delay_sel[d] == 1) { node[delay_in[d]] =< delay[d]; node[delay_input[d].value () $ int] => delaya[d]; delay[d] =< node[delay_out[d]]; delaya[d] => node[delay_output[d].value () $ int]; delay_label[d].name ("DelayA " + d); } if (delay_sel[d] == 2) { node[delay_in[d]] =< delaya[d]; node[delay_input[d].value () $ int] => delayl[d]; delaya[d] =< node[delay_out[d]]; delayl[d] => node[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) { node[delay_in[d]] =< delay[d]; node[delay_input[d].value () $ int] => delay[d]; } if (delay_sel[d] == 1) { node[delay_in[d]] =< delaya[d]; node[delay_input[d].value () $ int] => delaya[d]; } if (delay_sel[d] == 2) { node[delay_in[d]] =< delayl[d]; node[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] =< node[delay_out[d]]; delay[d] => node[delay_output[d].value () $ int]; } if (delay_sel[d] == 1) { delaya[d] =< node[delay_out[d]]; delaya[d] => node[delay_output[d].value () $ int]; } if (delay_sel[d] == 2) { delayl[d] =< node[delay_out[d]]; delayl[d] => node[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 for 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); delaya[d].delay (delay_dur[d].value () :: ms); delayl[d].delay (delay_dur[d].value () :: ms); } } for (0 => int d; d < num_delays; d++) { spork ~ delay_dur_adj (d); } // shreds to watch the ugen buttons and sliders of reverbs // reverb label button function void reverb_label_adj (int r) { while (true) { reverb_label[r] => now; if (reverb_label[r].state ()) { (reverb_sel[r] + 1) % 3 => reverb_sel[r]; if (reverb_sel[r] == 0) { node[reverb_in[r]] =< prcrev[r]; node[reverb_input[r].value () $ int] => jcrev[r]; prcrev[r] =< node[reverb_out[r]]; jcrev[r] => node[reverb_output[r].value () $ int]; reverb_label[r].name ("JCRev " + r); } if (reverb_sel[r] == 1) { node[reverb_in[r]] =< jcrev[r]; node[reverb_input[r].value () $ int] => nrev[r]; jcrev[r] =< node[reverb_out[r]]; nrev[r] => node[reverb_output[r].value () $ int]; reverb_label[r].name ("NRev " + r); } if (reverb_sel[r] == 2) { node[reverb_in[r]] =< nrev[r]; node[reverb_input[r].value () $ int] => prcrev[r]; nrev[r] =< node[reverb_out[r]]; prcrev[r] => node[reverb_output[r].value () $ int]; reverb_label[r].name ("PRCRev " + r); } } } } for (0 => int r; r < num_reverbs; r++) { spork ~ reverb_label_adj (r); } // shred for input node slider on reverbs function void reverb_input_adj (int r) { while (true) { reverb_input[r] => now; if (reverb_sel[r] == 0) { node[reverb_in[r]] =< jcrev[r]; node[reverb_input[r].value () $ int] => jcrev[r]; } if (reverb_sel[r] == 1) { node[reverb_in[r]] =< nrev[r]; node[reverb_input[r].value () $ int] => nrev[r]; } if (reverb_sel[r] == 2) { node[reverb_in[r]] =< prcrev[r]; node[reverb_input[r].value () $ int] => prcrev[r]; } reverb_input[r].value () $ int => reverb_in[r]; } } for (0 => int r; r < num_reverbs; r++) { spork ~ reverb_input_adj (r); } // shred for output node slider on reverbs function void reverb_output_adj (int r) { while (true) { reverb_output[r] => now; if (reverb_sel[r] == 0) { jcrev[r] =< node[reverb_out[r]]; jcrev[r] => node[reverb_output[r].value () $ int]; } if (reverb_sel[r] == 1) { nrev[r] =< node[reverb_out[r]]; nrev[r] => node[reverb_output[r].value () $ int]; } if (reverb_sel[r] == 2) { prcrev[r] =< node[reverb_out[r]]; prcrev[r] => node[reverb_output[r].value () $ int]; } reverb_output[r].value () $ int => reverb_out[r]; } } for (0 => int r; r < num_reverbs; r++) { spork ~ reverb_output_adj (r); } // shred for mix slider on reverbs function void reverb_mix_adj (int r) { while (true) { reverb_mix[r] => now; jcrev[r].mix (reverb_mix[r].value ()); nrev[r].mix (reverb_mix[r].value ()); prcrev[r].mix (reverb_mix[r].value ()); } } for (0 => int r; r < num_reverbs; r++) { spork ~ reverb_mix_adj (r); } // shreds to watch ugen buttons and sliders of counter view // shred for input node slider on counters function void counter_input_adj (int c) { while (true) { counter_input[c] => now; counter_input[c].value () $ int => counter_in[c]; } } for (0 => int c; c < num_counters; c++) { spork ~ counter_input_adj (c); } // shred for output node slider on counters function void counter_output_adj (int c, int b) { while (true) { counter_output[c][b] => now; if (counter_out[c][b] > 0) { counter_step[c][b] =< node[counter_out[c][b]]; } if (counter_output[c][b].value () > 0) { counter_step[c][b] => node[counter_output[c][b].value () $ int]; } counter_output[c][b].value () $ int => counter_out[c][b]; } } for (0 => int c; c < num_counters; c++) { for (0 => int b; b < num_bits; b++) { spork ~ counter_output_adj (c, b); } } // shred to update the pk2pk button on counters function void counter_pk2pk_adj (int c) { while (true) { counter_pk2pk[c] => now; if (counter_pk2pk[c].state ()) { counter_pk2pk[c].name ("-1 to 1"); } else { counter_pk2pk[c].name ("0 to 1"); } } } for (0 => int c; c < num_counters; c++) { spork ~ counter_pk2pk_adj (c); } // shred to count the counts and output them function void counter_adj (int c) { 0 => int count; int direction; Math.pow(2, num_bits) $ int => int count_limit; float bit_values[num_bits]; int shift_register; while (true) { // find the current count direction if (counter_in[c] > 0) { if (node[counter_in[c]].last () > 0) { // if input is logic 1 1 => direction; } else { -1 => direction; } } else { 1 => direction; } direction +=> count; // increment / decrement the counter // check for down count rollover if (count < 0) { count_limit +=> count; } // check for up count rollover count % count_limit => count; // counter is updated, now obtain the bit values count => shift_register; for (0 => int b; b < num_bits; b++) { shift_register % 2 => bit_values[b]; shift_register >> 1 => shift_register; } // set the bit values according to the pk2pk button if (counter_pk2pk[c].state ()) { for (0 => int b; b < num_bits; b++) { 2 * bit_values[b] - 1 => bit_values[b]; // change to (-1, 1) logic levels } } // apply the bit values to the Step ugens for (0 => int b; b < num_bits; b++) { counter_step[c][b].next (bit_values[b]); } note_period => now; // wait one note period between counts } } for (0 => int c; c < num_counters; c++) { spork ~ counter_adj (c); } // shreds to watch ugen buttons and sliders of envelope view // shred for input node slider on envelopes function void envelope_input_adj (int e) { while (true) { envelope_input[e] => now; node[envelope_in[e]] =< envelope[e]; node[envelope_input[e].value () $ int] => envelope[e]; envelope_input[e].value () $ int => envelope_in[e]; } } for (0 => int e; e < num_envelopes; e++) { spork ~ envelope_input_adj (e); } // shred for output node slider on envelopes function void envelope_output_adj (int e) { while (true) { envelope_output[e] => now; envelope[e] =< node[envelope_out[e]]; envelope[e] => node[envelope_output[e].value () $ int]; envelope_output[e].value () $ int => envelope_out[e]; } } for (0 => int e; e < num_envelopes; e++) { spork ~ envelope_output_adj (e); } // shred for trigger node slider on envelopes function void envelope_trigger_adj (int e) { while (true) { envelope_trigger[e] => now; envelope_trigger[e].value () $ int => envelope_trig[e]; } } for (0 => int e; e < num_envelopes; e++) { spork ~ envelope_trigger_adj (e); } // shred to continuously monitor envelope trigger function void envelope_onoff_adj (int e) { float envelope_previous; // previous value of envelope trigger input float envelope_current; // current value of envelope trigger input while (true) { envelope_current => envelope_previous; node[envelope_trig[e]].last () => envelope_current; if ( (envelope_previous <= 0) & (envelope_current > 0) ) { envelope[e].keyOn (); } if ( (envelope_previous > 0) & (envelope_current <= 0) ) { envelope[e].keyOff (); } clock_period => now; } } for (0 => int e; e < num_envelopes; e++) { spork ~ envelope_onoff_adj (e); } // shred for rate slider on envelopes function void envelope_duration_adj (int e) { while (true) { envelope_duration[e] => now; envelope[e].duration (envelope_duration[e].value () :: second); } } for (0 => int e; e < num_envelopes; e++) { spork ~ envelope_duration_adj (e); } // shreds to watch ugen buttons and sliders of misc view // shred for output node slider on noise function void noise_output_adj () { while (true) { noise_output => now; if (noise_out > 0) { noise =< node[noise_out]; } if (noise_output.value () > 0) { noise => node[noise_output.value () $ int]; } noise_output.value () $ int => noise_out; } } spork ~ noise_output_adj (); // shred for gain slider on noise function void noise_gain_adj () { while (true) { noise_gain => now; noise.gain (noise_gain.value ()); } } spork ~ noise_gain_adj (); // shred for input node slider on pitshift function void pitshift_input_adj () { while (true) { pitshift_input => now; node[pitshift_in] =< pitshift; node[pitshift_input.value () $ int] => pitshift; pitshift_input.value () $ int => pitshift_in; } } spork ~ pitshift_input_adj (); // shred for output node slider on pitshift function void pitshift_output_adj () { while (true) { pitshift_output => now; pitshift =< node[pitshift_out]; pitshift => node[pitshift_output.value () $ int]; pitshift_output.value () $ int => pitshift_out; } } spork ~ pitshift_output_adj (); // shred for mix slider on pitshift function void pitshift_mix_adj () { while (true) { pitshift_mix => now; pitshift.mix (pitshift_mix.value ()); } } spork ~ pitshift_mix_adj (); // shred for shift slider on pitshift function void pitshift_shift_adj () { while (true) { pitshift_shift => now; pitshift.shift (pitshift_shift.value ()); } } spork ~ pitshift_shift_adj (); // rect label button function void rect_label_adj (int r) { while (true) { rect_label[r] => now; if (rect_label[r].state ()) { (rect_sel[r] + 1) % 2 => rect_sel[r]; if (rect_sel[r] == 0) { node[rect_in[r]] =< fullrect[r]; node[rect_input[r].value () $ int] => halfrect[r]; fullrect[r] =< node[rect_out[r]]; halfrect[r] => node[rect_output[r].value () $ int]; rect_label[r].name ("Half Rect " + r); } if (rect_sel[r] == 1) { node[rect_in[r]] =< halfrect[r]; node[rect_input[r].value () $ int] => fullrect[r]; halfrect[r] =< node[rect_out[r]]; fullrect[r] => node[rect_output[r].value () $ int]; rect_label[r].name ("Full Rect " + r); } } } } for (0 => int r; r < num_rects; r++) { spork ~ rect_label_adj (r); } // shred for input node slider on rects function void rect_input_adj (int r) { while (true) { rect_input[r] => now; if (rect_sel[r] == 0) { node[rect_in[r]] =< halfrect[r]; node[rect_input[r].value () $ int] => halfrect[r]; } if (rect_sel[r] == 1) { node[rect_in[r]] =< fullrect[r]; node[rect_input[r].value () $ int] => fullrect[r]; } rect_input[r].value () $ int => rect_in[r]; } } for (0 => int r; r < num_rects; r++) { spork ~ rect_input_adj (r); } // shred for output node slider on rects function void rect_output_adj (int r) { while (true) { rect_output[r] => now; if (rect_sel[r] == 0) { halfrect[r] =< node[rect_out[r]]; halfrect[r] => node[rect_output[r].value () $ int]; } if (rect_sel[r] == 1) { fullrect[r] =< node[rect_out[r]]; fullrect[r] => node[rect_output[r].value () $ int]; } rect_output[r].value () $ int => rect_out[r]; } } for (0 => int r; r < num_rects; r++) { spork ~ rect_output_adj (r); } // shred for input node slider on zerox function void zerox_input_adj (int z) { while (true) { zerox_input[z] => now; node[zerox_in[z]] =< zerox[z]; node[zerox_input[z].value () $ int] => zerox[z]; zerox_input[z].value () $ int => zerox_in[z]; } } for (0 => int z; z < num_zerox; z++) { spork ~ zerox_input_adj (z); } // shred for output node slider on zerox function void zerox_output_adj (int z) { while (true) { zerox_output[z] => now; zerox[z] =< node[zerox_out[z]]; zerox[z] => node[zerox_output[z].value () $ int]; zerox_output[z].value () $ int => zerox_out[z]; } } for (0 => int z; z < num_zerox; z++) { spork ~ zerox_output_adj (z); } // shreds to watch ugen buttons and sliders of kbd view // shred for output node slider on kbd function void kbd_output_adj () { while (true) { kbd_output => now; kbd_env =< node[kbd_out]; kbd_env => node[kbd_output.value () $ int]; kbd_output.value () $ int => kbd_out; } } spork ~ kbd_output_adj (); // shred for monitoring key presses function void kbd_note_adj () { while (true) { hid => now; // wait for a key press while (hid.recv (hidmsg)) { // while new keys are in queue if (hidmsg.isButtonDown ()) { // check for button down message Std.mtof ((kbd_base_note.value () $ int) + hidmsg.which) => kbd.freq; // set kbd freq 1 => kbd.gain; // turn keyboard source on kbd_env.keyOn (); // turn on envelope note_period - kbd_env_dur => now; // wait for note to play kbd_env.keyOff (); // run off envelope kbd_env_dur => now; // allow envelope to decay } else { 0 => kbd.gain; // turn keyboard source off } } } } spork ~ kbd_note_adj (); // shreds to watch the ugen buttons and sliders of logic gates // logic gate label button function void logic_gate_label_adj (int g) { while (true) { logic_gate_label[g] => now; if (logic_gate_label[g].state ()) { (logic_gate_sel[g] + 1) % 6 => logic_gate_sel[g]; if (logic_gate_sel[g] == 0) { logic_gate_label[g].name ("AND " + g); } if (logic_gate_sel[g] == 1) { logic_gate_label[g].name ("OR " + g); } if (logic_gate_sel[g] == 2) { logic_gate_label[g].name ("XOR " + g); } if (logic_gate_sel[g] == 3) { logic_gate_label[g].name ("NAND " + g); } if (logic_gate_sel[g] == 4) { logic_gate_label[g].name ("NOR " + g); } if (logic_gate_sel[g] == 5) { logic_gate_label[g].name ("XNOR " + g); } } } } for (0 => int g; g < num_logic_gates; g++) { spork ~ logic_gate_label_adj (g); } // shred for output node slider on logic gates function void logic_gate_output_adj (int g) { while (true) { logic_gate_output[g] => now; logic_gate[g] =< node[logic_gate_out[g]]; logic_gate[g] => node[logic_gate_output[g].value () $ int]; logic_gate_output[g].value () $ int => logic_gate_out[g]; } } for (0 => int g; g < num_logic_gates; g++) { spork ~ logic_gate_output_adj (g); } // shred to continuously monitor logic gates function void logic_gate_adj (int g) { int value; while (true) { // loop through the evaluation many times to allow signals to propagate for (0 => int propagate; propagate < num_logic_gates; propagate ++) { if ((logic_gate_sel[g] % 3) == 0) { // AND gate or NAND gate 1 => value; for (0 => int i; i < num_logic_inputs; i++) { if (node[logic_gate_input[g][i].value () $ int].last () > 0) { value & 1 => value; } else { value & 0 => value; } } } if ((logic_gate_sel[g] % 3) == 1) { // OR gate or NOR gate 0 => value; for (0 => int i; i < num_logic_inputs; i++) { if (node[logic_gate_input[g][i].value () $ int].last () > 0) { value | 1 => value; } else { value | 0 => value; } } } if ((logic_gate_sel[g] % 3) == 2) { // XOR gate or XNOR gate 0 => value; for (0 => int i; i < num_logic_inputs; i++) { if (node[logic_gate_input[g][i].value () $ int].last () > 0) { value ^ 1 => value; } else { value ^ 0 => value; } } } if (logic_gate_sel[g] > 2) { // gate with inverted output if (value > 0) { 0 => value; } else { 1 => value; } } // set the step output value logic_gate[g].next (value); num_nodes::samp => now; } // wait one clock cycle, minus the time spent in the previous loop clock_period - (num_nodes * num_logic_gates)::samp => now; } } for (0 => int g; g < num_logic_gates; g++) { spork ~ logic_gate_adj (g); } // shreds to watch the ugen buttons and sliders of dynos // dyno label button function void dyno_label_adj (int d) { while (true) { dyno_label[d] => now; if (dyno_label[d].state ()) { (dyno_sel[d] + 1) % 4 => dyno_sel[d]; if (dyno_sel[d] == 0) { dyno_label[d].name ("Limiter " + d); dyno[d].limit (); } if (dyno_sel[d] == 1) { dyno_label[d].name ("Compressor " + d); dyno[d].compress (); } if (dyno_sel[d] == 2) { dyno_label[d].name ("Expander " + d); dyno[d].expand (); } if (dyno_sel[d] == 3) { dyno_label[d].name ("Noise Gate " + d); dyno[d].gate (); } } } } for (0 => int d; d < num_dynos; d++) { spork ~ dyno_label_adj (d); } // shred for input node slider on dynos function void dyno_input_adj (int d) { while (true) { dyno_input[d] => now; node[dyno_in[d]] =< dyno[d]; node[dyno_input[d].value () $ int] => dyno[d]; dyno_input[d].value () $ int => dyno_in[d]; } } for (0 => int d; d < num_dynos; d++) { spork ~ dyno_input_adj (d); } // shred for output node slider on dynos function void dyno_output_adj (int d) { while (true) { dyno_output[d] => now; dyno[d] =< node[dyno_out[d]]; dyno[d] => node[dyno_output[d].value () $ int]; dyno_output[d].value () $ int => dyno_out[d]; } } for (0 => int d; d < num_dynos; d++) { spork ~ dyno_output_adj (d); } // shreds to watch ugen buttons and sliders of echo view // shred for input node slider on echos function void echo_input_adj (int e) { while (true) { echo_input[e] => now; node[echo_in[e]] =< echo[e]; node[echo_input[e].value () $ int] => echo[e]; echo_input[e].value () $ int => echo_in[e]; } } for (0 => int e; e < num_echos; e++) { spork ~ echo_input_adj (e); } // shred for output node slider on echos function void echo_output_adj (int e) { while (true) { echo_output[e] => now; echo[e] =< node[echo_out[e]]; echo[e] => node[echo_output[e].value () $ int]; echo_output[e].value () $ int => echo_out[e]; } } for (0 => int e; e < num_echos; e++) { spork ~ echo_output_adj (e); } // shred for delay node slider on echos function void echo_delay_adj (int e) { while (true) { echo_delay[e] => now; echo[e].delay (echo_delay[e].value () :: ms); } } for (0 => int e; e < num_echos; e++) { spork ~ echo_delay_adj (e); } // shred for mix node slider on echos function void echo_mix_adj (int e) { while (true) { echo_mix[e] => now; echo[e].mix (echo_mix[e].value ()); } } for (0 => int e; e < num_echos; e++) { spork ~ echo_mix_adj (e); } // LEDs // shred to watch nodes and light LEDs function void led_adj () { while (true) { for (1 => int n; n <= num_nodes; n++) { if (node[n].last () > 0) { led_led[n-1].light (); } else { led_led[n-1].unlight (); } } note_period / 4 => now; } } spork ~ led_adj (); // patch panel function void patch_connect_adj () { while (true) { patch_connect => now; if (patch_connect.state ()) { for (0 => int nx; nx < num_nodes; nx++) { for (0 => int ny; ny < num_nodes; ny++) { if (patch_dot[nx][ny].state ()) { node[nx+1] => patch[nx][ny]; patch[nx][ny] => node[ny+1]; patch_dot[nx][ny].name ("X"); } else { node[nx+1] =< patch[nx][ny]; patch[nx][ny] =< node[ny+1]; patch_dot[nx][ny].name (""); } } } } } } spork ~ patch_connect_adj (); // lisa panel controls // shred for voice input node slider on lisa function void lisa_voice_input_adj () { while (true) { lisa_voice_input => now; lisa_voice_input.value () $ int => lisa_voice_in; } } spork ~ lisa_voice_input_adj (); // shred for rate input node slider on lisa function void lisa_rate_input_adj () { while (true) { lisa_rate_input => now; lisa_rate_input.value () $ int => lisa_rate_in; } } spork ~ lisa_rate_input_adj (); // shred to set rate for lisa function void lisa_rate_adj () { while (true) { lisa_rate => now; lisa.rate (lisa_voice.value () $ int, lisa_rate.value ()); } } spork ~ lisa_rate_adj (); // shred for clear input node slider on lisa function void lisa_clear_input_adj () { while (true) { lisa_clear_input => now; lisa_clear_input.value () $ int => lisa_clear_in; } } spork ~ lisa_clear_input_adj (); // shred for clear button on lisa function void lisa_clear_adj () { while (true) { lisa_clear => now; if (lisa_clear.state ()) { lisa.clear (); } } } spork ~ lisa_clear_adj (); // shred for record input node slider on lisa function void lisa_record_input_adj () { while (true) { lisa_record_input => now; lisa_record_input.value () $ int => lisa_record_in; } } spork ~ lisa_record_input_adj (); // shred for play input node slider on lisa function void lisa_play_input_adj () { while (true) { lisa_play_input => now; lisa_play_input.value () $ int => lisa_play_in; } } spork ~ lisa_play_input_adj (); // shred for record button on lisa function void lisa_record_adj () { while (true) { lisa_record => now; if (lisa_record.state ()) { lisa.recPos (0::second); lisa.record (1); } else { lisa.record (0); } } } spork ~ lisa_record_adj (); // shred for play button on lisa function void lisa_play_adj () { while (true) { lisa_play => now; if (lisa_play.state ()) { lisa.playPos (lisa_voice.value () $ int, 0::second); lisa.rampUp (lisa_voice.value () $ int, lisa_ramp_duration); } else { lisa.rampDown (lisa_voice.value () $ int, lisa_ramp_duration); } } } spork ~ lisa_play_adj (); // shred for backward button on lisa function void lisa_backward_adj () { while (true) { lisa_backward => now; if (lisa_backward.state ()) { lisa.bi (lisa_voice.value () $ int, 1); } else { lisa.bi (lisa_voice.value () $ int, 0); } } } spork ~ lisa_backward_adj (); // shred for input node slider on lisa function void lisa_input_adj () { while (true) { lisa_input => now; if (lisa_in > 0) { node[lisa_in] =< lisa; } if (lisa_input.value () > 0) { node[lisa_input.value () $ int] => lisa; } lisa_input.value () $ int => lisa_in; } } spork ~ lisa_input_adj (); // shred for output node slider on lisa function void lisa_output_adj () { while (true) { lisa_output => now; if (lisa_out >0) { lisa =< node[lisa_out]; } if (lisa_output.value () > 0) { lisa => node[lisa_output.value () $ int]; } lisa_output.value () $ int => lisa_out; } } spork ~ lisa_output_adj (); // shred to monitor control inputs and behave accordingly for lisa function void lisa_adj () { float voice, clear, record, play, backward; // get previous values of control inputs float previous_clear, previous_record, previous_play, previous_backward; if (lisa_clear_in) { node[lisa_clear_in].last () => previous_clear; } else { 0 => previous_clear; } if (lisa_record_in) { node[lisa_record_in].last () => previous_record; } else { 0 => previous_record; } if (lisa_play_in) { node[lisa_play_in].last () => previous_play; } else { 0 => previous_play; } if (lisa_backward_in) { node[lisa_backward_in].last () => previous_backward; } else { 0 => previous_backward; } while (true) { // get input values, null if connected to node 0 if (lisa_voice_in) { node[lisa_voice_in].last () => voice; } else { 0 => voice; } if (lisa_clear_in) { node[lisa_clear_in].last () => clear; } else { 0 => clear; } if (lisa_record_in) { node[lisa_record_in].last () => record; } else { 0 => record; } if (lisa_play_in) { node[lisa_play_in].last () => play; } else { 0 => play; } if (lisa_backward_in) { node[lisa_backward_in].last () => backward; } else { 0 => backward; } // check for a logic 0 to logic 1 transition on clear input if ( (node[lisa_clear_in].last () > 0) & (previous_clear <= 0) ) { // call the lisa clear method lisa.clear (); } // make sure the record button is not pressed if (!lisa_record.state ()) { // check for a logic 0 to logic 1 transition on record input if ( (node[lisa_record_in].last () > 0) & (previous_record <= 0) ) { // set the record position to the beginning lisa.recPos (0::second); // call the lisa record method lisa.record (1); <<<"record on">>>; } // check for a logic 1 to logic 0 transition on record input if ( (node[lisa_record_in].last () <= 0) & (previous_record > 0) ) { // call the lisa record method lisa.record (0); <<<"record off">>>; } } // make sure the play button is not pressed if (!lisa_play.state ()) { // check for a logic 0 to logic 1 transition on play input if ( (node[lisa_play_in].last () > 0) & (previous_play <= 0) ) { // set the play position to the beginning lisa.playPos (node[lisa_voice_in].last () $ int, 0::second); // call the lisa play method lisa.rampUp (node[lisa_voice_in].last () $ int, lisa_ramp_duration); <<<"play on">>>; } // check for a logic 1 to logic 0 transition on play input if ( (node[lisa_play_in].last () <= 0) & (previous_play > 0) ) { // call the lisa play method lisa.rampDown (node[lisa_voice_in].last () $ int, lisa_ramp_duration); <<<"play off">>>; } } // make sure the backward button is not pressed if (!lisa_backward.state ()) { // check for a logic 0 to logic 1 transition on backward input if ( (node[lisa_backward_in].last () > 0) & (previous_backward <= 0) ) { // call the lisa backward method lisa.bi (node[lisa_voice_in].last () $ int, 1); } // check for a logic 1 to logic 0 transition on backward input if ( (node[lisa_backward_in].last () <= 0) & (previous_backward > 0) ) { // call the lisa play method lisa.bi (node[lisa_voice_in].last () $ int, 0); } } // save previous values of control inputs clear => previous_clear; record => previous_record; play => previous_play; backward => previous_backward; // time delay note_period => now; } } spork ~ lisa_adj (); // initialization of instruments function void initialize () { // initialize clock frequency 1::second / main_clock_freq.value () => clock_period; // initialize note frequency 1::second / main_note_freq.value () => note_period; // initialize main volume master_left.gain (main_volume.value ()); master_right.gain (main_volume.value ()); // initialize nodes for (1 => int n; n <= num_nodes; n++) { node[n].gain (node_gain[n].value ()); // initialize the gain boosts 1 => node_boost_val[n]; } // initialize gains for (0 => int g; g < num_gains; g++) { node[g].gain (gain_gain[g].value ()); } // initialize oscillators for (0 => int o; o < num_osc; o++) { phasor[o].gain (osc_gain[o].value ()); phasor[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); phasor[o].phase (osc_phase[o].value ()); sinosc[o].gain (osc_gain[o].value ()); sinosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sinosc[o].phase (osc_phase[o].value ()); pulseosc[o].gain (osc_gain[o].value ()); pulseosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); pulseosc[o].phase (osc_phase[o].value ()); sqrosc[o].gain (osc_gain[o].value ()); sqrosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sqrosc[o].phase (osc_phase[o].value ()); triosc[o].gain (osc_gain[o].value ()); triosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); triosc[o].phase (osc_phase[o].value ()); sawosc[o].gain (osc_gain[o].value ()); sawosc[o].freq (osc_freq1[o].value () * Math.pow(10, osc_freq2[o].value ())); sawosc[o].phase (osc_phase[o].value ()); } // initialize filters for (0 => int f; f < num_filters; f++) { lpf[f].gain (filter_gain[f].value ()); lpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); lpf[f].Q (filter_q[f].value ()); bpf[f].gain (filter_gain[f].value ()); bpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); bpf[f].Q (filter_q[f].value ()); hpf[f].gain (filter_gain[f].value ()); hpf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); hpf[f].Q (filter_q[f].value ()); brf[f].gain (filter_gain[f].value ()); brf[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); brf[f].Q (filter_q[f].value ()); resonz[f].gain (filter_gain[f].value ()); resonz[f].freq (filter_freq1[f].value () * Math.pow(10, filter_freq2[f].value ())); resonz[f].Q (filter_q[f].value ()); } // initialize delays for (0 => int d; d < num_delays; d++) { delay[d].gain (delay_gain[d].value ()); delay[d].max (100::ms); delay[d].delay (delay_dur[d].value () :: ms); delaya[d].gain (delay_gain[d].value ()); delaya[d].max (100::ms); delaya[d].delay (delay_dur[d].value () :: ms); delayl[d].gain (delay_gain[d].value ()); delayl[d].max (100::ms); delayl[d].delay (delay_dur[d].value () :: ms); } // initialize reverbs for (0 => int r; r < num_reverbs; r++) { jcrev[r].mix (reverb_mix[r].value ()); nrev[r].mix (reverb_mix[r].value ()); prcrev[r].mix (reverb_mix[r].value ()); } // initialize envelopes for (0 => int e; e < num_envelopes; e++) { envelope[e].duration (envelope_duration[e].value () :: second); } // initialize misc view objects noise.gain (noise_gain.value ()); pitshift.mix (pitshift_mix.value ()); pitshift.shift (pitshift_shift.value ()); // initialize keyboard if (!hid.openKeyboard (kbd_device)) { 1 => exit; } <<<"keyboard " + hid.name () + " ready", "">>>; 0 => kbd.gain; // turn keyboard source off kbd_env.duration (kbd_env_dur); // set keyboard envelope duration // initialize echos for (0 => int e; e < num_echos; e++) { echo[e].max (1::second); echo[e].delay (echo_delay[e].value () :: ms); } // initialize patch panel for (0 => int nx; nx < num_nodes; nx++) { for (0 => int ny; ny < num_nodes; ny++) { patch[nx][ny].gain (1); } } // initialize lisa lisa.duration (lisa_buffer_duration); lisa.maxVoices (lisa_max_voices); lisa.clear (); // connect sinosc[0] to DAC node so Synth Lab starts up making sound //if (num_osc > 0) { // osc_output[0].value (num_nodes); // sinosc[0] => node[osc_output[0].value () $ int]; //} } initialize (); // loop until self-destruct signal is received while (true) { note_period => now; if (exit) { // self destruct activated break; } } // oops! check to see if we exited while recording and if so close the output file if (main_record.state ()) { wvout.closeFile (); } // pop up an exit window with a goodbye message (why not?) MAUI_View self_destruct_view; self_destruct_view.size (300, 50); self_destruct_view.position (screen_width / 2 - 300 / 2, screen_height /2 - 50 / 2); self_destruct_view.name ("Synth Lab Exiting"); self_destruct_view.display (); MAUI_Button self_destruct_message; // self destruct message button self_destruct_message.pushType (); self_destruct_message.size (300, 60); self_destruct_message.position (0, 0); self_destruct_message.name ("May the force be with you!"); self_destruct_view.addElement (self_destruct_message); // self destruct warning! make a fun sound just before closing the panels Phasor exit_phasor => SinOsc exit_sinosc => Gain exit_gain => Dyno exit_dyno => dac; dac => Delay exit_delay => exit_gain; exit_phasor.gain (1000); exit_phasor.freq (2); exit_gain.gain (2); exit_dyno.limit (); exit_delay.gain (1); exit_delay.max (200::ms); exit_delay.delay (50::ms); 1.5::second => now; // ending program due to self-destruct button press, so destroy the GUI lisa_view.destroy (); patch_view.destroy (); led_view.destroy (); echo_view.destroy (); dyno_view.destroy (); logic_gate_view.destroy (); kbd_view.destroy (); misc_view.destroy (); envelope_view.destroy (); counter_view.destroy (); reverb_view.destroy (); delay_view.destroy (); filter_view.destroy (); osc_view.destroy (); gain_view.destroy (); node_view.destroy (); main_view.destroy (); self_destruct_view.destroy ();