gtr/gtr.scd

// RUNME 0 =========================================
// todo countdown on density voices


( s.reboot{
    s.options.numBuffers = 1024 * 256; // increase this if you need to load more samples
	s.options.sampleRate = 44100; // also tried with 44000 value
    s.options.memSize = 8192 * 32; // increase this if you get "alloc failed" messages
    s.options.numWireBufs = 64; // increase this if you get "exceeded number of interconnect buffers" messages
    s.options.maxNodes = 1024 * 32; // increase this if you are getting drop outs and the message "too many nodes"
	s.options.numInputBusChannels = 8;
    s.options.numOutputBusChannels = 8;
})

// RUNME 1 =========================================


( // SETUP ---------------=--------------------------
// Allocate a 4 second mono buffer
b = Buffer.alloc(s, s.sampleRate * 4.0, 1);
~b1 = Buffer.alloc(s, s.sampleRate * 4.0, 1);
f = Buffer.alloc(s, s.sampleRate * 4.0, 1);

// load a test file
//f = Buffer.read(s, thisProcess.nowExecutingPath.dirname +/+ "sounds/Front_Left.wav");
//b = Buffer.read(s,  "/usr/share/sounds/alsa/Front_Left.wav");

//b=f;

// Open port 57121 for ESP32 UDP OSC
thisProcess.openUDPPort(57121);
///////////////////////////////////////
~sourceGroup = Group.new;
~fxGroup = Group.after(~sourceGroup);
~reverbBus = Bus.audio(s, 1);
~ringModBus = Bus.audio(s, 1);


//load the gui

"/home/rob/gtr/gtr-gui-manual.scd".load;

);

s.plotTree;

// RUNME 2 ==========================================
// -------------------------------------------------


(( // DEFINE SYNTHS ---------------------------------

s.meter;


// -------------------------------------------------

( // direct signal + reverb -------------------------

SynthDef("dryIn", { arg in=0, instrPanModeIndex=0, out=0,  sensorInstrPan=0, instrPitch=0.7, instrAmp=1;
	var signal, dry, wet, instrPan, instrPanMode0, instrPanMode1, instrPanMode2, instrPanMode3, instrPanMode4, instrPanMode5;

	instrPanMode0 = 0; //LFNoise1.kr(100).range(-0.2, 0.2);
	instrPanMode1 = 1; //LFNoise1.kr(100).range(-0.2, 0.2);
	instrPanMode2 = SinOsc.kr(0.33).range(-0.2, 0.2);
	instrPanMode3 = LFNoise1.kr(10).range(-0.2, 0.2);
	instrPanMode4 = LFSaw.kr(0.33).bipolar.range(-1,1);
	instrPanMode5 = LFNoise1.kr(10).range(-1, 1);

	instrPan = Select.kr(instrPanModeIndex,
		[instrPanMode0, instrPanMode1, instrPanMode2, instrPanMode3,
		instrPanMode4, instrPanMode5, sensorInstrPan]);

	signal = SoundIn.ar(in);
	//signal = PanAz.ar(4, signal, instrPan);
	signal = signal * instrAmp;

	//wet = PitchShift.ar(signal, pitchRatio: instrPitch, pitchDispersion: 0.3, timeDispersion: 0.1);
	Out.ar(out, signal);
	//Out.ar(0, Mix.ar( [signal, wet] ));
}).add;
);

(
SynthDef("freeVerb", {
	arg in=0;
	var signal, dry, wet;
	dry = In.ar(in);
	wet = FreeVerb.ar(dry, mix:0.5, room:0.99, damp:0.5,);
	signal = wet * 0.9;
	Out.ar(0, signal!2);
}).add;
);

SynthDef("ringModulator", {
	arg in=0, modulator=300, mulrate=0.2;
	var signal, rm , carrier, multiplier;
	signal = In.ar(in);
	multiplier = SinOsc.ar(mulrate);
	rm = signal * SinOsc.ar(modulator, mul:multiplier);
	signal = (rm + signal) * 0.5;
	Out.ar(0, signal!2);
}).add;
);




// ---------~posMode = 1; -------------------------------------------

/*(  // Granulator --------------------------------------r.get(\in).postln;

// ----------------------------------------------------

// a custom envelope
//var winenv;
//winenv = Env([0, 1, 0], [0.5, 0.5], [8, -8]);
//z = Buffer.sendCollection(s, winenv.discretize, 1);
// ~rndpos = LFNoise2.kr(0.1).range(0, 1);

SynthDef(\buf_grain, { | out=0, gate = 1, amp = 0.5,
	sndbuf, envbuf, pan=0,  imp=50,
	pitchmodeindex=0, sensorpitch=1, sensorgdur=0.1, sensorgpan=0,
	 posModeindex=0, gdurmodeindex=0, gpanmodeindex=0,
	sensorposition=0, impulsemodeindex=0, sensorimpulse=0,
	signalChannelIndex=1, dseqarrayIndex=1,
	rlow= -1, rhigh=10 |

	var signal, env, freqdev, pos,
	pitchmode0, pitchmode1, pitchmode2,pitchmode3,pitchmode4,pitchmode5, pitchmode6, pitch,
	gdurmode0, gdurmode1, gdurmode2, gdurmode3,  gdurmode4, gdurmode5,  gdurmode6, gdur,
	gpanmode0, gpanmode1, gpanmode2,gpanmode3, gpanmode4, gpanmode5,gpanmode6, gpanmode7, gpanmode8, gpan,
	posMode0, posMode1, posMode2, posMode3, position,
	impulsemode0, impulsemode1, impulse,
	xdseq, dseq_array1, dseq_array2, dseq_array3, dseq_array4, dseq_array5, dseq_array6,
	stereosignal, quadsignalL, quadsignalR, quadsignal, signalchannels;

	// grain duration mode -untransposed, random, or sensor controlled
	gdurmode0 = 0.2;
	gdurmode1 = 0.5;
	gdurmode2 = LFNoise1.kr.range(0.1, 0.3);
	gdurmode3 = LFNoise1.kr.range(0.1, 0.6);
	gdurmode4 = LFNoise1.kr.range(1, 2);
	gdurmode5 = LFNoise1.kr.range(1, 4);
	gdurmode6 = LFNoise1.kr.range(4, 4);

	gdur = Select.kr(gdurmodeindex,
		[gdurmode0, gdurmode1, gdurmode2, gdurmode3, gdurmode4, gdurmode5, gdurmode6, sensorgdur]);

	// grain pan mode STEREO, QUAD, ROTATING
		gpanmode0 = 0; //LFNoise1.kr(100).range(-0.2, 0.2);
	gpanmode1 = 1; //LFNoise1.kr(100).range(-0.2, 0.2);
	gpanmode2 = SinOsc.kr(0.33).range(-0.2, 0.2);
	gpanmode3 = LFNoise1.kr(10).range(-0.2, 0.2);
	gpanmode4 = LFSaw.kr(0.33).bipolar.range(-1,1);
	gpanmode5 = LFNoise1.kr(10).range(-1, 1);
	gpanmode6 = LFNoise1.kr(10).range(-1, 1);
	gpanmode7 = LFNoise1.kr(10).range(-1, 1);
	gpanmode8 = LFNoise1.kr(10).range(-1, 1);
	gdurmode6 = LFNoise1.kr.range(4, 4);
	gdurmode6 = LFNoise1.kr.range(4, 4);


	gpan = Select.kr(gpanmodeindex,
		[gpanmode0, gpanmode1, gpanmode2, gpanmode3, gpanmode4, gpanmode5, gpanmode6, gpanmode7, gpanmode8, sensorgpan]);

	// grain pitch mode -untransposed, random, or sensor controlled

	pitchmode0 = 1;
	//pitchmode1 = Demand.kr(Impulse.kr(imp), 0, Dseq([1,-1, 2, 1, -1.5, 1, 1.33, 1,  -0.5, 1,  3, 1, 2.37, 1, -0.33, 1], inf));
	pitchmode1 = Demand.kr(Impulse.kr(imp), 0, Drand([1,1, 1,1,1,1, 2, 3, 3, 0.5, 0.5], inf));
	pitchmode2 = Demand.kr(Impulse.kr(imp), 0, Drand(Scale.minor.degrees.midiratio, inf) * Drand([0.5, 0.25,1,2], inf));
	pitchmode3 = Demand.kr(Impulse.kr(imp), 0, Dseq([1,-1, -0.5, 1, 1.33, 1], inf));
	pitchmode4 = Demand.kr(Impulse.kr(imp), 0, Drand([0.5, 0.25,1,2], inf));
	pitchmode5 = Demand.kr(Impulse.kr(imp), 0, Drand(Scale.diminished.degrees.midiratio, inf));
	pitchmode6 = LFNoise1.kr(imp).range(rlow, rhigh);

	pitch = Select.kr(pitchmodeindex,
		[pitchmode0, sensorpitch, pitchmode1, pitchmode2 ,pitchmode3, pitchmode4, pitchmode5, pitchmode6]);

	// granular playhead mode - fixed random or sensor controlled
	posMode0 = 0.2;
	posMode1 = (Phasor.ar(0.01, 1 * BufRateScale.ir(b), 0, BufSamples.ir(b)) + LFNoise1.ar(100).bipolar(0.1 * SampleRate.ir) ) / BufSamples.ir(b);
	posMode2 = LFNoise1.kr.range(0.05, (BufSamples.ir(b)-1) - 1000 );
	posMode3 = LFNoise1.kr.range(0.1, 3.8 );

	position = Select.kr(posModeindex,
		[posMode0, posMode1, posMode2, posMode3, sensorposition]);

	//  grain impulse frequency mode - random, metric or sensor based impulse modes
	impulsemode0 = Impulse.kr(imp);
	impulsemode1 = Dust.kr(imp);
	impulse = Select.kr(impulsemodeindex,
		[impulsemode0, impulsemode1, sensorimpulse]);

	env = EnvGen.kr( Env([0, 1, 0], [1, 1], \sin, 1), gate, levelScale: amp, doneAction: 2);

	signal = TGrains.ar(4, impulse, b, pitch, position, gdur, gpan, amp, 4) * env;

	Out.ar(0, signal);

}).add;
);*/

(
~micBus = Bus.audio(s,1);
~ptrBus = Bus.audio(s,1);
);

(
SynthDef.new(\mic, {
	arg in=0, out=0, amp=1;
	var sig;
	sig = SoundIn.ar(in) * amp;
	Out.ar(out, sig);
}).add;

SynthDef.new(\ptr, {
	arg out=0, buf=0;
	var sig;
	sig = Phasor.ar(0, BufRateScale.kr(buf), 0, BufFrames.kr(buf));
	Out.ar(out, sig);
}).add;

b.numFrames;

SynthDef.new(\rec, {
	arg ptrIn=0, micIn=0, buf=0;
	var ptr, sig;
	ptr = In.ar(ptrIn, 1);
	sig = In.ar(micIn, 1);
	BufWr.ar(sig, buf, ptr);
}).add;

( // mono buffer recorder ----------------------------
// with loop and overdub modes /////////////////////
SynthDef("recBuf",{
	arg in=0, out=0, ptrIn=0, bufnum=0, t_trig=0, l=0, overdub=0;
	var sig, ptr, chain, onsets;
	sig = SoundIn.ar(in, 1);
//	ptr = In.ar(ptrIn, 1);

	//	Onsets
	//chain = FFT(LocalBuf(512), sig);
	//onsets = Onsets.kr(chain, MouseX.kr(0,1), \rcomplex);

	RecordBuf.ar(sig, bufnum, loop:l,
		recLevel: 1,
		preLevel: overdub,
		doneAction: 0, trigger:t_trig,
		//offset: ptr,

	);
}).add;
);



SynthDef.new(\gran, {
	arg amp=0.5, out=0, buf=0,
	atk=1, rel=1, gate=1,
	sync=1, dens=40,
	baseDur=0.05, durRand=1,
	rate=1, rateRand=1,
	pan=0, panRand=0,
	grainEnv=(-1), ptrBus=0, ptrSampleDelay=20000,
	ptrRandSamples=5000, minPtrDelay=1000;

	var sig, env, densCtrl, durCtrl, rateCtrl, panCtrl, ptr, ptrRand, totalDelay, maxGrainDur;

	env= EnvGen.kr(Env.asr(atk,1,rel),gate, doneAction:2);
	densCtrl = Select.ar(sync, [Dust.ar(dens), Impulse.ar(dens)]);
	durCtrl = baseDur * LFNoise1.ar(100).exprange(1/durRand, durRand);
	rateCtrl = rate * LFNoise1.ar(100).exprange(1/rateRand, rateRand);
	panCtrl = pan + LFNoise1.kr(100).bipolar(panRand);

	ptrRand = LFNoise1.ar(100).bipolar(ptrRandSamples);
	totalDelay = max(ptrSampleDelay - ptrRand, minPtrDelay); // make sure value doesnt go below this value, which would cross discontinuity point

	ptr = In.ar(ptrBus, 1);
	ptr = ptr - totalDelay; // how far ptr lags behind discontinuity point
	ptr = ptr / BufFrames.kr(buf); //normalise to 0 - 1 range

	maxGrainDur = (totalDelay / rateCtrl) /  SampleRate.ir;
	durCtrl = min(durCtrl, maxGrainDur);


	sig = GrainBuf.ar(
		4,
		densCtrl,
		durCtrl,
		buf,
		rateCtrl,
		ptr,
		2,
		panCtrl,
		grainEnv
	);

	sig = sig * env * amp;
	Out.ar(out, sig);

}).add;

)




)

/*(  // New Granulator --------------------------------------

SynthDef(\buf_grain, { | out=0, gate = 1, amp = 0.5,
	sndbuf, envbuf, pan=0,  imp=50,
	pitchmodeindex=0, sensorpitch=1, sensordensity=1, sensorgdur=0.1, sensorgpan=0,
	 posModeindex=0, gdurmodeindex=0, gpanmodeindex=0, densitymodeindex=0,
	sensorposition=0, impulsemodeindex=0, sensorimpulse=0,
	signalChannelIndex=1, dseqarrayIndex=1,
	rlow= -1, rhigh=10 |

	var signal, env, freqdev, pos,
	pitchmode0, pitchmode1, pitchmode2,pitchmode3,pitchmode4,pitchmode5, pitchmode6, pitch,
	gdurmode0, gdurmode1, gdurmode2, gdurmode3,  gdurmode4, gdurmode5,  gdurmode6, gdur,
	gpanmode0, gpanmode1, gpanmode2, gpan,
	posMode0, posMode1, posMode2, posMode3, position,
	densmode0,densmode1,densmode2,densmode3,densmode4,densmode5,densmode6,densmode7, density,
	impulsemode0, impulsemode1, impulse,
	xdseq, dseq_array1, dseq_array2, dseq_array3, dseq_array4, dseq_array5, dseq_array6,
	stereosignal, quadsignalL, quadsignalR, quadsignal, signalchannels;

	// grain duration mode -untransposed, random, or sensor controlled
	gdurmode0 = 0.2;
	gdurmode1 = 0.5;
	gdurmode2 = LFNoise1.kr.range(0.1, 0.3);
	gdurmode3 = LFNoise1.kr.range(0.1, 0.6);
	gdurmode4 = LFNoise1.kr.range(1, 2);
	gdurmode5 = LFNoise1.kr.range(1, 4);
	gdurmode6 = LFNoise1.kr.range(4, 4);

	gdur = Select.kr(gdurmodeindex,
		[gdurmode0, gdurmode1, gdurmode2, gdurmode3, gdurmode4, gdurmode5, gdurmode6, sensorgdur]);

	// grain pan mode STEREO, QUAD, ROTATING

	gpanmode0 = LFNoise1.kr(100).range(-0.2, 0.2);
	gpanmode1 = LFSaw.kr(0.33).bipolar.range(-1,1);
	gpanmode2 = LFNoise1.kr(100).range(-1, 1);
	gpan = Select.kr(gpanmodeindex,
		[gpanmode0, gpanmode1, gpanmode2, sensorgpan]);


	// density mode

	dens0 = 1;
	dens1 = 2;
	dens2 = 4;
	dens3 = 8;
	dens4 = 16;
	dens5 = 32;
	dens6 = 64;
	dens7 = 128;
	density = Select.kr(densitymodeindex,
		[dens0,dens1,dens2,dens3,dens4,dens5,dens6,dens7]);


	// grain pitch mode -untransposed, random, or sensor controlled
	pitchmode0 = 1;
	//pitchmode1 = Demand.kr(Impulse.kr(imp), 0, Dseq([1,-1, 2, 1, -1.5, 1, 1.33, 1,  -0.5, 1,  3, 1, 2.37, 1, -0.33, 1], inf));
	pitchmode1 = Demand.kr(Impulse.kr(imp), 0, Drand([1,1, 1,1,1,1, 2, 3, 3, 0.5, 0.5], inf));
	pitchmode2 = Demand.kr(Impulse.kr(imp), 0, Drand(Scale.minor.degrees.midiratio, inf) * Drand([0.5, 0.25,1,2], inf));
	pitchmode3 = Demand.kr(Impulse.kr(imp), 0, Dseq([1,-1, -0.5, 1, 1.33, 1], inf));
	pitchmode4 = Demand.kr(Impulse.kr(imp), 0, Drand([0.5, 0.25,1,2], inf));
	pitchmode5 = Demand.kr(Impulse.kr(imp), 0, Drand(Scale.diminished.degrees.midiratio, inf));
	pitchmode6 = LFNoise1.kr(imp).range(rlow, rhigh);

	pitch = Select.kr(pitchmodeindex,
		[pitchmode0, sensorpitch, pitchmode1, pitchmode2 ,pitchmode3, pitchmode4, pitchmode5, pitchmode6]);

	// granular playhead mode - fixed random or sensor controlled
	posMode0 = 0.2;
	posMode1 = (Phasor.ar(0.01, 1 * BufRateScale.ir(b), 0, BufSamples.ir(b)) + LFNoise1.ar(100).bipolar(0.1 * SampleRate.ir) ) / BufSamples.ir(b);
	posMode2 = LFNoise1.kr.range(0.05, (BufSamples.ir(b)-1) - 1000 );
	posMode3 = LFNoise1.kr.range(0.1, 3.8 );

	position = Select.kr(posModeindex,
		[posMode0, posMode1, posMode2, posMode3, sensorposition]);

	//  grain impulse frequency mode - random, metric or sensor based impulse modes
	impulsemode0 = Impulse.kr(imp);
	impulsemode1 = Dust.kr(imp);
	impulse = Select.kr(impulsemodeindex,
		[impulsemode0, impulsemode1, sensorimpulse]);

	env = EnvGen.kr( Env([0, 1, 0], [1, 1], \sin, 1), gate, levelScale: amp, doneAction: 2);

	signal = TGrains.ar(4, impulse, b, pitch, position, gdur, gpan, amp, 4) * env;

	Out.ar(0, signal);

}).add;
)*/

(  // RUNME 3  ==========================================

	// START SYNTHS ---------------------------------

	r = Synth(\recBuf, [\in, 0, \out, 0, \bufnum, b, \t_trig, 0]); // recorder
	~gtrIn = Synth(\dryIn, [\instrAmp, 1, \out, ~reverbBus], ~sourceGroup); // dry audio signaL
	~reverbFX = Synth(\freeVerb, [\in, ~reverbBus], ~fxGroup);
	~ringMod = Synth(\ringModulator, [\in, ~ringModBus], ~fxGroup);

		b.zero;

		~g = 1.collect({
			arg n;
			Synth(\gran,[
				\amp, 0.15,
				// \amp, n.linlin(0,4, -3,-20).dbamp,
				\buf, b, // which buffer
				\out, 0,
				\atk, 1,
				\rel, 1,
				\gate, 1,
				\sync, 1,
				\dens, 21,  // exprand(2,80),
				\baseDur, 1, //0.08
				\durRand, 1,
				\rate, 1,
				\rateRand, 1,
				\pan, 0,
				\panRand, 1,
				\grainEnv, -1,
				\ptrBus, ~ptrBus, // make different style ptrs
				//\ptrSampleDelay, n.linlin(0,4, 20000, s.sampleRate*2),
				\ptrSampleDelay, 20000, // how far pointer lags behind write head
				\ptrRandSamples, 2000,  // how much to randomly jump around
				\minPtrDelay, 1000, // dont get any closer to the ptr than this
			], ~granGrp);
		});
	);

));


// RUNME 4  ==========================================
// ----------------------------------------------

OSCFunc.trace(true); // Turn posting on
OSCFunc.trace(false); // Turn posting off

(( // OSC Receivers // ENABLE SENSOR AND SWITCH VALUES  <--

// ----------------------------------------------------
~overdubMode= 0; ~pitchMode = 0; ~posMode = 0; ~impulseMode = 1;
~gdurMode=0; ~gpanMode=0; ~channelmode=0;
~instrPanMode=0;

~btnstate = [];
~btnsA = [];
~btnsB = [];
~btnsC = [];

~btn0val = -1; ~btn1val = -1; ~btn2val = -1; ~btn3val = -1;
~btn4val = -1; ~btn5val = -1; ~btn6val = -1; ~btn7val = -1;
~btn8val = -1; // shift buttons

~btn9val = -1; ~btn10val = -1; ~btn11val = -1; ~btn12val = -1;
~btn13val = -1; ~btn14val = -1; ~btn15val = -1; ~btn16val = -1;


	( // accel gyro quaternion mapping ///////////////////
		// msg[1] msg[2] msg[3]  X Y Z ==> ROLL, PITCH, YAW

		o = OSCdef(\test, { arg msg, time, addr, recvPort, rlow, rhigh;


			~g.do({arg n; n.set(\rateRand, msg[2].linlin(0, 1, 1, 50); )}; );
			//~g.do({arg n; n.set(\rateRand, msg[2].linlin(0, 1, 1, 50).postln; )}; );
			//~g.do({arg n; n.set(\rate, 1; )}; );


			/*			// PAN ------- X Roll
			~g1.set(\pan, msg[1].linlin(-0.3,  0.3,  -1, 1));
			~g1.set(\gpanmodeindex, ~gpanMode );



			// PITCH ------- Y Pitch
			~g1.set(\sensorpitch,  msg[3]+1 * 2);
			~g1.set(\pitchmodeindex, ~pitchMode );

			// POSITION ------- Z Yaw
			~g1.set(\sensorposition, msg[1].linlin(-0.2, 0.6, 0.05, 3.99));
			~g1.set(\posModeindex, ~posMode );

			// RATE ------- X (roll [with PAN])

			~g1.set(\sensorimpulse, msg[2].linlin(-1, 1, 5, 50));
			~g1.set(\impulsemodeindex, ~impulseMode );

			~g1.set(\sensorgdur, msg[2].linlin(-1, 1, 0.1, 1));
			~g1.set(\gdurmodeindex, ~gdurMode );

			~g1.set(\sensordensity, msg[2].linlin(-1, 1, 0.1, 1));
			~g1.set(\densitymodeindex, ~gdurMode );

			~g1.set(\sensorgpan, msg[2]);
			~g1.set(\gpanmodeindex, ~gpanMode );

			//~g1.set(\sensorgpan, msg[2].linlin(-1, 1, -1, 1));
			//~g1.set(\signalChannelIndex, ~channelmode );

			~gtrIn.set(\sensorInstrPan, msg[2].wrap(0, 5).linlin(0, 5, -1, 1));
			~gtrIn.set(\instrPanModeIndex, ~instrPanMode);*/
			//
			//msg.postln;

		}; , '/euler');
	);


// ----------------------------------------------------
// send message back to nodejs
	m = NetAddr("127.0.0.1", 57100);
	// on off osconoff accelerometer data
	m.sendMsg("/xyzc", 1);
	m.sendMsg("/xyzc", 0);

// ----------------------------------------------------
// button press mapping ///////////////////////////////
// ----------------------------------------------------
	n = NetAddr("127.0.0.1", NetAddr.langPort);

	//~switchArray = [0, 0, 0, 0 ,0 ,0 ,0, 0, 0, 0, 0, 0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ,0 ];
	//~switchArray.put(15, 1); ~switchArray.put(11, 1); ~switchArray.put(10, 1);  ~switchArray.put(9, 1);

	//j = List.new;

	//j = ~switchArray.replace("[", "").replace("]", "");

	//n.sendMsg("/keys", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	//n.sendMsg("/keys",);

	//n.sendMsg("/keys", 1,2,3,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);


	p = OSCdef(\keys, { arg msg, time, addr, recvPort;
		//msg[1].postln;
		~btnsA[~btn2val, ~btn3val];
		~btnsB[~btn4val, ~btn5val, ~btn6val, ~btn7val];
		~btnsC[~btn5val];

		~btnstate = [~btnsA, ~btnsB, ~btnsC];

		/// PRESETS !!!!!!!!!!!!!!!!!!!!!!!

		if (msg[9] == 1 &&  msg[10] == 1,  {

			( ~btn0val = (~btn0val + 1) % 5 ) ;
			switch( ~btn0val,
				0, { "PONTALISTIFANTASTICO".postln;

					~g.do({arg n; n.set(\baseDur, 0.5 )});
					~g.do({arg n; n.set(\durRand, 1)});
					~g.do({arg n; n.set(\dens, 32)});
					~g.do({arg n; n.set(\rate, 1)});
					~g.do({arg n; n.set(\rateRand, 32)});
					~g.do({arg n; n.set(\sync, 1)});
					~g.do({arg n; n.set(\ptrRandSamples, 6400000, )});
				},

				1, { "DRONAUSAURUS".postln;
					~g.do({arg n; n.set([\baseDur, 1, \durRand, 2, \dens, 100, \rate, 1, \rateRand, 1, \sync, 0, \ptrRandSamples, 200000, ])}); },
				2, { "MINIMAL5THsISM".postln;
					~g.do({arg n; n.set([\baseDur, 0, \durRand, 6, \dens, 1, \rate, 1, \rateRand, 1.1, \sync, 1, \ptrRandSamples, 200000, ])}); },
				3, { "PONTALISTIFANTASTICO====".postln;
					~g.do({arg n; n.set([\baseDur, 0, \durRand, 6, \dens, 1, \rate, 1, \rateRand, 1.1, \sync, 1, \ptrRandSamples, 200000, ])}); },
				4, { "PONTALISTIFANTASTICO+++++++++".postln;
					~g.do({arg n; n.set([\baseDur, 0, \durRand, 6, \dens, 1, \rate, 1, \rateRand, 1.1, \sync, 1, \ptrRandSamples, 200000, ])}); },
					);

		});

		// ==============================
		// BUTTON MAPPING
		// ==============================

		// TRIGGER BUTTONS (3) ------------------------------

		// if SHIFT key is 0:
		if (msg[9] == 0, {

		// BUTTON X ----- TRIGGER ONESHOT BUFFER RECORD
			if (msg[10] == 1, {
				r.set( \in, 0, \l, 0, \t_trig, 1); "/////////// SAMPLING!".postln; { ~recTrigButton.value_(0) }.defer;

			}, {
				{~recTrigButton.value_(1) }.defer
			} );

			// BUTTON X ----> LOOP RECORDING MODE ON/OFF
			if (msg[11]==1,
				{
					( ~btn2val = (~btn2val + 1) % 3 ) ;
					switch( ~btn2val,
						0, { r.set(\l, 0); "RECORD LOOPING OFF".postln; { ~recModeGui.value_(0) }.defer;  },
						1, { r.set(\l, 1); "RECORD LOOPING ON".postln;  { ~recModeGui.value_(1) }.defer; },
						2, { r.set(\l, 0); "ONSET DETECTION ON".postln; { ~recModeGui.value_(2) }.defer; },
					);
			});

			// BUTTON X ----> OVERDUB RECORDING MODE ON/OFF
			if (msg[12]==1,
				{
					( ~btn3val = (~btn3val + 1) % 6 ) ;
					switch( ~btn3val,
						0, {  ~overdubMode = 0;  "SAMPLE OVERDUB OFF".postln;     },
						1, {  ~overdubMode = 1;  "SAMPLE OVERDUB ON 30%".postln;  },
						2, {  ~overdubMode = 2;  "SAMPLE OVERDUB ON 50%".postln;  },
						3, {  ~overdubMode = 3;  "SAMPLE OVERDUB ON 75%".postln;  },
						4, {  ~overdubMode = 4;  "SAMPLE OVERDUB ON 90%".postln;  },
						5, {  ~overdubMode = 5;  "SAMPLE OVERDUB ON 100%".postln; },
					)
			});

/////  GUI UPDATER CODE   /////////////////////////////////////////////////////////////////

			//// sampler gui

			case
			{~overdubMode == 0 }{{~overdubModeGui.value_(0) }.defer; r.set(\overdub, 0); }
			{~overdubMode == 1 }{{~overdubModeGui.value_(1) }.defer; r.set(\overdub, 0.3); }
			{~overdubMode == 2 }{{~overdubModeGui.value_(2) }.defer; r.set(\overdub, 0.5); }
			{~overdubMode == 3 }{{~overdubModeGui.value_(3) }.defer; r.set(\overdub, 0.75); }
			{~overdubMode == 4 }{{~overdubModeGui.value_(4) }.defer; r.set(\overdub, 0.9); }
			{~overdubMode == 5 }{{~overdubModeGui.value_(5) }.defer; r.set(\overdub, 1); }
			{~overdubMode == 6 }{{~overdubModeGui.value_(6) }.defer; r.set(\overdub, 0); }
			{~overdubMode == 7 }{{~overdubModeGui.value_(7) }.defer; r.set(\overdub, 0); };

			// ~recTrigButton
			// ~recModeGui

			// granular gui ////////////////////////////////////////////////////////////////

			case
			{~pitchMode == 0 }{{~pitchModeGui.value_(0) }.defer; ~g.do({arg n; n.set(\rateRand, 1, \rate, 1) }); }
			{~pitchMode == 1 }{{~pitchModeGui.value_(1) }.defer; ~g.do({arg n; n.set(\rate, 2, \rateRand, 1) }); }
			{~pitchMode == 2 }{{~pitchModeGui.value_(2) }.defer; ~g.do({arg n; n.set(\rate, 0.5, \rateRand, 1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 3 }{{~pitchModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\rate, 1, \rateRand, 1.1) }); }
			{~pitchMode == 4 }{{~pitchModeGui.value_(4) }.defer; ~g.do({arg n; n.set(\rate, 0.25, \rateRand, 5) }); }
			{~pitchMode == 5 }{{~pitchModeGui.value_(5) }.defer; ~g.do({arg n; n.set(\rate, 0.1, \rateRand, 100) }); }
			{~pitchMode == 6 }{{~pitchModeGui.value_(6) }.defer; ~g.do({arg n; n.set(\rate, 10, \rateRand, 1000) }); }
			{~pitchMode == 7 }{{~pitchModeGui.value_(7) }.defer; ~g.do({arg n; n.set(\rate, 1) }); };

			case
			{~gdurMode == 0 }{{~durModeGui.value_(0) }.defer; ~g.do({arg n; n.set(\baseDur, 1, \durRand, 1)}); }
			{~gdurMode == 1 }{{~durModeGui.value_(1) }.defer; ~g.do({arg n; n.set(\baseDur, 2, \durRand, 1)}); }
			{~gdurMode == 2 }{{~durModeGui.value_(2) }.defer; ~g.do({arg n; n.set(\baseDur, 4, \durRand, 1)});}
			{~gdurMode == 3 }{{~durModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\baseDur, 1/4, \durRand, 1)});}
			{~gdurMode == 4 }{{~durModeGui.value_(4) }.defer; ~g.do({arg n; n.set(\baseDur, 1/8, \durRand, 1)});}
			{~gdurMode == 5 }{{~durModeGui.value_(5) }.defer; ~g.do({arg n; n.set(\baseDur, 1/16, \durRand, 1)});}
			{~gdurMode == 6 }{{~durModeGui.value_(6) }.defer; ~g.do({arg n; n.set(\baseDur, 1/32, \durRand, 1)});}
			{~gdurMode == 7 }{{~durModeGui.value_(7) }.defer; ~g.do({arg n; n.set(\baseDur, 1/64, \durRand, 1)});};

			case
			{~posMode == 0 }{{~posModeGui.value_(0) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, b.numFrames, \minPtrDelay, 1000) }); }
			{~posMode == 1 }{{~posModeGui.value_(1) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, b.numFrames/4, \minPtrDelay, 1000 ) }); }
			{~posMode == 2 }{{~posModeGui.value_(2) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, b.numFrames/8,  \minPtrDelay, 1000 ) }); }
			{~posMode == 3 }{{~posModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, b.numFrames/16, \minPtrDelay, 1000 ) }); }
			{~posMode == 4 }{{~posModeGui.value_(4) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, b.numFrames/32) }); }
			{~posMode == 5 }{{~posModeGui.value_(5) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, b.numFrames/64) }); }
			{~posMode == 6 }{{~posModeGui.value_(6) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, 0.001, \minPtrDelay, 10 ) }); }
			{~posMode == 7 }{{~posModeGui.value_(7) }.defer; ~g.do({arg n; n.set(\ptrRandSamples, b.numFrames/200000, \minPtrDelay, 1000;) }); };

			case
			{~densMode == 0 }{{~densityModeGui.value_(0) }.defer; ~g.do({arg n; n.set(\dens, 1, \amp, 1)}); }
			{~densMode == 1 }{{~densityModeGui.value_(1) }.defer; ~g.do({arg n; n.set(\dens, 2, \amp, 1)}); }
			{~densMode == 2 }{{~densityModeGui.value_(2) }.defer; ~g.do({arg n; n.set(\dens, 3, \amp, 1)});}
			{~densMode == 3 }{{~densityModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\dens, 5, \amp, 1)});}
			{~densMode == 4 }{{~densityModeGui.value_(4) }.defer; ~g.do({arg n; n.set(\dens, 8, \amp, 0.9)});}
			{~densMode == 5 }{{~densityModeGui.value_(5) }.defer; ~g.do({arg n; n.set(\dens, 13, \amp, 0.85)});}
			{~densMode == 6 }{{~densityModeGui.value_(6) }.defer; ~g.do({arg n; n.set(\dens, 21, \amp, 0.8)});}
			{~densMode == 7 }{{~densityModeGui.value_(7) }.defer; ~g.do({arg n; n.set(\dens, 34, \amp, 0.75)}); }
			{~densMode == 8 }{{~densityModeGui.value_(8) }.defer; ~g.do({arg n; n.set(\dens, 55, \amp, 0.65)}); }
			{~densMode == 9 }{{~densityModeGui.value_(9) }.defer; ~g.do({arg n; n.set(\dens, 89, \amp, 0.5)}); }
			{~densMode == 10 }{{~densityModeGui.value_(10) }.defer; ~g.do({arg n; n.set(\dens, 144, \amp, 0.45)}); }
			{~densMode == 11 }{{~densityModeGui.value_(11) }.defer; ~g.do({arg n; n.set(\dens, 233, \amp, 0.4)}); }
			{~densMode == 12 }{{~densityModeGui.value_(12) }.defer; ~g.do({arg n; n.set(\dens, 377, \amp, 0.2)}); };

			case
			{~gpanMode == 0 }{{~gPanModeGui.value_(0) }.defer; ~g.do({arg n; n.set(\panRand, 0.25, \pan, 0)}); }
			{~gpanMode == 1 }{{~gPanModeGui.value_(1) }.defer; ~g.do({arg n; n.set(\panRand, 0.25, \pan, 0)}); }
			{~gpanMode == 2 }{{~gPanModeGui.value_(2) }.defer; ~g.do({arg n; n.set(\pan, 0,  \panRand, 1)}); }
			{~gpanMode == 3 }{{~gPanModeGui.value_(3) }.defer; ~g.do({arg n; n.set(\panRand, 0)}); }
			{~gpanMode == 4 }{{~gPanModeGui.value_(4) }.defer; ~g.do({arg n; n.set(\panRand, 0)}); }
			{~gpanMode == 5 }{{~gPanModeGui.value_(5) }.defer; ~g.do({arg n; n.set(\panRand, 0)}); }
			{~gpanMode == 6 }{{~gPanModeGui.value_(6) }.defer; ~g.do({arg n; n.set(\panRand, 0)}); }
			{~gpanMode == 7 }{{~gPanModeGui.value_(7) }.defer; ~g.do({arg n; n.set(\panRand, 0)}); };

			case
			{~impulseMode == 0 }{{~impulseModeGui.value_(0) }.defer; ~g.do({arg n; n.set(\sync, 1)}); }
			{~impulseMode == 1 }{{~impulseModeGui.value_(1) }.defer; ~g.do({arg n; n.set(\sync, 0)}); };

			////////////////// instrument mode gui ////////////////////////////

			case
			{~instrPanMode == 0 }{{~instrPanModeGui.value_(0) }.defer }
			{~instrPanMode == 1 }{{~instrPanModeGui.value_(1) }.defer }
			{~instrPanMode == 2 }{{~instrPanModeGui.value_(2) }.defer }
			{~instrPanMode == 3 }{{~instrPanModeGui.value_(3) }.defer }
			{~instrPanMode == 4 }{{~instrPanModeGui.value_(4) }.defer }
			{~instrPanMode == 5 }{{~instrPanModeGui.value_(5) }.defer }
			{~instrPanMode == 6 }{{~instrPanModeGui.value_(6) }.defer }
			{~instrPanMode == 7 }{{~instrPanModeGui.value_(7) }.defer };

			case
			{~fxMode == 0 }{{~fxModeGui.value_(0) }.defer;  ~gtrIn.set(\out, ~ringModBus); ~ringMod.set(\modulator, 0, \mulrate, 0);  }
			{~fxMode == 1 }{{~fxModeGui.value_(1) }.defer; ~gtrIn.set(\out, ~ringModBus); ~ringMod.set(\modulator, 77, \mulrate, 0.1); }
			{~fxMode == 2 }{{~fxModeGui.value_(2) }.defer; ~gtrIn.set(\out, ~ringModBus); ~ringMod.set(\modulator, 277, \mulrate, 10.1);}
			{~fxMode == 3 }{{~fxModeGui.value_(3) }.defer; ~gtrIn.set(\out, [~reverbBus, ~ringModBus]); ~ringMod.set(\modulator, 277, \mulrate, 10.1);}
			{~fxMode == 4 }{{~fxModeGui.value_(4) }.defer; ~gtrIn.set(\out, ~reverbBus);  }
			{~fxMode == 5 }{{~fxModeGui.value_(5) }.defer; ~gtrIn.set(\out, ~ringModBus); ~ringMod.set(\modulator, 0, \mulrate, 0);  }
			{~fxMode == 6 }{{~fxModeGui.value_(6) }.defer; ~gtrIn.set(\out, ~ringModBus);  ~ringMod.set(\modulator, 0, \mulrate, 0); }
			{~fxMode == 7 }{{~fxModeGui.value_(7) }.defer; ~gtrIn.set(\out, ~ringModBus);  ~ringMod.set(\modulator, 0, \mulrate, 0); };

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

			// BUTTON X ----> toggle fx
			if (msg[13]==1,
				{
					( ~btn4val = (~btn4val + 1) % 8 ) ;
					switch( ~btn4val,
						0, {  ~fxMode=0; "fx0".postln; },
						1, {  ~fxMode=1; "fx1".postln; },
						2, {  ~fxMode=2; "fx2".postln; },
						3, {  ~fxMode=3; "fx3".postln; },
						4, {  ~fxMode=4; "fx4".postln; },
						5, {  ~fxMode=5; "fx5".postln; },
						6, {  ~fxMode=6; "fx6".postln; },
						7, {  ~fxMode=7; "fx7".postln; },
					);
			});

			/////////////////// RESET RANDOM PITCH TO FIXED PITCH IN ONE TAP

			if (msg[14]==1,
				{
					( ~btn5val = (~btn5val + 1) % 2 ) ;
					switch( ~btn5val,
						0, { ~pitchMode = 0; "PITCH RESET TO UNTRANSPOSED MODE".postln; },
						1, { ~pitchMode = 1; "PITCH IN SENSOR MODE".postln; }
					);
			});

			// INCREASE IMPULSE RATE ---------------------------------------
			// todo - counter wrap around -- to ping pong count up and down
			// if counter is > then + otherwise minus counter
			if (msg[15]==1,
				{
					( ~btn6val = (~btn6val + 1) % 13 ) ;
					switch(~btn6val,
						0, {  ~densMode = 0;  "DENSITY MODE 0".postln; },
						1, {  ~densMode = 1;  "DENSITY MODE 1".postln; },
						2, {  ~densMode = 2;  "DENSITY MODE 2".postln; },
						3, {  ~densMode = 3;  "DENSITY MODE 3".postln; },
						4, {  ~densMode = 4;  "DENSITY MODE 4".postln; },
						5, {  ~densMode = 5;  "DENSITY MODE 5".postln; },
						6, {  ~densMode = 6;  "DENSITY MODE 6".postln; },
						7, {  ~densMode = 7;  "DENSITY MODE 7".postln; },
						8, {  ~densMode = 8;  "DENSITY MODE 8".postln; },
						9, {  ~densMode = 9;  "DENSITY MODE 9".postln; },
						10, {  ~densMode = 10;  "DENSITY MODE 10".postln; },
						11, {  ~densMode = 11;  "DENSITY MODE 11".postln; },
						12, {  ~densMode = 12;  "DENSITY MODE 12".postln; },


					)
			});

			// BUTTON X ----- G PANNING MODE
			// TODO FIX MAPPINGS - GUI AND REALITY DO NOT MATCH
			if (msg[16]==1,
				{
					( ~btn7val = (~btn7val + 1) % 9 ) ;
					switch( ~btn7val,
						0, { ~gpanMode = 0 ; "SIGNAL OFF".postln;  },
						1, { ~gpanMode = 1 ; "DRY FRONT {STERE0}".postln; },
						2, { ~gpanMode = 2 ; "DRY BACK {STERE0}".postln; },
						3, { ~gpanMode = 3 ; "L/R PAN {STEREO}".postln;  },
						4, { ~gpanMode = 4 ; "DRY RaND {STEREO}".postln; },
						5, { ~gpanMode = 5 ; "DRY ROTATE {QUAD}".postln; },
						6, { ~gpanMode = 6 ; "DRY RaND {QUAD}".postln;   },
						7, { ~gpanMode = 7 ; "DRY SENSOR {QUAD}".postln; },
						8, { ~gpanMode = 8 ; "PAN RANDOM QUAD".postln;   },
					)
			});


		}, /// SHIFT 0 LOGIC ENDS HERE --------------------------------------------

		{
			// SHIFT IN STATE 1 ======================= ..........................

			// GTR INPUT =======================
			if (msg[11]==1,
				{
					( ~btn10val = (~btn10val + 1) % 9 ) ;


					switch(~btn10val,

						0, { ~gtrIn.set(\instrAmp, 0 );  "DRY SIGNAL OFF".postln;  },
						1, { ~instrPanMode=0; ~gtrIn.set(\instrAmp, 1 );  "DRY FRONT {STERE0}".postln; },
						2, { ~instrPanMode=1;  "DRY BACK {STERE0}".postln;  },
						3, { ~instrPanMode=2;  "DRY RaND {STEREO}".postln; },
						4, { ~instrPanMode=3;  "L/R PAN {STEREO}".postln;  },
						5, { ~instrPanMode=4;  "DRY ROTATE {QUAD}".postln; },
						6, { ~instrPanMode=5;  "DRY RaND {QUAD}".postln; },
						7, { ~instrPanMode=6;  "DRY SENSOR {QUAD}".postln; },
						8, { ~instrPanMode=7;  "DRY SENSOR {QUAD}".postln; },

					)
			});


			// BUTTON X && X RESET/ZERO SENSORS [in firmware just here for notificaton]
			if (msg[12] == 1, { " ===== EULER ZEROED! =====".postln }, {});


			// BUTTON X ----- GRANULAR POSITION MODE
			if (msg[13]==1,
				{
					( ~btn12val = (~btn12val + 1) % 8 ) ;
					switch(~btn12val,
						0, { ~posMode = 0;  "~posMode 0 ".postln;    },
						1, { ~posMode = 1;   "~posMode 1 ".postln;    },
						2, {  ~posMode = 2;   "~posMode 2".postln;    },
						3, {  ~posMode = 3;  "~posMode 3".postln;    },
						4, {  ~posMode = 5; "~posMode 4".postln;    },
						5, {  ~posMode = 6;  "~posMode 5".postln;    },
						6, {  ~posMode = 7;  "~posMode 6 ".postln;    },
						7, {  ~posMode = 8;  "~posMode 7 ".postln;    },
					)
			});

			// BUTTON X ----- GRANULAR PITCH MODE
			if (msg[14]==1,
				{
					( ~btn13val = ((~btn13val + 1) % 8 ) ) ;
					switch(~btn13val,
						0, { ~pitchMode = 0;  "pitch mode 0".postln;  },
						1, { ~pitchMode = 1;  "pitch mode 1".postln;  },
						2, { ~pitchMode = 2;  "pitch mode 2".postln;  },
						3, { ~pitchMode = 3;  "pitch mode 3".postln;  },
						4, { ~pitchMode = 4;  "pitch mode 4".postln;  },
						5, { ~pitchMode = 5;  "pitch mode 5".postln;  },
						6, { ~pitchMode = 6;  "pitch mode 6".postln;  },
						7, { ~pitchMode = 7;  "pitch mode 7".postln;  },
					)
			});

			//~durBtn = 1;

			// BUTTON X ----- GRAIN DURATION MODE
			if (msg[15]==1,
				{
					( ~btn14val = (~btn14val + 1) % 8 ) ;
					switch(~btn14val,
						0, {  ~gdurMode = 0; "DURATION MODE 0".postln;    },
						1, {  ~gdurMode = 1; "DURATION MODE 1".postln;    },
						2, {  ~gdurMode = 2; "DURATION MODE 2".postln;    },
						3, {  ~gdurMode = 3;  "DURATION MODE 3".postln;   },
						4, {  ~gdurMode = 4;  "DURATION MODE 4".postln;   },
						5, {  ~gdurMode = 5;  "DURATION MODE 5".postln;   },
						6, {  ~gdurMode = 6;  "DURATION MODE 6".postln;   },
						7, {  ~gdurMode = 7;  "DURATION MODE: SENSOR".postln; },
					)
			});

			// BUTTON X ----- GRANULAR IMPULSE MODE
			if (msg[16]==1,
				{
					( ~btn15val = (~btn15val + 1) % 2 ) ;
					switch( ~btn15val,
						0, { ~impulseMode = 0; ~g1.set(\impulsemodeindex, 0 ); "IMPULSE MODE FIXED".postln;  },
						1, { ~impulseMode = 1; ~g1.set(\impulsemodeindex, 1 ); "IMPULSE MODE DUST".postln;   },
					)
			});

		}); // SHIFT ONE LOGIC ENDS HERE ================

	} , '/keys');
//	} , '/localhostInLevels');

));




~gdurMode = 2;


// ----------------------------------------------------
// LIVE CODE / PERFORMABLE PARAMETERS /////////////////
// ----------------------------------------------------
// set recorder loop and overdub modes ////////////
// start recording (without button)
r.set(\in, 0, \l, 0, \overdub, 0,  \t_trig, 1);
r.set(\l, 0); // looping record on/off 0/1  -  MAPPED TO SWITCH 3
r.set(\overdub, 0.9); // overdub mode 0 - 0.99 - MAPPED TO SWITCH 4

~ptrGrp.set(\rate, 0.2);

~g.set(\gate, 0);
~g.do({arg n; n.set(\gate, 1 )});
~g.do({arg n; n.set(\rate, 2 )});

\amp, n.linlin(0,4, -3,-20).dbamp,

~g.do({arg n; n.set(\amp, 1, \rateRand, 1000 )});
~g.do({arg n; n.set(\amp, 1, \rateRand, 1 )});
~g.do({arg n; n.set(\amp, 0,  \dens, 1 )});
~g.do({arg n; n.set(\rateRand, 0)});
~g.do({arg n; n.set(\panRand, 1)});
~g.do({arg n; n.set(\sync, 1 )});
~g.do({arg n; n.set(\atk, exprand(0.1, 1) )});
~g.do({arg n; n.set(\rel, 1 )});
~g.do({arg n; n.set(\dens, exprand(1,80) )});
~g.do({arg n; n.set(\dens,1)});


~g.do({arg n; n.set(\panRand, 1 )});

\ptrSampleDelay, n.linlin(0,4, 20000, s.sampleRate*2),

~g.do({arg n; n.set(\ptrSampleDelay, s.sampleRate * 1) });
~g.do({arg n; n.set(\ptrRandSamples, 20000 )});
~g.do({arg n; n.set(\minPtrDelay, 2000000 )});

~g.do({arg n; n.set([\baseDur, 10])});
~g.do({arg n; n.set([\durRand, 1000])});


~g.do({arg n; n.set([\baseDur, 0, \durRand, 6, \dens, 1, \rate, 1, \rateRand, 1.1, \sync, 1, \ptrRandSamples, 200000, ])});


~g.do({arg n; n.set(\baseDur, 0.008, \durRand, 10.1)});
~g.do({arg n; n.set([\baseDur, 1.08, \durRand, 3, \sync, 0, \dens, 25 ])});


~rec.set(\overdubLevel, 0.1);

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

thisProcess.platform.recordingsDir;// find where the recordings are written to
s.record(numChannels:4); // record



// CODE DUMP ZONE ///////////////////////////////

// switch to the custom env
//~g1.set(\envbuf, z);
//~g1.set(\envbuf, -1);
n = NetAddr("127.0.0.1", NetAddr.langPort);
//n = NetAddr.new("224.0.1.9", 6696);