├── 01-installing-chuck-and-related-tools └── ReadMe.txt ├── 02-your-first-program-and-your-first-sound ├── hello-world.ck └── our-first-sound.ck ├── 03-viewing-sounds-with-audacity └── save-a-sound-to-disk.ck ├── 04-running-chuck-on-the-command-line └── line.ck ├── 05-the-now-keyword ├── playtime.ck └── time.ck ├── 06-loops ├── counter.ck ├── drop.ck ├── for.ck └── infinite.ck ├── 07-arrays ├── hello-array.ck ├── loop-array.ck └── pitch-array.ck ├── 08-basic-music-theory ├── falling-triads.ck └── theory.ck ├── 09-ugens-the-adsr-ugen └── ugen.ck ├── 10-functions ├── functions.ck └── multiply.ck ├── 11-reverbs-and-delays └── reverb.ck ├── 12-pan.ck ├── 12-panning-and-randomization ├── pan-end.ck └── pan-start.ck ├── 13-working-with-samples-using-the-sndbuf-ugen ├── guitar.wav ├── sndbuf-aleatoric.ck └── sndbuf-simple-reverse.ck ├── 14-if-statements ├── c-hat.wav ├── clap.wav ├── drumMachine-electro.ck ├── drumMachine-house.ck ├── kick.wav ├── o-hat.wav └── snare.wav ├── 15-shreds ├── arpeggio.ck ├── kick.ck ├── kick.wav ├── machine.ck └── reverbs.ck ├── 16-filters ├── filters-and-shreds.ck └── filters.ck ├── 17-scores ├── bass1.ck ├── bass2.ck ├── hi-hat.ck ├── kick-snare.ck ├── pad.ck ├── panning1.ck └── score.ck ├── 18-cutting-up-breaks ├── break2.wav └── breaks.ck ├── 19-oscillator-sync ├── fmVoice.ck └── lfo.ck ├── 20-classes ├── BPM.ck ├── ChordProvider.ck ├── Chords.ck ├── alvin.ck ├── initialize.ck ├── score.ck ├── simon.ck └── theodore.ck ├── 21-dyno-ugen ├── dyno-example-1-stereo.ck ├── dyno-example-1.ck ├── dyno-example-2.ck └── shortBreak2.wav ├── 22-stereo-processing └── pan.ck ├── 23-subclasses ├── HATT1.wav ├── break2.wav ├── chopBuffer.ck ├── inheritance.ck ├── subclass-music.ck └── subclass.ck ├── 24-chubgraphs ├── chub1.ck ├── graph.ck ├── initialize.ck ├── stk-moog.ck ├── synthvoice.ck └── use.ck ├── 25-livecoding ├── initialize.ck ├── live.ck ├── loop.ck ├── mod.ck ├── panning.ck └── synthvoice.ck ├── 26-LiSa ├── hybrid.ck ├── lisa-ex-1.ck ├── lisa-ex-2.ck └── lisa-loop-1.ck ├── 27-events ├── event-test-1.ck ├── event-test-2.ck └── event-test-3.ck ├── 28-midi ├── midi-test-2.ck ├── midi-test-3.ck └── midi-test.ck ├── 29-the-stk └── stk-test-1.ck ├── 30-file-io ├── file-test-1.ck ├── file-test-2.ck ├── file-test-3.ck ├── file-test-4.ck ├── file-test-5.ck ├── int.txt ├── int2.txt └── lines.txt ├── 31-basic-theory-part-2 ├── chromatic.ck ├── diatonic.ck ├── fifths.ck └── random-thirds.ck ├── 32-pulse-oscillator ├── PWM.ck └── pulse-widths.ck ├── 33-file-output ├── file-output-test-1.ck ├── file-output-test-2.ck ├── file-output-test-3.ck ├── file-output-test-4.ck ├── file-output-test-4b.ck ├── file-output-test-5.ck └── file-output-test-5b.ck ├── 34-open-sound-control ├── osc-client-test-1.ck ├── osc-server-test-1.ck └── osc-transmit-test-1.ck ├── 35-chord-functions └── make-chord-examples.ck ├── 36-equal-temperament ├── equal1.ck ├── equal2.ck ├── equal3.ck ├── equal4.ck └── guitar.wav ├── 37-fancy-sampler ├── sampler-test-1.ck ├── sampler-test-2.ck ├── sampler-test-3.ck ├── sampler-test-4.ck ├── sampler-test-5.ck ├── sampler-test-6.ck ├── sampler-test-7.ck └── sampler-test-8.ck ├── 39-midi-clock └── midi-clock.ck ├── 40-classic-video-game-soundtrack └── SMB1-ground │ ├── chip-noise-osc.ck │ ├── chip-pulse-osc.ck │ ├── chip-tri-osc.ck │ ├── initialize.ck │ ├── noise-1.txt │ ├── noise-2.txt │ ├── noise-3.txt │ ├── noise-4.txt │ ├── noise-5.txt │ ├── p1-1.txt │ ├── p1-2.txt │ ├── p1-3.txt │ ├── p1-4.txt │ ├── p1-5.txt │ ├── p2-1.txt │ ├── p2-2.txt │ ├── p2-3.txt │ ├── p2-4.txt │ ├── p2-5.txt │ ├── score.ck │ ├── tri-1.txt │ ├── tri-2.txt │ ├── tri-3.txt │ ├── tri-4.txt │ └── tri-5.txt ├── 41-constructors-and-help ├── doc-test.ck ├── filtered-osc.ck ├── sine-alternate.ck ├── sine-example.ck ├── test1.ck ├── test2.ck ├── test3.ck ├── test4.ck └── test5.ck ├── README.md ├── misc ├── laser-result.wav ├── laser-single.wav └── pewpew.ck ├── sounds ├── 14-drum-machine-sounds.zip └── guitar.wav └── ugen.ck /01-installing-chuck-and-related-tools/ReadMe.txt: -------------------------------------------------------------------------------- 1 | There's no code in this file because we haven't learned how to write it yet! 2 | 3 | Download ChucK from: 4 | https://chuck.stanford.edu/ 5 | 6 | Download VS Code from: 7 | https://code.visualstudio.com/ 8 | 9 | Download Audacity from: 10 | https://www.audacityteam.org/ -------------------------------------------------------------------------------- /02-your-first-program-and-your-first-sound/hello-world.ck: -------------------------------------------------------------------------------- 1 | "Clint" => string name; 2 | 3 | <<< "Hello", name >>>; -------------------------------------------------------------------------------- /02-your-first-program-and-your-first-sound/our-first-sound.ck: -------------------------------------------------------------------------------- 1 | <<< "Our first sound" >>>; 2 | 3 | SinOsc osc => dac; 4 | 5 | 440 => osc.freq; 6 | 0.5 => osc.gain; 7 | 8 | 1::second => now; -------------------------------------------------------------------------------- /03-viewing-sounds-with-audacity/save-a-sound-to-disk.ck: -------------------------------------------------------------------------------- 1 | <<< "Saving a sound to disk..." >>>; 2 | 3 | SinOsc osc => dac => WvOut waveOut => blackhole; 4 | 5 | "test.wav" => waveOut.wavFilename; 6 | 7 | 440 => osc.freq; 8 | 0.5 => osc.gain; 9 | 10 | 1::second => now; -------------------------------------------------------------------------------- /04-running-chuck-on-the-command-line/line.ck: -------------------------------------------------------------------------------- 1 | <<< "This is on the command line!" >>>; 2 | 3 | SinOsc osc => dac; 4 | 5 | 440 => osc.freq; 6 | 0.5 => osc.gain; 7 | 8 | 1::second => now; -------------------------------------------------------------------------------- /05-the-now-keyword/playtime.ck: -------------------------------------------------------------------------------- 1 | 1::second / 2 => dur beat; 2 | 3 | <<< "Start time:", now >>>; 4 | 5 | SinOsc osc => dac; 6 | 7 | 200 => osc.freq; 8 | 0.5 => osc.gain; 9 | 10 | <<< "Time:", now, "Osc frequency:", osc.freq() >>>; 11 | beat => now; 12 | 13 | 300 => osc.freq; 14 | 15 | <<< "Time:", now, "Osc frequency:", osc.freq() >>>; 16 | beat / 2 => now; 17 | 18 | 400 => osc.freq; 19 | 20 | <<< "Time:", now, "Osc frequency:", osc.freq() >>>; 21 | beat / 2 => now; 22 | 23 | <<< "End Time:", now >>>; -------------------------------------------------------------------------------- /05-the-now-keyword/time.ck: -------------------------------------------------------------------------------- 1 | <<< "Start" >>>; 2 | <<< now >>>; 3 | 4 | 1::second => dur beat; 5 | beat => now; 6 | 7 | <<< now >>>; 8 | <<< "End" >>>; -------------------------------------------------------------------------------- /06-loops/counter.ck: -------------------------------------------------------------------------------- 1 | 1 => int counter; 2 | 3 | while(counter <= 10) 4 | { 5 | 500::ms => now; 6 | <<< counter >>>; 7 | counter + 1 => counter; 8 | } -------------------------------------------------------------------------------- /06-loops/drop.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => dac; 2 | 0.5 => osc.gain; 3 | 4 | for( 1000 => int i; i > 0; i--) 5 | { 6 | i => osc.freq; 7 | <<< i >>>; 8 | 4::ms => now; 9 | } -------------------------------------------------------------------------------- /06-loops/for.ck: -------------------------------------------------------------------------------- 1 | for(1 => int i; i <= 10; i++) 2 | { 3 | <<< i >>>; 4 | 100::ms => now; 5 | } -------------------------------------------------------------------------------- /06-loops/infinite.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => dac; 2 | 3 | 0.5 => osc.gain; 4 | 5 | while(true) 6 | { 7 | 440 => osc.freq; 8 | 50::ms => now; 9 | 660 => osc.freq; 10 | 50::ms => now; 11 | 880 => osc.freq; 12 | 50::ms => now; 13 | } -------------------------------------------------------------------------------- /07-arrays/hello-array.ck: -------------------------------------------------------------------------------- 1 | string words[2]; 2 | 3 | "Hello" => words[0]; 4 | "World!" => words[1]; 5 | 6 | <<< words[0], words[1] >>>; -------------------------------------------------------------------------------- /07-arrays/loop-array.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => dac; 2 | 0.25 => osc.gain; 3 | 4 | [ 110, 220, 440, 660, 770, 880, 1320] @=> int frequencies[]; 5 | 6 | while(true) 7 | { 8 | for(0 => int i; i < frequencies.cap(); i++) 9 | { 10 | frequencies[i] => osc.freq; 11 | 200::ms => now; 12 | } 13 | } -------------------------------------------------------------------------------- /07-arrays/pitch-array.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => dac; 2 | 0.25 => osc.gain; 3 | 4 | [60,62,64,65,67,69,71,72] @=> int pitches[]; 5 | 6 | while(true) 7 | { 8 | for(0 => int i; i < pitches.cap(); i++) 9 | { 10 | Std.mtof(pitches[i]) => osc.freq; 11 | 200::ms => now; 12 | } 13 | } -------------------------------------------------------------------------------- /08-basic-music-theory/falling-triads.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => dac; 2 | 3 | 0.5 => osc.gain; 4 | 5 | [0,4,7] @=> int major[]; 6 | [0,3,7] @=> int minor[]; 7 | 8 | 48 => int offset; 9 | int position; 10 | 11 | 25::ms => dur eighth; 12 | 0 => position; 13 | 14 | while(true) 15 | { 16 | 17 | for(48 => int i; i > 0; i--) 18 | { 19 | i => position; 20 | for(0 => int j; j < 3; j++) 21 | { 22 | Std.mtof(major[j] + offset + position) => osc.freq; 23 | eighth => now; 24 | } 25 | } 26 | 27 | } -------------------------------------------------------------------------------- /08-basic-music-theory/theory.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => dac; 2 | 3 | 0.5 => osc.gain; 4 | 5 | [0,4,7] @=> int major[]; 6 | [0,3,7] @=> int minor[]; 7 | 8 | 48 => int offset; 9 | int position; 10 | 11 | 150::ms => dur eighth; 12 | 0 => position; 13 | 14 | while(true) 15 | { 16 | 0 => position; 17 | for(0 => int i; i < 4; i++) 18 | { 19 | for(0 => int j; j < 3; j++) 20 | { 21 | Std.mtof(major[j] + offset + position) => osc.freq; 22 | eighth => now; 23 | } 24 | } 25 | 26 | -3 => position; 27 | for(0 => int i; i < 4; i++) 28 | { 29 | for(0 => int j; j < 3; j++) 30 | { 31 | Std.mtof(minor[j] + offset + position) => osc.freq; 32 | eighth => now; 33 | } 34 | } 35 | 36 | 5 => position; 37 | for(0 => int i; i < 4; i++) 38 | { 39 | for(0 => int j; j < 3; j++) 40 | { 41 | Std.mtof(major[j] + offset + position) => osc.freq; 42 | eighth => now; 43 | } 44 | } 45 | 46 | 7 => position; 47 | for(0 => int i; i < 4; i++) 48 | { 49 | for(0 => int j; j < 3; j++) 50 | { 51 | Std.mtof(major[j] + offset + position) => osc.freq; 52 | eighth => now; 53 | } 54 | } 55 | } -------------------------------------------------------------------------------- /09-ugens-the-adsr-ugen/ugen.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => ADSR env1 => dac; 2 | TriOsc osc2 => ADSR env2 => dac; 3 | 4 | 2::second => dur beat; 5 | (beat /2, beat /2, 0, 1::ms) => env1.set; 6 | (1::ms, beat / 8, 0, 1::ms) => env2.set; 7 | 8 | 0.2 => osc.gain; 9 | 0.1 => osc2.gain; 10 | 11 | [0,4,7,12] @=> int major[]; 12 | [0,3,7,12] @=> int minor[]; 13 | 14 | 48 => int offset; 15 | int position; 16 | 17 | while(true) 18 | { 19 | 0 => position; 20 | for(0 => int i; i < 4; i++) 21 | { 22 | Std.mtof(minor[0] + offset + position) => osc.freq; 23 | 1 => env1.keyOn; 24 | for(0 => int j; j < 4; j++) 25 | { 26 | Std.mtof(minor[j] + offset + position + 12) => osc2.freq; 27 | 1 => env2.keyOn; 28 | beat / 8 => now; 29 | } 30 | } 31 | 32 | -4 => position; 33 | for(0 => int i; i < 4; i++) 34 | { 35 | Std.mtof(major[0] + offset + position) => osc.freq; 36 | 1 => env1.keyOn; 37 | for(0 => int j; j < 4; j++) 38 | { 39 | Std.mtof(major[j] + offset + position + 12) => osc2.freq; 40 | 1 => env2.keyOn; 41 | beat / 8 => now; 42 | } 43 | } 44 | 45 | -2 => position; 46 | for(0 => int i; i < 4; i++) 47 | { 48 | Std.mtof(major[0] + offset + position) => osc.freq; 49 | 1 => env1.keyOn; 50 | for(0 => int j; j < 4; j++) 51 | { 52 | Std.mtof(major[j] + offset + position + 12) => osc2.freq; 53 | 1 => env2.keyOn; 54 | beat / 8 => now; 55 | } 56 | } 57 | 58 | -5 => position; 59 | for(0 => int i; i < 4; i++) 60 | { 61 | Std.mtof(major[0] + offset + position) => osc.freq; 62 | 1 => env1.keyOn; 63 | for(0 => int j; j < 4; j++) 64 | { 65 | Std.mtof(major[j] + offset + position + 12) => osc2.freq; 66 | 1 => env2.keyOn; 67 | beat / 8 => now; 68 | } 69 | } 70 | } -------------------------------------------------------------------------------- /10-functions/functions.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => ADSR env1 => dac; 2 | TriOsc osc2 => ADSR env2 => dac; 3 | 4 | 1::second => dur beat; 5 | (beat /2, beat /2, 0, 1::ms) => env1.set; 6 | (1::ms, beat / 8, 0, 1::ms) => env2.set; 7 | 8 | 0.2 => osc.gain; 9 | 0.1 => osc2.gain; 10 | 11 | [0,4,7,12] @=> int major[]; 12 | [0,3,7,12] @=> int minor[]; 13 | 14 | 48 => int offset; 15 | int position; 16 | 17 | fun void playTwoBars(int position, int chord[]) 18 | { 19 | for(0 => int i; i < 4; i++) 20 | { 21 | Std.mtof(chord[0] + offset + position) => osc.freq; 22 | 1 => env1.keyOn; 23 | for(0 => int j; j < 4; j++) 24 | { 25 | Std.mtof(chord[j] + offset + position + 12) => osc2.freq; 26 | 1 => env2.keyOn; 27 | beat / 8 => now; 28 | } 29 | } 30 | } 31 | 32 | while(true) 33 | { 34 | playTwoBars(0, minor); 35 | playTwoBars(-4, major); 36 | playTwoBars(-2, major); 37 | playTwoBars(-5, major); 38 | 39 | playTwoBars(-7, minor); 40 | playTwoBars(-2, major); 41 | playTwoBars(3, major); 42 | playTwoBars(-5, major); 43 | } 44 | 45 | -------------------------------------------------------------------------------- /10-functions/multiply.ck: -------------------------------------------------------------------------------- 1 | fun int multiply(int x, int y) 2 | { 3 | <<< "I'm in the multiply function!" >>>; 4 | return x * y; 5 | } 6 | 7 | 2 => int x; 8 | 3 => int y; 9 | <<< x, y, multiply(x,y) >>>; -------------------------------------------------------------------------------- /11-reverbs-and-delays/reverb.ck: -------------------------------------------------------------------------------- 1 | <<< "Reverbs & Delays" >>>; 2 | 3 | SinOsc osc => ADSR env1 => NRev rev1 => dac; 4 | env1 => Delay delay1 => dac; 5 | delay1 => delay1; 6 | 7 | 0.2 => rev1.mix; 8 | 9 | 0.5::second => dur beat; 10 | (1::ms, beat/8, 0, 1::ms) => env1.set; 11 | 0.25 => osc.gain; 12 | 13 | beat => delay1.max; 14 | beat /4 => delay1.delay; 15 | 0.5 => delay1.gain; 16 | 17 | [0,4,7] @=> int major[]; 18 | [0,3,7] @=> int minor[]; 19 | 20 | 60 => int offset; 21 | int position; 22 | 23 | for(0 => int i; i < 4; i++) 24 | { 25 | for(0 => int j; j < minor.cap(); j++) 26 | { 27 | Std.mtof(minor[j] + offset + position) => osc.freq; 28 | 1 => env1.keyOn; 29 | beat => now; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /12-pan.ck: -------------------------------------------------------------------------------- 1 | <<< "Panning and Randomization" >>>; 2 | 3 | SinOsc osc => ADSR env1 => dac; 4 | 5 | 0.25::second => dur beat; 6 | (1::ms, beat/8, 0, 1::ms) => env1.set; 7 | 0.25 => osc.gain; 8 | 9 | [0,4,7] @=> int major[]; 10 | [0,3,7] @=> int minor[]; 11 | 12 | 60 => int offset; 13 | int position; 14 | 15 | for(0 => int i; i < 4; i++) 16 | { 17 | for(0 => int j; j < minor.cap(); j++) 18 | { 19 | Std.mtof(minor[0] + offset + position) => osc.freq; 20 | 1 => env1.keyOn; 21 | beat => now; 22 | } 23 | } 24 | 25 | -------------------------------------------------------------------------------- /12-panning-and-randomization/pan-end.ck: -------------------------------------------------------------------------------- 1 | <<< "Panning and Randomization" >>>; 2 | <<< "This is what the file is like at the end of the video" >>>; 3 | 4 | SinOsc osc => ADSR env1 => NRev rev => Pan2 pan => dac; 5 | 6 | 0.15 => rev.mix; 7 | 8 | -1.0 => pan.pan; 9 | 10 | 0.25::second => dur beat; 11 | (1::ms, beat/8, 0, 1::ms) => env1.set; 12 | 0.25 => osc.gain; 13 | 14 | [0,4,7] @=> int major[]; 15 | [0,3,7] @=> int minor[]; 16 | 17 | 48 => int offset; 18 | int position; 19 | 20 | for(0 => int i; i < 4; i++) 21 | { 22 | for(-1.0 => float j; j < 1.0;0.1 +=> j) 23 | { 24 | beat / Math.random2(2,16) => env1.decayTime; 25 | Math.random2(0,3) * 12 => position; 26 | Math.random2f(-1.0, 1.0) => float panValue; 27 | panValue => pan.pan; 28 | <<< "pan:", panValue >>>; 29 | Math.random2(0, minor.cap() -1) => int note; 30 | Std.mtof(minor[note] + offset + position) => osc.freq; 31 | 1 => env1.keyOn; 32 | beat => now; 33 | } 34 | } 35 | 36 | -------------------------------------------------------------------------------- /12-panning-and-randomization/pan-start.ck: -------------------------------------------------------------------------------- 1 | <<< "Panning and Randomization" >>>; 2 | <<< "Use this file as a starting point for the video" >>>; 3 | 4 | SinOsc osc => ADSR env1 => dac; 5 | 6 | 0.25::second => dur beat; 7 | (1::ms, beat/8, 0, 1::ms) => env1.set; 8 | 0.25 => osc.gain; 9 | 10 | [0,4,7] @=> int major[]; 11 | [0,3,7] @=> int minor[]; 12 | 13 | 60 => int offset; 14 | int position; 15 | 16 | for(0 => int i; i < 4; i++) 17 | { 18 | for(0 => int j; j < minor.cap(); j++) 19 | { 20 | Std.mtof(minor[0] + offset + position) => osc.freq; 21 | 1 => env1.keyOn; 22 | beat => now; 23 | } 24 | } 25 | 26 | -------------------------------------------------------------------------------- /13-working-with-samples-using-the-sndbuf-ugen/guitar.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/13-working-with-samples-using-the-sndbuf-ugen/guitar.wav -------------------------------------------------------------------------------- /13-working-with-samples-using-the-sndbuf-ugen/sndbuf-aleatoric.ck: -------------------------------------------------------------------------------- 1 | <<< "Sampling with SndBuf" >>>; 2 | 3 | SndBuf guitar => ADSR env1 => NRev rev1 => Pan2 pan => dac; 4 | SndBuf guitar2 => ADSR env2 => NRev rev2 => dac; 5 | 1::second => dur beat; 6 | 0.1 => rev1.mix => rev2.mix; 7 | 0.75 => guitar.gain => guitar2.gain; 8 | 9 | (5::ms, beat / 4, 0, 5::ms) => env1.set; 10 | (200::ms, beat, 0, 5::ms) => env2.set; 11 | me.dir() + "guitar.wav" => string filename; 12 | 13 | filename => guitar.read => guitar2.read; 14 | <<< guitar.samples() >>>; 15 | 16 | while(true) 17 | { 18 | playGuitar(2.0); 19 | playGuitar(4.0/3.0); 20 | playGuitar(2.0); 21 | playGuitar(1.5); 22 | } 23 | 24 | fun void playGuitar(float rate) 25 | { 26 | for(0 => int i; i < 8; i++) 27 | { 28 | rate => guitar.rate; 29 | (0 - rate) / 2 => guitar2.rate; 30 | Math.random2f(-1.0, 1.0) => pan.pan; 31 | Math.random2(0, guitar.samples()) => guitar.pos => guitar2.pos; 32 | 1 => env2.keyOn; 33 | 1 => env1.keyOn; 34 | beat / 4 => now; 35 | 1 => env1.keyOn; 36 | beat / 4 => now; 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /13-working-with-samples-using-the-sndbuf-ugen/sndbuf-simple-reverse.ck: -------------------------------------------------------------------------------- 1 | <<< "Samples and the SndBuf Ugen" >>>; 2 | 3 | SndBuf guitar => dac; 4 | 5 | me.dir() + "guitar.wav" => string filename; 6 | filename => guitar.read; 7 | 8 | //guitar.samples() => guitar.pos; //stops playback 9 | 10 | -0.5 => guitar.rate; 11 | guitar.samples() -1 => guitar.pos; 12 | 10::second => now; -------------------------------------------------------------------------------- /14-if-statements/c-hat.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/14-if-statements/c-hat.wav -------------------------------------------------------------------------------- /14-if-statements/clap.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/14-if-statements/clap.wav -------------------------------------------------------------------------------- /14-if-statements/drumMachine-electro.ck: -------------------------------------------------------------------------------- 1 | <<< "If/Else Drum Machine" >>>; 2 | 3 | SndBuf kick => dac; 4 | SndBuf snare => dac; 5 | SndBuf cHat => dac; 6 | SndBuf oHat => dac; 7 | 8 | me.dir() + "kick.wav" => string kickFilename; 9 | me.dir() + "clap.wav" => string snareFilename; 10 | me.dir() + "c-hat.wav" => string cHatFilename; 11 | me.dir() + "o-hat.wav" => string oHatFilename; 12 | 13 | kickFilename => kick.read; 14 | snareFilename => snare.read; 15 | cHatFilename => cHat.read; 16 | oHatFilename => oHat.read; 17 | 18 | fun void SilenceAllBuffers() 19 | { 20 | kick.samples() => kick.pos; 21 | snare.samples() => snare.pos; 22 | oHat.samples() => oHat.pos; 23 | cHat.samples() => cHat.pos; 24 | } 25 | 26 | 0.45::second => dur beat; 27 | 28 | fun void Drum(int select, dur duration) 29 | { 30 | if(select == 0) 31 | { 32 | 0 => kick.pos; 33 | 0 => cHat.pos; 34 | } 35 | if(select == 1) 36 | { 37 | 0 => oHat.pos; 38 | } 39 | if(select == 2) 40 | { 41 | 0 => kick.pos; 42 | 0 => cHat.pos; 43 | 0 => snare.pos; 44 | } 45 | if(select == 3) 46 | { 47 | 0 => snare.pos; 48 | } 49 | duration => now; 50 | SilenceAllBuffers(); 51 | } 52 | 53 | SilenceAllBuffers(); 54 | 55 | // while(true) 56 | // { 57 | // Drum(0, beat/2); 58 | // Drum(1, beat/2); 59 | // Drum(2, beat/2); 60 | // Drum(1, beat/2); 61 | // Drum(0, beat/2); 62 | // Drum(1, beat/2); 63 | // Drum(2, beat/2); 64 | // Drum(1, beat * 0.28); 65 | // Drum(1, beat * 0.22); 66 | // } 67 | 68 | while(true) 69 | { 70 | for(0=> int i; i<4; i++) 71 | { 72 | Drum(0, beat/4); 73 | } 74 | Drum(3, beat /2); 75 | Drum(0, beat/4); 76 | Drum(0, beat/4); 77 | for(0=> int i; i<3; i++) 78 | { 79 | Drum(0, beat/3); 80 | } 81 | Drum(3, beat ); 82 | } 83 | 84 | -------------------------------------------------------------------------------- /14-if-statements/drumMachine-house.ck: -------------------------------------------------------------------------------- 1 | <<< "If Statements Drum Machine" >>>; 2 | 3 | SndBuf kick => dac; 4 | SndBuf snare => dac; 5 | SndBuf cHat => dac; 6 | SndBuf oHat => dac; 7 | 8 | me.dir() + "kick.wav" => string kickFileName; 9 | me.dir() + "snare.wav" => string snareFileName; 10 | me.dir() + "c-hat.wav" => string cHatFileName; 11 | me.dir() + "o-hat.wav" => string oHatFileName; 12 | 13 | kickFileName => kick.read; 14 | snareFileName => snare.read; 15 | cHatFileName => cHat.read; 16 | oHatFileName => oHat.read; 17 | 18 | fun void SilenceAllBuffers() 19 | { 20 | kick.samples() => kick.pos; 21 | snare.samples() => snare.pos; 22 | cHat.samples() => cHat.pos; 23 | oHat.samples() => oHat.pos; 24 | } 25 | SilenceAllBuffers(); 26 | 27 | 0.45::second => dur beat; 28 | 29 | fun void Drum(int select, dur duration) 30 | { 31 | if(select == 0) 32 | { 33 | 0 => kick.pos; 34 | 0 => cHat.pos; 35 | } 36 | if(select == 1) 37 | { 38 | 0 => oHat.pos; 39 | } 40 | if(select == 2) 41 | { 42 | 0 => kick.pos; 43 | 0 => cHat.pos; 44 | 0 => snare.pos; 45 | } 46 | duration => now; 47 | SilenceAllBuffers(); 48 | } 49 | 50 | fun void HouseLoop() 51 | { 52 | Drum(0, 0.5::beat); 53 | Drum(1, 0.5::beat); 54 | 55 | Drum(2, 0.5::beat); 56 | Drum(1, 0.5::beat); 57 | 58 | Drum(0, 0.5::beat); 59 | Drum(1, 0.5::beat); 60 | 61 | Drum(2, 0.5::beat); 62 | Drum(1, 0.5::beat); 63 | } 64 | 65 | while(true) 66 | { 67 | HouseLoop(); 68 | } -------------------------------------------------------------------------------- /14-if-statements/kick.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/14-if-statements/kick.wav -------------------------------------------------------------------------------- /14-if-statements/o-hat.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/14-if-statements/o-hat.wav -------------------------------------------------------------------------------- /14-if-statements/snare.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/14-if-statements/snare.wav -------------------------------------------------------------------------------- /15-shreds/arpeggio.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1 => ADSR env1 => NRev rev1 => dac; 2 | 3 | 0.5::second => dur beat; 4 | 5 | 0.15 => osc1.gain; 6 | (1::ms, beat / 4, 0, 1::ms) => env1.set; 7 | 0.1 => rev1.mix; 8 | 9 | 60 => int offset; 10 | 0 => int position; 11 | 12 | [0,4,7,12] @=> int major[]; 13 | 14 | while(true) 15 | { 16 | for(0 => int i; i < major.cap(); i++) 17 | { 18 | Std.mtof(major[i] + offset + position) => osc1.freq; 19 | 1 => env1.keyOn; 20 | beat /4 => now; 21 | } 22 | } -------------------------------------------------------------------------------- /15-shreds/kick.ck: -------------------------------------------------------------------------------- 1 | SndBuf kick => dac; 2 | 3 | me.dir() + "kick.wav" => string kickFileName; 4 | kickFileName => kick.read; 5 | 6 | fun void SilenceAllBuffers() 7 | { 8 | kick.samples() => kick.pos; 9 | } 10 | SilenceAllBuffers(); 11 | 12 | 0.5::second => dur beat; 13 | 14 | fun void Drum(int select, dur duration, float gain) 15 | { 16 | if(select == 0) 17 | { 18 | gain => kick.gain; 19 | 0 => kick.pos; 20 | } 21 | duration => now; 22 | SilenceAllBuffers(); 23 | } 24 | 25 | while(true) 26 | { 27 | Drum(0, beat * 0.75, 0.5); 28 | Drum(0, beat * 0.25, 0.05); 29 | } -------------------------------------------------------------------------------- /15-shreds/kick.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/15-shreds/kick.wav -------------------------------------------------------------------------------- /15-shreds/machine.ck: -------------------------------------------------------------------------------- 1 | me.dir() + "kick.ck" => string kickFilename; 2 | me.dir() + "arpeggio.ck" => string arpFilename; 3 | 4 | 0.5::second => dur beat; 5 | 6 | Machine.add(kickFilename) => int kickId; 7 | 8 | beat * 4 => now; 9 | 10 | Machine.replace(kickId, arpFilename); 11 | 12 | beat * 4 => now; 13 | 14 | Machine.replace(kickId, kickFilename); 15 | Machine.add(arpFilename) => int arpId; 16 | 17 | beat * 4 => now; 18 | 19 | Machine.remove(kickId); 20 | Machine.remove(arpId); -------------------------------------------------------------------------------- /15-shreds/reverbs.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1 => ADSR env1 => NRev rev3 => dac; 2 | rev3 => Delay del1 => NRev rev1 => dac.left; 3 | rev3 => Delay del2 => NRev rev2 => dac.right; 4 | del1 => del2; 5 | del2 => del1; 6 | 1::second / 2 => dur beat; 7 | (1::ms, beat/8, 0, 1::ms) => env1.set; 8 | 9 | 0.5 => del1.gain; 10 | 0.5 => del2.gain; 11 | 12 | beat => del1.max => del2.max; 13 | beat /4 => del1.delay; 14 | beat /2 => del2.delay; 15 | 0.2 => rev1.mix => rev2.mix => rev3.mix; 16 | 17 | 48 => int offset; 18 | int position; 19 | [0,4,7] @=> int major[]; 20 | [0,3,7] @=> int minor[]; 21 | 0.15 => osc1.gain; 22 | [0,12,24] @=> int positions[]; 23 | 24 | 25 | while(true) 26 | { 27 | for(0 => int i; i < 3; i++) 28 | { 29 | for(0 => int j; j < minor.cap(); j++) 30 | { 31 | Std.mtof(minor[Math.random2(0,2)] + offset + positions[Math.random2(0,2)]) => osc1.freq; 32 | 1 => env1.keyOn; 33 | beat => now; 34 | } 35 | 36 | } 37 | } 38 | 8 * beat => now; -------------------------------------------------------------------------------- /16-filters/filters-and-shreds.ck: -------------------------------------------------------------------------------- 1 | <<< "Filters and Shreds" >>>; 2 | 3 | SqrOsc osc1 => ADSR env1 => BPF filter => dac; 4 | SawOsc osc2 => env1 => filter => dac; 5 | filter => Delay d1 => dac.right; 6 | filter => Delay d2 => dac.left; 7 | 8 | 0.6::second => dur beat; 9 | 10 | //set delay timing 11 | 2::second => d1.max => d2.max; 12 | beat /2 => d1.delay; 13 | beat => d2.delay; 14 | 0.75 => d1.gain => d2.gain; 15 | d1 => d2; 16 | d2 => d1; 17 | 18 | //set pitch collection 19 | [0,7,12,16,19,24, 5, 28, 31] @=> int pitches[]; 20 | 36 => int offset; 21 | 22 | //set default for envelope and filter 23 | (1::ms, beat * 4, 0, 1::ms) => env1.set; 24 | 10000 => filter.freq; 25 | 8 => filter.Q; 26 | 0.025 => osc1.gain => osc2.gain; 27 | 28 | spork ~ SweepFilter(); 29 | //play some random stuff 30 | while(true) 31 | { 32 | pitches[Math.random2(0,pitches.cap() -1)] => int randomPitch; 33 | Std.mtof(randomPitch + offset) => osc1.freq; 34 | Std.mtof(randomPitch + offset + 7) => osc2.freq; 35 | 1 => env1.keyOn; 36 | 37 | beat / 3 => now; 38 | } 39 | 40 | 41 | 42 | fun void SweepFilter() 43 | { 44 | while(true) 45 | { 46 | for(3000 => int i; i > 250; i--) 47 | { 48 | i => filter.freq; 49 | 0.5::ms => now; 50 | } 51 | for(250 => int j; j < 3000; j++) 52 | { 53 | j => filter.freq; 54 | 0.5::ms => now; 55 | } 56 | } 57 | } -------------------------------------------------------------------------------- /16-filters/filters.ck: -------------------------------------------------------------------------------- 1 | <<< "Filters" >>>; 2 | 3 | SqrOsc osc => LPF filter => dac => WvOut waveOut => blackhole; 4 | 5 | "filters.wav" => waveOut.wavFilename; 6 | 7 | 0 => filter.freq; 8 | 110 => osc.freq; 9 | 6 => filter.Q; 10 | 0.1 => osc.gain; 11 | <<< "Hit Ctrl-C to stop if you're on a command line :)" >>>; 12 | while(true) 13 | { 14 | for(2000 => int i; i >0; i--) 15 | { 16 | i => filter.freq; 17 | 0.1::ms => now; 18 | } 19 | } -------------------------------------------------------------------------------- /17-scores/bass1.ck: -------------------------------------------------------------------------------- 1 | <<< "bass1.ck" >>>; 2 | 3 | SqrOsc osc1 => LPF filter1 => ADSR env1 => dac; 4 | 5 | 36 => int offset; 6 | 0.5::second => dur beat; 7 | 8 | beat / 4 => dur sixteenth; 9 | 10 | 0.1 => osc1.gain; 11 | 1000 => filter1.freq; 12 | (1::ms, beat /4, 0, 1::ms) => env1.set; 13 | 14 | function void PlayBassFigure(int position) 15 | { 16 | Std.mtof(offset + position) => osc1.freq; 17 | 1 => env1.keyOn; 18 | sixteenth * 3 => now; 19 | 1 => env1.keyOn; 20 | sixteenth * 3 => now; 21 | 1 => env1.keyOn; 22 | sixteenth * 2 => now; 23 | Std.mtof(offset + position + 12) => osc1.freq; 24 | 1 => env1.keyOn; 25 | sixteenth * 3 => now; 26 | 1 => env1.keyOn; 27 | sixteenth * 3 => now; 28 | 1 => env1.keyOn; 29 | Std.mtof(offset + position) => osc1.freq; 30 | sixteenth * 2 => now; 31 | } 32 | 33 | while(true) 34 | { 35 | PlayBassFigure(0); 36 | PlayBassFigure(0); 37 | PlayBassFigure(8); 38 | PlayBassFigure(5); 39 | } -------------------------------------------------------------------------------- /17-scores/bass2.ck: -------------------------------------------------------------------------------- 1 | <<< "bass2.ck" >>>; 2 | 3 | SqrOsc osc1 => BPF filter1 => ADSR env1 => dac; 4 | env1 => Delay leftDelay => dac.left; 5 | Delay rightDelay => dac.right; 6 | 7 | 0.5::second => dur beat; 8 | beat / 4 => dur sixteenth; 9 | 10 | beat => leftDelay.max => rightDelay.max; 11 | leftDelay => rightDelay; 12 | rightDelay => leftDelay; 13 | beat /2 => leftDelay.delay => rightDelay.delay; 14 | 0.35 => leftDelay.gain => rightDelay.gain; 15 | 16 | 17 | 36 => int offset; 18 | 19 | 20 | 21 | 22 | 0.2 => osc1.gain; 23 | 2000 => filter1.freq; 24 | 6 => filter1.Q; 25 | (1::ms, beat , 0, 1::ms) => env1.set; 26 | 27 | function void PlayBassFigure(int position) 28 | { 29 | Std.mtof(offset + position) => osc1.freq; 30 | 1 => env1.keyOn; 31 | sixteenth * 3 => now; 32 | 1 => env1.keyOn; 33 | sixteenth * 3 => now; 34 | 1 => env1.keyOn; 35 | sixteenth * 2 => now; 36 | Std.mtof(offset + position + 12) => osc1.freq; 37 | 1 => env1.keyOn; 38 | sixteenth * 3 => now; 39 | 1 => env1.keyOn; 40 | sixteenth * 3 => now; 41 | 1 => env1.keyOn; 42 | Std.mtof(offset + position) => osc1.freq; 43 | sixteenth * 2 => now; 44 | } 45 | spork ~ SweepFilter(); 46 | 47 | function void SweepFilter() 48 | { 49 | while(true) 50 | { 51 | for(2500 => int i; i> 800; i--) 52 | { 53 | i => filter1.freq; 54 | 1::ms => now; 55 | } 56 | for(800 => int i; i< 2500; i++) 57 | { 58 | i => filter1.freq; 59 | 1::ms => now; 60 | } 61 | } 62 | } 63 | 64 | while(true) 65 | { 66 | PlayBassFigure(0); 67 | PlayBassFigure(0); 68 | PlayBassFigure(8); 69 | PlayBassFigure(5); 70 | } -------------------------------------------------------------------------------- /17-scores/hi-hat.ck: -------------------------------------------------------------------------------- 1 | <<< "hi-hat.ck" >>>; 2 | Noise osc => BPF filter1 => ADSR env1 => Pan2 pan => dac; 3 | 4 | 0.5::second => dur beat; 5 | (1::ms, beat / 16, 0,1::ms) => env1.set; 6 | 0.15 => osc.gain; 7 | 4 => filter1.Q; 8 | 9 | while(true) 10 | { 11 | Math.random2(1000,10000) => filter1.freq; 12 | Math.random2f(-0.8,0.8) => pan.pan; 13 | Math.random2(4, 16) => int beatDivisor; 14 | beat / beatDivisor => env1.decayTime; 15 | 1 => env1.keyOn; 16 | beat / 4 => now; 17 | } -------------------------------------------------------------------------------- /17-scores/kick-snare.ck: -------------------------------------------------------------------------------- 1 | <<< "kick-snare.ck" >>>; 2 | 3 | SinOsc kick => ADSR kickEnv => dac; 4 | Noise snare => BPF snareFilter => ADSR snareEnv => dac; 5 | Impulse imp => dac; 6 | 7 | 8 | 0.5::second => dur beat; 9 | 10 | 60 => kick.freq; 11 | 0.2 => kick.gain; 12 | (1::ms, beat /2, 0,1::ms ) => kickEnv.set; 13 | 14 | function void kickPitch() 15 | { 16 | for(160 => int i; i > 55; i--) 17 | { 18 | i => kick.freq; 19 | 1::ms => now; 20 | } 21 | } 22 | 23 | function void PlayKick() 24 | { 25 | while (true) 26 | { 27 | 55 => kick.freq; 28 | 1 => kickEnv.keyOn; 29 | spork ~ kickPitch(); 30 | 0.2 => imp.next; 31 | beat => now; 32 | } 33 | } 34 | 35 | 0.5 => snare.gain; 36 | 1750 => snareFilter.freq; 37 | 1 => snareFilter.Q; 38 | (1::ms, beat /4, 0.05, 1::ms) => snareEnv.set; 39 | 40 | function void PlaySnare() 41 | { 42 | while(true) 43 | { 44 | beat => now; 45 | 1 => snareEnv.keyOn; 46 | beat => now; 47 | 1 => snareEnv.keyOff; 48 | } 49 | } 50 | 51 | spork ~ PlayKick(); 52 | spork ~ PlaySnare(); 53 | 54 | while(true) 55 | { 56 | beat => now; 57 | } 58 | 59 | -------------------------------------------------------------------------------- /17-scores/pad.ck: -------------------------------------------------------------------------------- 1 | <<< "pad.ck" >>>; 2 | 3 | SawOsc osc[3] => LPF filter[3] => ADSR env[3]; 4 | env[0] => dac; 5 | env[1] => dac.left; 6 | env[2] => dac.right; 7 | 8 | 0.5::second => dur beat; 9 | 60 => int offset; 10 | 2.5 => filter[0].Q => filter[1].Q => filter[2].Q; 11 | for(0 => int i; i < osc.cap(); i++) 12 | { 13 | 0.05 => osc[i].gain; 14 | } 15 | 16 | (1::ms, beat /4, 0.05, 1::ms) => env[0].set; 17 | (1::ms, beat /4, 0.05, 1::ms) => env[1].set; 18 | (1::ms, beat /4, 0.05, 1::ms) => env[2].set; 19 | 20 | spork ~ SweepFilter(); 21 | 22 | function void SweepFilter() 23 | { 24 | while(true) 25 | { 26 | for(1000 => int i; i> 300; i--) 27 | { 28 | i => filter[0].freq => filter[1].freq => filter[2].freq; 29 | 5::ms => now; 30 | } 31 | for(300 => int i; i< 1000; i++) 32 | { 33 | i => filter[0].freq => filter[1].freq => filter[2].freq; 34 | 5::ms => now; 35 | } 36 | } 37 | } 38 | 39 | [[0,2,7],[0,3,7]] @=> int pitches[][]; 40 | 41 | while(true) 42 | { 43 | for(0 => int i; i < pitches.cap(); i++) 44 | { 45 | for(0 => int j; j osc[j].freq; 48 | } 49 | for(0 => int k; k < 8; k++) 50 | { 51 | 1 => env[0].keyOn => env[1].keyOn => env[2].keyOn; 52 | beat / 2 => now; 53 | } 54 | } 55 | } -------------------------------------------------------------------------------- /17-scores/panning1.ck: -------------------------------------------------------------------------------- 1 | <<< "Panning and Randomization" >>>; 2 | 3 | SinOsc osc => ADSR env1 => NRev rev => Pan2 pan => dac; 4 | env1 => Delay delay => rev; 5 | 0.02 => rev.mix; 6 | 0.5::second => dur beat; 7 | (1::ms, beat/4, 0, 1::ms) => env1.set; 8 | 0.25 => osc.gain; 9 | beat => delay.max; 10 | beat /4 => delay.delay; 11 | 0.5 => delay.gain; 12 | delay => delay; 13 | 14 | [0,4,7] @=> int major[]; 15 | [0,3,7] @=> int minor[]; 16 | 17 | 48 => int offset; 18 | int position; 19 | 20 | while(true){ 21 | for(0 => int i; i < 4; i++) 22 | { 23 | for(-1 => float j; j <= 1; 0.1 + j => j) 24 | { 25 | Math.random2(0,4) * 12 => position; 26 | Math.random2f(-1,1) => float panValue; 27 | panValue => pan.pan; 28 | 29 | Math.random2(0,2) => int note; 30 | beat/Math.random2(2,16) => env1.decayTime; 31 | 32 | Std.mtof(minor[note] + offset + position) => osc.freq; 33 | 1 => env1.keyOn; 34 | beat / 2 => now; 35 | } 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /17-scores/score.ck: -------------------------------------------------------------------------------- 1 | <<< "score.ck" >>>; 2 | 3 | me.dir() + "bass1.ck" => string bass1Filename; 4 | me.dir() + "bass2.ck" => string bass2Filename; 5 | me.dir() + "kick-snare.ck" => string kickSnareFilename; 6 | me.dir() + "panning1.ck" => string panningFilename; 7 | me.dir() + "hi-hat.ck" => string hiHatFilename; 8 | me.dir() + "pad.ck" => string padFilename; 9 | 10 | 0.5::second => dur beat; 11 | 12 | beat * 4 => dur bar; 13 | 14 | //start with kick and snare, 4 bars 15 | Machine.add(kickSnareFilename) => int kick; 16 | 4 * bar => now; 17 | //add in bass2, 8 bars 18 | Machine.add(bass2Filename) => int bass2; 19 | 8 * bar => now; 20 | // add in hi hat, 4 bars 21 | Machine.add(hiHatFilename) => int hats; 22 | 4 * bar => now; 23 | //kill the kick and snare, 4 bars 24 | Machine.remove(kick); 25 | 4 * bar => now; 26 | //remove hi hat and bass 2 27 | Machine.remove(bass2); 28 | Machine.remove(hats); 29 | 30 | //start the pad, 4 bars 31 | Machine.add(padFilename) => int pad; 32 | 4 * bar => now; 33 | //Add bass 1 34 | Machine.add(bass1Filename) => int bass1; 35 | 4 * bar => now; 36 | //add in panner, hats and kick, 8 bars 37 | Machine.add(panningFilename) => int panner; 38 | Machine.add(hiHatFilename) => hats; 39 | Machine.add(kickSnareFilename) => kick; 40 | 8 * bar => now; 41 | //kill bass1 and pad, start bass 2, 8 bars 42 | Machine.remove(bass1); 43 | Machine.add(bass2Filename) => int bass2; 44 | Machine.remove(pad); 45 | 8 * bar => now; 46 | //start pad back up, kill kick, 4 bars 47 | Machine.add(padFilename) => pad; 48 | Machine.remove(kick); 49 | 4 * bar => now; 50 | 51 | //Kill everything but the kick, snare, and panner 52 | Machine.remove(pad); 53 | Machine.remove(hats); 54 | Machine.remove(pad); 55 | Machine.add(kickSnareFilename) => kick; 56 | 8 * bar => now; 57 | //add the pad back in, 4 bars 58 | Machine.add(padFilename) => pad; 59 | 4 * bar => now; 60 | //remove pad, add bass, 4 bars 61 | Machine.remove(pad); 62 | Machine.add(bass1Filename) => bass1; 63 | 4 * bar => now; 64 | //add hats, 8 bars 65 | Machine.add(hiHatFilename) => hats; 66 | 8 * bar => now; 67 | //remove panner, 8 bars 68 | Machine.remove(panner); 69 | 8 * bar => now; 70 | //remove hats and kick, end song 71 | Machine.remove(hats); 72 | Machine.remove(kick); 73 | 8 * bar => now; 74 | //remove all the basses 75 | Machine.remove(bass1); 76 | Machine.remove(bass2); 77 | -------------------------------------------------------------------------------- /18-cutting-up-breaks/break2.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/18-cutting-up-breaks/break2.wav -------------------------------------------------------------------------------- /18-cutting-up-breaks/breaks.ck: -------------------------------------------------------------------------------- 1 | <<< "breaks.ck" >>>; 2 | 3 | SndBuf fakeAmen => Pan2 pan => dac; 4 | fakeAmen => NRev rev => dac; 5 | rev =< dac; 6 | 0.4 => rev.mix; 7 | 0.5 => rev.gain; 8 | 9 | 0.6 => fakeAmen.gain; 10 | me.dir() + "break2.wav" => string filename; 11 | filename => fakeAmen.read; 12 | 13 | 1.4 => float MAIN_RATE; 14 | second / (2 * MAIN_RATE) => dur beat; 15 | 16 | MAIN_RATE => fakeAmen.rate; 17 | 18 | function void cutBreak(int sliceChoice, dur duration) 19 | { 20 | fakeAmen.samples() / 32 => int slice; 21 | slice * sliceChoice => int position; 22 | fakeAmen.pos(position); 23 | duration => now; 24 | } 25 | 26 | function void stutter(int sliceChoice, dur duration, int divisor) 27 | { 28 | for(0 => int i; i < divisor; i++) 29 | { 30 | cutBreak(sliceChoice, duration / divisor); 31 | } 32 | } 33 | 34 | function void volumeRamp(dur duration, int divisor) 35 | { 36 | duration / divisor => dur durationSlice; 37 | fakeAmen.gain() - (fakeAmen.gain() / 8 ) => float rampHeight; 38 | fakeAmen.gain() / 8 => fakeAmen.gain; 39 | for(0 => int i; i < divisor; i++) 40 | { 41 | fakeAmen.gain() + (rampHeight / divisor) => fakeAmen.gain; 42 | durationSlice => now; 43 | } 44 | } 45 | 46 | function void rampUp(int sliceChoice, dur duration, int divisor) 47 | { 48 | spork ~ volumeRamp(duration, divisor); 49 | stutter(sliceChoice, duration, divisor); 50 | } 51 | 52 | while(true) 53 | { 54 | cutBreak(8, 2 * beat); 55 | cutBreak(24, 2 * beat); 56 | cutBreak(2, 1 * beat); 57 | cutBreak(2, 1 * beat); 58 | cutBreak(8, 1.5 * beat); 59 | cutBreak(8, 0.25 * beat); 60 | cutBreak(8, 0.25 * beat); 61 | 62 | cutBreak(8, 2 * beat); 63 | cutBreak(24, 2 * beat); 64 | rev => dac.right; 65 | cutBreak(2, 1 * beat); 66 | rev =< dac.right; 67 | rev => dac.left; 68 | cutBreak(2, 1 * beat); 69 | rev =< dac; 70 | cutBreak(8, 2 * beat); 71 | 72 | cutBreak(8, .25 * beat); 73 | cutBreak(8, .25 * beat); 74 | cutBreak(8, .25 * beat); 75 | cutBreak(8, .25 * beat); 76 | cutBreak(2, .25 * beat); 77 | cutBreak(1, .25 * beat); 78 | cutBreak(2, .25 * beat); 79 | cutBreak(2, .25 * beat); 80 | cutBreak(8, .5 * beat); 81 | cutBreak(2, 1.5 * beat); 82 | cutBreak(8, .5 * beat); 83 | cutBreak(2, 1.5 * beat); 84 | cutBreak(8, 1.5 * beat); 85 | cutBreak(8, 0.25 * beat); 86 | cutBreak(8, 0.25 * beat); 87 | 88 | cutBreak(8, 1 * beat); 89 | MAIN_RATE * -1 => fakeAmen.rate; 90 | cutBreak(10, 1 * beat); 91 | MAIN_RATE => fakeAmen.rate; 92 | cutBreak(2, 0.5 * beat); 93 | cutBreak(2, 1.5 * beat); 94 | cutBreak(8, 1.5 * beat); 95 | cutBreak(4, 1.5 * beat); 96 | MAIN_RATE - .4 => fakeAmen.rate; 97 | cutBreak(2, 0.25 * beat); 98 | MAIN_RATE => fakeAmen.rate; 99 | cutBreak(6, 0.25 * beat); 100 | MAIN_RATE - .3 => fakeAmen.rate; 101 | cutBreak(2, 0.25 * beat); 102 | MAIN_RATE - .2 => fakeAmen.rate; 103 | cutBreak(2, 0.25 * beat); 104 | MAIN_RATE => fakeAmen.rate; 105 | 106 | MAIN_RATE / 2 => fakeAmen.rate; 107 | -0.5 => pan.pan; 108 | cutBreak(8, 1 * beat); 109 | 0.5 => pan.pan; 110 | cutBreak(10, 1 * beat); 111 | 0 => pan.pan; 112 | MAIN_RATE => fakeAmen.rate; 113 | cutBreak(2, 1 * beat); 114 | cutBreak(2, 1 * beat); 115 | cutBreak(8, 1.5 * beat); 116 | cutBreak(4, 1.5 * beat); 117 | cutBreak(2, 1 * beat); 118 | 119 | stutter(0, 1 * beat, 8); 120 | stutter(2, 1 * beat, 8); 121 | cutBreak(2, 1 * beat); 122 | cutBreak(2, 1 * beat); 123 | cutBreak(8, 1 * beat); 124 | cutBreak(2, 1 * beat); 125 | stutter(2, 1 * beat, 4); 126 | stutter(2, 0.5 * beat, 8); 127 | stutter(2, 0.5 * beat, 12); 128 | 129 | rev => dac; 130 | rampUp(2, 2 * beat, 16); 131 | -0.8 => pan.pan; 132 | rampUp(0, 1 * beat, 8); 133 | 0.8 => pan.pan; 134 | rampUp(2, 1 * beat, 16); 135 | rev =< dac; 136 | 0 => pan.pan; 137 | cutBreak(2, 1 * beat); 138 | cutBreak(2, 1 * beat); 139 | cutBreak(8, 1.5 * beat); 140 | -1.0 => pan.pan; 141 | cutBreak(8, 0.25 * beat); 142 | 1.0 => pan.pan; 143 | cutBreak(8, 0.25 * beat); 144 | 0 => pan.pan; 145 | 146 | -1.0 => pan.pan; 147 | stutter(8, 1 * beat, 4); 148 | 1.0 => pan.pan; 149 | stutter(8, 1 * beat, 4); 150 | 0 => pan.pan; 151 | rampUp(2, 1 * beat, 4); 152 | stutter(2, 1 * beat, 8); 153 | 154 | cutBreak(2, 1 * beat); 155 | cutBreak(2, 1 * beat); 156 | 2.1 => fakeAmen.rate; 157 | rampUp(2, 1* beat, 8); 158 | -0.8 => pan.pan; 159 | 1.4 => fakeAmen.rate; 160 | stutter(2, 0.25 * beat, 4); 161 | -0.4 => pan.pan; 162 | 1.3 => fakeAmen.rate; 163 | stutter(6, 0.25 * beat, 4); 164 | 0.4 => pan.pan; 165 | 1.2 => fakeAmen.rate; 166 | stutter(2, 0.25 * beat, 4); 167 | 0.8 => pan.pan; 168 | 1.1 => fakeAmen.rate; 169 | stutter(2, 0.25 * beat, 4); 170 | 0 => pan.pan; 171 | 1.4 => fakeAmen.rate; 172 | } -------------------------------------------------------------------------------- /19-oscillator-sync/fmVoice.ck: -------------------------------------------------------------------------------- 1 | SinOsc mod1 => ADSR env1 => 2 | SinOsc carrier => ADSR env2 => NRev revM => 3 | dac => 4 | WvOut2 wave => 5 | blackhole; 6 | 7 | env2 => Delay d1 => NRev revL => dac.left; 8 | d1 => Delay d2 => NRev revR => dac.right; 9 | d2 => d1; 10 | 11 | 2::second => d2.max => d1.max; 12 | 13 | 1::second => d1.delay; 14 | 1::second => d2.delay; 15 | 16 | 0.5 => d1.gain => d2.gain; 17 | 0.4 => revL.mix => revR.mix; 18 | 0.2 => revM.mix; 19 | 20 | "test.wav" => wave.wavFilename; 21 | 2 => carrier.sync; 22 | 0.4 => carrier.gain; 23 | 24 | 220 => carrier.freq; 25 | 211 => mod1.freq; 26 | 27 | 500 => mod1.gain; 28 | 29 | 30 | (1::ms, 2.9::second, 0, 1::ms) => env1.set; 31 | (1::ms, 3::second, 0, 1::ms) => env2.set; 32 | 1 => env1.keyOn => env2.keyOn; 33 | 4::second => now; 34 | 35 | 1 => env1.keyOn => env2.keyOn; 36 | 4::second => now; 37 | 38 | 110 => carrier.freq; 39 | 40 | 1 => env1.keyOn => env2.keyOn; 41 | 4::second => now; 42 | 43 | 105.5 => mod1.freq; 44 | 55 => carrier.freq; 45 | 0.3 => carrier.gain; 46 | 47 | 1 => env1.keyOn => env2.keyOn; 48 | 10::second => now; -------------------------------------------------------------------------------- /19-oscillator-sync/lfo.ck: -------------------------------------------------------------------------------- 1 | SinOsc lfo2 => blackhole; 2 | SinOsc lfo => blackhole; 3 | SqrOsc osc => LPF filter => dac; 4 | 5 | 0.5 => lfo2.freq; 6 | 1 => lfo.freq; 7 | 55 => int oscFreq => osc.freq; 8 | 0.1 => float oscGain => osc.gain; 9 | 500 => float filterFreq => filter.freq; 10 | 3 => filter.Q; 11 | 12 | while( true ) 13 | { 14 | ((lfo2.last() +1) * 5 ) => lfo.freq; 15 | filterFreq + ((lfo.last()) * filterFreq) => filter.freq; 16 | 1::ms => now; 17 | } 18 | -------------------------------------------------------------------------------- /20-classes/BPM.ck: -------------------------------------------------------------------------------- 1 | public class BPM 2 | { 3 | dur myDuration[3]; 4 | static dur quarterNote, eighthNote, sextupletNote, bar; 5 | 6 | fun void tempo(float beat) 7 | { 8 | 60.0/(beat) => float SPB; 9 | SPB::second => quarterNote; 10 | quarterNote / 2 => eighthNote; 11 | eighthNote / 3 => sextupletNote; 12 | quarterNote * 4 => bar; 13 | 14 | [quarterNote, eighthNote, sextupletNote] @=> myDuration; 15 | } 16 | } -------------------------------------------------------------------------------- /20-classes/ChordProvider.ck: -------------------------------------------------------------------------------- 1 | public class ChordProvider 2 | { 3 | [0,3,7] @=> static int chord[]; 4 | 0 => static int position; 5 | } -------------------------------------------------------------------------------- /20-classes/Chords.ck: -------------------------------------------------------------------------------- 1 | public class Chords 2 | { 3 | [0,3,7] @=> static int minor[]; 4 | [0,4,7] @=> static int major[]; 5 | [0,5,7] @=> static int sus4[]; 6 | [0,2,7] @=> static int sus2[]; 7 | [0,4,7,10] @=> static int dom7[]; 8 | [0,4,7,11] @=> static int maj7[]; 9 | [0,3,7,10] @=> static int min7[]; 10 | } -------------------------------------------------------------------------------- /20-classes/alvin.ck: -------------------------------------------------------------------------------- 1 | <<< "Alvin" >>>; 2 | 3 | // private class ChordProvider 4 | // { 5 | // [0,3,7] @=> int chord[]; 6 | // 0 => int position; 7 | // } 8 | ChordProvider a; 9 | BPM bpm; 10 | 11 | SinOsc osc => ADSR env1 => NRev rev => Pan2 pan => dac; 12 | env1 => Delay delay => rev; 13 | 0.02 => rev.mix; 14 | bpm.quarterNote => dur beat; 15 | (1::ms, beat/4, 0, 1::ms) => env1.set; 16 | 0.25 => osc.gain; 17 | beat => delay.max; 18 | beat /4 => delay.delay; 19 | 0.25 => delay.gain; 20 | delay => delay; 21 | 22 | [0,4,7] @=> int major[]; 23 | [0,3,7] @=> int minor[]; 24 | 25 | 48 => int offset; 26 | int position; 27 | 28 | while(true){ 29 | for(0 => int i; i < 4; i++) 30 | { 31 | for(-1 => float j; j <= 1; 0.1 + j => j) 32 | { 33 | (Math.random2(0,4) * 12) + a.position => position; 34 | Math.random2f(-1,1) => float panValue; 35 | panValue => pan.pan; 36 | 37 | Math.random2(0,2) => int note; 38 | beat/Math.random2(2,16) => env1.decayTime; 39 | 40 | 41 | Std.mtof(a.chord[note] + offset + position) => osc.freq; 42 | 1 => env1.keyOn; 43 | beat / 2 => now; 44 | 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /20-classes/initialize.ck: -------------------------------------------------------------------------------- 1 | Machine.add(me.dir() + "ChordProvider.ck"); 2 | Machine.add(me.dir() + "Chords.ck"); 3 | Machine.add(me.dir() + "BPM.ck"); 4 | 5 | Machine.add(me.dir() + "score.ck"); -------------------------------------------------------------------------------- /20-classes/score.ck: -------------------------------------------------------------------------------- 1 | me.dir() + "alvin.ck" => string alvin; 2 | me.dir() + "simon.ck" => string simon; 3 | me.dir() + "theodore.ck" => string theodore; 4 | 5 | ChordProvider cp; 6 | Chords chords; 7 | BPM bpm; 8 | 9 | Machine.add(alvin) => int stopAlvin; 10 | Machine.add(simon) => int stopSimon; 11 | Machine.add(theodore) => int stopTheodore; 12 | 80 => bpm.tempo; 13 | 14 | 15 | 16 | 0 => cp.position; 17 | chords.minor @=> cp.chord; 18 | bpm.bar => now; 19 | 20 | 5 => cp.position; 21 | chords.minor @=> cp.chord; 22 | bpm.bar => now; 23 | 24 | 7 => cp.position; 25 | chords.sus4 @=> cp.chord; 26 | bpm.bar => now; 27 | 28 | 7 => cp.position; 29 | chords.dom7 @=> cp.chord; 30 | bpm.bar => now; 31 | 32 | 0 => cp.position; 33 | chords.minor @=> cp.chord; 34 | bpm.quarterNote * 2 => now; 35 | chords.dom7 @=> cp.chord; 36 | bpm.quarterNote * 2 => now; 37 | 38 | 5 => cp.position; 39 | chords.minor @=> cp.chord; 40 | bpm.quarterNote * 2 => now; 41 | 8 => cp.position; 42 | chords.maj7 @=> cp.chord; 43 | bpm.quarterNote * 2 => now; 44 | 45 | 7 => cp.position; 46 | chords.sus4 @=> cp.chord; 47 | bpm.bar => now; 48 | 49 | chords.dom7 @=> cp.chord; 50 | bpm.bar => now; 51 | 52 | Machine.remove(stopAlvin); 53 | Machine.remove(stopSimon); 54 | Machine.remove(stopTheodore); -------------------------------------------------------------------------------- /20-classes/simon.ck: -------------------------------------------------------------------------------- 1 | <<< "Simon" >>>; 2 | 3 | // private class ChordProvider 4 | // { 5 | // [0,3,7] @=> int chord[]; 6 | // 0 => int position; 7 | // } 8 | ChordProvider s; 9 | BPM bpm; 10 | 11 | SqrOsc osc => LPF lpf => ADSR env1 => dac; 12 | SqrOsc osc2 => lpf; 13 | 0.4 => osc.gain; 14 | 0.1 => osc2.gain; 15 | 400 => lpf.freq; 16 | bpm.quarterNote => dur beat; 17 | (1::ms, beat/4, 0, 1::ms) => env1.set; 18 | 36 => int offset; 19 | int position; 20 | 21 | while(true) 22 | { 23 | beat / 4 => dur sixteenth; 24 | Std.mtof(s.chord[0] + offset + s.position) => osc.freq; 25 | Std.mtof(s.chord[0] + offset + s.position - 24) => osc2.freq; 26 | 1 => env1.keyOn; 27 | sixteenth * 3 => now; 28 | 1 => env1.keyOn; 29 | sixteenth * 3 => now; 30 | 1 => env1.keyOn; 31 | sixteenth * 2 => now; 32 | } -------------------------------------------------------------------------------- /20-classes/theodore.ck: -------------------------------------------------------------------------------- 1 | <<< "Theodore" >>>; 2 | 3 | // private class ChordProvider 4 | // { 5 | // [0,3,7] @=> int chord[]; 6 | // 0 => int position; 7 | // } 8 | ChordProvider t; 9 | BPM bpm; 10 | 11 | bpm.quarterNote => dur beat; 12 | 48 => int offset; 13 | 14 | fun void PlayNote(int note, int position, dur duration) 15 | { 16 | SinOsc lfo => SawOsc osc => LPF lpf => ADSR env1 => dac.left; 17 | env1 => Delay delay => dac.right; 18 | duration => delay.max; 19 | duration / 4 => delay.delay; 20 | delay => delay; 21 | 1 => delay.gain; 22 | 23 | 3 => lfo.gain; 24 | 6 => lfo.freq; 25 | 2 => osc.sync; 26 | 0.1 => osc.gain; 27 | 500 => lpf.freq; 28 | Std.mtof(note + offset + position) => osc.freq; 29 | (1::ms, duration * 2, 0, 1::ms) => env1.set; 30 | 1 => env1.keyOn; 31 | duration => now; 32 | } 33 | 34 | while(true) 35 | { 36 | for(0 => int i; i < t.chord.cap(); i++) 37 | { 38 | spork ~ PlayNote(t.chord[i], t.position, beat); 39 | } 40 | beat => now; 41 | 42 | } -------------------------------------------------------------------------------- /21-dyno-ugen/dyno-example-1-stereo.ck: -------------------------------------------------------------------------------- 1 | SndBuf2 drumBreak; 2 | drumBreak.chan(0) => Dyno dyno => Gain gain => Dyno limiter => dac.left => WvOut2 waveOut => blackhole; 3 | drumBreak.chan(1) => Dyno dyno2 => Gain gain2 => Dyno limiter2 => dac.right; //=> WvOut2 waveOut => blackhole; 4 | me.dir() + "shortBreak2.wav" => drumBreak.read; 5 | "compressBreak.wav" => waveOut.wavFilename; 6 | 7 | <<< drumBreak.channels() >>>; 8 | 9 | 30 => dyno.ratio => dyno2.ratio; 10 | 0::ms => dyno.attackTime => dyno2.attackTime; 11 | 0.05 => dyno.thresh => dyno2.thresh; 12 | 13 | 24 => gain.gain => gain2.gain; 14 | 15 | 0.9 => limiter.thresh => limiter2.thresh; 16 | 0::ms => limiter.attackTime => limiter2.attackTime; 17 | 18 | while(true) 19 | { 20 | -1 => dyno.op => dyno2.op; 21 | -1 => gain.op => gain2.op; 22 | 23 | 0 => drumBreak.pos; 24 | 2::second => now; 25 | 0 => drumBreak.pos; 26 | 2::second => now; 27 | 28 | 1 => dyno.op => dyno2.op; 29 | 1 => gain.op => gain2.op; 30 | 31 | 0 => drumBreak.pos; 32 | 2::second => now; 33 | 0 => drumBreak.pos; 34 | 2::second => now; 35 | } 36 | 37 | waveOut.closeFile(); -------------------------------------------------------------------------------- /21-dyno-ugen/dyno-example-1.ck: -------------------------------------------------------------------------------- 1 | SndBuf2 drumBreak => Dyno dyno => Gain gain => Dyno limiter => dac => WvOut2 waveOut => blackhole; 2 | me.dir() + "shortBreak2.wav" => drumBreak.read; 3 | "compressBreak.wav" => waveOut.wavFilename; 4 | 5 | 30 => dyno.ratio; 6 | 0::ms => dyno.attackTime; 7 | 0.05 => dyno.thresh; 8 | 9 | 24 => gain.gain; 10 | 11 | 0.9 => limiter.thresh; 12 | 0::ms => limiter.attackTime; 13 | 14 | while(true) 15 | { 16 | -1 => dyno.op; 17 | -1 => gain.op; 18 | 19 | 0 => drumBreak.pos; 20 | 2::second => now; 21 | 0 => drumBreak.pos; 22 | 2::second => now; 23 | 24 | 1 => dyno.op; 25 | 1 => gain.op; 26 | 27 | 0 => drumBreak.pos; 28 | 2::second => now; 29 | 0 => drumBreak.pos; 30 | 2::second => now; 31 | } 32 | 33 | waveOut.closeFile(); -------------------------------------------------------------------------------- /21-dyno-ugen/dyno-example-2.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1 => Dyno dyno => dac => WvOut2 waveOut => blackhole; 2 | 3 | "addSines.wav" => waveOut.wavFilename; 4 | 5 | 0::ms => dyno.attackTime; 6 | 0.8 => dyno.thresh; 7 | 8 | 1.0 => osc1.gain; 9 | 220 => osc1.freq; 10 | 11 | 2::second => now; 12 | 13 | SinOsc osc2 => dyno; 14 | .5 => osc2.gain; 15 | 110 => osc2.freq; 16 | 17 | 2::second => now; -------------------------------------------------------------------------------- /21-dyno-ugen/shortBreak2.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/21-dyno-ugen/shortBreak2.wav -------------------------------------------------------------------------------- /22-stereo-processing/pan.ck: -------------------------------------------------------------------------------- 1 | <<< "Panning and Randomization" >>>; 2 | 3 | SinOsc osc => ADSR env1 => Pan2 pan => NRev rev[2] => Dyno limiter[2] => dac; 4 | 5 | 1 => limiter[0].op => limiter[1].op; 6 | 5 => limiter[0].ratio => limiter[1].ratio; 7 | 0.2 => limiter[0].thresh => limiter[1].thresh; 8 | 0::ms => limiter[0].attackTime => limiter[1].attackTime; 9 | 3 => limiter[0].gain => limiter[1].gain; 10 | 11 | 1 => rev[0].op => rev[1].op; 12 | 0.05 => rev[0].mix => rev[1].mix; 13 | 14 | 0.5::second => dur beat; 15 | 16 | 1 => env1.op; 17 | (1::ms, beat/4, 0, 1::ms) => env1.set; 18 | 19 | 0.25 => osc.gain; 20 | 21 | [0,4,7] @=> int major[]; 22 | [0,3,7] @=> int minor[]; 23 | 24 | 36 => int offset; 25 | int position; 26 | 27 | for(0 => int i; i < 4; i++) 28 | { 29 | for(-1 => float j; j <= 1; 0.1 + j => j) 30 | { 31 | Math.random2(0,4) * 12 => position; 32 | Math.random2f(-1,1) => float panValue; 33 | panValue => pan.pan; 34 | 35 | Math.random2(0,2) => int note; 36 | beat/Math.random2(2,16) => env1.decayTime; 37 | <<< "pan:", panValue, "position", position, "note:", note>>>; 38 | 39 | 40 | Std.mtof(minor[note] + offset + position) => osc.freq; 41 | 1 => env1.keyOn; 42 | beat / 2 => now; 43 | // 1 => env1.keyOff; 44 | // beat / 4 => now; 45 | // 1 => env1.keyOn; 46 | // beat / 4 => now; 47 | } 48 | } 49 | 50 | -------------------------------------------------------------------------------- /23-subclasses/HATT1.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/23-subclasses/HATT1.wav -------------------------------------------------------------------------------- /23-subclasses/break2.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/23-subclasses/break2.wav -------------------------------------------------------------------------------- /23-subclasses/chopBuffer.ck: -------------------------------------------------------------------------------- 1 | <<< "breaks.ck" >>>; 2 | 3 | public class ChopBuffer extends SndBuf2 4 | { 5 | function void cutBreak(int sliceChoice, dur duration) 6 | { 7 | this.samples() / 32 => int slice; 8 | slice * sliceChoice => int position; 9 | this.pos(position); 10 | duration => now; 11 | } 12 | 13 | function void stutter(int sliceChoice, dur duration, int divisor) 14 | { 15 | for(0 => int i; i < divisor; i++) 16 | { 17 | cutBreak(sliceChoice, duration / divisor); 18 | } 19 | } 20 | 21 | function void volumeRamp(dur duration, int divisor) 22 | { 23 | duration / divisor => dur durationSlice; 24 | this.gain() - (this.gain() / 8 ) => float rampHeight; 25 | this.gain() / 8 => this.gain; 26 | for(0 => int i; i < divisor; i++) 27 | { 28 | this.gain() + (rampHeight / divisor) => this.gain; 29 | durationSlice => now; 30 | } 31 | } 32 | 33 | function void rampUp(int sliceChoice, dur duration, int divisor) 34 | { 35 | spork ~ volumeRamp(duration, divisor); 36 | stutter(sliceChoice, duration, divisor); 37 | } 38 | } 39 | 40 | ChopBuffer fakeAmen => Pan2 pan => dac; 41 | fakeAmen => NRev rev => dac; 42 | ChopBuffer strings => pan; 43 | strings => rev; 44 | 45 | rev =< dac; 46 | 0.4 => rev.mix; 47 | 0.5 => rev.gain; 48 | 49 | 0.6 => fakeAmen.gain => strings.gain; 50 | me.dir() + "break2.wav" => string filename; 51 | filename => fakeAmen.read; 52 | fakeAmen.samples() => fakeAmen.pos; 53 | 54 | me.dir() + "HATT1.wav" => string stringsFilename; 55 | stringsFilename => strings.read; 56 | strings.samples() => strings.pos; 57 | 58 | 1.4 => float MAIN_RATE; 59 | second / (2 * MAIN_RATE) => dur beat; 60 | 61 | MAIN_RATE => fakeAmen.rate => strings.rate; 62 | 63 | fun void fakeAmenScore() 64 | { 65 | while(true) 66 | { 67 | <<< "this is launching!" >>>; 68 | fakeAmen.cutBreak(8, 2 * beat); 69 | fakeAmen.cutBreak(24, 2 * beat); 70 | fakeAmen.cutBreak(2, 1 * beat); 71 | fakeAmen.cutBreak(2, 1 * beat); 72 | fakeAmen.cutBreak(8, 1.5 * beat); 73 | fakeAmen.cutBreak(8, 0.25 * beat); 74 | fakeAmen.cutBreak(8, 0.25 * beat); 75 | 76 | fakeAmen.cutBreak(8, 2 * beat); 77 | fakeAmen.cutBreak(24, 2 * beat); 78 | rev => dac.right; 79 | fakeAmen.cutBreak(2, 1 * beat); 80 | rev =< dac.right; 81 | rev => dac.left; 82 | fakeAmen.cutBreak(2, 1 * beat); 83 | rev =< dac; 84 | fakeAmen.cutBreak(8, 2 * beat); 85 | 86 | fakeAmen.cutBreak(8, .25 * beat); 87 | fakeAmen.cutBreak(8, .25 * beat); 88 | fakeAmen.cutBreak(8, .25 * beat); 89 | fakeAmen.cutBreak(8, .25 * beat); 90 | fakeAmen.cutBreak(2, .25 * beat); 91 | fakeAmen.cutBreak(1, .25 * beat); 92 | fakeAmen.cutBreak(2, .25 * beat); 93 | fakeAmen.cutBreak(2, .25 * beat); 94 | fakeAmen.cutBreak(8, .5 * beat); 95 | fakeAmen.cutBreak(2, 1.5 * beat); 96 | fakeAmen.cutBreak(8, .5 * beat); 97 | fakeAmen.cutBreak(2, 1.5 * beat); 98 | fakeAmen.cutBreak(8, 1.5 * beat); 99 | fakeAmen.cutBreak(8, 0.25 * beat); 100 | fakeAmen.cutBreak(8, 0.25 * beat); 101 | 102 | fakeAmen.cutBreak(8, 1 * beat); 103 | MAIN_RATE * -1 => fakeAmen.rate; 104 | fakeAmen.cutBreak(10, 1 * beat); 105 | MAIN_RATE => fakeAmen.rate; 106 | fakeAmen.cutBreak(2, 0.5 * beat); 107 | fakeAmen.cutBreak(2, 1.5 * beat); 108 | fakeAmen.cutBreak(8, 1.5 * beat); 109 | fakeAmen.cutBreak(4, 1.5 * beat); 110 | MAIN_RATE - .4 => fakeAmen.rate; 111 | fakeAmen.cutBreak(2, 0.25 * beat); 112 | MAIN_RATE => fakeAmen.rate; 113 | fakeAmen.cutBreak(6, 0.25 * beat); 114 | MAIN_RATE - .3 => fakeAmen.rate; 115 | fakeAmen.cutBreak(2, 0.25 * beat); 116 | MAIN_RATE - .2 => fakeAmen.rate; 117 | fakeAmen.cutBreak(2, 0.25 * beat); 118 | MAIN_RATE => fakeAmen.rate; 119 | 120 | MAIN_RATE / 2 => fakeAmen.rate; 121 | -0.5 => pan.pan; 122 | fakeAmen.cutBreak(8, 1 * beat); 123 | 0.5 => pan.pan; 124 | fakeAmen.cutBreak(10, 1 * beat); 125 | 0 => pan.pan; 126 | MAIN_RATE => fakeAmen.rate; 127 | fakeAmen.cutBreak(2, 1 * beat); 128 | fakeAmen.cutBreak(2, 1 * beat); 129 | fakeAmen.cutBreak(8, 1.5 * beat); 130 | fakeAmen.cutBreak(4, 1.5 * beat); 131 | fakeAmen.cutBreak(2, 1 * beat); 132 | 133 | fakeAmen.stutter(0, 1 * beat, 8); 134 | fakeAmen.stutter(2, 1 * beat, 8); 135 | fakeAmen.cutBreak(2, 1 * beat); 136 | fakeAmen.cutBreak(2, 1 * beat); 137 | fakeAmen.cutBreak(8, 1 * beat); 138 | fakeAmen.cutBreak(2, 1 * beat); 139 | fakeAmen.stutter(2, 1 * beat, 4); 140 | fakeAmen.stutter(2, 0.5 * beat, 8); 141 | fakeAmen.stutter(2, 0.5 * beat, 12); 142 | 143 | rev => dac; 144 | fakeAmen.rampUp(2, 2 * beat, 16); 145 | -0.8 => pan.pan; 146 | fakeAmen.rampUp(0, 1 * beat, 8); 147 | 0.8 => pan.pan; 148 | fakeAmen.rampUp(2, 1 * beat, 16); 149 | rev =< dac; 150 | 0 => pan.pan; 151 | fakeAmen.cutBreak(2, 1 * beat); 152 | fakeAmen.cutBreak(2, 1 * beat); 153 | fakeAmen.cutBreak(8, 1.5 * beat); 154 | -1.0 => pan.pan; 155 | fakeAmen.cutBreak(8, 0.25 * beat); 156 | 1.0 => pan.pan; 157 | fakeAmen.cutBreak(8, 0.25 * beat); 158 | 0 => pan.pan; 159 | 160 | -1.0 => pan.pan; 161 | fakeAmen.stutter(8, 1 * beat, 4); 162 | 1.0 => pan.pan; 163 | fakeAmen.stutter(8, 1 * beat, 4); 164 | 0 => pan.pan; 165 | fakeAmen.rampUp(2, 1 * beat, 4); 166 | fakeAmen.stutter(2, 1 * beat, 8); 167 | 168 | fakeAmen.cutBreak(2, 1 * beat); 169 | fakeAmen.cutBreak(2, 1 * beat); 170 | MAIN_RATE * 1.5 => fakeAmen.rate; 171 | fakeAmen.rampUp(2, 1* beat, 8); 172 | -0.8 => pan.pan; 173 | MAIN_RATE => fakeAmen.rate; 174 | fakeAmen.stutter(2, 0.25 * beat, 4); 175 | -0.4 => pan.pan; 176 | MAIN_RATE - 0.1 => fakeAmen.rate; 177 | fakeAmen.stutter(6, 0.25 * beat, 4); 178 | 0.4 => pan.pan; 179 | MAIN_RATE - 0.2 => fakeAmen.rate; 180 | fakeAmen.stutter(2, 0.25 * beat, 4); 181 | 0.8 => pan.pan; 182 | MAIN_RATE - 0.3 => fakeAmen.rate; 183 | fakeAmen.stutter(2, 0.25 * beat, 4); 184 | 0 => pan.pan; 185 | MAIN_RATE => fakeAmen.rate; 186 | } 187 | } 188 | 189 | fun void stringsScore() 190 | { 191 | while(true) 192 | { 193 | <<< "strings launching" >>>; 194 | strings.cutBreak(8, 2 * beat); 195 | strings.cutBreak(24, 2 * beat); 196 | strings.cutBreak(2, 1 * beat); 197 | strings.cutBreak(2, 1 * beat); 198 | strings.cutBreak(8, 1.5 * beat); 199 | strings.cutBreak(8, 0.25 * beat); 200 | strings.cutBreak(8, 0.25 * beat); 201 | 202 | strings.cutBreak(8, 2 * beat); 203 | strings.cutBreak(24, 2 * beat); 204 | rev => dac.right; 205 | strings.cutBreak(2, 1 * beat); 206 | rev =< dac.right; 207 | rev => dac.left; 208 | strings.cutBreak(2, 1 * beat); 209 | rev =< dac; 210 | strings.cutBreak(8, 2 * beat); 211 | 212 | strings.cutBreak(8, .25 * beat); 213 | strings.cutBreak(8, .25 * beat); 214 | strings.cutBreak(8, .25 * beat); 215 | strings.cutBreak(8, .25 * beat); 216 | strings.cutBreak(2, .25 * beat); 217 | strings.cutBreak(1, .25 * beat); 218 | strings.cutBreak(2, .25 * beat); 219 | strings.cutBreak(2, .25 * beat); 220 | strings.cutBreak(8, .5 * beat); 221 | strings.cutBreak(2, 1.5 * beat); 222 | strings.cutBreak(8, .5 * beat); 223 | strings.cutBreak(2, 1.5 * beat); 224 | strings.cutBreak(8, 1.5 * beat); 225 | strings.cutBreak(8, 0.25 * beat); 226 | strings.cutBreak(8, 0.25 * beat); 227 | 228 | strings.cutBreak(8, 1 * beat); 229 | MAIN_RATE * -1 => strings.rate; 230 | strings.cutBreak(10, 1 * beat); 231 | MAIN_RATE => strings.rate; 232 | strings.cutBreak(2, 0.5 * beat); 233 | strings.cutBreak(2, 1.5 * beat); 234 | strings.cutBreak(8, 1.5 * beat); 235 | strings.cutBreak(4, 1.5 * beat); 236 | MAIN_RATE - .4 => strings.rate; 237 | strings.cutBreak(2, 0.25 * beat); 238 | MAIN_RATE => strings.rate; 239 | strings.cutBreak(6, 0.25 * beat); 240 | MAIN_RATE - .3 => strings.rate; 241 | strings.cutBreak(2, 0.25 * beat); 242 | MAIN_RATE - .2 => strings.rate; 243 | strings.cutBreak(2, 0.25 * beat); 244 | MAIN_RATE => strings.rate; 245 | 246 | MAIN_RATE / 2 => strings.rate; 247 | -0.5 => pan.pan; 248 | strings.cutBreak(8, 1 * beat); 249 | 0.5 => pan.pan; 250 | strings.cutBreak(10, 1 * beat); 251 | 0 => pan.pan; 252 | MAIN_RATE => strings.rate; 253 | strings.cutBreak(2, 1 * beat); 254 | strings.cutBreak(2, 1 * beat); 255 | strings.cutBreak(8, 1.5 * beat); 256 | strings.cutBreak(4, 1.5 * beat); 257 | strings.cutBreak(2, 1 * beat); 258 | 259 | strings.stutter(0, 1 * beat, 8); 260 | strings.stutter(2, 1 * beat, 8); 261 | strings.cutBreak(2, 1 * beat); 262 | strings.cutBreak(2, 1 * beat); 263 | strings.cutBreak(8, 1 * beat); 264 | strings.cutBreak(2, 1 * beat); 265 | strings.stutter(2, 1 * beat, 4); 266 | strings.stutter(2, 0.5 * beat, 8); 267 | strings.stutter(2, 0.5 * beat, 12); 268 | 269 | rev => dac; 270 | strings.rampUp(2, 2 * beat, 16); 271 | -0.8 => pan.pan; 272 | strings.rampUp(0, 1 * beat, 8); 273 | 0.8 => pan.pan; 274 | strings.rampUp(2, 1 * beat, 16); 275 | rev =< dac; 276 | 0 => pan.pan; 277 | strings.cutBreak(2, 1 * beat); 278 | strings.cutBreak(2, 1 * beat); 279 | strings.cutBreak(8, 1.5 * beat); 280 | -1.0 => pan.pan; 281 | strings.cutBreak(8, 0.25 * beat); 282 | 1.0 => pan.pan; 283 | strings.cutBreak(8, 0.25 * beat); 284 | 0 => pan.pan; 285 | 286 | -1.0 => pan.pan; 287 | strings.stutter(8, 1 * beat, 4); 288 | 1.0 => pan.pan; 289 | strings.stutter(8, 1 * beat, 4); 290 | 0 => pan.pan; 291 | strings.rampUp(2, 1 * beat, 4); 292 | strings.stutter(2, 1 * beat, 8); 293 | 294 | strings.cutBreak(2, 1 * beat); 295 | strings.cutBreak(2, 1 * beat); 296 | MAIN_RATE * 1.5 => strings.rate; 297 | strings.rampUp(2, 1* beat, 8); 298 | -0.8 => pan.pan; 299 | MAIN_RATE => strings.rate; 300 | strings.stutter(2, 0.25 * beat, 4); 301 | -0.4 => pan.pan; 302 | MAIN_RATE - 0.1 => strings.rate; 303 | strings.stutter(6, 0.25 * beat, 4); 304 | 0.4 => pan.pan; 305 | MAIN_RATE - 0.2 => strings.rate; 306 | strings.stutter(2, 0.25 * beat, 4); 307 | 0.8 => pan.pan; 308 | MAIN_RATE - 0.3 => strings.rate; 309 | strings.stutter(2, 0.25 * beat, 4); 310 | 0 => pan.pan; 311 | MAIN_RATE => strings.rate; 312 | } 313 | } 314 | 315 | spork ~ fakeAmenScore(); 316 | spork ~ stringsScore(); 317 | 60::second => now; -------------------------------------------------------------------------------- /23-subclasses/inheritance.ck: -------------------------------------------------------------------------------- 1 | public class MusicTri extends TriOsc 2 | { 3 | SinOsc vibrato => this; 4 | 2 => this.sync; 5 | 6 => vibrato.freq; 6 | 5 => vibrato.gain; 7 | 8 | 48 => int offset; 9 | fun void note(int noteNumber) 10 | { 11 | Std.mtof(noteNumber + offset) => this.freq; 12 | } 13 | } 14 | 15 | MusicTri osc => dac; 16 | 17 | 220 => osc.freq; 18 | 0.2 => osc.gain; 19 | 20 | [0,4,7,11] @=> int notes[]; 21 | 48 => int offset; 22 | 23 | while(true) 24 | { 25 | -1 => osc.vibrato.op; 26 | for(0 => int i; i < notes.cap(); i++) 27 | { 28 | notes[i] => osc.note; 29 | 1::second / 4 => now; 30 | } 31 | 32 | 1 => osc.vibrato.op; 33 | for(0 => int i; i < notes.cap(); i++) 34 | { 35 | 10 * i => osc.vibrato.freq; 36 | notes[i] => osc.note; 37 | 1::second / 4 => now; 38 | } 39 | } 40 | 41 | 42 | -------------------------------------------------------------------------------- /23-subclasses/subclass-music.ck: -------------------------------------------------------------------------------- 1 | public class MusicTri extends TriOsc 2 | { 3 | 48 => int offset; 4 | 5 | SinOsc lfo => this; 6 | 2 => this.sync; 7 | 6 => lfo.freq; 8 | 5 => lfo.gain; 9 | 10 | fun void note(float noteNumber) 11 | { 12 | Std.mtof(noteNumber + offset) => this.freq; 13 | } 14 | 15 | fun void setLfo(float freq, float gain) 16 | { 17 | freq => lfo.freq; 18 | gain => lfo.gain; 19 | } 20 | }; 21 | 22 | MusicTri osc => dac; 23 | MusicTri osc2 => Pan2 pan1 => dac; 24 | MusicTri osc3 => Pan2 pan2 => dac; 25 | 26 | Delay delay1 => dac.left; 27 | Delay delay2 => dac.right; 28 | 29 | 1::second => delay1.max => delay2.max; 30 | 1::second / 6 => delay1.delay => delay2.delay; 31 | delay1 => delay2; 32 | delay2 => delay1; 33 | 34 | 0.4 => delay1.gain => delay2.gain; 35 | 36 | pan1.left => delay1; 37 | pan2.left => delay1; 38 | pan1.right => delay2; 39 | pan2.right => delay2; 40 | 41 | 42 | 0.2 => osc2.width; 43 | 0.7 => osc3.width; 44 | 45 | 0.2 => osc.gain => osc2.gain => osc3.gain; 46 | osc.setLfo(8, 2); 47 | osc2.setLfo(6, 5); 48 | osc3.setLfo(6, 7); 49 | 50 | -0.6 => pan1.pan; 51 | 0.6 => pan2.pan; 52 | 53 | while (true) 54 | { 55 | 36 => osc.offset; 56 | 48 => osc2.offset; 57 | 60 => osc3.offset; 58 | [0,4,7,11,14] @=> int notes[]; 59 | notes[Math.random2(0,2)] => osc.note; 60 | for(0 => int i; i < notes.cap(); i++) 61 | { 62 | notes[Math.random2(0,4)] => osc2.note; 63 | notes[Math.random2(0,4)] => osc3.note; 64 | 1::second / 6 => now; 65 | } 66 | 67 | // 1 => osc.lfo.op; 68 | // 12 +=> osc.offset; 69 | // for(0 => int i; i < notes.cap(); i++) 70 | // { 71 | // i * 10 => osc.lfo.gain; 72 | // notes[i] => osc.note; 73 | // 1::second / 4 => now; 74 | // } 75 | } -------------------------------------------------------------------------------- /23-subclasses/subclass.ck: -------------------------------------------------------------------------------- 1 | public class SynthSaw extends SawOsc 2 | { 3 | 48 => int offset; 4 | 5 | SinOsc lfo => this; 6 | 2 => this.sync; 7 | 6 => lfo.freq; 8 | 5 => lfo.gain; 9 | 10 | fun void note(float noteNumber) 11 | { 12 | Std.mtof(noteNumber + offset) => this.freq; 13 | } 14 | 15 | fun void setLfo(float freq, float gain) 16 | { 17 | freq => lfo.freq; 18 | gain => lfo.gain; 19 | } 20 | }; 21 | 22 | SynthSaw osc => LPF lpf => dac; 23 | 24 | 200 => lpf.freq; 25 | 26 | -1 => lpf.op; 27 | 28 | 29 | 30 | 0.2 => osc.gain; 31 | osc.setLfo(8, 5); 32 | 33 | while (true) 34 | { 35 | -1 => osc.lfo.op; 36 | 48 => osc.offset; 37 | [0,4,7,11] @=> int notes[]; 38 | for(0 => int i; i < notes.cap(); i++) 39 | { 40 | notes[i] => osc.note; 41 | 1::second / 4 => now; 42 | } 43 | 44 | 1 => osc.lfo.op; 45 | 12 +=> osc.offset; 46 | for(0 => int i; i < notes.cap(); i++) 47 | { 48 | i * 10 => osc.lfo.gain; 49 | notes[i] => osc.note; 50 | 1::second / 4 => now; 51 | } 52 | } -------------------------------------------------------------------------------- /24-chubgraphs/chub1.ck: -------------------------------------------------------------------------------- 1 | class MyOsc extends Chugraph 2 | { 3 | //set up graph 4 | SawOsc osc => LPF lpf => Dyno limiter => outlet; 5 | SawOsc osc2 => lpf; 6 | Noise noise => lpf; 7 | 8 | //set initial values 9 | 0.2 => osc.gain => osc2.gain; 10 | 0 => noise.gain; 11 | 400 => lpf.freq; 12 | 0::second => limiter.attackTime; 13 | 48 => int offset; 14 | 7 => int osc2Offset; 15 | 16 | //make helper functions 17 | fun void note(float noteNumber) 18 | { 19 | Std.mtof(noteNumber + offset) => osc.freq; 20 | Std.mtof(noteNumber + offset + osc2Offset) => osc2.freq; 21 | } 22 | 23 | fun void SetOsc2(int newOffset) 24 | { 25 | newOffset => osc2Offset; 26 | } 27 | 28 | } 29 | 30 | class HPFDelay extends Chugraph 31 | { 32 | //set up sub graph 33 | inlet => HPF hpf => Delay delay => outlet; 34 | hpf => outlet; 35 | 36 | //default values 37 | 800 => hpf.freq; 38 | 1::second => delay.max; 39 | 0.5 => delay.gain; 40 | 0.5::second => delay.delay; 41 | delay => delay; 42 | 43 | //helper functions 44 | } 45 | 46 | HPFDelay hpfdelay[2]; 47 | Gain gain; 48 | <<< gain.channels() >>>; 49 | 50 | MyOsc osc => hpfdelay => dac; 51 | 0.25::second => hpfdelay[1].delay.delay; 52 | 53 | 1 => hpfdelay[0].op => hpfdelay[1].op; 54 | 55 | 0.5 => osc.gain; 56 | 7 => osc.SetOsc2; 57 | 600 => osc.lpf.freq; 58 | 59 | [0,3,7,12,15,19,-12,-9] @=> int notes[]; 60 | 61 | while(true) 62 | { 63 | Math.random2(0, notes.cap() - 1) => int note; 64 | notes[note] => osc.note; 65 | 1::second / 4 => now; 66 | } 67 | 68 | 69 | -------------------------------------------------------------------------------- /24-chubgraphs/graph.ck: -------------------------------------------------------------------------------- 1 | class LowpassDelay extends Chugraph 2 | { 3 | inlet => LPF lpf => Delay delay => outlet; 4 | 500 => lpf.freq; 5 | 1::second => delay.max; 6 | 0.5 => delay.gain; 7 | 1::second / 2 => delay.delay; 8 | delay => delay; 9 | 10 | lpf => outlet; 11 | } 12 | 13 | 14 | SawOsc osc => LowpassDelay graph[2] => dac; 15 | 16 | 0.5 => osc.gain; 17 | 220 => osc.freq; 18 | 19 | 1::second / 4 => graph[1].delay.delay; 20 | 21 | 48 => int offset; 22 | [0,4,7,11] @=> int notes[]; 23 | while(true) 24 | { 25 | for(0 => int i; i < notes.cap(); i++) 26 | { 27 | Std.mtof(offset + notes[i]) => osc.freq; 28 | 1::second / 4 => now; 29 | } 30 | } -------------------------------------------------------------------------------- /24-chubgraphs/initialize.ck: -------------------------------------------------------------------------------- 1 | me.dir() + "synthvoice.ck" => string voiceFile; 2 | me.dir() + "use.ck" => string useFile; 3 | 4 | Machine.add(voiceFile); 5 | Machine.add(useFile); 6 | -------------------------------------------------------------------------------- /24-chubgraphs/stk-moog.ck: -------------------------------------------------------------------------------- 1 | Moog osc => Delay delay[2] => dac; 2 | 3 | 1::second => delay[0].max => delay[1].max; 4 | 0.5 => delay[0].gain => delay[1].gain; 5 | 0.5::second => delay[0].delay; 6 | 0.25::second => delay[1].delay; 7 | osc => dac; 8 | 9 | 0.25 => osc.gain; 10 | 220 => osc.freq; 11 | 12 | 0 => osc.filterQ; 13 | 14 | 48 => int offset; 15 | [0,4,7,11] @=> int notes[]; 16 | while(true) 17 | { 18 | for(0 => int i; i < notes.cap(); i++) 19 | { 20 | Std.mtof(offset + notes[i]) => osc.freq; 21 | 1 => osc.noteOn; 22 | 1::second / 4 => now; 23 | } 24 | } -------------------------------------------------------------------------------- /24-chubgraphs/synthvoice.ck: -------------------------------------------------------------------------------- 1 | public class SynthVoice extends Chugraph 2 | { 3 | SawOsc saw1 => LPF lpf => ADSR adsr => Dyno limiter => NRev rev => outlet; 4 | SawOsc saw2 => lpf; 5 | Noise noiseSource => lpf; 6 | 7 | 0 => noiseSource.gain; 8 | 9 | TriOsc tri1, tri2; 10 | SqrOsc sqr1, sqr2; 11 | 12 | SinOsc SinLfo; 13 | SawOsc SawLfo; 14 | SqrOsc SqrLfo; 15 | SinLfo => Gain pitchLfo => blackhole; 16 | SinLfo => Gain filterLfo => blackhole; 17 | 18 | fun void SetLfoFreq(float frequency) 19 | { 20 | frequency => SinLfo.freq => SawLfo.freq => SqrLfo.freq; 21 | } 22 | 23 | 6.0 => SetLfoFreq; 24 | 0 => filterLfo.gain; 25 | 0 => pitchLfo.gain; 26 | 27 | 2 => saw1.sync => saw2.sync => tri1.sync => tri2.sync => sqr1.sync => sqr2.sync; 28 | pitchLfo => saw1; 29 | pitchLfo => saw2; 30 | pitchLfo => tri1; 31 | pitchLfo => tri2; 32 | pitchLfo => sqr1; 33 | pitchLfo => sqr2; 34 | 35 | 0::ms => limiter.attackTime; 36 | 0.8 => limiter.thresh; 37 | 38 | 0.1 => tri1.gain => tri2.gain; 39 | 0.1 => saw1.gain => saw2.gain; 40 | 0.1 => sqr1.gain => sqr2.gain; 41 | 42 | 10 => float filterCutoff; 43 | filterCutoff => lpf.freq; 44 | 45 | 1::ms => adsr.attackTime; 46 | 150::ms => adsr.decayTime; 47 | 0 => adsr.sustainLevel; 48 | 1::ms => adsr.releaseTime; 49 | 50 | 24 => int offset; 51 | 0 => float filterEnv; 52 | 53 | 1 => float osc2Detune; 54 | 0 => int oscOffset; 55 | 56 | fun void SetOsc1Freq(float frequency) 57 | { 58 | frequency => tri1.freq => sqr1.freq => saw1.freq; 59 | } 60 | 61 | fun void SetOsc2Freq(float frequency) 62 | { 63 | frequency => tri2.freq => sqr2.freq => saw2.freq; 64 | } 65 | 66 | fun void keyOn(int noteNumber) 67 | { 68 | Std.mtof(offset + noteNumber) => SetOsc1Freq; 69 | Std.mtof(offset + noteNumber + oscOffset) - osc2Detune => SetOsc2Freq; 70 | 1 => adsr.keyOn; 71 | spork ~ filterEnvelope(); 72 | } 73 | 74 | fun void ChooseOsc1(int oscType) 75 | { 76 | if(oscType == 0) 77 | { 78 | tri1 =< lpf; 79 | saw1 =< lpf; 80 | sqr1 =< lpf; 81 | } 82 | if(oscType == 1) 83 | { 84 | tri1 => lpf; 85 | saw1 =< lpf; 86 | sqr1 =< lpf; 87 | } 88 | if(oscType == 2) 89 | { 90 | tri1 =< lpf; 91 | saw1 => lpf; 92 | sqr1 =< lpf; 93 | } 94 | if(oscType == 3) 95 | { 96 | tri1 =< lpf; 97 | saw1 =< lpf; 98 | sqr1 => lpf; 99 | } 100 | } 101 | 102 | fun void ChooseOsc2(int oscType) 103 | { 104 | if(oscType == 0) 105 | { 106 | tri2 =< lpf; 107 | saw2 =< lpf; 108 | sqr2 =< lpf; 109 | } 110 | if(oscType == 1) 111 | { 112 | tri2 => lpf; 113 | saw2 =< lpf; 114 | sqr2 =< lpf; 115 | } 116 | if(oscType == 2) 117 | { 118 | tri2 =< lpf; 119 | saw2 => lpf; 120 | sqr2 =< lpf; 121 | } 122 | if(oscType == 3) 123 | { 124 | tri2 =< lpf; 125 | saw2 =< lpf; 126 | sqr2 => lpf; 127 | } 128 | } 129 | 130 | fun void ChooseLfo(int oscType) 131 | { 132 | if(oscType == 0) 133 | { 134 | SinLfo =< filterLfo; 135 | SinLfo =< pitchLfo; 136 | SawLfo =< filterLfo; 137 | SawLfo =< pitchLfo; 138 | SqrLfo =< filterLfo; 139 | SqrLfo =< pitchLfo; 140 | } 141 | if(oscType == 1) 142 | { 143 | SinLfo => filterLfo; 144 | SinLfo => pitchLfo; 145 | SawLfo =< filterLfo; 146 | SawLfo =< pitchLfo; 147 | SqrLfo =< filterLfo; 148 | SqrLfo =< pitchLfo; 149 | } 150 | if(oscType == 2) 151 | { 152 | SinLfo =< filterLfo; 153 | SinLfo =< pitchLfo; 154 | SawLfo => filterLfo; 155 | SawLfo => pitchLfo; 156 | SqrLfo =< filterLfo; 157 | SqrLfo =< pitchLfo; 158 | } 159 | if(oscType == 3) 160 | { 161 | SinLfo =< filterLfo; 162 | SinLfo =< pitchLfo; 163 | SawLfo =< filterLfo; 164 | SawLfo =< pitchLfo; 165 | SqrLfo => filterLfo; 166 | SqrLfo => pitchLfo; 167 | } 168 | } 169 | 170 | fun void keyOff(int noteNumber) 171 | { 172 | noteNumber => adsr.keyOff; 173 | } 174 | 175 | fun void filterEnvelope() 176 | { 177 | filterCutoff => float startFreq; 178 | while((adsr.state() != 0 && adsr.value() == 0) == false) 179 | { 180 | (filterEnv * adsr.value()) + startFreq + filterLfo.last() => lpf.freq; 181 | 10::ms => now; 182 | } 183 | 184 | } 185 | 186 | fun void cutoff(float amount) 187 | { 188 | if(amount > 100) 189 | { 190 | 100 => amount; 191 | } 192 | if(amount < 1) 193 | { 194 | 0 => amount; 195 | } 196 | (amount / 100) * 5000 => filterCutoff; 197 | 10::ms => now; 198 | } 199 | 200 | fun void rez(float amount) 201 | { 202 | if(amount > 100) 203 | { 204 | 100 => amount; 205 | } 206 | if(amount < 1) 207 | { 208 | 0 => amount; 209 | } 210 | 20 * (amount / 100) + 0.3 => lpf.Q; 211 | } 212 | 213 | fun void env(float amount) 214 | { 215 | if(amount > 100) 216 | { 217 | 100 => amount; 218 | } 219 | if(amount < 1) 220 | { 221 | 0 => amount; 222 | } 223 | 5000 * (amount / 100) => filterEnv; 224 | } 225 | 226 | fun void detune(float amount) 227 | { 228 | if(amount > 100) 229 | { 230 | 100 => amount; 231 | } 232 | if(amount < 1) 233 | { 234 | 0 => amount; 235 | } 236 | 5 * (amount / 100) => osc2Detune; 237 | } 238 | 239 | fun void pitchMod(float amount) 240 | { 241 | if(amount > 100) 242 | { 243 | 100 => amount; 244 | } 245 | if(amount < 1) 246 | { 247 | 0 => amount; 248 | } 249 | 84 * (amount / 100) => pitchLfo.gain; 250 | } 251 | 252 | fun void cutoffMod(float amount) 253 | { 254 | if(amount > 100) 255 | { 256 | 100 => amount; 257 | } 258 | if(amount < 1) 259 | { 260 | 0 => amount; 261 | } 262 | 500 * (amount / 100) => filterLfo.gain; 263 | } 264 | 265 | fun void noise(float amount) 266 | { 267 | if(amount > 100) 268 | { 269 | 100 => amount; 270 | } 271 | if(amount < 1) 272 | { 273 | 0 => amount; 274 | } 275 | 1.0 * (amount / 100) => noiseSource.gain; 276 | } 277 | 278 | fun void reverb(float amount) 279 | { 280 | if(amount > 100) 281 | { 282 | 100 => amount; 283 | } 284 | if(amount < 1) 285 | { 286 | 0 => amount; 287 | } 288 | 0.2 * (amount / 100) => rev.mix; 289 | } 290 | 291 | fun void displayHelp() 292 | { 293 | <<< "Classic mono synth voice" >>>; 294 | <<< "Designed by Clint Hoagland, 03/22/2021" >>>; 295 | <<< "usage:" >>>; 296 | <<< "keyOn: triggers adsr (0-127 in semitones)">>>; 297 | <<< "offset: controls note offset in semitones" >>>; 298 | <<< "cutoff: filter cutoff (0-100)" >>>; 299 | <<< "rez: filter resonance (0-100)" >>>; 300 | <<< "env: filter ADSR tracking (0-100)" >>>; 301 | <<< "ChooseOsc1: select osc type (0-3)" >>>; 302 | <<< "ChooseOsc2: select osc type (0-3)" >>>; 303 | <<< " (silence, tri, saw, square)" >>>; 304 | <<< "ChooseLFO: select LFO type (0-3)" >>>; 305 | <<< " (disabled, sine, saw, square)" >>>; 306 | <<< "detune: detune the two voice oscs (1-100)" >>>; 307 | <<< "oscOffset: offset the two voice oscs (in semitones)" >>>; 308 | <<< "adsr: works like a standard adsr" >>>; 309 | <<< "limiter: used as a hard limiter Dyno" >>>; 310 | <<< "SetLfoFreq: sets the LFO rate in Hz" >>>; 311 | <<< "pitchMod: osc LFO tracking amount (0-100)" >>>; 312 | <<< "cutoffMod: filter LFO tracking amount (0-100)">>>; 313 | <<< "noise: noise amount (0-100)" >>>; 314 | <<< "reverb: reverb amount (0-100)" >>>; 315 | } 316 | 317 | } 318 | 319 | SynthVoice voice; 320 | voice.displayHelp(); 321 | -------------------------------------------------------------------------------- /24-chubgraphs/use.ck: -------------------------------------------------------------------------------- 1 | SynthVoice voice => Dyno dyno => dac; 2 | [0,4,7,11,14,16,19,23,24] @=> int notes[]; 3 | //[0,0,12,10] @=> int notes[]; 4 | 10 => voice.cutoff; 5 | 2 => voice.ChooseOsc1; 6 | 3 => voice.ChooseOsc2; 7 | 10 => voice.detune; 8 | 0 => voice.oscOffset; 9 | 1.5 => voice.pitchMod; 10 | 50 => voice.cutoffMod; 11 | 0 => voice.ChooseLfo; 12 | 5 => voice.SetLfoFreq; 13 | 0 => voice.noise; 14 | 5 => voice.reverb; 15 | 1::ms => voice.adsr.attackTime; 16 | 150::ms => voice.adsr.decayTime; 17 | 1 => voice.adsr.gain; 18 | while(true) 19 | { 20 | Math.random2(1,3) => int nextOsc; 21 | nextOsc => voice.ChooseOsc1; 22 | nextOsc => voice.ChooseOsc2; 23 | Math.random2(1,10) => voice.SetLfoFreq; 24 | Math.random2(1,15) => voice.rez; 25 | Math.random2(1,100) => voice.env; 26 | notes[Math.random2(0, notes.cap()-1)] + 12 => voice.keyOn; 27 | 1::second / 8 => now; 28 | 1 => voice.keyOff; 29 | } -------------------------------------------------------------------------------- /25-livecoding/initialize.ck: -------------------------------------------------------------------------------- 1 | me.dir() + "synthvoice.ck" => string voiceFile; 2 | me.dir() + "loop.ck" => string loopFile; 3 | 4 | Machine.add(voiceFile); 5 | Machine.add(loopFile); 6 | -------------------------------------------------------------------------------- /25-livecoding/live.ck: -------------------------------------------------------------------------------- 1 | 1::second / 2 => dur beat; 2 | beat - (now % beat) => now; 3 | 4 | SynthVoice voice => Delay delay[2] => dac; 5 | 1::second => delay[0].max => delay[1].max; 6 | 0.2 => delay[0].gain => delay[1].gain; 7 | 1 => delay[0].op => delay[1].op; 8 | beat / 4 => delay[0].delay; 9 | beat / 2 => delay[1].delay; 10 | delay => delay; 11 | voice => dac; 12 | 13 | 50 => voice.cutoff; 14 | 10 => voice.env; 15 | 48 => voice.offset; 16 | 1 => voice.ChooseOsc1; 17 | 1 => voice.ChooseOsc2; 18 | 15 => voice.detune; 19 | 12 => voice.oscOffset; 20 | 0 => voice.pitchMod; 21 | 0 => voice.cutoffMod; 22 | 1 => voice.ChooseLfo; 23 | 4 => voice.SetLfoFreq; 24 | 0 => voice.noise; 25 | 40 => voice.reverb; 26 | 150::ms => voice.adsr.attackTime; 27 | 150::ms => voice.adsr.decayTime; 28 | 0 => voice.adsr.sustainLevel; 29 | 0.5 => voice.adsr.gain; 30 | 0 => voice.rez; 31 | 32 | while(true) 33 | { 34 | [0,4,7,11,12,14,19,23] @=> int notes[]; 35 | while(true) 36 | { 37 | 38 | for(0 => int i; i < notes.cap(); i++) 39 | { 40 | 36 => voice.offset; 41 | voice.keyOn(notes[Math.random2(0, notes.cap()-1)]); 42 | //voice.keyOn(12); 43 | beat / 4 => now; 44 | 1 => voice.keyOff; 45 | } 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /25-livecoding/loop.ck: -------------------------------------------------------------------------------- 1 | 0 => int removeSynth; 2 | 0 => int removePanning; 3 | me.dir() + "live.ck" => string synthFile; 4 | me.dir() + "panning.ck" => string panFile; 5 | 6 | 1::second / 2 => dur beat; 7 | 8 | while(true) 9 | { 10 | Machine.remove(removeSynth); 11 | Machine.remove(removePanning); 12 | 13 | Machine.add(synthFile) => removeSynth; 14 | Machine.add(panFile) => removePanning; 15 | beat * 16 => now; 16 | } -------------------------------------------------------------------------------- /25-livecoding/mod.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => dac; 2 | 3 | 0.5 => osc.gain; 4 | 5 | while(true) 6 | { 7 | for(0 => int i; i < 16; i++) 8 | { 9 | Std.mtof(48 + ((i % 4) * 12)) => osc.freq; 10 | .25::second => now; 11 | } 12 | 13 | 14 | } 15 | -------------------------------------------------------------------------------- /25-livecoding/panning.ck: -------------------------------------------------------------------------------- 1 | //<<< "Panning and Randomization" >>>; 2 | 3 | SinOsc osc => ADSR env1 => NRev rev => Pan2 pan => dac; 4 | 5 | 0.05 => rev.mix; 6 | 7 | -1.0 => pan.pan; 8 | 9 | 0.5::second => dur beat; 10 | beat - (now % beat) => now; 11 | //T - (now % T) => now; 12 | ( 1::ms , beat/8, 0, 1::ms) => env1.set; 13 | 0.1 => osc.gain; 14 | 15 | [0,4,7, 11] @=> int major[]; 16 | [0,3,7] @=> int minor[]; 17 | 18 | 48 => int offset; 19 | int position; 20 | 21 | // <<< "TriOsc channels: ", osc.channels()>>>; 22 | // <<< "ADSR channels: ", env1.channels()>>>; 23 | // <<< "Reverb channels: ", rev.channels()>>>; 24 | // <<< "Pan channels: ", pan.channels()>>>; 25 | // <<< "DAC channels", dac.channels()>>>; 26 | 27 | while(true) 28 | { 29 | for(-1.0 => float j; j < 1.0; 0.1 +=> j) 30 | { 31 | beat / Math.random2(1, 16) => env1.decayTime; 32 | Math.random2(0,3) * 12 => position; 33 | Math.random2f(-1.0, 1.0) => float panValue; 34 | Math.random2(0, major.cap() -1) => int note; 35 | panValue => pan.pan; 36 | //<<< "pan:", panValue >>>; 37 | Std.mtof(major[note] + offset + position) => osc.freq; 38 | 1 => env1.keyOn; 39 | beat / 2 => now; 40 | } 41 | } 42 | 4::beat => now; 43 | 44 | -------------------------------------------------------------------------------- /25-livecoding/synthvoice.ck: -------------------------------------------------------------------------------- 1 | public class SynthVoice extends Chugraph 2 | { 3 | SawOsc saw1 => LPF lpf => ADSR adsr => Dyno limiter => NRev rev => outlet; 4 | SawOsc saw2 => lpf; 5 | Noise noiseSource => lpf; 6 | 7 | 0 => noiseSource.gain; 8 | 9 | TriOsc tri1, tri2; 10 | SqrOsc sqr1, sqr2; 11 | 12 | SinOsc SinLfo; 13 | SawOsc SawLfo; 14 | SqrOsc SqrLfo; 15 | SinLfo => Gain pitchLfo => blackhole; 16 | SinLfo => Gain filterLfo => blackhole; 17 | 18 | fun void SetLfoFreq(float frequency) 19 | { 20 | frequency => SinLfo.freq => SawLfo.freq => SqrLfo.freq; 21 | } 22 | 23 | 6.0 => SetLfoFreq; 24 | 0 => filterLfo.gain; 25 | 0 => pitchLfo.gain; 26 | 27 | 2 => saw1.sync => saw2.sync => tri1.sync => tri2.sync => sqr1.sync => sqr2.sync; 28 | pitchLfo => saw1; 29 | pitchLfo => saw2; 30 | pitchLfo => tri1; 31 | pitchLfo => tri2; 32 | pitchLfo => sqr1; 33 | pitchLfo => sqr2; 34 | 35 | 0::ms => limiter.attackTime; 36 | 0.8 => limiter.thresh; 37 | 38 | 0.1 => tri1.gain => tri2.gain; 39 | 0.1 => saw1.gain => saw2.gain; 40 | 0.1 => sqr1.gain => sqr2.gain; 41 | 42 | 10 => float filterCutoff; 43 | filterCutoff => lpf.freq; 44 | 45 | 1::ms => adsr.attackTime; 46 | 150::ms => adsr.decayTime; 47 | 0 => adsr.sustainLevel; 48 | 1::ms => adsr.releaseTime; 49 | 50 | 24 => int offset; 51 | 0 => float filterEnv; 52 | 53 | 1 => float osc2Detune; 54 | 0 => int oscOffset; 55 | 56 | fun void SetOsc1Freq(float frequency) 57 | { 58 | frequency => tri1.freq => sqr1.freq => saw1.freq; 59 | } 60 | 61 | fun void SetOsc2Freq(float frequency) 62 | { 63 | frequency => tri2.freq => sqr2.freq => saw2.freq; 64 | } 65 | 66 | fun void keyOn(int noteNumber) 67 | { 68 | Std.mtof(offset + noteNumber) => SetOsc1Freq; 69 | Std.mtof(offset + noteNumber + oscOffset) - osc2Detune => SetOsc2Freq; 70 | 1 => adsr.keyOn; 71 | spork ~ filterEnvelope(); 72 | } 73 | 74 | fun void ChooseOsc1(int oscType) 75 | { 76 | if(oscType == 0) 77 | { 78 | tri1 =< lpf; 79 | saw1 =< lpf; 80 | sqr1 =< lpf; 81 | } 82 | if(oscType == 1) 83 | { 84 | tri1 => lpf; 85 | saw1 =< lpf; 86 | sqr1 =< lpf; 87 | } 88 | if(oscType == 2) 89 | { 90 | tri1 =< lpf; 91 | saw1 => lpf; 92 | sqr1 =< lpf; 93 | } 94 | if(oscType == 3) 95 | { 96 | tri1 =< lpf; 97 | saw1 =< lpf; 98 | sqr1 => lpf; 99 | } 100 | } 101 | 102 | fun void ChooseOsc2(int oscType) 103 | { 104 | if(oscType == 0) 105 | { 106 | tri2 =< lpf; 107 | saw2 =< lpf; 108 | sqr2 =< lpf; 109 | } 110 | if(oscType == 1) 111 | { 112 | tri2 => lpf; 113 | saw2 =< lpf; 114 | sqr2 =< lpf; 115 | } 116 | if(oscType == 2) 117 | { 118 | tri2 =< lpf; 119 | saw2 => lpf; 120 | sqr2 =< lpf; 121 | } 122 | if(oscType == 3) 123 | { 124 | tri2 =< lpf; 125 | saw2 =< lpf; 126 | sqr2 => lpf; 127 | } 128 | } 129 | 130 | fun void ChooseLfo(int oscType) 131 | { 132 | if(oscType == 0) 133 | { 134 | SinLfo =< filterLfo; 135 | SinLfo =< pitchLfo; 136 | SawLfo =< filterLfo; 137 | SawLfo =< pitchLfo; 138 | SqrLfo =< filterLfo; 139 | SqrLfo =< pitchLfo; 140 | } 141 | if(oscType == 1) 142 | { 143 | SinLfo => filterLfo; 144 | SinLfo => pitchLfo; 145 | SawLfo =< filterLfo; 146 | SawLfo =< pitchLfo; 147 | SqrLfo =< filterLfo; 148 | SqrLfo =< pitchLfo; 149 | } 150 | if(oscType == 2) 151 | { 152 | SinLfo =< filterLfo; 153 | SinLfo =< pitchLfo; 154 | SawLfo => filterLfo; 155 | SawLfo => pitchLfo; 156 | SqrLfo =< filterLfo; 157 | SqrLfo =< pitchLfo; 158 | } 159 | if(oscType == 3) 160 | { 161 | SinLfo =< filterLfo; 162 | SinLfo =< pitchLfo; 163 | SawLfo =< filterLfo; 164 | SawLfo =< pitchLfo; 165 | SqrLfo => filterLfo; 166 | SqrLfo => pitchLfo; 167 | } 168 | } 169 | 170 | fun void keyOff(int noteNumber) 171 | { 172 | noteNumber => adsr.keyOff; 173 | } 174 | 175 | fun void filterEnvelope() 176 | { 177 | filterCutoff => float startFreq; 178 | while((adsr.state() != 0 && adsr.value() == 0) == false) 179 | { 180 | (filterEnv * adsr.value()) + startFreq + filterLfo.last() => lpf.freq; 181 | 10::ms => now; 182 | } 183 | } 184 | 185 | fun void cutoff(float amount) 186 | { 187 | if(amount > 100) 188 | { 189 | 100 => amount; 190 | } 191 | if(amount < 1) 192 | { 193 | 0 => amount; 194 | } 195 | (amount / 100) * 5000 => filterCutoff; 196 | 10::ms => now; 197 | } 198 | 199 | fun void rez(float amount) 200 | { 201 | if(amount > 100) 202 | { 203 | 100 => amount; 204 | } 205 | if(amount < 1) 206 | { 207 | 0 => amount; 208 | } 209 | 20 * (amount / 100) + 0.3 => lpf.Q; 210 | } 211 | 212 | fun void env(float amount) 213 | { 214 | if(amount > 100) 215 | { 216 | 100 => amount; 217 | } 218 | if(amount < 1) 219 | { 220 | 0 => amount; 221 | } 222 | 5000 * (amount / 100) => filterEnv; 223 | } 224 | 225 | fun void detune(float amount) 226 | { 227 | if(amount > 100) 228 | { 229 | 100 => amount; 230 | } 231 | if(amount < 1) 232 | { 233 | 0 => amount; 234 | } 235 | 5 * (amount / 100) => osc2Detune; 236 | } 237 | 238 | fun void pitchMod(float amount) 239 | { 240 | if(amount > 100) 241 | { 242 | 100 => amount; 243 | } 244 | if(amount < 1) 245 | { 246 | 0 => amount; 247 | } 248 | 84 * (amount / 100) => pitchLfo.gain; 249 | } 250 | 251 | fun void cutoffMod(float amount) 252 | { 253 | if(amount > 100) 254 | { 255 | 100 => amount; 256 | } 257 | if(amount < 1) 258 | { 259 | 0 => amount; 260 | } 261 | 500 * (amount / 100) => filterLfo.gain; 262 | } 263 | 264 | fun void noise(float amount) 265 | { 266 | if(amount > 100) 267 | { 268 | 100 => amount; 269 | } 270 | if(amount < 1) 271 | { 272 | 0 => amount; 273 | } 274 | 1.0 * (amount / 100) => noiseSource.gain; 275 | } 276 | 277 | fun void reverb(float amount) 278 | { 279 | if(amount > 100) 280 | { 281 | 100 => amount; 282 | } 283 | if(amount < 1) 284 | { 285 | 0 => amount; 286 | } 287 | 0.2 * (amount / 100) => rev.mix; 288 | } 289 | 290 | fun void help() 291 | { 292 | <<< "Classic mono synth voice" >>>; 293 | <<< "Designed by Clint Hoagland, 03/22/2021" >>>; 294 | <<< "usage:" >>>; 295 | <<< "keyOn: triggers adsr (0-127 in semitones)">>>; 296 | <<< "offset: controls note offset in semitones" >>>; 297 | <<< "cutoff: filter cutoff (0-100)" >>>; 298 | <<< "rez: filter resonance (0-100)" >>>; 299 | <<< "env: filter ADSR tracking (0-100)" >>>; 300 | <<< "ChooseOsc1: select osc type (0-3)" >>>; 301 | <<< "ChooseOsc2: select osc type (0-3)" >>>; 302 | <<< " (silence, tri, saw, square)" >>>; 303 | <<< "ChooseLFO: select LFO type (0-3)" >>>; 304 | <<< " (disabled, sine, saw, square)" >>>; 305 | <<< "detune: detune the two voice oscs (1-100)" >>>; 306 | <<< "oscOffset: offset the two voice oscs (in semitones)" >>>; 307 | <<< "adsr: works like a standard adsr" >>>; 308 | <<< "limiter: used as a hard limiter Dyno" >>>; 309 | <<< "SetLfoFreq: sets the LFO rate in Hz" >>>; 310 | <<< "pitchMod: osc LFO tracking amount (0-100)" >>>; 311 | <<< "cutoffMod: filter LFO tracking amount (0-100)">>>; 312 | <<< "noise: noise amount (0-100)" >>>; 313 | <<< "reverb: reverb amount (0-100)" >>>; 314 | } 315 | 316 | } 317 | 318 | SynthVoice voice; 319 | voice.help(); 320 | 321 | // SynthVoice voice => Dyno dyno => dac; 322 | // [0,4,7,11,14,16,19,23,24] @=> int notes[]; 323 | // //[0,0,12,10] @=> int notes[]; 324 | // 10 => voice.cutoff; 325 | // 2 => voice.ChooseOsc1; 326 | // 2 => voice.ChooseOsc2; 327 | // 0 => voice.detune; 328 | // -12 => voice.oscOffset; 329 | // 1.5 => voice.pitchMod; 330 | // 50 => voice.cutoffMod; 331 | // 1 => voice.ChooseLfo; 332 | // 5 => voice.SetLfoFreq; 333 | // 15 => voice.noise; 334 | // 10 => voice.reverb; 335 | // 250::ms => voice.adsr.attackTime; 336 | // 250::ms => voice.adsr.decayTime; 337 | // while(true) 338 | // { 339 | // Math.random2(1,3) => int nextOsc; 340 | // 2 => voice.ChooseOsc1; 341 | // 2 => voice.ChooseOsc2; 342 | // Math.random2(1,10) => voice.SetLfoFreq; 343 | // Math.random2(1,25) => voice.rez; 344 | // Math.random2(1,50) => voice.env; 345 | // notes[Math.random2(0, notes.cap()-1)] + 24 => voice.keyOn; 346 | // 1::second / 2 => now; 347 | // 1 => voice.keyOff; 348 | 349 | // } 350 | -------------------------------------------------------------------------------- /26-LiSa/hybrid.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => NRev rev => dac; 2 | adc => LiSa lisa => rev; 3 | 4 | 1::second / 2 => dur beat; 5 | 6 | 0.25 => osc.gain; 7 | 8 | 4::beat => lisa.duration; 9 | 10 | (1::ms, 150::ms, 0, 1::ms) => env.set; 11 | 12 | 0.2 => rev.mix; 13 | 14 | 48 => int offset; 15 | 16 | 17 | while(true) 18 | { 19 | [0,4,7,11,12,16,19,23] @=> int notes[]; 20 | 1 => lisa.record; 21 | for(0 => int i; i < notes.cap(); i++) 22 | { 23 | Std.mtof(notes[i] + offset) => osc.freq; 24 | 1 => env.keyOn; 25 | 0.5::beat => now; 26 | } 27 | 0 => lisa.record; 28 | 1 => lisa.loop; 29 | 1::ms => lisa.rampUp; 30 | 1 => lisa.bi; 31 | 32 | for(0 => float i; i < 2; i + 1 => i) 33 | { 34 | 3::beat => lisa.loopStart; 35 | 4::beat => lisa.loopEnd; 36 | 4::beat => now; 37 | } 38 | 1::ms => lisa.rampDown; 39 | 40 | 1 => lisa.record; 41 | for(0 => int i; i < notes.cap(); i++) 42 | { 43 | Std.mtof(notes[i] + offset + 5) => osc.freq; 44 | 1 => env.keyOn; 45 | 0.5::beat => now; 46 | } 47 | 0 => lisa.record; 48 | 1::ms => lisa.rampUp; 49 | 50 | for(0 => float i; i < 2; i + 1 => i) 51 | { 52 | 3::beat => lisa.loopStart; 53 | 4::beat => lisa.loopEnd; 54 | 4::beat => now; 55 | } 56 | 0::ms => lisa.rampDown; 57 | } -------------------------------------------------------------------------------- /26-LiSa/lisa-ex-1.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => NRev rev => dac; 2 | rev => LiSa lisa => dac; 3 | lisa => Delay delay[2] => dac; 4 | 5 | 0.5::second => dur beat; 6 | 7 | beat => delay[0].max => delay[1].max; 8 | 30::ms => delay[0].delay; 9 | 40::ms => delay[1].delay; 10 | 11 | 880 => osc.freq; 12 | 0.25 => osc.gain; 13 | 14 | (1::ms, 5::ms, 0, 1::ms) => env.set; 15 | 16 | 0.2 => rev.mix; 17 | 18 | 4::beat => lisa.duration; 19 | 20 | 1 => lisa.record; 21 | 1 => env.keyOn; 22 | 4::beat => now; 23 | 0 => lisa.record; 24 | 1 => lisa.play; 25 | while(true) 26 | { 27 | 0::beat => lisa.playPos; 28 | [0.25, 0.5, 1.0, 1.5, 2.0] @=> float rates[]; 29 | rates[Math.random2(0,4)] => lisa.rate; 30 | 0.25::beat => now; 31 | } 32 | 33 | -------------------------------------------------------------------------------- /26-LiSa/lisa-ex-2.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => NRev rev => dac; 2 | rev => LiSa lisa => dac; 3 | 4 | 0.5::second => dur beat; 5 | 4::beat => lisa.duration; 6 | 7 | (1::ms, 5::ms, 0, 1::ms) => env.set; 8 | 9 | 880 => osc.freq; 10 | 0.25 => osc.gain; 11 | 12 | 0.2 => rev.mix; 13 | 14 | 1 => lisa.record; 15 | 1 => env.keyOn; 16 | 4::beat => now; 17 | 0 => lisa.record; 18 | 1 => lisa.play; 19 | 1 => lisa.bi; 20 | 8::beat => now; -------------------------------------------------------------------------------- /26-LiSa/lisa-loop-1.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR adsr => JCRev rev[2] => dac; 2 | rev => Dyno dyno[2] => LiSa lisa => BPF lpf; 3 | -1 => lpf.op; 4 | 5 | 0::ms => dyno[0].attackTime; 6 | 0::ms => dyno[1].attackTime; 7 | 8 | 0.8 => dyno[0].thresh; 9 | 0.8 => dyno[1].thresh; 10 | 11 | 12 | dac => WvOut waveOut => blackhole; 13 | "lisa1.wav" => waveOut.wavFilename; 14 | 15 | 1::second => lisa.duration; 16 | 1::ms => lisa.recRamp; 17 | 18 | lpf => Echo delay[3]; 19 | for(0 => int i; i < delay.cap(); i++) 20 | { 21 | 1 => delay[i].op; 22 | 2::second => delay[i].max; 23 | 0.250::second * (i+1) => delay[i].delay; 24 | 0.5 => delay[i].mix; 25 | } 26 | 27 | delay[0] => dac.left; 28 | delay[1] => dac; 29 | delay[2] => dac.right; 30 | 31 | 32 | 33 | 0.3 => osc.gain; 34 | 0.4 => rev[0].mix => rev[1].mix; 35 | 36 | ( 1::ms, 100::ms, 0, 0::ms) => adsr.set; 37 | [-24,-12,0,3,7,10,12] @=> int notes[]; 38 | lisa.record(1); 39 | for(0 => int i; i < notes.cap(); i++) 40 | { 41 | Std.mtof(notes[i] + 72) => osc.freq; 42 | 1 => adsr.keyOn; 43 | 1::second / 6 => now; 44 | } 45 | 46 | //1::second => now; 47 | lisa.record(0); 48 | 49 | lisa.play(1); 50 | lisa.loop(1); 51 | lisa.bi(1); 52 | spork ~ FilterLFO(); 53 | 54 | fun void FilterLFO() 55 | { 56 | while(true) 57 | { 58 | (Math.random2f(50,800), Math.random2f(1.0,8.0)) => lpf.set; 59 | 0.25::second => now; 60 | } 61 | } 62 | 63 | while(true) 64 | { 65 | (0, 1) => lisa.rate; 66 | lisa.play(1); 67 | for(0 => int i; i<4; i++) 68 | { 69 | 1::second => now; 70 | } 71 | (0, .667) => lisa.rate; 72 | lisa.play(1); 73 | for(0 => int i; i<4; i++) 74 | { 75 | 1::second => now; 76 | } 77 | (0, 1) => lisa.rate; 78 | lisa.play(1); 79 | for(0 => int i; i<4; i++) 80 | { 81 | 1::second => now; 82 | } 83 | (0, 1.333) => lisa.rate; 84 | lisa.play(1); 85 | for(0 => int i; i<4; i++) 86 | { 87 | 1::second => now; 88 | } 89 | } -------------------------------------------------------------------------------- /27-events/event-test-1.ck: -------------------------------------------------------------------------------- 1 | class WaitWithPosition extends Event 2 | { 3 | int position; 4 | } 5 | 6 | 48 => int offset; 7 | 8 | [0,4,7,11] @=> int notes[]; 9 | 10 | fun void playArp(WaitWithPosition wait) 11 | { 12 | SinOsc osc => dac; 13 | 0.25 => osc.gain; 14 | while (true) 15 | { 16 | for(0 => int i; i < notes.cap(); i ++ ) 17 | { 18 | offset + notes[i] + wait.position => Std.mtof => osc.freq; 19 | 0.25::second => now; 20 | } 21 | <<< wait.position, "waiting..." >>>; 22 | wait => now; 23 | <<< wait.position, "...go" >>>; 24 | } 25 | } 26 | 27 | WaitWithPosition wait; 28 | 29 | 0 => wait.position; 30 | spork ~ playArp(wait); 31 | 2::second => now; 32 | 33 | 12 => wait.position; 34 | spork ~ playArp(wait); 35 | 2::second => now; 36 | 37 | 24 => wait.position; 38 | spork ~ playArp(wait); 39 | 40 | while(true) 41 | { 42 | 2::second => now; 43 | wait.signal(); 44 | } -------------------------------------------------------------------------------- /27-events/event-test-2.ck: -------------------------------------------------------------------------------- 1 | Hid hi; 2 | HidMsg msg; 3 | 4 | if( !hi.openKeyboard( 0 ) ) me.exit(); 5 | <<< "keyboard '" + hi.name() + "' ready", "" >>>; 6 | 7 | // infinite event loop 8 | while( true ) 9 | { 10 | // wait on event 11 | hi => now; 12 | 13 | // get one or more messages 14 | while( hi.recv( msg ) && msg.which != 29 ) //ignore ctrl key 15 | { 16 | // check for action type 17 | if( msg.isButtonDown() ) 18 | { 19 | <<< "down:", msg.which, "(code)", msg.key, "(usb key)", msg.ascii, "(ascii)" >>>; 20 | } 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /27-events/event-test-3.ck: -------------------------------------------------------------------------------- 1 | //set up audio chain 2 | SinOsc osc => ADSR env1 => NRev rev => dac; 3 | 0.5 => osc.gain; 4 | (1::ms, 100::ms, 0.0, 1::ms) => env1.set; 5 | 0.1 => rev.mix; 6 | 7 | //set up keyboard 8 | Hid hi; 9 | HidMsg msg; 10 | if( !hi.openKeyboard( 0 ) ) me.exit(); 11 | <<< "keyboard '" + hi.name() + "' ready", "" >>>; 12 | 13 | fun void PlayBeep(int key) 14 | { 15 | key => Std.mtof => osc.freq; 16 | 1 => env1.keyOn; 17 | 100::ms => now; 18 | 1 => env1.keyOff; 19 | } 20 | 21 | while( true ) 22 | { 23 | hi => now; 24 | while( hi.recv( msg ) && msg.which != 29 ) //ignore ctrl key 25 | { 26 | if( msg.isButtonDown() ) 27 | { 28 | spork ~ PlayBeep(msg.ascii); 29 | } 30 | } 31 | } -------------------------------------------------------------------------------- /28-midi/midi-test-2.ck: -------------------------------------------------------------------------------- 1 | //set up audio chain 2 | LPF lpf => NRev rev => Dyno dyno => dac; 3 | 500 => lpf.freq; 4 | 5 => lpf.Q; 5 | 0.05 => rev.mix; 6 | 7 | //Get MIDI device input 8 | MidiIn midi; 9 | MidiMsg msg; 10 | 0 => int device; 11 | if( me.args() ) me.arg(0) => Std.atoi => device; 12 | if( !midi.open( device ) ) me.exit(); 13 | <<< "MIDI device:", midi.num(), " -> ", midi.name() >>>; 14 | 15 | fun void PlayBeep(int key, int velocity) 16 | { 17 | SawOsc osc => ADSR env1 => lpf; 18 | 0.25 * (velocity / 127.0) => osc.gain; 19 | (1::ms, 1000::ms, 0.0, 1::ms) => env1.set; 20 | 21 | 22 | key => Std.mtof => osc.freq; 23 | 1 => env1.keyOn; 24 | 1000::ms => now; 25 | 1 => env1.keyOff; 26 | } 27 | 28 | while( true ) 29 | { 30 | midi => now; 31 | while( midi.recv( msg ) ) 32 | { 33 | if( msg.data1 == 144 ) 34 | { 35 | spork ~ PlayBeep(msg.data2, msg.data3); 36 | <<< msg.data1, msg.data2, msg.data3 >>>; 37 | } 38 | if( msg.data1 == 176) 39 | { 40 | 4000 * (msg.data3 / 127.0) => lpf.freq; 41 | } 42 | } 43 | } -------------------------------------------------------------------------------- /28-midi/midi-test-3.ck: -------------------------------------------------------------------------------- 1 | MidiOut gma; 2 | gma.open(2); 3 | MidiMsg msg; 4 | 5 | 48 => int offset; 6 | [0,4,7,11] @=> int chord[]; 7 | 8 | fun void PlayGma(int note) 9 | { 10 | <<< note >>>; 11 | 144 => msg.data1; 12 | note => msg.data2; 13 | 127 => msg.data3; 14 | gma.send(msg); 15 | 50::ms => now; 16 | 17 | 128 => msg.data1; 18 | note => msg.data2; 19 | 127 => msg.data3; 20 | gma.send(msg); 21 | 50::ms => now; 22 | } 23 | 24 | while(true) 25 | { 26 | Math.random2(0,3) * 12 => int position; 27 | Math.random2(0, chord.cap() -1) => int note; 28 | PlayGma(chord[note] + position + offset); 29 | } -------------------------------------------------------------------------------- /28-midi/midi-test.ck: -------------------------------------------------------------------------------- 1 | // number of the device to open (see: chuck --probe) 2 | 0 => int device; 3 | // get command line 4 | if( me.args() ) me.arg(0) => Std.atoi => device; 5 | 6 | // the midi event 7 | MidiIn min; 8 | // the message for retrieving data 9 | MidiMsg msg; 10 | 11 | // open the device 12 | if( !min.open( device ) ) me.exit(); 13 | 14 | // print out device that was opened 15 | <<< "MIDI device:", min.num(), " -> ", min.name() >>>; 16 | 17 | // infinite time-loop 18 | while( true ) 19 | { 20 | // wait on the event 'min' 21 | min => now; 22 | 23 | // get the message(s) 24 | while( min.recv(msg) ) 25 | { 26 | // print out midi message 27 | <<< msg.data1, msg.data2, msg.data3 >>>; 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /29-the-stk/stk-test-1.ck: -------------------------------------------------------------------------------- 1 | BandedWG stk => dac; 2 | 3 | //Delays, for fun 4 | stk => Delay delays[2] => dac; 5 | 1::second => delays[0].max => delays[1].max; 6 | 500::ms => delays[0].delay; 7 | 250::ms => delays[1].delay; 8 | 0.5 => delays[0].gain => delays[1].gain; 9 | delays[0] => delays[1]; 10 | delays[1] => delays[0]; 11 | 12 | [0,4,7,11] @=> int notes[]; 13 | 14 | 48 => int offset; 15 | 16 | 0.5 => stk.bowPressure; 17 | 0 => stk.preset; 18 | 19 | while(true) 20 | { 21 | Math.random2(0,3) => stk.preset; 22 | <<< stk.preset() >>>; 23 | Math.random2(0,2) => int position; 24 | (position * 12) + offset + notes[Math.random2(0, notes.cap() -1)] => int note; 25 | //48 => int note; 26 | note => Std.mtof => stk.freq; 27 | 1.0 => stk.pluck; 28 | 125::ms => now; 29 | 1.0 => stk.pluck; 30 | 125::ms => now; 31 | //1.0 => stk.stopBowing; 32 | //200::ms => now; 33 | } -------------------------------------------------------------------------------- /30-file-io/file-test-1.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => dac; 2 | (1::ms, 100::ms, 0, 1::ms) => env.set; 3 | 4 | FileIO io; 5 | 6 | <<< io.open("int.txt", FileIO.READ) >>>; 7 | 8 | while(io => int val) 9 | { 10 | <<< val >>>; 11 | 60 + val => Std.mtof => osc.freq; 12 | 1 => env.keyOn; 13 | 250::ms => now; 14 | } -------------------------------------------------------------------------------- /30-file-io/file-test-2.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => dac; 2 | (1::ms, 100::ms, 0, 1::ms) => env.set; 3 | 4 | FileIO io; 5 | 6 | <<< io.open("int2.txt", FileIO.READ) >>>; 7 | 8 | 2::second => dur beat; 9 | 60 => int offset; 10 | 11 | while(true) 12 | { 13 | while(io.eof() == false) 14 | { 15 | io => int note; 16 | io => int div; 17 | io => float vol; 18 | <<< note, div, vol >>>; 19 | note + offset => Std.mtof => osc.freq; 20 | vol => osc.gain; 21 | 1 => env.keyOn; 22 | beat / div => now; 23 | } 24 | 0 => io.seek; 25 | } -------------------------------------------------------------------------------- /30-file-io/file-test-3.ck: -------------------------------------------------------------------------------- 1 | SqrOsc osc => ADSR env => LPF lpf => Pan2 pan => dac; 2 | (1::ms, 100::ms, 0, 1::ms) => env.set; 3 | 4 | FileIO io; 5 | StringTokenizer tok; 6 | <<< io.open("lines.txt", FileIO.READ) >>>; 7 | 8 | 2::second => dur beat; 9 | 48 => int offset; 10 | 11 | 0.2 => osc.gain; 12 | 13 | 1000 => lpf.freq; 14 | 4 => lpf.Q; 15 | 16 | while(true) 17 | { 18 | while(io.more()) 19 | { 20 | io.readLine() => string line; 21 | 22 | if (line.find("//") == 0 ) 23 | { 24 | line => ProcessComment; 25 | } 26 | else if (line.find("R") == 0) 27 | { 28 | line => ProcessRest; 29 | } 30 | else 31 | { 32 | line => ProcessNote; 33 | } 34 | } 35 | 0 => io.seek; 36 | } 37 | 38 | fun void ProcessComment(string line) 39 | { 40 | <<< line >>>; 41 | } 42 | 43 | fun void ProcessRest(string line) 44 | { 45 | tok.set(line); 46 | tok.next() => string rest; 47 | tok.next() => Std.atoi => int div; 48 | <<< rest, div >>>; 49 | beat / div => now; 50 | } 51 | 52 | fun void ProcessNote(string line) 53 | { 54 | tok.set(line); 55 | tok.next() => Std.atoi => int note; 56 | tok.next() => Std.atoi => int div; 57 | <<< note, div >>>; 58 | note + offset => Std.mtof => osc.freq; 59 | 1 => env.keyOn; 60 | ProcessExtras(tok); 61 | beat / div => now; 62 | } 63 | 64 | fun void ProcessExtras(StringTokenizer tok) 65 | { 66 | while(tok.more()) 67 | { 68 | tok.next() => string extra; 69 | if(extra.find("P")==0) 70 | { 71 | extra.substring(1) => Std.atof => pan.pan; 72 | } 73 | if(extra.find("F")==0) 74 | { 75 | extra.substring(1) => Std.atof => lpf.freq; 76 | } 77 | if(extra.find("Q")==0) 78 | { 79 | extra.substring(1) => Std.atof => lpf.Q; 80 | } 81 | } 82 | } -------------------------------------------------------------------------------- /30-file-io/file-test-4.ck: -------------------------------------------------------------------------------- 1 | FileIO io; 2 | 3 | io.open("int.txt", FileIO.READ) => int success; 4 | 5 | int display; 6 | while(io.eof() == false) 7 | { 8 | io => display; 9 | <<< display >>>; 10 | } 11 | -------------------------------------------------------------------------------- /30-file-io/file-test-5.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => dac; 2 | (1::ms, 100::ms, 0, 1::ms) => env.set; 3 | 4 | FileIO io; 5 | 6 | <<< io.open("int2.txt", FileIO.READ) >>>; 7 | 8 | 2::second => dur beat; 9 | 60 => int offset; 10 | 11 | while(true) 12 | { 13 | while (io.eof() == false) 14 | { 15 | io => int note; 16 | io => int div; // divisor для 1/8 и 1/16 бита 17 | io => float vol; // volume 18 | <<< note, div >>>; 19 | note + offset => Std.mtof => osc.freq; 20 | vol => osc.gain; 21 | 1 => env.keyOn; 22 | beat / div => now; 23 | <<< "last thing in the inner loop", io.tell() >>>; 24 | } 25 | <<< "last thing before the seek", io.tell() >>>; 26 | 0 => io.seek; // показывает что выбрать дальше, 0 - выбирает первый токен, чтобы сделать луп - но почему-то не делает 27 | } -------------------------------------------------------------------------------- /30-file-io/int.txt: -------------------------------------------------------------------------------- 1 | 0 12 4 11 7 -1 -12-24 2 | 3 | -------------------------------------------------------------------------------- /30-file-io/int2.txt: -------------------------------------------------------------------------------- 1 | 0 4 1.0 2 | 3 | 4 | 5 | 4 16 0.2 6 | 7 16 0.4 7 | 11 16 0.6 8 | 12 16 0.8 9 | 5 8 0.8 10 | 11 | 9 8 0.8 12 | 13 | 5 16 0.2 14 | 9 16 0.4 15 | 12 16 0.6 16 | 16 16 0.8 17 | 0 8 0.8 18 | 19 | -12 16 0.4 20 | -24 16 0.6 21 | 4 16 0.2 22 | 7 16 0.4 23 | 11 16 0.6 24 | 12 16 0.8 25 | 5 8 0.4 26 | 27 | 9 8 0.2 28 | 29 | 5 16 0.2 30 | 9 16 0.4 31 | 12 16 0.6 32 | 16 16 0.8 -------------------------------------------------------------------------------- /30-file-io/lines.txt: -------------------------------------------------------------------------------- 1 | //Bar one --- the beginning of the song 2 | -12 16 3 | R 16 4 | R 16 5 | 0 16 6 | 12 16 P-1.0 F400 7 | 12 16 P1.0 F600 8 | R 16 9 | 12 16 F800 10 | 3 8 P0.5 Q1.0 11 | 7 8 Q2.0 12 | -14 16 F200 Q8.0 13 | -14 16 F400 14 | -14 16 F600 15 | -14 16 F800 -------------------------------------------------------------------------------- /31-basic-theory-part-2/chromatic.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => dac; 2 | 3 | 1::second / 30 => dur frame; 4 | 5 | 48 => int offset; 6 | for(0 => int i; i <= 12; i++) 7 | { 8 | offset + i => Std.mtof => osc.freq; 9 | <<< i >>>; 10 | 10::frame => now; 11 | } -------------------------------------------------------------------------------- /31-basic-theory-part-2/diatonic.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => dac; 2 | 3 | 1::second / 30 => dur frame; 4 | 5 | [0,2,4,5,7,9,11,12] @=> int major[]; 6 | 7 | 48 => int offset; 8 | for(0 => int i; i < major.cap(); i++) 9 | { 10 | offset + major[i] => Std.mtof => osc.freq; 11 | <<< major[i] >>>; 12 | 10::frame => now; 13 | } -------------------------------------------------------------------------------- /31-basic-theory-part-2/fifths.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => dac; 2 | TriOsc osc2 => dac; 3 | dac => WvOut outFile => blackhole; 4 | 5 | "fifths-example.wav" => outFile.wavFilename; 6 | 7 | 0.5 => osc.gain => osc2.gain; 8 | 9 | 1::second / 30 => dur frame; 10 | 11 | [0,2,4,5,7,9,11,12,14,16,17,19] @=> int major[]; 12 | 13 | 60 => int offset; 14 | for(0 => int i; i < 7; i++) 15 | { 16 | offset + major[i] => Std.mtof => osc.freq; 17 | offset + major[i + 4] => Std.mtof => osc2.freq; 18 | <<< major[i], major[i + 4] >>>; 19 | 20::frame => now; 20 | } 21 | 30::frame => now; -------------------------------------------------------------------------------- /31-basic-theory-part-2/random-thirds.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => Delay delay[2]; 2 | SinOsc osc2 => delay; 3 | delay => dac => WvOut2 outFile => blackhole; 4 | osc => dac; 5 | osc2 => dac; 6 | 7 | 8 | 2::second => delay[0].max => delay[1].max; 9 | 10 | "random-thirds.wav" => outFile.wavFilename; 11 | 12 | 0.25 => osc.gain => osc2.gain; 13 | 0.5 => delay[0].gain => delay[1].gain; 14 | 15 | 1::second / 60 => dur frame; 16 | 17 | 10::frame => delay[0].delay; 18 | 20::frame => delay[1].delay; 19 | 20 | delay[0] => delay[1]; 21 | 22 | [0,2,4,5,7,9,11,12,14,16,17,19] @=> int major[]; 23 | 24 | 60 => int offset; 25 | while(true) 26 | { 27 | Math.random2(0,8) => int i; 28 | offset + major[i] => Std.mtof => osc.freq; 29 | offset + major[i + 2] => Std.mtof => osc2.freq; 30 | <<< major[i], major[i + 2] >>>; 31 | 20::frame => now; 32 | } 33 | -------------------------------------------------------------------------------- /32-pulse-oscillator/PWM.ck: -------------------------------------------------------------------------------- 1 | PulseOsc osc => LPF lpf => ADSR env1 => dac => WvOut2 waveOut => blackhole; 2 | 3 | TriOsc LFO => blackhole; 4 | -1 => lpf.op; 5 | 6 | env1 => Delay delay[2] => dac; 7 | 8 | 1500 => lpf.freq; 9 | 10 | 4::second => delay[0].max => delay[1].max; 11 | 12 | "pulse-test-2.wav" => waveOut.wavFilename; 13 | 14 | 110 => osc.freq; 15 | 16 | 0.25 => osc.gain; 17 | .1 => osc.width; 18 | 19 | 0.5::second => dur beat; 20 | 1::beat => delay[0].delay; 21 | 2::beat => delay[1].delay; 22 | delay[0] => delay[1] => delay [0]; 23 | .75 => delay[0].gain => delay[1].gain; 24 | 25 | [0,3,7,10,14] @=> int chord[]; 26 | 27 | 36 => int offset; 28 | 29 | 0.40 => LFO.gain; 30 | 1 => LFO.freq; 31 | 32 | 33 | fun void processLfo() 34 | { 35 | while(true) 36 | { 37 | (LFO.last()) + 0.5 => osc.width; 38 | 1::ms => now; 39 | } 40 | } 41 | spork ~ processLfo(); 42 | 43 | (2::beat,100::ms, 0.5, 1::beat) => env1.set; 44 | 45 | while(true) 46 | { 47 | Math.random2(0,3) * 12 => int octave; 48 | Math.random2(0,chord.cap()-1) => int note; 49 | Math.random2f(10.0,100.0); 50 | octave + chord[note] + offset => Std.mtof => osc.freq; 51 | <<< osc.width() >>>; 52 | 1 => env1.keyOn; 53 | 2::beat => now; 54 | 1 => env1.keyOff; 55 | 2::beat => now; 56 | } -------------------------------------------------------------------------------- /32-pulse-oscillator/pulse-widths.ck: -------------------------------------------------------------------------------- 1 | PulseOsc osc => dac => WvOut2 waveOut => blackhole; 2 | 3 | 0.5 => osc.gain; 4 | 48 => int offset; 5 | 6 | [0,4,7,12] @=> int notes[]; 7 | [.50,.40,.30,.20,.10] @=> float widths[]; 8 | 9 | for(0 => int w; w int i; i<4; i++) 12 | { 13 | for(0 => int j; j osc.width; 16 | notes[j] + offset + i => Std.mtof => osc.freq; 17 | 150::ms => now; 18 | } 19 | } 20 | } -------------------------------------------------------------------------------- /33-file-output/file-output-test-1.ck: -------------------------------------------------------------------------------- 1 | FileIO fout; 2 | 3 | // open for write 4 | fout.open( "out.txt", FileIO.WRITE ); 5 | 6 | // test 7 | if( !fout.good() ) 8 | { 9 | cherr <= "can't open file for writing..." <= IO.newline(); 10 | me.exit(); 11 | } 12 | 13 | // write some stuff 14 | fout <= 1 <= " " <= 2 <= " " <= "foo"; 15 | fout <= 1 <= " " <= 2 <= " " <= "foo"; 16 | // close the thing 17 | fout.close(); 18 | -------------------------------------------------------------------------------- /33-file-output/file-output-test-2.ck: -------------------------------------------------------------------------------- 1 | FileIO fout; 2 | 3 | // open for write 4 | fout.open( "out2.txt", FileIO.WRITE ); 5 | 6 | // test 7 | if( !fout.good() ) 8 | { 9 | cherr <= "can't open file for writing..." <= IO.newline(); 10 | me.exit(); 11 | } 12 | 13 | // write some stuff 14 | fout.write( 1 ); 15 | fout.write( 2 ); 16 | fout.write( "boo" ); 17 | 18 | // close the thing 19 | fout.close(); 20 | -------------------------------------------------------------------------------- /33-file-output/file-output-test-3.ck: -------------------------------------------------------------------------------- 1 | FileIO fout; 2 | 3 | 4 | fout.open( "out3.txt", FileIO.APPEND ); 5 | 6 | for(1 => int i; i <= 1000; i++) 7 | { 8 | 9 | 10 | if( !fout.good() ) 11 | { 12 | cherr <= "can't open file for writing..." <= IO.newline(); 13 | me.exit(); 14 | } 15 | 16 | fout <= i <= IO.newline(); 17 | 18 | } 19 | fout.close(); 20 | 21 | -------------------------------------------------------------------------------- /33-file-output/file-output-test-4.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => Pan2 pan => NRev rev[2] => dac; 2 | 3 | FileIO partFile; 4 | partFile.open( "part.txt", FileIO.WRITE ); 5 | 6 | 0.25 => osc.gain; 7 | (1::ms, 100::ms, 0, 1::ms) => env.set; 8 | 0.1 => rev[0].mix => rev[1].mix; 9 | 10 | [0,3,7,10,12,14] @=> int notes[]; 11 | 48 => int offset; 12 | 0 => int position; 13 | 14 | for(0 => int i; i < 256; i++) 15 | { 16 | Math.random2(0,2) * 12 => position; 17 | 18 | notes[Math.random2(0, notes.cap()-1)] + offset + position => int note; 19 | note => Std.mtof => osc.freq; 20 | Math.random2f(-1.0,1.0) => pan.pan; 21 | Math.random2(1, 500) => int decay; 22 | decay::ms => env.decayTime; 23 | 24 | 1 => env.keyOn; 25 | partFile <= note <= " " <= pan.pan() <= " " <= decay <= IO.newline(); 26 | 125::ms => now; 27 | } 28 | 29 | partFile.close(); -------------------------------------------------------------------------------- /33-file-output/file-output-test-4b.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => Pan2 pan => NRev rev[2] => dac; 2 | 3 | FileIO partFile; 4 | partFile.open( "part.txt", FileIO.READ ); 5 | 6 | 0.25 => osc.gain; 7 | (1::ms, 100::ms, 0, 1::ms) => env.set; 8 | 0.1 => rev[0].mix => rev[1].mix; 9 | 10 | while(true) 11 | { 12 | while(partFile.eof() == false) 13 | { 14 | partFile => int note; 15 | partFile => float panPos; 16 | partFile => int decay; 17 | 18 | note => Std.mtof => osc.freq; 19 | panPos => pan.pan; 20 | decay::ms => env.decayTime; 21 | 22 | 1 => env.keyOn; 23 | 24 | 125::ms => now; 25 | } 26 | 0 => partFile.seek; 27 | } 28 | partFile.close(); -------------------------------------------------------------------------------- /33-file-output/file-output-test-5.ck: -------------------------------------------------------------------------------- 1 | int divisor; 2 | int offset; 3 | 4 | FileIO partFile; 5 | "part.txt" => string fileName; 6 | partFile.open( fileName, FileIO.WRITE ); 7 | 8 | fun void SetDivisor(int newDivisor) 9 | { 10 | newDivisor => divisor; 11 | <<< "Divisor is", divisor >>>; 12 | } 13 | SetDivisor(16); 14 | 15 | fun void SetOffset(int newOffset) 16 | { 17 | newOffset => offset; 18 | <<< "Offset is", offset >>>; 19 | } 20 | SetOffset(60); 21 | 22 | SinOsc osc => ADSR env => dac; 23 | 0.25 => osc.gain; 24 | (1::ms, 100::ms, 0, 1::ms) => env.set; 25 | 26 | Hid hi; 27 | HidMsg msg; 28 | 1 => int keepGoing; 29 | 30 | if( !hi.openKeyboard( 0 ) ) me.exit(); 31 | <<< "keyboard '" + hi.name() + "' ready,", "Step sequencer awaiting input for", fileName >>>; 32 | 33 | fun void HandleNote(int note) 34 | { 35 | partFile <= note <= " " <= divisor <= IO.newline(); 36 | <<< note, divisor >>>; 37 | PlayBeep(note); 38 | } 39 | 40 | fun void HandleRest() 41 | { 42 | partFile <= "R" <= " " <= divisor <= IO.newline(); 43 | <<< "R", divisor >>>; 44 | } 45 | 46 | fun void PlayBeep(int note) 47 | { 48 | note => Std.mtof => osc.freq; 49 | 1 => env.keyOn; 50 | } 51 | 52 | fun void HandleKeyPress(int which) 53 | { 54 | //handle each key individually :( 55 | 56 | //Handle offset changes 57 | if(which == 44) // z 58 | { 59 | SetOffset(offset - 12); 60 | } 61 | if(which == 45) // y 62 | { 63 | SetOffset(offset + 12); 64 | } 65 | 66 | //Handle divisor changes 67 | if(which == 2) 68 | { 69 | SetDivisor(1); 70 | } 71 | if(which == 3) 72 | { 73 | SetDivisor(2); 74 | } 75 | if(which == 4) 76 | { 77 | SetDivisor(3); 78 | } 79 | if(which == 5) 80 | { 81 | SetDivisor(4); 82 | } 83 | if(which == 7) 84 | { 85 | SetDivisor(6); 86 | } 87 | if(which == 9) 88 | { 89 | SetDivisor(8); 90 | } 91 | if(which == 10) 92 | { 93 | SetDivisor(16); 94 | } 95 | if(which == 11) 96 | { 97 | SetDivisor(32); 98 | } 99 | 100 | //Computer keyboard 101 | if(which == 30) //a 102 | { 103 | HandleNote(offset); 104 | } 105 | if(which == 31) //s 106 | { 107 | HandleNote(offset + 2); 108 | } 109 | if(which == 32) //d 110 | { 111 | HandleNote(offset + 4); 112 | } 113 | if(which == 33) //f 114 | { 115 | HandleNote(offset + 5); 116 | } 117 | if(which == 34) //g 118 | { 119 | HandleNote(offset + 7); 120 | } 121 | if(which == 35) //h 122 | { 123 | HandleNote(offset + 9); 124 | } 125 | if(which == 36) //j 126 | { 127 | HandleNote(offset + 11); 128 | } 129 | if(which == 37) //k 130 | { 131 | HandleNote(offset + 12); 132 | } 133 | if(which == 17) //w 134 | { 135 | HandleNote(offset + 1); 136 | } 137 | if(which == 18) //e 138 | { 139 | HandleNote(offset + 3); 140 | } 141 | if(which == 20) //t 142 | { 143 | HandleNote(offset + 6); 144 | } 145 | if(which == 21) //y 146 | { 147 | HandleNote(offset + 8); 148 | } 149 | if(which == 22) //u 150 | { 151 | HandleNote(offset + 10); 152 | } 153 | 154 | //rest 155 | if(which == 25) //p 156 | { 157 | HandleRest(); 158 | } 159 | 160 | //exit 161 | if(which == 1) 162 | { 163 | 0 => keepGoing; 164 | } 165 | 166 | } 167 | 168 | while( keepGoing == 1 ) 169 | { 170 | hi => now; 171 | 172 | while( hi.recv( msg ) && msg.which != 29 ) //ignore ctrl key 173 | { 174 | if( msg.isButtonDown() ) 175 | { 176 | HandleKeyPress(msg.which); 177 | } 178 | } 179 | } 180 | <<< "wrote to", fileName >>>; 181 | partFile.close(); -------------------------------------------------------------------------------- /33-file-output/file-output-test-5b.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => LPF lpf => Pan2 pan => dac; 2 | (1::ms, 100::ms, 0, 1::ms) => env.set; 3 | 4 | FileIO io; 5 | StringTokenizer tok; 6 | //<<< >>>; 7 | 2::second => dur beat; 8 | 48 => int offset; 9 | 10 | 0.2 => osc.gain; 11 | 12 | -1 => lpf.op; 13 | 1 => lpf.Q; 14 | 15 | while(true) 16 | { 17 | io.open("part.txt", FileIO.READ); 18 | while(io.more()) 19 | { 20 | io.readLine() => string line; 21 | if(io.more()) 22 | { 23 | if (line.find("//") == 0 ) 24 | { 25 | line => ProcessComment; 26 | } 27 | else if (line.find("R") == 0) 28 | { 29 | line => ProcessRest; 30 | } 31 | else if (line.length() > 0) 32 | { 33 | line => ProcessNote; 34 | } 35 | } 36 | } 37 | io.close(); 38 | } 39 | 40 | fun void ProcessComment(string line) 41 | { 42 | <<< line >>>; 43 | } 44 | 45 | fun void ProcessRest(string line) 46 | { 47 | tok.set(line); 48 | tok.next() => string rest; 49 | tok.next() => Std.atoi => int div; 50 | <<< rest, div >>>; 51 | beat / div => now; 52 | } 53 | 54 | fun void ProcessNote(string line) 55 | { 56 | tok.set(line); 57 | tok.next() => Std.atoi => int note; 58 | tok.next() => Std.atoi => int div; 59 | <<< note, div >>>; 60 | note => Std.mtof => osc.freq; 61 | 1 => env.keyOn; 62 | ProcessExtras(tok); 63 | beat / div => now; 64 | } 65 | 66 | fun void ProcessExtras(StringTokenizer tok) 67 | { 68 | while(tok.more()) 69 | { 70 | tok.next() => string extra; 71 | if(extra.find("P")==0) 72 | { 73 | extra.substring(1) => Std.atof => pan.pan; 74 | } 75 | if(extra.find("F")==0) 76 | { 77 | extra.substring(1) => Std.atof => lpf.freq; 78 | } 79 | if(extra.find("Q")==0) 80 | { 81 | extra.substring(1) => Std.atof => lpf.Q; 82 | } 83 | } 84 | } -------------------------------------------------------------------------------- /34-open-sound-control/osc-client-test-1.ck: -------------------------------------------------------------------------------- 1 | OscOut oscOut; 2 | 3 | oscOut.dest("localhost", 9000); 4 | 5 | [-12,0,3,7,10,12,14] @=> int notes[]; 6 | 7 | while(true) 8 | { 9 | oscOut.start("/myOsc/Hello"); 10 | notes[Math.random2(0, notes.cap()-1)] + 60 => int note; 11 | note => oscOut.add; 12 | 13 | oscOut.send(); 14 | 150::ms => now; 15 | } -------------------------------------------------------------------------------- /34-open-sound-control/osc-server-test-1.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc => ADSR env => dac; 2 | env => NRev reverb => dac; 3 | 0.25 => osc.gain; 4 | (1::ms, 100::ms, 0,1::ms) => env.set; 5 | 0.1 => reverb.mix; 6 | 7 | OscIn oscIn; 8 | OscMsg oscMsg; 9 | 10 | 9000 => oscIn.port; 11 | oscIn.addAddress("/myOsc/Hello"); 12 | 13 | while(true) 14 | { 15 | <<< "waiting for an OSC message..." >>>; 16 | oscIn => now; 17 | 18 | while(oscIn.recv(oscMsg) !=0) 19 | { 20 | oscMsg.getInt(0) => int note; 21 | <<< "Playing note", note >>>; 22 | note => Std.mtof => osc.freq; 23 | 1 => env.keyOn; 24 | } 25 | } -------------------------------------------------------------------------------- /34-open-sound-control/osc-transmit-test-1.ck: -------------------------------------------------------------------------------- 1 | OscOut xmit; 2 | 6449 => int port; 3 | xmit.dest("192.168.1.67", port); //this was my local IP address, it would be something else on your network 4 | [-12,0,4,7,11,12,14] @=> int notes[]; 5 | 6 | while(true) 7 | { 8 | xmit.start("/myChuck/OSCNote"); 9 | notes[Math.random2(0, notes.cap()-1)] + 60 => int note; 10 | Math.random2f(0.1,1.0) => float velocity; 11 | "Hello from the other PC!" => string message; 12 | 13 | note => xmit.add; 14 | velocity => xmit.add; 15 | message => xmit.add; 16 | 17 | <<< "sending:", note, velocity, message >>>; 18 | 19 | xmit.send(); 20 | 21 | 1::second / 2 => now; 22 | } -------------------------------------------------------------------------------- /35-chord-functions/make-chord-examples.ck: -------------------------------------------------------------------------------- 1 | dac => WvOut wvOut => blackhole; 2 | 3 | "doowop.wav" => wvOut.wavFilename; 4 | 5 | 0.5::second => dur beat; 6 | 7 | fun void PlayNote(int note, dur duration) 8 | { 9 | 60 => int offset; 10 | TriOsc osc => ADSR env => dac; 11 | 0.25 => osc.gain; 12 | note + offset => Std.mtof => osc.freq; 13 | (1::ms, duration - 2::ms,0, 1::ms) => env.set; 14 | 1 => env.keyOn; 15 | duration => now; 16 | } 17 | 18 | fun void PlayMelody() 19 | { 20 | 1.5::beat => now; 21 | PlayNote(16, 0.5::beat); 22 | PlayNote(17, 0.5::beat); 23 | PlayNote(16, 0.5::beat); 24 | PlayNote(14, 0.5::beat); 25 | PlayNote(12, 0.5::beat); 26 | 27 | PlayNote(9, 1.5::beat); 28 | PlayNote(16, 0.5::beat); 29 | PlayNote(17, 0.5::beat); 30 | PlayNote(16, 0.5::beat); 31 | PlayNote(14, 0.5::beat); 32 | PlayNote(12, 0.5::beat); 33 | 34 | PlayNote(11, 1.5::beat); 35 | 1.5::beat => now; 36 | PlayNote(9, 0.5::beat); 37 | PlayNote(7, 0.5::beat); 38 | 39 | PlayNote(9, 0.5::beat); 40 | PlayNote(12, 0.5::beat); 41 | PlayNote(9, 0.5::beat); 42 | PlayNote(7, 0.5::beat); 43 | 2::beat => now; 44 | 45 | 4::beat => now; 46 | } 47 | 48 | 49 | fun void PlayChords() 50 | { 51 | for (0 => int j; j < 2; j++) 52 | { 53 | for( 0 => int i; i < 4; i++) 54 | { 55 | spork ~ PlayNote(0, 1::second); 56 | spork ~ PlayNote(4, 1::second); 57 | spork ~ PlayNote(7, 1::second); 58 | 0.5::second => now; 59 | } 60 | 61 | for( 0 => int i; i < 4; i++) 62 | { 63 | spork ~ PlayNote(-3, 1::second); 64 | spork ~ PlayNote(0, 1::second); 65 | spork ~ PlayNote(4, 1::second); 66 | 0.5::second => now; 67 | } 68 | 69 | for( 0 => int i; i < 4; i++) 70 | { 71 | spork ~ PlayNote(-10, 1::second); 72 | spork ~ PlayNote(-7, 1::second); 73 | spork ~ PlayNote(-3, 1::second); 74 | 0.5::second => now; 75 | } 76 | 77 | for( 0 => int i; i < 4; i++) 78 | { 79 | spork ~ PlayNote(-5, 1::second); 80 | spork ~ PlayNote(-1, 1::second); 81 | spork ~ PlayNote(2, 1::second); 82 | 0.5::second => now; 83 | } 84 | } 85 | 86 | spork ~ PlayNote(0, 1::second); 87 | spork ~ PlayNote(4, 1::second); 88 | spork ~ PlayNote(7, 1::second); 89 | 0.5::second => now; 90 | 1::second => now; 91 | } 92 | 93 | // spork ~ PlayMelody(); 94 | // 4::beat => now; 95 | spork ~ PlayChords(); 96 | 18::second => now; 97 | 98 | 99 | -------------------------------------------------------------------------------- /36-equal-temperament/equal1.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1 => dac; 2 | 3 | 0.5 => osc1.gain; 4 | 100 => osc1.freq; 5 | 6 | <<< 0, osc1.freq() >>>; 7 | 2::second => now; 8 | 9 | 10 | for(1 => int i; i < 13; i++) 11 | { 12 | osc1.freq() * 1.5 => osc1.freq; 13 | <<< i , osc1.freq() >>>; 14 | i++; 15 | 2::second => now; 16 | (osc1.freq() / 2) * 1.5 => osc1.freq; 17 | <<< i , osc1.freq() >>>; 18 | 2::second => now; 19 | } -------------------------------------------------------------------------------- /36-equal-temperament/equal2.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1 => dac; 2 | 3 | 0.5 => osc1.gain; 4 | 100 => osc1.freq; 5 | 6 | <<< 0, osc1.freq() >>>; 7 | 1::second => now; 8 | 9 | 1.0594630943592952645618252949463 => float semitone; 10 | 11 | for(1 => int i; i < 13; i++) 12 | { 13 | osc1.freq() * semitone => osc1.freq; 14 | <<< i, osc1.freq() >>>; 15 | 1::second => now; 16 | } 17 | 18 | -------------------------------------------------------------------------------- /36-equal-temperament/equal3.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1 => dac; 2 | 3 | 0.5 => osc1.gain; 4 | 440 => osc1.freq; 5 | 6 | <<< 0, osc1.freq() >>>; 7 | 1::second => dur beat; 8 | beat => now; 9 | 10 | 1.0594630943592952645618252949463 => float semitone; 11 | 12 | for(1 => int i; i < 13; i++) 13 | { 14 | transpose(osc1.freq(), 7) => osc1.freq; 15 | <<< i , osc1.freq() >>>; 16 | i++; 17 | beat => now; 18 | transpose(osc1.freq(), -12) => osc1.freq; 19 | transpose(osc1.freq(), 7) => osc1.freq; 20 | <<< i , osc1.freq() >>>; 21 | beat => now; 22 | } 23 | 24 | fun float transpose(float frequency, int semitones) 25 | { 26 | frequency => float result; 27 | if(semitones > 0) 28 | { 29 | for(1 => int j; j <= semitones; j++) 30 | { 31 | result * semitone => result; 32 | } 33 | } 34 | else if(semitones < 0) 35 | { 36 | for(1 => int j; j <= Math.abs(semitones); j++) 37 | { 38 | result * (1 / semitone ) => result; 39 | } 40 | } 41 | return result; 42 | } 43 | 44 | -------------------------------------------------------------------------------- /36-equal-temperament/equal4.ck: -------------------------------------------------------------------------------- 1 | SndBuf buffer => Dyno dynoC => dac; 2 | buffer => Delay delayL => Dyno dynoL => dac.left; 3 | Delay delayR => Dyno dynoR => dac.right; 4 | 5 | 0.5::second => dur beat; 6 | 7 | 4::beat => delayL.max => delayR.max; 8 | 9 | beat * .75 => delayL.delay; 10 | beat * .75 => delayR.delay; 11 | 0.85 => delayL.gain => delayR.gain; 12 | 13 | delayL => delayR; 14 | delayR => delayL; 15 | 16 | me.dir() + "guitar.wav" => string filename; 17 | filename => buffer.read; 18 | 19 | 1 => buffer.gain; 20 | -0.5 => buffer.rate; 21 | 4 * 44100 => int spot; 22 | 23 | <<< 0, buffer.rate() >>>; 24 | 25 | spot => buffer.pos; 26 | .75::beat => now; 27 | spot => buffer.pos; 28 | .75::beat => now; 29 | spot => buffer.pos; 30 | .5::beat => now; 31 | 32 | 1.0594630943592952645618252949463 => float semitone; 33 | 34 | 35 | while(true) 36 | { 37 | for(1 => int i; i < 13; i++) 38 | { 39 | transpose(buffer.rate(), 7) => buffer.rate; 40 | <<< i , buffer.rate() >>>; 41 | i++; 42 | spot => buffer.pos; 43 | .75::beat => now; 44 | spot => buffer.pos; 45 | .75::beat => now; 46 | transpose(buffer.rate(), -12) => buffer.rate; 47 | spot => buffer.pos; 48 | .5::beat => now; 49 | transpose(buffer.rate(), 7) => buffer.rate; 50 | <<< i , buffer.rate() >>>; 51 | spot => buffer.pos; 52 | .75::beat => now; 53 | spot => buffer.pos; 54 | .75::beat => now; 55 | spot => buffer.pos; 56 | .5::beat => now; 57 | 58 | } 59 | } 60 | 61 | fun float transpose(float rate, int semitones) 62 | { 63 | rate => float result; 64 | if(semitones > 0) 65 | { 66 | for(1 => int j; j <= semitones; j++) 67 | { 68 | result * semitone => result; 69 | } 70 | } 71 | else if(semitones < 0) 72 | { 73 | for(1 => int j; j <= Math.abs(semitones); j++) 74 | { 75 | result * (1 / semitone ) => result; 76 | } 77 | } 78 | return result; 79 | } -------------------------------------------------------------------------------- /36-equal-temperament/guitar.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/36-equal-temperament/guitar.wav -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-1.ck: -------------------------------------------------------------------------------- 1 | 2 | "mellow-flute-c3.wav" => string filename; 3 | 4 | class Sampler extends Chugraph 5 | { 6 | SndBuf buffer => outlet; 7 | 8 | fun void open(string filename) 9 | { 10 | buffer.read(filename); 11 | } 12 | 13 | 1 => buffer.loop; 14 | 15 | } 16 | 17 | Sampler sampler => dac; 18 | 19 | sampler.open(filename); 20 | 21 | 10::second => now; 22 | -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-2.ck: -------------------------------------------------------------------------------- 1 | 2 | "mellow-flute-c3.wav" => string filename; 3 | 4 | class Sampler extends Chugraph 5 | { 6 | SndBuf buffer => ADSR ampEnv => outlet; 7 | (1::second,1::second,0.0, 1::ms ) => ampEnv.set; 8 | 9 | fun void open(string filename) 10 | { 11 | buffer.read(filename); 12 | } 13 | 14 | fun void play() 15 | { 16 | 0 => buffer.pos; 17 | 1 => ampEnv.keyOn; 18 | } 19 | 20 | } 21 | 22 | Sampler sampler => dac; 23 | 24 | sampler.open(filename); 25 | 26 | sampler.play(); 27 | 28 | 2::second => now; 29 | 30 | 1::ms => sampler.ampEnv.attackTime; 31 | 32 | sampler.play(); 33 | 34 | 2::second => now; 35 | -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-3.ck: -------------------------------------------------------------------------------- 1 | 2 | "mellow-flute-c3.wav" => string filename; 3 | 4 | class Sampler extends Chugraph 5 | { 6 | SndBuf buffer => ADSR ampEnv => outlet; 7 | (1::second,1::second,0.0, 1::ms ) => ampEnv.set; 8 | 9 | fun void open(string filename) 10 | { 11 | buffer.read(filename); 12 | } 13 | 14 | 0 => int startPos; 15 | 16 | fun void play(int semitones) 17 | { 18 | startPos => buffer.pos; 19 | 1 => ampEnv.keyOn; 20 | transpose(1, semitones) => buffer.rate; 21 | } 22 | 23 | fun float transpose(float frequency, int semitones) 24 | { 25 | 1.0594630943592952645618252949463 => float semitone; 26 | frequency => float result; 27 | if(semitones > 0) 28 | { 29 | for(1 => int j; j <= semitones; j++) 30 | { 31 | result * semitone => result; 32 | } 33 | } 34 | else if(semitones < 0) 35 | { 36 | for(1 => int j; j <= Math.abs(semitones); j++) 37 | { 38 | result * (1 / semitone ) => result; 39 | } 40 | } 41 | return result; 42 | } 43 | 44 | } 45 | 46 | Sampler sampler => dac; 47 | 48 | sampler.open(filename); 49 | 50 | 0.5 => sampler.gain; 51 | 52 | 0.5::second => dur beat; 53 | 54 | 1::ms => sampler.ampEnv.attackTime; 55 | beat => sampler.ampEnv.decayTime; 56 | 57 | 0 * 44100 => sampler.startPos; 58 | 59 | [-12,-9, -5,-2, 0, 3, 7, 10] @=> int notes[]; 60 | 61 | while(true) 62 | { 63 | sampler.play(notes[Math.random2(0, notes.cap()-1)] + (12 * Math.random2(-2,2))); 64 | beat => now; 65 | } -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-4.ck: -------------------------------------------------------------------------------- 1 | //"guitar.wav" => string filename; 2 | "Mell Flute C3.WAV" => string filename; 3 | 4 | class Sampler extends Chugraph 5 | { 6 | SndBuf buffer => ADSR ampEnv => Gain noiseGain => outlet; 7 | (1::second,1::second,0.0, 1::ms ) => ampEnv.set; 8 | 9 | fun void open(string filename) 10 | { 11 | buffer.read(filename); 12 | } 13 | 14 | 0 => int startPos; 15 | 16 | fun void play(int semitones) 17 | { 18 | startPos => buffer.pos; 19 | 1 => ampEnv.keyOn; 20 | transpose(1, semitones) => buffer.rate; 21 | } 22 | 23 | fun float transpose(float frequency, int semitones) 24 | { 25 | 1.0594630943592952645618252949463 => float semitone; 26 | frequency => float result; 27 | if(semitones > 0) 28 | { 29 | for(1 => int j; j <= semitones; j++) 30 | { 31 | result * semitone => result; 32 | } 33 | } 34 | else if(semitones < 0) 35 | { 36 | for(1 => int j; j <= Math.abs(semitones); j++) 37 | { 38 | result * (1 / semitone ) => result; 39 | } 40 | } 41 | return result; 42 | } 43 | 44 | } 45 | 46 | Sampler sampler => Delay delay[2] => dac; 47 | sampler => dac; 48 | 49 | 2::second => delay[0].max => delay[1].max; 50 | 51 | sampler.open(filename); 52 | 53 | 0.5 => sampler.gain; 54 | 55 | 0.5::second => dur beat; 56 | 57 | beat / 2 => delay[0].delay; 58 | beat / 4 => delay[1].delay; 59 | 0.75 => delay[0].gain => delay[1].gain; 60 | delay[0] => delay[1] => delay[0]; 61 | 62 | 1::ms => sampler.ampEnv.attackTime; 63 | beat => sampler.ampEnv.decayTime; 64 | 65 | 0 * 44100 => sampler.startPos; 66 | //3 * 44100 => sampler.startPos; //for using guitar sample 67 | 68 | [-12,-9, -5,-2, 0, 3, 7,10] @=> int notes[]; 69 | 70 | while(true) 71 | { 72 | notes[Math.random2(0, notes.cap()-1)] => int note; 73 | sampler.play(note); 74 | beat * 2 => now; 75 | } -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-5.ck: -------------------------------------------------------------------------------- 1 | 2 | "guitar.wav" => string filename; 3 | //"Mell Flute C3.WAV" => string filename; 4 | 5 | class Sampler extends Chugraph 6 | { 7 | SndBuf buffer => ADSR ampEnv => Gain noiseGain => outlet; 8 | (1::second,2::second,0.0, 1::ms ) => ampEnv.set; 9 | 10 | fun void open(string filename) 11 | { 12 | buffer.read(filename); 13 | } 14 | 15 | 0 => int startPos; 16 | buffer.samples() => int loopLength; 17 | 18 | fun void setLoopLength(int samples) 19 | { 20 | samples => loopLength; 21 | } 22 | 23 | fun void play(int semitones) 24 | { 25 | 1 => ampEnv.keyOn; 26 | startPos => buffer.pos; 27 | transpose(1, semitones) => buffer.rate; 28 | 1::ms => now; 29 | <<< ampEnv.state(), ampEnv.value() >>>; 30 | while( ampEnv.value() != 0.0 ) 31 | { 32 | 33 | 1::ms => now; 34 | if(buffer.pos() > startPos + loopLength) 35 | { 36 | startPos => buffer.pos; 37 | } 38 | else 39 | { 40 | continue; 41 | } 42 | } 43 | } 44 | 45 | fun float transpose(float frequency, int semitones) 46 | { 47 | 1.0594630943592952645618252949463 => float semitone; 48 | frequency => float result; 49 | if(semitones > 0) 50 | { 51 | for(1 => int j; j <= semitones; j++) 52 | { 53 | result * semitone => result; 54 | } 55 | } 56 | else if(semitones < 0) 57 | { 58 | for(1 => int j; j <= Math.abs(semitones); j++) 59 | { 60 | result * (1 / semitone ) => result; 61 | } 62 | } 63 | return result; 64 | } 65 | 66 | } 67 | 68 | Sampler sampler => Delay delay[2] => dac; 69 | sampler => dac; 70 | 71 | 2::second => delay[0].max => delay[1].max; 72 | 73 | sampler.open(filename); 74 | 75 | 0.5 => sampler.gain; 76 | 77 | 0.5::second => dur beat; 78 | 79 | beat / 2 => delay[0].delay; 80 | beat / 4 => delay[1].delay; 81 | 0.75 => delay[0].gain => delay[1].gain; 82 | delay[0] => delay[1] => delay[0]; 83 | 84 | 1::ms => sampler.ampEnv.attackTime; 85 | 2::beat => sampler.ampEnv.decayTime; 86 | 87 | 3 * 44100 => sampler.startPos; 88 | 89 | 22050 / 16 => sampler.loopLength; 90 | 91 | [-12,-9, -5,-2, 0, 3, 7,10] @=> int notes[]; 92 | 93 | while(true) 94 | { 95 | notes[Math.random2(0, notes.cap()-1)] => int note; 96 | spork ~ sampler.play(note); 97 | beat * 2 => now; 98 | } 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-6.ck: -------------------------------------------------------------------------------- 1 | 2 | //"guitar.wav" => string filename; 3 | "mellow-flute-c3.wav" => string filename; 4 | 5 | class Sampler extends Chugraph 6 | { 7 | SndBuf buffer => ADSR ampEnv => LPF lpf => Dyno dyno => outlet; 8 | (1::second,1::second,0.0, 1::ms ) => ampEnv.set; 9 | 10 | fun void open(string filename) 11 | { 12 | buffer.read(filename); 13 | } 14 | 15 | 0 => int startPos; 16 | 17 | fun void play(int semitones) 18 | { 19 | startPos => buffer.pos; 20 | 1 => ampEnv.keyOn; 21 | transpose(1, semitones) => buffer.rate; 22 | } 23 | 24 | fun float transpose(float frequency, int semitones) 25 | { 26 | 1.0594630943592952645618252949463 => float semitone; 27 | frequency => float result; 28 | if(semitones > 0) 29 | { 30 | for(1 => int j; j <= semitones; j++) 31 | { 32 | result * semitone => result; 33 | } 34 | } 35 | else if(semitones < 0) 36 | { 37 | for(1 => int j; j <= Math.abs(semitones); j++) 38 | { 39 | result * (1 / semitone ) => result; 40 | } 41 | } 42 | return result; 43 | } 44 | 45 | } 46 | 47 | Sampler sampler => Delay delay[2] => Dyno dyno[2] => dac; 48 | sampler => dyno[0]; 49 | sampler => dyno[1]; 50 | 51 | 1::ms => dyno[0].attackTime => dyno[1].attackTime; 52 | 0.4 => dyno[0].thresh => dyno[1].thresh; 53 | 54 | 2::second => delay[0].max => delay[1].max; 55 | 56 | sampler.open(filename); 57 | 58 | 0.9 => sampler.gain; 59 | 60 | 0.5::second => dur beat; 61 | 62 | beat / 2 => delay[0].delay; 63 | beat / 4 => delay[1].delay; 64 | 0.9 => delay[0].gain => delay[1].gain; 65 | delay[0] => delay[1] => delay[0]; 66 | 67 | 1::ms => sampler.ampEnv.attackTime; 68 | beat => sampler.ampEnv.decayTime; 69 | 70 | 0 * 44100 => sampler.startPos; 71 | 72 | 500 => sampler.lpf.freq; 73 | 74 | [-12,-9, -5,-2, 0, 3, 7, 10] @=> int notes[]; 75 | 76 | while(true) 77 | { 78 | Math.random2(250, 3000) => sampler.lpf.freq; 79 | Math.random2f(0.5,10.0) => sampler.lpf.Q; 80 | sampler.play(notes[Math.random2(0, notes.cap()-1)] + (12 * Math.random2(-2,2))); 81 | beat => now; 82 | } -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-7.ck: -------------------------------------------------------------------------------- 1 | class Sampler extends Chugraph 2 | { 3 | LiSa lisa => ADSR ampEnv => outlet; 4 | (1::ms,1::second,1.0, 1::ms ) => ampEnv.set; 5 | 6 | fun void open(string filename) 7 | { 8 | load(filename); 9 | 1.0 => lisa.rate; 10 | 1 => lisa.loop; 11 | 1 => lisa.bi; 12 | } 13 | 14 | fun void load( string filename ) 15 | { 16 | SndBuf buffy; 17 | filename => buffy.read; 18 | 19 | buffy.samples()::samp => lisa.duration; 20 | 21 | for( 0 => int i; i < buffy.samples(); i++ ) 22 | { 23 | lisa.valueAt( buffy.valueAt(i), i::samp ); 24 | } 25 | } 26 | 27 | 0::ms => dur playPos; 28 | 29 | fun void play(int semitones) 30 | { 31 | transpose(1, semitones) => lisa.rate; 32 | 33 | playPos => lisa.playPos; 34 | playPos => lisa.loopStart; 35 | playPos + 1::second => lisa.loopEnd; 36 | 37 | 1 => ampEnv.keyOn; 38 | 1 => lisa.play; 39 | } 40 | 41 | fun float transpose(float frequency, int semitones) 42 | { 43 | 1.0594630943592952645618252949463 => float semitone; 44 | frequency => float result; 45 | if(semitones > 0) 46 | { 47 | for(1 => int j; j <= semitones; j++) 48 | { 49 | result * semitone => result; 50 | } 51 | } 52 | else if(semitones < 0) 53 | { 54 | for(1 => int j; j <= Math.abs(semitones); j++) 55 | { 56 | result * (1 / semitone ) => result; 57 | } 58 | } 59 | return result; 60 | } 61 | } 62 | 63 | "guitar.wav" => string filename; 64 | 65 | Sampler sampler => Pan2 pan => dac; 66 | 67 | sampler.open(filename); 68 | 69 | 0.5 => sampler.gain; 70 | 71 | 1::second => dur beat; 72 | 73 | 0::beat => sampler.playPos; 74 | 75 | 1::ms => sampler.ampEnv.attackTime; 76 | 1::beat => sampler.ampEnv.decayTime; 77 | 78 | [-12,-9, -5,-2, 0, 3, 7, 10] @=> int notes[]; 79 | 80 | <<< Chugraph.help() >>>; 81 | 82 | while(true) 83 | { 84 | sampler.play(notes[Math.random2(0, notes.cap()-1)] + (12 * Math.random2(0,2))); 85 | Math.random2f(-1.0, 1.0) => pan.pan; 86 | 1::beat => now; 87 | } 88 | 89 | 90 | -------------------------------------------------------------------------------- /37-fancy-sampler/sampler-test-8.ck: -------------------------------------------------------------------------------- 1 | 2 | "guitar.wav" => string filename; 3 | //"Mell Flute C3.WAV" => string filename; 4 | 5 | class Sampler extends Chugraph 6 | { 7 | LiSa lisa => ADSR ampEnv => Gain noiseGain => outlet; 8 | (1::second,1::second,0.0, 1::ms ) => ampEnv.set; 9 | 10 | fun void open(string filename) 11 | { 12 | load(filename); 13 | } 14 | 15 | fun void load( string filename ) 16 | { 17 | SndBuf buffer; 18 | filename => buffer.read; 19 | 20 | buffer.samples()::samp => lisa.duration; 21 | 22 | for( 0 => int i; i < buffer.samples(); i++ ) 23 | { 24 | lisa.valueAt( buffer.valueAt(i), i::samp ); 25 | } 26 | } 27 | 28 | 0::second => dur startPos; 29 | 30 | fun void play(int semitones) 31 | { 32 | 1 => ampEnv.keyOn; 33 | transpose(1, semitones) => lisa.rate; 34 | startPos => lisa.playPos; 35 | 1 => lisa.play; 36 | } 37 | 38 | fun float transpose(float frequency, int semitones) 39 | { 40 | 1.0594630943592952645618252949463 => float semitone; 41 | frequency => float result; 42 | if(semitones > 0) 43 | { 44 | for(1 => int j; j <= semitones; j++) 45 | { 46 | result * semitone => result; 47 | } 48 | } 49 | else if(semitones < 0) 50 | { 51 | for(1 => int j; j <= Math.abs(semitones); j++) 52 | { 53 | result * (1 / semitone ) => result; 54 | } 55 | } 56 | return result; 57 | } 58 | 59 | } 60 | 61 | Sampler sampler => Delay delay[2] => dac; 62 | sampler => dac; 63 | 64 | 2::second => delay[0].max => delay[1].max; 65 | 66 | sampler.open(filename); 67 | 68 | 0.5 => sampler.gain; 69 | 70 | 0.5::second => dur beat; 71 | 72 | beat / 2 => delay[0].delay; 73 | beat / 4 => delay[1].delay; 74 | 0.75 => delay[0].gain => delay[1].gain; 75 | delay[0] => delay[1] => delay[0]; 76 | 77 | 1::ms => sampler.ampEnv.attackTime; 78 | beat => sampler.ampEnv.decayTime; 79 | 80 | 3::second => sampler.startPos; 81 | 82 | [-12,-9, -5,-2, 0, 3, 7,10] @=> int notes[]; 83 | 84 | while(true) 85 | { 86 | notes[Math.random2(0, notes.cap()-1)] => int note; 87 | sampler.play(note); 88 | beat * 2 => now; 89 | } 90 | 91 | 92 | 93 | -------------------------------------------------------------------------------- /39-midi-clock/midi-clock.ck: -------------------------------------------------------------------------------- 1 | dur tick; 2 | dur beat; 3 | dur bar; 4 | 5 | MidiOut drumMachine; 6 | drumMachine.open(2); 7 | 8 | MidiMsg midiStart; 9 | 250 => midiStart.data1; 10 | 0 => midiStart.data2; 11 | 0 => midiStart.data3; 12 | 13 | MidiMsg midiStop; 14 | 252 => midiStop.data1; 15 | 0 => midiStop.data2; 16 | 0 => midiStop.data3; 17 | 18 | MidiMsg midiClockPulse; 19 | 248 => midiClockPulse.data1; 20 | 0 => midiClockPulse.data2; 21 | 0 => midiClockPulse.data3; 22 | 23 | fun void SetTempo(float tempo) 24 | { 25 | tempo => float bpm; 26 | ((1 / bpm))::minute => beat; 27 | 4::beat => bar; 28 | beat / 24 => tick; 29 | } 30 | 31 | fun void PulseMidiClock() 32 | { 33 | while(true) 34 | { 35 | midiClockPulse => drumMachine.send; 36 | tick => now; 37 | } 38 | } 39 | 40 | 80 => SetTempo; 41 | spork ~ PulseMidiClock(); 42 | midiStart => drumMachine.send; 43 | 44 | 1::bar => now; 45 | 120 => SetTempo; 46 | 1::bar => now; 47 | 160 => SetTempo; 48 | 1::bar => now; 49 | 60 => SetTempo; 50 | 1::bar => now; 51 | beat / 4 => now; 52 | 53 | midiStop => drumMachine.send; 54 | beat => now; -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/chip-noise-osc.ck: -------------------------------------------------------------------------------- 1 | public class ChipNoiseOsc 2 | { 3 | Noise osc => ADSR env => LPF lpf => dac; 4 | FileIO io; 5 | StringTokenizer tok; 6 | 7 | 0.2 => osc.gain; 8 | 1.2::second => dur bar; 9 | 36 => int offset; 10 | 11 | fun void SetBarDuration(dur newDuration) 12 | { 13 | newDuration => bar; 14 | <<< "bar length is", bar / 44100 >>>; 15 | } 16 | 17 | fun void PlayFile(string fileName) 18 | { 19 | <<< io.open(fileName, FileIO.READ) >>>; 20 | while(io.more()) 21 | { 22 | io.readLine() => string line; 23 | 24 | if (line.find("//") == 0 || line.length() == 0) 25 | { 26 | line => ProcessComment; 27 | } 28 | else if (line.find("r") == 0) 29 | { 30 | line => ProcessRest; 31 | } 32 | else 33 | { 34 | line => ProcessNote; 35 | } 36 | } 37 | } 38 | 39 | fun void ProcessComment(string line) 40 | { 41 | <<< line >>>; 42 | } 43 | 44 | fun void ProcessRest(string line) 45 | { 46 | tok.set(line); 47 | tok.next() => string rest; 48 | tok.next() => Std.atoi => int div; 49 | <<< rest, div >>>; 50 | bar / div => now; 51 | } 52 | 53 | fun void ProcessNote(string line) 54 | { 55 | tok.set(line); 56 | tok.next() => Std.atoi => int note; 57 | tok.next() => Std.atoi => int div; 58 | <<< note, div >>>; 59 | 60 | bar / div => dur duration; 61 | SetNoise(note, duration); 62 | 1 => env.keyOn; 63 | ProcessExtras(tok); 64 | duration => now; 65 | 1 => env.keyOff; 66 | } 67 | 68 | fun void SetNoise(int note, dur duration) 69 | { 70 | if(note == 1) 71 | { 72 | (44100 / 16) * 1 => lpf.freq; 73 | (1::ms, duration / 8, 0.0, 1::ms) => env.set; 74 | } 75 | if(note == 2) 76 | { 77 | (44100 / 16) * 4 => lpf.freq; 78 | (1::ms, duration / 8, 0.0, 1::ms) => env.set; 79 | } 80 | if(note == 3) 81 | { 82 | (44100 / 16) * 4 => lpf.freq; 83 | (1::ms, duration, 0.0, 1::ms) => env.set; 84 | } 85 | } 86 | 87 | fun void ProcessExtras(StringTokenizer tok) 88 | { 89 | while(tok.more()) 90 | { 91 | tok.next() => string extra; 92 | // if(extra.find("p")==0) 93 | // { 94 | // extra.substring(1) => Std.atof => pan.pan; 95 | // } 96 | } 97 | } 98 | } -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/chip-pulse-osc.ck: -------------------------------------------------------------------------------- 1 | public class ChipPulseOsc 2 | { 3 | PulseOsc osc => ADSR env => dac; 4 | FileIO io; 5 | StringTokenizer tok; 6 | 7 | 0.2 => osc.gain; 8 | 1.2::second => dur bar; 9 | 48 => int offset; 10 | 11 | fun void SetPulseWidth(float width) 12 | { 13 | width => osc.width; 14 | } 15 | 16 | fun void SetBarDuration(dur newDuration) 17 | { 18 | newDuration => bar; 19 | <<< "bar length is", bar / 44100 >>>; 20 | } 21 | 22 | fun void PlayFile(string fileName) 23 | { 24 | <<< io.open(fileName, FileIO.READ) >>>; 25 | while(io.more()) 26 | { 27 | io.readLine() => string line; 28 | 29 | if (line.find("//") == 0 || line.length() == 0) 30 | { 31 | line => ProcessComment; 32 | } 33 | else if (line.find("r") == 0) 34 | { 35 | line => ProcessRest; 36 | } 37 | else 38 | { 39 | line => ProcessNote; 40 | } 41 | } 42 | } 43 | 44 | fun void ProcessComment(string line) 45 | { 46 | <<< line >>>; 47 | } 48 | 49 | fun void ProcessRest(string line) 50 | { 51 | tok.set(line); 52 | tok.next() => string rest; 53 | tok.next() => Std.atoi => int div; 54 | <<< rest, div >>>; 55 | bar / div => now; 56 | } 57 | 58 | fun void ProcessNote(string line) 59 | { 60 | tok.set(line); 61 | tok.next() => Std.atoi => int note; 62 | tok.next() => Std.atoi => int div; 63 | <<< note, div >>>; 64 | note + offset => Std.mtof => osc.freq; 65 | bar / div => dur duration; 66 | (1::ms, duration, 0, 1::ms) => env.set; 67 | 1 => env.keyOn; 68 | ProcessExtras(tok); 69 | duration => now; 70 | } 71 | 72 | fun void ProcessExtras(StringTokenizer tok) 73 | { 74 | while(tok.more()) 75 | { 76 | tok.next() => string extra; 77 | // if(extra.find("p")==0) 78 | // { 79 | // extra.substring(1) => Std.atof => pan.pan; 80 | // } 81 | } 82 | } 83 | } -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/chip-tri-osc.ck: -------------------------------------------------------------------------------- 1 | public class ChipTriOsc 2 | { 3 | TriOsc osc => ADSR env => dac; 4 | FileIO io; 5 | StringTokenizer tok; 6 | 7 | 0.4 => osc.gain; 8 | 1.2::second => dur bar; 9 | 36 => int offset; 10 | 11 | fun void SetBarDuration(dur newDuration) 12 | { 13 | newDuration => bar; 14 | <<< "bar length is", bar / 44100 >>>; 15 | } 16 | 17 | fun void PlayFile(string fileName) 18 | { 19 | <<< io.open(fileName, FileIO.READ) >>>; 20 | while(io.more()) 21 | { 22 | io.readLine() => string line; 23 | 24 | if (line.find("//") == 0 || line.length() == 0) 25 | { 26 | line => ProcessComment; 27 | } 28 | else if (line.find("r") == 0) 29 | { 30 | line => ProcessRest; 31 | } 32 | else 33 | { 34 | line => ProcessNote; 35 | } 36 | } 37 | } 38 | 39 | fun void ProcessComment(string line) 40 | { 41 | <<< line >>>; 42 | } 43 | 44 | fun void ProcessRest(string line) 45 | { 46 | tok.set(line); 47 | tok.next() => string rest; 48 | tok.next() => Std.atoi => int div; 49 | <<< rest, div >>>; 50 | bar / div => now; 51 | } 52 | 53 | fun void ProcessNote(string line) 54 | { 55 | tok.set(line); 56 | tok.next() => Std.atoi => int note; 57 | tok.next() => Std.atoi => int div; 58 | <<< note, div >>>; 59 | note + offset => Std.mtof => osc.freq; 60 | bar / div => dur duration; 61 | (1::ms, duration, 0, 1::ms) => env.set; 62 | 1 => env.keyOn; 63 | ProcessExtras(tok); 64 | duration => now; 65 | } 66 | 67 | fun void ProcessExtras(StringTokenizer tok) 68 | { 69 | while(tok.more()) 70 | { 71 | tok.next() => string extra; 72 | // if(extra.find("p")==0) 73 | // { 74 | // extra.substring(1) => Std.atof => pan.pan; 75 | // } 76 | } 77 | } 78 | } -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/initialize.ck: -------------------------------------------------------------------------------- 1 | Machine.add(me.dir() + "chip-tri-osc.ck"); 2 | Machine.add(me.dir() + "chip-pulse-osc.ck"); 3 | Machine.add(me.dir() + "chip-noise-osc.ck"); 4 | 5 | Machine.add(me.dir() + "score.ck"); -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/noise-1.txt: -------------------------------------------------------------------------------- 1 | 3 4 2 | 2 8 3 | 3 4 4 | 2 8 5 | 3 4 6 | 7 | 3 4 8 | r 8 9 | 2 8 10 | 1 8 11 | 1 8 12 | 2 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/noise-2.txt: -------------------------------------------------------------------------------- 1 | 1 4 2 | 2 6 3 | 2 12 4 | 3 4 5 | 2 6 6 | 2 12 7 | 8 | 1 4 9 | 2 6 10 | 2 12 11 | 3 4 12 | 2 6 13 | 2 12 14 | 15 | 1 4 16 | 2 6 17 | 2 12 18 | 3 4 19 | 2 6 20 | 2 12 21 | 22 | 1 4 23 | 2 6 24 | 2 12 25 | 3 4 26 | 2 6 27 | 2 12 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/noise-3.txt: -------------------------------------------------------------------------------- 1 | 1 4 2 | 2 6 3 | 2 12 4 | 3 4 5 | 2 6 6 | 2 12 7 | 8 | 1 4 9 | 2 6 10 | 2 12 11 | 3 4 12 | 2 6 13 | 2 12 14 | 15 | 1 4 16 | 2 6 17 | 2 12 18 | 3 4 19 | 2 6 20 | 2 12 21 | 22 | 1 4 23 | 2 6 24 | 2 12 25 | 3 4 26 | 2 6 27 | 2 12 28 | 29 | 1 4 30 | 2 6 31 | 2 12 32 | 3 4 33 | 2 6 34 | 2 12 35 | 36 | 1 4 37 | 2 6 38 | 2 12 39 | 3 4 40 | 2 6 41 | 2 12 42 | 43 | 1 4 44 | 2 6 45 | 2 12 46 | 3 4 47 | 2 6 48 | 2 12 49 | 50 | 1 4 51 | 2 6 52 | 2 12 53 | 3 4 54 | 2 6 55 | 2 12 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/noise-4.txt: -------------------------------------------------------------------------------- 1 | 3 4 2 | 2 8 3 | 3 4 4 | 2 8 5 | 3 4 6 | 7 | 3 4 8 | r 8 9 | 2 8 10 | 1 8 11 | 1 8 12 | 2 8 13 | 1 8 14 | 15 | 3 4 16 | 2 8 17 | 3 4 18 | 2 8 19 | 3 4 20 | 21 | 3 4 22 | r 8 23 | 2 8 24 | 1 8 25 | 1 8 26 | 2 8 27 | 1 8 28 | 29 | 3 4 30 | 2 8 31 | 3 4 32 | 2 8 33 | 3 4 34 | 35 | 3 4 36 | r 8 37 | 2 8 38 | 1 8 39 | 1 8 40 | 2 8 41 | 1 8 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/noise-5.txt: -------------------------------------------------------------------------------- 1 | 2 4 2 | r 8 3 | 2 8 4 | 3 4 5 | 2 4 6 | 7 | 2 4 8 | r 8 9 | 2 8 10 | 3 4 11 | 2 4 12 | 13 | 2 4 14 | r 8 15 | 2 8 16 | 3 4 17 | 2 4 18 | 19 | 2 4 20 | r 8 21 | 2 8 22 | 3 4 23 | 2 4 24 | 25 | 2 4 26 | r 8 27 | 2 8 28 | 3 4 29 | 2 4 30 | 31 | 2 4 32 | r 8 33 | 2 8 34 | 3 4 35 | 2 4 36 | 37 | 2 4 38 | r 8 39 | 2 8 40 | 3 4 41 | 2 4 42 | 43 | 2 4 44 | r 8 45 | 2 8 46 | 3 4 47 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p1-1.txt: -------------------------------------------------------------------------------- 1 | 16 8 2 | 16 8 3 | r 8 4 | 16 8 5 | r 8 6 | 12 8 7 | 16 8 8 | r 8 9 | 19 4 10 | r 4 11 | 7 4 12 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p1-2.txt: -------------------------------------------------------------------------------- 1 | 12 8 2 | r 8 3 | r 8 4 | 7 8 5 | r 8 6 | r 8 7 | 4 8 8 | r 8 9 | 10 | r 8 11 | 9 8 12 | r 8 13 | 11 8 14 | r 8 15 | 10 8 16 | 9 8 17 | r 8 18 | 19 | 7 6 20 | 16 6 21 | 19 6 22 | 21 8 23 | r 8 24 | 17 8 25 | 19 8 26 | 27 | r 8 28 | 16 8 29 | r 8 30 | 12 8 31 | 14 8 32 | 11 8 33 | r 8 34 | r 8 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p1-3.txt: -------------------------------------------------------------------------------- 1 | r 4 2 | 19 8 3 | 18 8 4 | 17 8 5 | 15 8 6 | r 8 7 | 16 8 8 | 9 | r 8 10 | 8 8 11 | 9 8 12 | 12 8 13 | r 8 14 | 9 8 15 | 12 8 16 | 14 8 17 | 18 | r 4 19 | 19 8 20 | 18 8 21 | 17 8 22 | 15 8 23 | r 8 24 | 16 8 25 | 26 | r 8 27 | 19 8 28 | r 8 29 | 19 8 30 | 19 8 31 | r 8 32 | r 4 33 | 34 | r 4 35 | 19 8 36 | 18 8 37 | 17 8 38 | 15 8 39 | r 8 40 | 16 8 41 | 42 | r 8 43 | 8 8 44 | 9 8 45 | 12 8 46 | r 8 47 | 9 8 48 | 12 8 49 | 14 8 50 | 51 | r 4 52 | 15 4 53 | r 8 54 | 14 8 55 | r 4 56 | 57 | 12 4 58 | r 4 59 | r 4 60 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p1-4.txt: -------------------------------------------------------------------------------- 1 | 12 8 2 | 12 8 3 | r 8 4 | 12 8 5 | r 8 6 | 12 8 7 | 14 4 8 | 9 | 16 8 10 | 12 8 11 | r 8 12 | 9 8 13 | 7 4 14 | r 4 15 | 16 | 12 8 17 | 12 8 18 | r 8 19 | 12 8 20 | r 8 21 | 12 8 22 | 14 8 23 | 16 8 24 | 25 | r 1 26 | 27 | 12 8 28 | 12 8 29 | r 8 30 | 12 8 31 | r 8 32 | 12 8 33 | 14 4 34 | 35 | 16 8 36 | 12 8 37 | r 8 38 | 9 8 39 | 7 4 40 | r 4 41 | -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p1-5.txt: -------------------------------------------------------------------------------- 1 | 16 8 2 | 12 8 3 | r 8 4 | 7 8 5 | r 4 6 | 8 4 7 | 8 | 9 8 9 | 17 8 10 | r 8 11 | 17 8 12 | 9 4 13 | r 4 14 | 15 | 11 6 16 | 21 6 17 | 21 6 18 | 21 6 19 | 19 6 20 | 17 6 21 | 22 | 16 8 23 | 12 8 24 | r 8 25 | 9 8 26 | 7 4 27 | r 4 28 | 29 | 16 8 30 | 12 8 31 | r 8 32 | 7 8 33 | r 4 34 | 8 4 35 | 36 | 9 8 37 | 17 8 38 | r 8 39 | 17 8 40 | 9 4 41 | r 4 42 | 43 | 11 8 44 | 17 8 45 | r 8 46 | 17 8 47 | 17 6 48 | 16 6 49 | 14 6 50 | 51 | 12 4 52 | r 4 53 | r 4 54 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p2-1.txt: -------------------------------------------------------------------------------- 1 | 6 8 2 | 6 8 3 | r 8 4 | 6 8 5 | r 8 6 | 6 8 7 | 6 8 8 | r 8 9 | 11 4 10 | r 4 11 | r 4 12 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p2-2.txt: -------------------------------------------------------------------------------- 1 | 4 8 2 | r 8 3 | r 8 4 | 0 8 5 | r 8 6 | r 8 7 | -5 8 8 | r 8 9 | 10 | r 8 11 | 0 8 12 | r 8 13 | 2 8 14 | r 8 15 | 1 8 16 | 0 8 17 | r 8 18 | 19 | 0 6 20 | 7 6 21 | 11 6 22 | 12 8 23 | r 8 24 | 9 8 25 | 11 8 26 | 27 | r 8 28 | 9 8 29 | r 8 30 | 4 8 31 | 5 8 32 | 2 8 33 | r 8 34 | r 8 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p2-3.txt: -------------------------------------------------------------------------------- 1 | r 4 2 | 15 8 3 | 14 8 4 | 13 8 5 | 11 8 6 | r 8 7 | 12 8 8 | 9 | r 8 10 | 4 8 11 | 5 8 12 | 7 8 13 | r 8 14 | 0 8 15 | 4 8 16 | 5 8 17 | 18 | r 4 19 | 15 8 20 | 14 8 21 | 13 8 22 | 11 8 23 | r 8 24 | 12 8 25 | 26 | r 8 27 | 17 8 28 | r 8 29 | 17 8 30 | 17 8 31 | r 8 32 | r 4 33 | 34 | r 4 35 | 15 8 36 | 14 8 37 | 13 8 38 | 11 8 39 | r 8 40 | 12 8 41 | 42 | r 8 43 | 4 8 44 | 5 8 45 | 7 8 46 | r 8 47 | 0 8 48 | 4 8 49 | 5 8 50 | 51 | r 4 52 | 8 4 53 | r 8 54 | 5 8 55 | r 4 56 | 57 | 4 4 58 | r 4 59 | r 4 60 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p2-4.txt: -------------------------------------------------------------------------------- 1 | 8 8 2 | 8 8 3 | r 8 4 | 8 8 5 | r 8 6 | 8 8 7 | 10 4 8 | 9 | 7 8 10 | 4 8 11 | r 8 12 | 4 8 13 | 0 4 14 | r 4 15 | 16 | 8 8 17 | 8 8 18 | r 8 19 | 8 8 20 | r 8 21 | 8 8 22 | 10 8 23 | 7 8 24 | 25 | r 1 26 | 27 | 8 8 28 | 8 8 29 | r 8 30 | 8 8 31 | r 8 32 | 8 8 33 | 10 4 34 | 35 | 7 8 36 | 4 8 37 | r 8 38 | 4 8 39 | 0 4 40 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/p2-5.txt: -------------------------------------------------------------------------------- 1 | 12 8 2 | 9 8 3 | r 8 4 | 4 8 5 | r 4 6 | 4 4 7 | 8 | 5 8 9 | 12 8 10 | r 8 11 | 12 8 12 | 5 4 13 | r 4 14 | 15 | 7 6 16 | 17 6 17 | 17 6 18 | 17 6 19 | 16 6 20 | 14 6 21 | 22 | 12 8 23 | 9 8 24 | r 8 25 | 5 8 26 | 4 4 27 | r 4 28 | 29 | 12 8 30 | 9 8 31 | r 8 32 | 4 8 33 | r 4 34 | 4 4 35 | 36 | 5 8 37 | 12 8 38 | r 8 39 | 12 8 40 | 5 4 41 | r 4 42 | 43 | 7 8 44 | 14 8 45 | r 8 46 | 14 8 47 | 14 6 48 | 12 6 49 | 11 6 50 | 51 | 7 8 52 | 4 8 53 | r 8 54 | 4 8 55 | 0 8 56 | r 8 57 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/score.ck: -------------------------------------------------------------------------------- 1 | ChipTriOsc triOsc; 2 | ChipPulseOsc pulseOsc1; 3 | ChipPulseOsc pulseOsc2; 4 | ChipNoiseOsc noiseOsc; 5 | 6 | 1.2::second => dur bar; 7 | bar => triOsc.SetBarDuration; 8 | bar => pulseOsc1.SetBarDuration; 9 | bar => pulseOsc2.SetBarDuration; 10 | 11 | 0.125 => pulseOsc1.SetPulseWidth; 12 | 0.125 => pulseOsc2.SetPulseWidth; 13 | 14 | spork ~ triOsc.PlayFile("tri-1.txt"); 15 | spork ~ pulseOsc1.PlayFile("p1-1.txt"); 16 | spork ~ pulseOsc2.PlayFile("p2-1.txt"); 17 | spork ~ noiseOsc.PlayFile("noise-1.txt"); 18 | 2::bar => now; 19 | 20 | spork ~ triOsc.PlayFile("tri-2.txt"); 21 | spork ~ pulseOsc1.PlayFile("p1-2.txt"); 22 | spork ~ pulseOsc2.PlayFile("p2-2.txt"); 23 | spork ~ noiseOsc.PlayFile("noise-2.txt"); 24 | 4::bar => now; 25 | 26 | spork ~ triOsc.PlayFile("tri-2.txt"); 27 | spork ~ pulseOsc1.PlayFile("p1-2.txt"); 28 | spork ~ pulseOsc2.PlayFile("p2-2.txt"); 29 | spork ~ noiseOsc.PlayFile("noise-2.txt"); 30 | 4::bar => now; 31 | 32 | 0.25 => pulseOsc1.SetPulseWidth; 33 | 0.25 => pulseOsc2.SetPulseWidth; 34 | 35 | spork ~ triOsc.PlayFile("tri-3.txt"); 36 | spork ~ pulseOsc1.PlayFile("p1-3.txt"); 37 | spork ~ pulseOsc2.PlayFile("p2-3.txt"); 38 | spork ~ noiseOsc.PlayFile("noise-3.txt"); 39 | 8::bar => now; 40 | 41 | spork ~ triOsc.PlayFile("tri-3.txt"); 42 | spork ~ pulseOsc1.PlayFile("p1-3.txt"); 43 | spork ~ pulseOsc2.PlayFile("p2-3.txt"); 44 | spork ~ noiseOsc.PlayFile("noise-3.txt"); 45 | 8::bar => now; 46 | 47 | spork ~ triOsc.PlayFile("tri-4.txt"); 48 | spork ~ pulseOsc1.PlayFile("p1-4.txt"); 49 | spork ~ pulseOsc2.PlayFile("p2-4.txt"); 50 | spork ~ noiseOsc.PlayFile("noise-4.txt"); 51 | 6::bar => now; 52 | 53 | 0.125 => pulseOsc1.SetPulseWidth; 54 | 0.125 => pulseOsc2.SetPulseWidth; 55 | 56 | spork ~ triOsc.PlayFile("tri-1.txt"); 57 | spork ~ pulseOsc1.PlayFile("p1-1.txt"); 58 | spork ~ pulseOsc2.PlayFile("p2-1.txt"); 59 | spork ~ noiseOsc.PlayFile("noise-1.txt"); 60 | 2::bar => now; 61 | 62 | spork ~ triOsc.PlayFile("tri-2.txt"); 63 | spork ~ pulseOsc1.PlayFile("p1-2.txt"); 64 | spork ~ pulseOsc2.PlayFile("p2-2.txt"); 65 | spork ~ noiseOsc.PlayFile("noise-2.txt"); 66 | 4::bar => now; 67 | 68 | spork ~ triOsc.PlayFile("tri-2.txt"); 69 | spork ~ pulseOsc1.PlayFile("p1-2.txt"); 70 | spork ~ pulseOsc2.PlayFile("p2-2.txt"); 71 | spork ~ noiseOsc.PlayFile("noise-2.txt"); 72 | 4::bar => now; 73 | 74 | 0.25 => pulseOsc1.SetPulseWidth; 75 | 0.25 => pulseOsc2.SetPulseWidth; 76 | 77 | spork ~ triOsc.PlayFile("tri-5.txt"); 78 | spork ~ pulseOsc1.PlayFile("p1-5.txt"); 79 | spork ~ pulseOsc2.PlayFile("p2-5.txt"); 80 | spork ~ noiseOsc.PlayFile("noise-5.txt"); 81 | 8::bar => now; 82 | 83 | spork ~ triOsc.PlayFile("tri-5.txt"); 84 | spork ~ pulseOsc1.PlayFile("p1-5.txt"); 85 | spork ~ pulseOsc2.PlayFile("p2-5.txt"); 86 | spork ~ noiseOsc.PlayFile("noise-5.txt"); 87 | 8::bar => now; 88 | 89 | spork ~ triOsc.PlayFile("tri-4.txt"); 90 | spork ~ pulseOsc1.PlayFile("p1-4.txt"); 91 | spork ~ pulseOsc2.PlayFile("p2-4.txt"); 92 | spork ~ noiseOsc.PlayFile("noise-4.txt"); 93 | 6::bar => now; 94 | 95 | 0.125 => pulseOsc1.SetPulseWidth; 96 | 0.125 => pulseOsc2.SetPulseWidth; 97 | 98 | spork ~ triOsc.PlayFile("tri-1.txt"); 99 | spork ~ pulseOsc1.PlayFile("p1-1.txt"); 100 | spork ~ pulseOsc2.PlayFile("p2-1.txt"); 101 | spork ~ noiseOsc.PlayFile("noise-1.txt"); 102 | 2::bar => now; 103 | 104 | 0.25 => pulseOsc1.SetPulseWidth; 105 | 0.25 => pulseOsc2.SetPulseWidth; 106 | 107 | spork ~ triOsc.PlayFile("tri-5.txt"); 108 | spork ~ pulseOsc1.PlayFile("p1-5.txt"); 109 | spork ~ pulseOsc2.PlayFile("p2-5.txt"); 110 | spork ~ noiseOsc.PlayFile("noise-5.txt"); 111 | 8::bar => now; -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/tri-1.txt: -------------------------------------------------------------------------------- 1 | 2 8 2 | 2 8 3 | r 8 4 | 2 8 5 | r 8 6 | 2 8 7 | 2 8 8 | r 8 9 | 19 4 10 | r 4 11 | 7 4 12 | r 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/tri-2.txt: -------------------------------------------------------------------------------- 1 | 7 8 2 | r 8 3 | r 8 4 | 4 8 5 | r 8 6 | r 8 7 | 0 8 8 | r 8 9 | 10 | r 8 11 | 5 8 12 | r 8 13 | 7 8 14 | r 8 15 | 6 8 16 | 5 8 17 | r 8 18 | 19 | 4 6 20 | 12 6 21 | 16 6 22 | 17 8 23 | r 8 24 | 14 8 25 | 16 8 26 | 27 | r 8 28 | 12 8 29 | r 8 30 | 9 8 31 | 11 8 32 | 7 8 33 | r 8 34 | r 8 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/tri-3.txt: -------------------------------------------------------------------------------- 1 | 0 4 2 | r 8 3 | 7 8 4 | r 4 5 | 12 8 6 | r 8 7 | 8 | 5 4 9 | r 8 10 | 12 8 11 | 12 4 12 | 5 4 13 | 14 | 0 4 15 | r 8 16 | 7 8 17 | r 4 18 | 7 8 19 | 12 8 20 | 21 | r 8 22 | 36 8 23 | r 8 24 | 36 8 25 | 36 8 26 | r 8 27 | 7 4 28 | 29 | 0 4 30 | r 8 31 | 7 8 32 | r 4 33 | 12 8 34 | r 8 35 | 36 | 5 4 37 | r 8 38 | 12 8 39 | 12 4 40 | 5 4 41 | 42 | 0 4 43 | 8 4 44 | r 8 45 | 10 8 46 | r 4 47 | 48 | 12 4 49 | r 8 50 | 7 8 51 | 7 4 52 | 0 4 53 | -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/tri-4.txt: -------------------------------------------------------------------------------- 1 | -4 4 2 | r 8 3 | 3 8 4 | r 4 5 | 8 4 6 | 7 | 7 4 8 | r 8 9 | 0 8 10 | r 4 11 | -5 4 12 | 13 | -4 4 14 | r 8 15 | 3 8 16 | r 4 17 | 8 4 18 | 19 | 7 4 20 | r 8 21 | 0 8 22 | r 4 23 | -5 4 24 | 25 | -4 4 26 | r 8 27 | 3 8 28 | r 4 29 | 8 4 30 | 31 | 7 4 32 | r 8 33 | 0 8 34 | r 4 35 | -5 4 -------------------------------------------------------------------------------- /40-classic-video-game-soundtrack/SMB1-ground/tri-5.txt: -------------------------------------------------------------------------------- 1 | 0 4 2 | r 8 3 | 6 8 4 | 7 4 5 | 12 4 6 | 7 | 5 4 8 | 5 4 9 | 12 8 10 | 12 8 11 | 5 4 12 | 13 | 2 4 14 | r 8 15 | 5 8 16 | 7 4 17 | 11 4 18 | 19 | 7 4 20 | 7 4 21 | 12 8 22 | 12 8 23 | 7 4 24 | 25 | 0 4 26 | r 8 27 | 6 8 28 | 7 4 29 | 12 4 30 | 31 | 5 4 32 | 5 4 33 | 12 8 34 | 12 8 35 | 5 4 36 | 37 | 7 4 38 | r 8 39 | 7 8 40 | 7 6 41 | 9 6 42 | 11 6 43 | 44 | 12 4 45 | 7 4 46 | 0 4 47 | r 4 -------------------------------------------------------------------------------- /41-constructors-and-help/doc-test.ck: -------------------------------------------------------------------------------- 1 | SndBuf osc1; 2 | 3 | osc1.help(); -------------------------------------------------------------------------------- /41-constructors-and-help/filtered-osc.ck: -------------------------------------------------------------------------------- 1 | class FilteredOsc extends Chugraph 2 | { 3 | SawOsc osc(440) => LPF lpf => Gain g(.25) => outlet; 4 | } 5 | 6 | FilteredOsc osc => dac; 7 | 8 | 1::second => now; -------------------------------------------------------------------------------- /41-constructors-and-help/sine-alternate.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1(880) => Gain vca(0.25) => dac; 2 | 3 | 1::second => now; -------------------------------------------------------------------------------- /41-constructors-and-help/sine-example.ck: -------------------------------------------------------------------------------- 1 | SinOsc osc1 => dac; 2 | 3 | 880 => osc1.freq; 4 | 5 | 1::second => now; -------------------------------------------------------------------------------- /41-constructors-and-help/test1.ck: -------------------------------------------------------------------------------- 1 | class FilteredOsc extends Chugraph 2 | { 3 | SawOsc osc(440) => LPF lpf => Gain vca(.25) => outlet; 4 | } 5 | 6 | FilteredOsc osc => dac; 7 | 8 | 1::second => now; -------------------------------------------------------------------------------- /41-constructors-and-help/test2.ck: -------------------------------------------------------------------------------- 1 | class FilteredOsc extends Chugraph 2 | { 3 | fun @construct() 4 | { 5 | SawOsc osc(440) => LPF lpf => Gain g(.25) => outlet; 6 | 3000 => lpf.freq; 7 | } 8 | } 9 | 10 | FilteredOsc osc => dac; 11 | 12 | 1::second => now; -------------------------------------------------------------------------------- /41-constructors-and-help/test3.ck: -------------------------------------------------------------------------------- 1 | class FilteredOsc extends Chugraph 2 | { 3 | fun @construct() 4 | { 5 | SawOsc osc(440) => LPF lpf => Gain g(.25) => outlet; 6 | 3000 => lpf.freq; 7 | } 8 | 9 | fun @construct(float oscFreq) 10 | { 11 | SawOsc osc(oscFreq) => LPF lpf => Gain g(.25) => outlet; 12 | 3000 => lpf.freq; 13 | } 14 | } 15 | 16 | FilteredOsc osc(220) => dac; 17 | FilteredOsc osc2(137.5) => dac; 18 | FilteredOsc osc3(165) => dac; 19 | 20 | 1::second => now; -------------------------------------------------------------------------------- /41-constructors-and-help/test4.ck: -------------------------------------------------------------------------------- 1 | class FilteredOsc extends Chugraph 2 | { 3 | fun @construct() 4 | { 5 | SawOsc osc(440) => LPF lpf => Gain g(.25) => outlet; 6 | 3000 => lpf.freq; 7 | } 8 | 9 | fun @construct(float oscFreq) 10 | { 11 | SawOsc osc(oscFreq) => LPF lpf => Gain g(.25) => outlet; 12 | 3000 => lpf.freq; 13 | } 14 | 15 | fun @construct(float oscFreq, float lpfFreq, float lpfQ) 16 | { 17 | SawOsc osc(oscFreq) => LPF lpf => Gain g(.25) => outlet; 18 | lpfFreq => lpf.freq; 19 | lpfQ => lpf.Q; 20 | } 21 | } 22 | 23 | FilteredOsc osc(110, 4400, 4 ) => dac; 24 | FilteredOsc osc2(137.5, 880, 0.6) => dac; 25 | FilteredOsc osc3(165, 1000, 2) => dac; 26 | 27 | 1::second => now; 28 | osc3.help(); -------------------------------------------------------------------------------- /41-constructors-and-help/test5.ck: -------------------------------------------------------------------------------- 1 | class FilteredOsc extends Chugraph 2 | { 3 | fun @construct() 4 | { 5 | SawOsc osc(440) => LPF lpf => Gain g(.25) => outlet; 6 | 3000 => lpf.freq; 7 | } 8 | 9 | fun @construct(float oscFreq) 10 | { 11 | SawOsc osc(oscFreq) => LPF lpf => Gain g(.25) => outlet; 12 | 3000 => lpf.freq; 13 | } 14 | 15 | fun @construct(float oscFreq, float lpfFreq, float lpfQ) 16 | { 17 | SawOsc osc(oscFreq) => LPF lpf => Gain g(.25) => outlet; 18 | lpfFreq => lpf.freq; 19 | lpfQ => lpf.Q; 20 | } 21 | 22 | fun @construct(float oscFreq, Osc osc) 23 | { 24 | osc => LPF lpf => Gain g(.25) => outlet; 25 | oscFreq => osc.freq; 26 | 3000 => lpf.freq; 27 | } 28 | } 29 | 30 | FilteredOsc osc(110, new SawOsc) => dac; 31 | FilteredOsc osc2(165, new SqrOsc) => dac; 32 | 33 | 1::second => now; -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # chuck-examples 2 | Example code to help people follow along with [the tutorials](https://www.youtube.com/playlist?list=PL-9SSIBe1phI_r3JsylOZXZyAXuEKRJOS). 3 | 4 | [Download](https://chuck.cs.princeton.edu/) the ChucK music programming language to get started! 5 | 6 | Note: I wrote this code as I was learning ChucK so not everything here is how I would write it now with the benefit of hindsight. But it should match the videos! 7 | -------------------------------------------------------------------------------- /misc/laser-result.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/misc/laser-result.wav -------------------------------------------------------------------------------- /misc/laser-single.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/misc/laser-single.wav -------------------------------------------------------------------------------- /misc/pewpew.ck: -------------------------------------------------------------------------------- 1 | "laser-single.wav" => string laser; 2 | dac => WvOut waveOut => blackhole; 3 | "laser-result.wav" => waveOut.wavFilename; 4 | 5 | 100::ms => dur rate; 6 | 7 | fun void pew() 8 | { 9 | SndBuf buffer => dac; 10 | 11 | Math.random2f(0.1, 0.3) => buffer.gain; 12 | Math.random2f(0.8, 1.2) => float rateMod; 13 | rateMod => buffer.rate; 14 | laser => buffer.read; 15 | buffer.length() * rateMod => now; 16 | } 17 | 18 | 0.5 => float min; 19 | 5.0 => float max; 20 | 21 | for (0 => int i; i < 40; i++) 22 | { 23 | spork ~ pew(); 24 | Math.random2f(min, max) * rate => now; 25 | } -------------------------------------------------------------------------------- /sounds/14-drum-machine-sounds.zip: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/sounds/14-drum-machine-sounds.zip -------------------------------------------------------------------------------- /sounds/guitar.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vscomputer/chuck-examples/77070512a4aadd5624ab39edf2e46f49a59c9021/sounds/guitar.wav -------------------------------------------------------------------------------- /ugen.ck: -------------------------------------------------------------------------------- 1 | TriOsc osc => ADSR env1 => dac; 2 | TriOsc osc2 => ADSR env2 => dac; 3 | 4 | 2::second => dur beat; 5 | (beat /2, beat /2, 0, 1::ms) => env1.set; 6 | (1::ms, beat / 8, 0, 1::ms) => env2.set; 7 | 8 | 0.2 => osc.gain; 9 | 0.1 => osc2.gain; 10 | 11 | [0,4,7,12] @=> int major[]; 12 | [0,3,7,12] @=> int minor[]; 13 | 14 | 48 => int offset; 15 | int position; 16 | 17 | while(true) 18 | { 19 | 20 | 0 => position; 21 | for(0 => int i; i < 4; i++) 22 | { 23 | Std.mtof(minor[0] + offset + position) => osc.freq; 24 | 1 => env1.keyOn; 25 | for(0 => int j; j < 4; j++) 26 | { 27 | Std.mtof(minor[j] + offset + position + 12) => osc2.freq; 28 | 1 => env2.keyOn; 29 | beat / 8 => now; 30 | } 31 | } 32 | 33 | -4 => position; 34 | for(0 => int i; i < 4; i++) 35 | { 36 | Std.mtof(major[0] + offset + position) => osc.freq; 37 | 1 => env1.keyOn; 38 | for(0 => int j; j < 4; j++) 39 | { 40 | Std.mtof(major[j] + offset + position + 12) => osc2.freq; 41 | 1 => env2.keyOn; 42 | beat / 8 => now; 43 | } 44 | } 45 | 46 | -2 => position; 47 | for(0 => int i; i < 4; i++) 48 | { 49 | Std.mtof(major[0] + offset + position) => osc.freq; 50 | 1 => env1.keyOn; 51 | for(0 => int j; j < 4; j++) 52 | { 53 | Std.mtof(major[j] + offset + position + 12) => osc2.freq; 54 | 1 => env2.keyOn; 55 | beat / 8 => now; 56 | } 57 | } 58 | 59 | -5 => position; 60 | for(0 => int i; i < 4; i++) 61 | { 62 | Std.mtof(major[0] + offset + position) => osc.freq; 63 | 1 => env1.keyOn; 64 | for(0 => int j; j < 4; j++) 65 | { 66 | Std.mtof(major[j] + offset + position + 12) => osc2.freq; 67 | 1 => env2.keyOn; 68 | beat / 8 => now; 69 | } 70 | } 71 | } 72 | 73 | --------------------------------------------------------------------------------