// =====================================================================
// SuperCollider Workspace
// =====================================================================

(
SynthDef("kick1", {arg out = 0, amp = 0.3, sinFreq = 60, glissf = 0.9, att = 0.01, rel = 0.45, pan = 0;
	var gliss = XLine.kr(sinFreq, sinFreq*glissf, rel);
	var snd = SinOsc.ar(gliss);
	var env = Env.perc(att, rel).kr(doneAction: 2);
	snd = snd * env * amp;
	Out.ar(out, Pan2.ar(snd, pan));
},
metadata: (
	credit: "Bruno Tucunduva Ruviaro",
	category: \drums,
	tags: [\percussion, \kick]
)
).add;

/* Recieved from
https://github.com/supercollider-quarks/SynthDefPool/blob/master/pool/kick_chrp.scd
A kick made using what radio folks would call a "chirp"
Modified by Bruno Ruviaro and Josh Mitchell 8/19.
*/

SynthDef(\kick_chirp, {

	arg out = 0, amp = 0.1, pan = 0, curve = -20, att = 0.001, rel = 0.5, maxFreq = 500;

    var env, snd;

	env = Env.perc(attackTime: att, releaseTime: rel, curve: curve).exprange(0, maxFreq).kr(doneAction: 2);

    snd = SinOsc.ar(freq: env, mul: amp);
    snd = LeakDC.ar(snd);

Out.ar(out, Pan2.ar(snd, pan))
},
metadata: (
	credit: "Original by dan stowell. public domain",
	category: \drums,
	tags: [\kick, \drum, \percussion, \chirp]
	)
).add;

SynthDef("hihat1", {arg out = 0, amp = 0.5, att = 0.01, rel = 0.2, ffreq = 6000, pan = 0;
	var snd = WhiteNoise.ar(amp);
	var env = Env.perc(att, rel).kr(doneAction: 2);
	snd = HPF.ar(snd * env, ffreq);
	Out.ar(out, Pan2.ar(snd, pan));
},
metadata: (
	credit: "Bruno Tucunduva Ruviaro",
	category: \drums,
	tags: [\percussion, \hihat]
)
).add;
)


TempoClock.default.tempo = 90/60;
Ndef(\kick).play
Ndef(\kick).stop
Ndef(\kick).proxyspace.quant = 8;
Ndef(\kick).proxyspace.tempo = 90;
Ndef(\kick).fadeTime = 0.001;

(

Ndef(\kick,
	
	Ppar([
		Pbind( \instrument, \kick1,
			//\dur, Pseq([1.5,1,1.5], inf),
			\dur, Pseq([0.75,0.75, 0.5], inf),
			\rel, 1,
			\glissf, 0.6,
			\amp, 0.8
		),
		Pbind( \instrument, \kick_chirp,
			\dur, Pseq([0.75, 1, 0.75, 0.25],inf),
			\dur, Prand([
				Pseq([0.75, 0.5, 0.75]),
				Pseq([0.75, 0.75, 0.5]),
				Pseq([0.75, 0.75, 0.25,0.25]),
				Pseq([0.75, 0.25,0.25, 0.75]),
				Pseq([0.75, 0.25,0.75, 0.25]),
				Pseq([0.75, 0.25, 0.5, 0.5]),
				//Pseq([0.25],8),
				//Pseq([0.5],4),
				Pseq([1],2),
			], inf),
			\amp, 0.02
		),
		Pbind(\instrument, \hihat1,
			\dur, Pseq([Rest(0.27),0.23,0.25,0.25], inf),
			\amp, Pseq([0, 0.04,0.09,0.01], inf) ,
			\ffreq, 10000,
		),
		Pbind(\instrument, \hihat1,
			\dur, Pseq([Pseq([0.26,0.24],7),Prand([1/8,Rest(1/8)]), 1/8],inf),
			\amp, Pseq([0.01,0.02], inf) ,
			\ffreq, 5000
		),inf
	])
	
)
)










///////////////////////////////////////////////////////////////////////////////////////////////////




(
{
    EnvGen.kr(
        Env([0, 1, 0, 0.2, 0, 0.5, 0.8, 0], [0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01], releaseNode: 5, loopNode: 1),
        gate: Trig.kr(1, 3.9)
    );
}.plot(duration: 4)
)





( // synthdefi
SynthDef(\monitorInput, {
	arg out = 0;
	var snd = SoundIn.ar([0,1], 1);
	Out.ar(out,snd);
}).play;
)

Ndef(\ndefMonIn).play
Ndef(\ndefMonIn).fadeTime = 10;
(
Ndef(\ndefMonIn, {
	var snd = SoundIn.ar([0,1], 1);

	snd*0.5;
}).fadeTime = 10;
)

// Execute the following in order
(
// allocate a Buffer
s = Server.local;
b = Buffer.alloc(s, 44100 * 4.0, 1); // a four second 1 channel Buffer
)

// record for four seconds
(
SynthDef(\help_RecordBuf, { arg out = 0, bufnum = 0;
    var snd = SoundIn.ar(0,1);
    RecordBuf.ar(snd, bufnum, doneAction: Done.freeSelf, loop: 0);
	
}).play(s,[\out, 0, \bufnum, b]);
)

// play it back
(
SynthDef(\help_RecordBuf_playback, { arg out = 0, bufnum = 0;
    var playbuf;
    playbuf = PlayBuf.ar(1,bufnum);
    FreeSelfWhenDone.kr(playbuf); // frees the synth when the PlayBuf is finished
    Out.ar(out, playbuf);
}).play(s, [\out, 0, \bufnum, b]);
)
b.plot

// overdub
(
SynthDef(\help_RecordBuf_overdub, { arg out=0, bufnum=0;
    var formant;
    formant = Formant.ar(XLine.kr(200, 1000, 4), 2000, 800, 0.125);
    // mixes equally with existing data
    RecordBuf.ar(formant, bufnum, 0, 0.3, 0.5, doneAction: Done.freeSelf, loop: 0);
}).play(s, [\out, 0, \bufnum, b]);
)

// play back the overdubbed version
Synth.new(\help_RecordBuf_playback, [\out, 0, \bufnum, b], s);

// write the contents of the buffer to a file (see Buffer for more options)
(
b.write(sampleFormat: 'int16');
thisProcess.platform.recordingsDir +/+ "SC_" ++ Date.localtime.stamp ++ ".aiff"; // generated path
)

b.close; b.free; // cleanup

Ndef(\bgrain).play

Ndef(\bgrain).fadeTime = 10;

(
Ndef(\bgrain, { |gate = 1, amp = 0, sndbuf, freq=90|
    var snd, pan, env, freqdev;
    // use mouse x to control panning
    //pan = MouseX.kr(-1, 1);
    pan = LFNoise1.kr(0.1).range(-1, 1) * LFNoise0.kr(freq).range(0.2,1);
    env = EnvGen.kr(
        Env([0, 1, 0], [1, 1], \sin, 1),
        gate,
        levelScale: amp,
        doneAction: Done.freeSelf);
	
	snd = GrainBuf.ar(
		numChannels:2,
		trigger:Impulse.kr(LFNoise1.kr(freq).range(0.8,1) * freq),
		dur: 0.2,
		sndbuf: b,
		rate: 1 * LFNoise1.kr.range(0.99, 1),
		pos: LFNoise2.kr(0.1).range(0, 1) * LFNoise0.kr(freq).range(1,1.01),
		interp: 2,
		pan: pan) * env;

	snd = RLPF.ar(snd, freq: LFNoise2.kr(0.1).exprange(400,10000));

	//snd = snd + (Greyhole.ar(snd, delayTime: 0.4,feedback: 0.4 ) * 0.8);
});
)



c = Buffer.alloc(s, 44100 * 4.0, 1); // a four second 1 channel Buffer
// record for four seconds
(
SynthDef(\help_RecordBuf, { arg out = 0, bufnum = 0;
    var snd = SoundIn.ar(0,1);
    RecordBuf.ar(snd, bufnum, doneAction: Done.freeSelf, loop: 0);
	
}).play(s,[\out, 0, \bufnum, c]);
)

Ndef(\bgrain2).play;
Ndef(\bgrain2).fadeTime = 3;
(
Ndef(\bgrain2, { |gate = 1, amp = -6.db, sndbuf, freq=90|
    var snd, pan, env, freqdev;
    // use mouse x to control panning
    //pan = MouseX.kr(-1, 1);
    pan = LFNoise1.kr(0.1).range(-1, 1) * LFNoise0.kr(freq).range(0.2,1);
    env = EnvGen.kr(
        Env([0, 1, 0], [5, 1], \sin, 1),
        gate,
        //levelScale: amp,
        doneAction: Done.freeSelf);
	
	snd = GrainBuf.ar(
		numChannels:2,
		trigger:Impulse.kr(LFNoise1.kr(freq).range(0.8,1) * freq),
		dur: 0.2,
		sndbuf: c,
		rate: 1 * LFNoise1.kr.range(0.99, 1),
		pos: LFNoise2.kr(0.03).range(0, 1) * LFNoise0.kr(freq).range(1,1.01),
		interp: 2,
		pan: pan) * env;

	snd = RLPF.ar(snd, freq: LFNoise2.kr(0.1).exprange(100,7000)) * amp;

	//snd = snd + (Greyhole.ar(snd, delayTime: 0.4,feedback: 0.4 ) * 0.8);
});
)


Ndef(\ba).play(~reverBus, addAction: \addToHead)

~reverbDelay = Synth(\verbDelayFX, [\inBus, ~reverBus, \outBus, 0], addAction: \addAfter);
~reverbDelay.set(\revWet, 1);
~reverbDelay.set(\dlyWet, 1);
~reverbDelay.free
//////////////////////////////////////////////////////////////////////////////////////////////


Quarks.gui

SynthDefPool.gui