Sway for monome norns

Engine_Sway.sc

Engine_Sway : CroneEngine {

	*new { arg context, doneCallback;
		^super.new(context, doneCallback);
	}

	alloc {
		NornsSway(\sway);
		NornsSway(\sway).input.set(\chan, context.in_b[0].index);
		NornsSway(\sway).analysis_input.set(\chan, context.in_b[0].index);
		NornsSway(\sway).output.play(context.out_b.index, 2, context.xg, addAction: \addToHead);
		NornsSway(\sway).verbose = false;
		
		this.addCommand("amp_thresh", "f", {|msg|
			NornsSway(\sway).amp_thresh = msg[1];
		});
		
		this.addCommand("clarity_thresh", "f", {|msg|
			NornsSway(\sway).clarity_thresh = msg[1];
		});
		
		this.addCommand("density_thresh", "f", {|msg|
			NornsSway(\sway).density_thresh = msg[1];
		});

		this.addCommand("verbose", "i", {|msg|
			if(msg[1] == 1, {
			NornsSway(\sway).verbose = true;
			}, {
			NornsSway(\sway).verbose = false;
			});
		});
		
		this.addCommand("polarity", "i", {|msg|
			if(msg[1] == 1, {
			NornsSway(\sway).polarity = false;
			NornsSway(\sway).change_polarity;
			}, {
			NornsSway(\sway).polarity = true;
			NornsSway(\sway).change_polarity;
			});
		});

		this.addCommand("fadetime", "i", {|msg|
			NornsSway(\sway).fade_time(msg[1]);
		});

		this.addCommand("timelimit", "i", {|msg|
			NornsSway(\sway).timelimit = msg[1];
		});
		
		this.addCommand("map_quadrant", "ii", {|msg|
			NornsSway(\sway).map_quadrant(msg[1], msg[2]);
		});

		this.addCommand("analysis_on", "i", {|msg|
			if(msg[1] == 1, {
			NornsSway(\sway).analysis_on = true;
			}, {
			NornsSway(\sway).analysis_on = false;
			});
		});
		
		this.addCommand("tracker_on", "i", {|msg|
			if(msg[1] == 1, {
			NornsSway(\sway).tracker_on = true;
			}, {
			NornsSway(\sway).tracker_on = false;
			});
		});
		
		this.addCommand("silence", "i", {|msg|
			NornsSway(\sway).silence;
		});
		
		this.addCommand("reverb", "i", {|msg|
			NornsSway(\sway).reverb;
		});

		this.addCommand("ampmod", "i", {|msg|
			NornsSway(\sway).ampmod;
		});

		this.addCommand("delay", "i", {|msg|
			NornsSway(\sway).delay;
		});

		this.addCommand("filter", "i", {|msg|
			NornsSway(\sway).filter;
		});

		this.addCommand("freeze", "i", {|msg|
			NornsSway(\sway).freeze;
		});

		this.addCommand("pitchbend", "i", {|msg|
			NornsSway(\sway).pitchbend;
		});

		this.addCommand("cascade", "i", {|msg|
			NornsSway(\sway).cascade;
		});
		
		this.addPoll("x_coord", {NornsSway(\sway).xy[0]});
		this.addPoll("y_coord", {NornsSway(\sway).xy[1]});

		this.addPoll("avg_amp", {var amp1, amp30; #amp1, amp30 = NornsSway(\sway).amplitude.bus.getnSynchronous(2); amp30;});

		this.addPoll("avg_onsets", {var onsets1, onsets30; #onsets1, onsets30 = NornsSway(\sway).onsets.bus.getnSynchronous(2);onsets30;});

		this.addPoll("avg_clarity", {var clarity1, clarity30; #clarity1, clarity30 = NornsSway(\sway).clarity.bus.getnSynchronous(2);clarity30;});

		this.addPoll("current_processing", {NornsSway(\sway).quadrant_names[(NornsSway(\sway).quadrant[0])]});
		
		this.addPoll("current_quadrant", {NornsSway(\sway).quadrant[0]});
		
		this.addPoll("quadrant0", {NornsSway(\sway).quadrant_names[0]});
		this.addPoll("quadrant1", {NornsSway(\sway).quadrant_names[1]});
		this.addPoll("quadrant2", {NornsSway(\sway).quadrant_names[2]});
		this.addPoll("quadrant3", {NornsSway(\sway).quadrant_names[3]});
		this.addPoll("quadrant4", {NornsSway(\sway).quadrant_names[4]});

	}

	free {
		NornsSway(\sway).end;
	}
}

NornsSway.sc

NornsSway : Singleton {
	//Carl Testa 2018
	//Special Thanks to Brian Heim, Joshua Parmenter, Chris McDonald, Scott Carver
	classvar <>short_win=1, <>long_win=30, <>refresh_rate=1.0, <>gravity=0.01, <>step=0.05;

	var <>xy, <>quadrant, <>quadrant_names, <>quadrant_map, <>input, <>output, <>analysis_input, <>buffer, <>fftbuffer, <>delaybuffer, <>recorder, <>processing, <>fade=30, <>onsets, <>amplitude, <>clarity, <>flatness, <>amfreq, <>rvmix, <>rvsize, <>rvdamp, <>delaytime, <>delayfeedback, <>delaylatch, <>pbtime, <>pbbend, <>graintrig, <>grainfreq, <>grainpos, <>grainsize, <>granpos, <>granenvspeed, <>granrate, <>filtfreq, <>filtrq, <>freezefreq, <>freezefade, <>panpos, <>pansign, <>analysis_loop, <>above_amp_thresh=false, <>above_clarity_thresh=false, <>above_density_thresh=false, <>amp_thresh=4, <>clarity_thresh=0.6, <>density_thresh=1.5, <>tracker, <>count=0, <>analysis_on=true, <>tracker_on=true, <>audio_processing=true, <>verbose=false, <>polarity=false, <>quadrant_flag=false, <>timelimit=200, <>available_processing, <>all_processing, <>global_change=false;

    init {
		//Setup initial parameters
		this.reset;

		//audio input with chan argument
		input = NodeProxy.audio(Server.default, 1).fadeTime_(fade)
		.source = { |chan=0| In.ar(chan) };

		//fft
		fftbuffer = Buffer.alloc(Server.default, 1024);

		//delaybuffer
		delaybuffer = Buffer.alloc(Server.default, 10*48000, 1);

		//audio recorder
		buffer = Buffer.alloc(Server.default, long_win*48000, 1);
		recorder = NodeProxy.audio(Server.default, 1)
		.source = {
			var off = Lag2.kr(A2K.kr(DetectSilence.ar(input.ar(1), 0.1), 0.3));
            var on = 1-off;
			var fade = MulAdd.new(on, 2, 1.neg);
			var out = XFade2.ar(Silent.ar(), input.ar(1), fade);
			RecordBuf.ar(out, buffer, loop: 1, run: on);
		};

		//this is the placeholder for audio procesing
		processing = NodeProxy.audio(Server.default, 1).fadeTime_(fade)
		.source = { Silent.ar(1) };

		//analysis input so there is option to decouple processed audio from analysed audio
		analysis_input = NodeProxy.audio(Server.default, 1)
		.source = { |chan=0| In.ar(chan) };

		//Build the analysis modules
		this.build_analysis;
		//Begin with an initial nonpolarity mapping of parameters
		this.nonpolarity_map;

		//audio output to listen and change channel
		output = NodeProxy.audio(Server.default, 2)
		.source = { Pan2.ar(processing.ar(1), panpos.kr(1)*pansign.kr(1)); };

		//Longer term analysis controlling placement on processing grid
		analysis_loop = TaskProxy.new({ loop {
			//if analysis on flag is set to true then do analysis
			if(analysis_on==true, {
			//if verbose is on report values
			if(verbose==true,{
			flatness.bus.get({|val|
				(this.name++" flatness: "++val[1]).postln;
					});
			onsets.bus.get({|val|
				(this.name++" onsets: "++val[1]).postln;
					});
			clarity.bus.get({|val|
				(this.name++" clarity: "++val[1]).postln;
					});
				});
			//if signal is above amplitude threshold do analysis
			amplitude.bus.get({|val|
				if(verbose==true,{(this.name++" amp: "++val[1]).postln});
				if( val[1] > amp_thresh, {
					above_amp_thresh=true;
					if(verbose==true,{(this.name++" amp threshold reached").postln});
					clarity.bus.get({|val|
						if( val[1] > clarity_thresh,
							{above_clarity_thresh=true;
							xy[0]=(xy[0]+step).clip(0,1)},
							{above_clarity_thresh=false;
							xy[0]=(xy[0]-step).clip(0,1)});
					});
					onsets.bus.get({|val|
						if( val[1] > density_thresh,
							{above_density_thresh=true;
							xy[1]=(xy[1]+step).clip(0,1)},
							{above_density_thresh=false;
							xy[1]=(xy[1]-step).clip(0,1)});
					});
				}, {
			//else if below threshold drift to center
					above_amp_thresh=false;
					if(verbose==true,{(this.name++" drift to center").postln});
					if(xy[0] > 0.5, {
						(xy[0]=xy[0]-gravity).clip(0,0.5)},{
						(xy[0]=xy[0]+gravity).clip(0,0.5)});
					if(xy[1] > 0.5, {
						(xy[1]=xy[1]-gravity).clip(0,0.5)},{
						(xy[1]=xy[1]+gravity).clip(0,0.5)});
				});
			});
		this.assign_quadrant(xy[0], xy[1]);
		//Checks to see if quadrant has changed, if so, it changes type of processing
		if (quadrant[0] == quadrant[1], {
					},{this.change_processing});
		if (quadrant_flag==true, {
				this.change_processing;
				quadrant_flag=false;
				},{});
		//Tracker processing grid changer is implemented here
			if (tracker_on==true, {
				if( tracker.any({|i,n|i>timelimit}), {//if any item in tracker is above timelimit
					//then choose new processing for that quadrant
					this.choose_new_processing(tracker.detectIndex({|i|i>timelimit}));
					(this.name++": processing grid changing").postln;
					if(verbose==false,{global_change=true;(this.name++": global change enabled").postln});
					quadrant_flag=true;
					tracker[tracker.detectIndex({|i|i>timelimit})]=0;
					//Change polarity for the hell of it
					this.change_polarity;
				},{});
				});
			});
		refresh_rate.wait;
		count=count+1;
		}}).play;
	}

	build_analysis {
		onsets = NodeProxy.control(Server.default, 2)
		.source = {
			//Density Tracker
			var buf = LocalBuf.new(512,1);
			var onsets = Onsets.kr(FFT(buf, analysis_input.ar(1)));
			var shortStats = OnsetStatistics.kr(onsets, short_win);
			var longStats = OnsetStatistics.kr(onsets, long_win);
			var shortValue = (shortStats[0]/short_win);
			var longValue = (longStats[0]/long_win);
			[shortValue, longValue];
		};

		amplitude = NodeProxy.control(Server.default, 2)
		.source = {
			//Amplitude Tracker
			var chain = FFT(LocalBuf(1024), analysis_input.ar(1));
            var loudness = Loudness.kr(chain);
			var shortAverage = AverageOutput.kr(loudness, Impulse.kr(short_win.reciprocal));
			var longAverage = AverageOutput.kr(loudness, Impulse.kr(long_win.reciprocal));
			[shortAverage, longAverage];
		};

		clarity = NodeProxy.control(Server.default, 2)
		.source = {
			var freq, hasFreq, shortAverage, longAverage;
			//Pitch hasfreq Tracker
			# freq, hasFreq = Pitch.kr(analysis_input.ar(1));
            shortAverage = AverageOutput.kr(hasFreq,Impulse.kr(short_win.reciprocal));
			longAverage = AverageOutput.kr(hasFreq,Impulse.kr(long_win.reciprocal));
			[shortAverage, longAverage];
		};

		flatness = NodeProxy.control(Server.default, 2)
		.source = {
			//Spectral Flatness Tracker
			var chain = FFT(LocalBuf(1024), analysis_input.ar(1));
            var flat = SpecFlatness.kr(chain);
			var shortAverage = AverageOutput.kr(flat, Impulse.kr(short_win.reciprocal));
			var longAverage = AverageOutput.kr(flat, Impulse.kr(long_win.reciprocal));
			[shortAverage, longAverage];
		};

		//Parameter Controls
		//amplitude modulation
		amfreq = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		//reverb
		rvmix = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		rvsize = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		rvdamp = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		//delay
		delaytime = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		delayfeedback = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		delaylatch = TaskProxy.new().play;
		//pitch bend
		pbbend = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		pbtime = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		//filter
		filtfreq = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		filtrq = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		//freeze
		freezefreq = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		freezefade = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		//output pan
		panpos = NodeProxy.control(Server.default, 1).fadeTime_(fade);
		pansign = NodeProxy.control(Server.default, 1).fadeTime_(fade);

	}

	nonpolarity_map {
		//TO DO: Modulate the mapping somehow with additional analysis
		//Mapping analysis data to parameter controls
		//amplitude modulation
		amfreq.source = { amplitude.kr(1,0).linlin(0,30,1,14)};
		//reverb
		rvmix.source = { onsets.kr(1,0).linlin(0,6,0.3,1) };
		rvsize.source = { amplitude.kr(1,0).linlin(0,30,0.3,1) };
		rvdamp.source = { clarity.kr(1,0).linlin(0,1,1,0) };
		//delay
		delaytime.source = { onsets.kr(1,0).linexp(0,7,0.5,9) };
		delayfeedback.source = { onsets.kr(1,0).linlin(0,10,0.5,0.05)};
		delaylatch.source = { loop {
			5.0.wait;
			if(0.5.coin, { processing.set(\trigger, 1, \toggle, 1) });
		} };
		//pitch bend
		pbtime.source = { onsets.kr(1,0).linlin(0,6,0.1,1) };
		pbbend.source = { amplitude.kr(1,0).linlin(0,10,0.75,1.5) };
		//filter
		filtfreq.source = { onsets.kr(1,0).linlin(0,6,500,5000) };
		filtrq.source = { amplitude.kr(1,0).linlin(0,10,0.3,0.8) };
		//freeze
		freezefreq.source = { onsets.kr(1,0).linlin(0,6,0.5,6) };
		freezefade.source = { onsets.kr(1,0).linlin(0,6,3,0.3) };
		//pan position
		panpos.source = { amplitude.kr(1,0).linlin(0,10,0,1) };
		pansign.source = { onsets.kr(1,0).linlin(0,6,(-1),1) };


	}

	polarity_map {
		//Mapping analysis data to parameter controls
		//amplitude modulation
		amfreq.source = { amplitude.kr(1,0).linlin(0,30,14,1)};
		//reverb

		rvmix.source = { onsets.kr(1,0).linlin(0,6,0.8,0.5) };
		rvsize.source = { amplitude.kr(1,0).linlin(0,30,0.9,0.7) };
		rvdamp.source = { clarity.kr(1,0).linlin(0,1,0.2,1) };

		//delay
		delaytime.source = { onsets.kr(1,0).linexp(0,7,9,0.5) };
		delayfeedback.source = { onsets.kr(1,0).linlin(0,10,0.05,0.5)};
		delaylatch.source = { loop {
			0.5.wait;
			if(0.5.coin, { processing.set(\trigger, 1, \toggle, 1) });
		} };
		//pitch bend
		pbtime.source = { onsets.kr(1,0).linlin(0,6,1,1.1) };
		pbbend.source = { amplitude.kr(1,0).linlin(0,10,1.5,0.75) };
		//filter
		filtfreq.source = { onsets.kr(1,0).linlin(0,6,5000,500) };
		filtrq.source = { amplitude.kr(1,0).linlin(0,10,0.9,0.3) };
		//freeze
		freezefreq.source = { onsets.kr(1,0).linlin(0,6,6,0.5) };
		freezefade.source = { onsets.kr(1,0).linlin(0,6,0.3,3) };
		//pan position
		panpos.source = { amplitude.kr(1,0).linlin(0,10,1,0) };
		pansign.source = { onsets.kr(1,0).linlin(0,6,1,(-1)) };
	}

	//TO DO: Here is where the different types of processing are defined. I'm wondering if I should separate these out into sub-classes. Would that make it easier to extend it and add processing?
	//Change processing to amplitude modulation
	ampmod {
		//control mapping:
		//amplitude -> freq
		processing.source = {
			var off = Lag2.kr(A2K.kr(DetectSilence.ar(input.ar(1),0.05),0.3));
            var on = 1-off;
			var fade = MulAdd.new(on, 2, 1.neg);
			var out = XFade2.ar(Silent.ar(), input.ar(1), fade);
			var sine = LFTri.ar(amfreq.kr(1), 0).unipolar;
		 	var am = out*sine;
			am;
		 };
		(this.name++": Amplitude Modulation").postln;
	}

	//Change processing to reverb
	reverb {
		//control mapping:
		//onsets -> mix
		//amplitude -> roomsize
		processing.source = { FreeVerb.ar(in: input.ar(1), mix: rvmix.kr(1), room: rvsize.kr(1), damp: rvdamp.kr(1)) };
		(this.name++": Reverb").postln;
		}

	//Change processing to freeze
	freeze {
		//control mapping:
		//onsets -> freezefreq
		//amplitude ->
		processing.source = {
			//First use gate on input
			var off = Lag2.kr(A2K.kr(DetectSilence.ar(input.ar(1),0.05),0.3));
            var on = 1-off;
			var fade = MulAdd.new(on, 2, 1.neg);
			var out = XFade2.ar(Silent.ar(), input.ar(1), fade);
			//then begin freeze
			var freeze;
			var amplitude = Amplitude.kr(out);
			var trig = amplitude > 0.2;
			var gate = Gate.kr(LFClipNoise.kr(freezefreq.kr(1)),trig);
			var chain = FFT(fftbuffer, out);
			chain = PV_Freeze(chain, gate);
			freeze = XFade2.ar(Silent.ar(), IFFT(chain), Lag2.kr(gate,freezefade.kr(1)));
			freeze = FreeVerb.ar(freeze, rvmix.kr(1), rvsize.kr(1));
			freeze = HPF.ar(freeze, 20);
			freeze;
		};
		(this.name++": Freeze").postln;
	}

	//Change processing to delay
	delay {
		//control mapping:
		//onsets -> delaytime
		//onsets -> feedback
		processing.source = {
			var time = Latch.kr(delaytime.kr(1), \trigger.tr);
			var feedback = delayfeedback.kr(1);
			var local = LocalIn.ar(1) + input.ar(1);
			var select = ToggleFF.kr(\toggle.tr(1.neg));
			var delay1 = BufDelayL.ar(delaybuffer, local, Latch.kr(time, 1- select));
			var delay2 = BufDelayL.ar(delaybuffer, local, Latch.kr(time, select));
			var fade = MulAdd.new(Lag2.kr(select, 4), 2, 1.neg);
			var delay = XFade2.ar(delay1, delay2, fade);
			LocalOut.ar(delay * feedback);
			delay;
		};
		(this.name++": Delay").postln;
	}
	//Change processing to pitch bend
	pitchbend {
		//control mapping:
		//onsets -> time
		//amplitude -> bend
		processing.source = {
			PitchShift.ar(input.ar(1), 1, pbbend.kr(1), 0.2, pbtime.kr(1))
		};
		(this.name++": Pitch Bend").postln;
	}

	filter {
		//control mapping:
		//onsets -> filtfreq
		//amplitude -> filtrq
		processing.source = {
			RLPF.ar(input.ar(1), filtfreq.kr(1), filtrq.kr(1)).tanh;
		};
		(this.name++": Filter").postln;
	}

	//change processing to cascading playback
	cascade {
		processing.source = {
			//TO DO: analysis control not implemented
			//pitch ->
			//amp -> number of layers??
			//onsets -> how far back in file does it read? Output current frame maybe?
			var sound = PlayBuf.ar(1, buffer.bufnum, 1, 0, {buffer.numFrames.rand}!16, 1);
			var env = SinOsc.kr(1/16, (0..15).linlin(0,15,8pi.neg,8pi), 0.375);
			var mix = Limiter.ar(Mix.new(sound*env), 1);
			mix;
		};
		(this.name++": Cascade").postln;
	}
	//Silence processing
	silence {
		processing.source = { Silent.ar(1) };
		(this.name++": Silence").postln;
	}

	//execute change in processing type
	change_processing {
		(quadrant_map[quadrant[0]]).value;
	}

	//assign which quadrant source is in based on x/y coordinates
	assign_quadrant { |x, y|
		quadrant = quadrant.shift(1);
		case
		    {(x<0.45) && (y<0.45)} {quadrant.put(0,3);tracker[3]=tracker[3]+1}//quadrant 3
		    {(x>0.55) && (y<0.45)} {quadrant.put(0,4);tracker[4]=tracker[4]+1}//quadrant 4
		    {(x<0.45) && (y>0.55)} {quadrant.put(0,2);tracker[2]=tracker[2]+1}//quadrant 2
		    {(x>0.55) && (y>0.55)} {quadrant.put(0,1);tracker[1]=tracker[1]+1}//quadrant 1
		{(x<0.55) && (x>0.45) && (y<0.55) && (y>0.45)} {quadrant.put(0,0);tracker[0]=tracker[0]+1};//quadrant 0
		//quadrant.postln;
	}

	//map different types of processing to the quadrants using the quadrant names
	map_quadrants {|names|
		names.do({|item,i|
			quadrant_map.put(i,all_processing.at(item));
			available_processing.removeAt(item);
			quadrant_names.put(i,item);
		});
	}

	//map single quadrant
	map_quadrant {|num, name|
		quadrant_map.put(num,all_processing.at(name));
		quadrant_names.put(num,name);
    }

	//change polarity
	change_polarity {
		if(polarity==false, {
			this.polarity_map;polarity=true;
			(this.name++": polarity mapping set").postln;
			},{
			this.nonpolarity_map;polarity=false;
			(this.name++": non-polarity mapping set").postln;
		});
	}

	//fade change
	fade_time { |time|
		//sound
		processing.fadeTime = time;
		//am
		amfreq.fadeTime = time;
		//reverb
		rvmix.fadeTime = time;
		rvsize.fadeTime = time;
		rvdamp.fadeTime = time;
		//delay
		delaytime.fadeTime = time;
		delayfeedback.fadeTime = time;
		//pitch bend
		pbbend.fadeTime = time;
		pbtime.fadeTime = time;
		//filter
		filtfreq.fadeTime = time;
		filtrq.fadeTime = time;
		//freeze
		freezefreq.fadeTime = time;
		freezefade.fadeTime = time;
		//output pan
		panpos.fadeTime = time;
		pansign.fadeTime = time;
	}

	choose_new_processing {|qrant|
		//choose_new_processing function receives a quadrant as an argument and assigns an available processing to that quadrant
		var old, new;
		//don't remap the center, keep it silent
		if(qrant!=0, {
		//get current processing type which is now "old"
		old = quadrant_names[qrant];
		//change processing to one that is available and capture its symbol
		new = available_processing.keys.choose;
		quadrant_map.put(qrant, available_processing.at(new));
		//update quadrant_names
		quadrant_names.put(qrant, new);
		//remove new processing from available
		available_processing.removeAt(new);
		//place old processing in available
		available_processing.put(old, all_processing.at(old));
		},{});
	}

	reset {
		//reset to initial parameters
		//intial placement on processing grid
		xy = [0.5,0.5];//random start
		tracker = [0,0,0,0,0];//number of times in each quadrant area
		//TO DO: the number of data structures I have to keep track of the quadrants and the names of the processing and all the available processing etc feels very clunky. There must be a better way to manage all this information.
		quadrant = Array.newClear(2);
		quadrant_map = Array.newClear(5);
		//change the initial mapping setup here:
		quadrant_names = Array.newClear(5);
		quadrant_names.put(0,1);
		quadrant_names.put(1,2);
		quadrant_names.put(2,8);
		quadrant_names.put(3,3);
		quadrant_names.put(4,4);
		all_processing = Dictionary.new;
		all_processing.put(1, {this.silence});
		all_processing.put(2, {this.delay});
		all_processing.put(3, {this.reverb});
		all_processing.put(4, {this.ampmod});
		all_processing.put(5, {this.pitchbend});
		all_processing.put(6, {this.cascade});
		all_processing.put(7, {this.filter});
		all_processing.put(8, {this.freeze});
		//make all processing currently available
		available_processing = Dictionary.new;
		available_processing.put(1, {this.silence});
		available_processing.put(2, {this.delay});
		available_processing.put(3, {this.reverb});
		available_processing.put(4, {this.ampmod});
		available_processing.put(5, {this.pitchbend});
		available_processing.put(6, {this.cascade});
		available_processing.put(7, {this.filter});
		available_processing.put(8, {this.freeze});
		this.assign_quadrant(xy[0], xy[1]);
		this.map_quadrants(quadrant_names);
		polarity=false;
		global_change=false;
		//quadrant_flag=true;
	}

	end {
		output.free(1);
		input.free(1);
		analysis_input.free(1);
		buffer.free;
		fftbuffer.free;
		delaybuffer.free;
		recorder.free(1);
		processing.free(1);
		onsets.free(1);
		amplitude.free(1);
		clarity.free(1);
		flatness.free(1);
		amfreq.free(1);
		rvmix.free(1);
		rvsize.free(1);
		rvdamp.free(1);
		delaytime.free(1);
		delayfeedback.free(1);
		delaylatch.stop;
		pbtime.free(1);
		pbbend.free(1);
		graintrig.free(1);
		grainfreq.free(1);
		grainpos.free(1);
		grainsize.free(1);
		granrate.free(1);
		granpos.free(1);
		granenvspeed.free(1);
		filtfreq.free(1);
		filtrq.free(1);
		freezefreq.free(1);
		freezefade.free(1);
		panpos.free(1);
		pansign.free(1);
		analysis_loop.stop;
		this.clear;
		//Server.freeAll;
	}

}

Singleton.sc

//Singleton from Singleton SuperCollider Quark by Scott Carver

Singleton {
	classvar all, <>know=false, creatingNew=false;
	var <>name;

	*initClass {
		all = IdentityDictionary();
	}

	*default {
		^\default
	}

	*all {
		^all[this] ?? IdentityDictionary()
	}

	*new {
		arg name ...settings;
		var sing, classAll, created=false;
		name = name ?? this.default;

		classAll = all.atFail(this, {
			all[this] = IdentityDictionary();
			all[this];
		});

		sing = classAll.atFail(name, {
			var newSingleton = this.createNew();
			created = true;
			newSingleton.name = name;
			classAll[name] = newSingleton;
			newSingleton.init(name);
			newSingleton;
		});

		if ((settings.notNil && settings.notEmpty) || created) {
			sing.set(*settings)
		};
		if (created) { { this.changed(\added, sing) }.defer(0) };
		^sing;
	}

	*createNew {
		arg ...args;
		^super.new(*args);
	}

	*doesNotUnderstand { arg selector ... args;
		var item;

		if (know && creatingNew.not) {
			creatingNew = true;		// avoid reentrancy
			protect {
				if (selector.isSetter) {
					selector = selector.asString;
					selector = selector[0..(selector.size - 2)].asSymbol;
					item = this.new(selector, *args);
				} {
					item = this.new(selector);
				}
			} {
				creatingNew = false;
			};

			^item;
		} {
			^this.superPerformList(\doesNotUnderstand, selector, args);
		}
	}

	init {}

	set {
		// Override this to receive 'settings' parameter from Singleton.new(name, settings)
	}

	*clear {
		|sing|
		var dict = all[this];
		if (dict.notNil) {
			var key = dict.findKeyForValue(sing);
			if (key.notNil) {
				dict[key] = nil;
				this.changed(\removed, sing);
			}
		}
	}

	clear {
		this.class.clear(this);
	}
}

sway.lua

-- Sway - live processing 
--  environment
-- 
-- Concept and Code by 
--   Carl Testa (2018)
--
-- analysis-driven live 
-- processing, play into 
-- input 1 (L), processing
-- will gradually change
--
-- key 2 toggles processing map
-- and analysis values view
-- 
-- greater control available
-- within parameter menu
--
-- more info @
-- http://sway.carltesta.net

local amp = 0
local density = 0
local clarity = 0
local x_coord = 0.5
local y_coord = 0.5
local processingtext =""
local screen_number = 0
local quadrants = {1,2,8,3,4}
local q0,q1,q2,q3,q4

engine.name = 'Sway'

function init()
   print("Sway")
   a = poll.set("avg_amp")
   a.callback = function(val) amp = val end
   a:start()
   
   o = poll.set("avg_onsets")
   o.callback = function(val) density = string.format("%.2f",val*10) end
   o:start()
   
   c = poll.set("avg_clarity")
   c.callback = function(val) clarity = string.format("%.2f",val*100) end
   c:start()
   
   x = poll.set("x_coord")
   x.callback = function(val) x_coord = string.format("%.2f",val) end
   x:start()
   
   y = poll.set("y_coord")
   y.callback = function(val) y_coord = string.format("%.2f",val) end
   y:start()
   
   z = poll.set("current_processing")
   z.callback = function(val) processingtext = decode(val) end
   z:start()
   
   q0 = poll.set("quadrant0")
   q0.callback = function(val) quadrants[1] = val end
   q0:start()
   
   q1 = poll.set("quadrant1")
   q1.callback = function(val) quadrants[2] = val end
   q1:start()
   
   q2 = poll.set("quadrant2")
   q2.callback = function(val) quadrants[3] = val end
   q2:start()
   
   q3 = poll.set("quadrant3")
   q3.callback = function(val) quadrants[4] = val end
   q3:start()
   
   q4 = poll.set("quadrant4")
   q4.callback = function(val) quadrants[5] = val end
   q4:start()
   
  t = metro.alloc()
  t.count = 0
  t.time = 1
  t.callback = function(stage)
    redraw()
  end
  
  params:add{type="number", id="amp_threshold", min=0, max=40,default=4,
    action=function(x) engine.amp_thresh(x) end}
  
  params:add{type="number", id="density_threshold", min=0, max=80, default=40,
    action=function(x) engine.density_thresh(x/10) end}
  
  params:add{type="number", id="clarity_threshold", min=0, max=100, default=70,
    action=function(x) engine.clarity_thresh(x/100) end}
  
  params:add_separator()
  
  params:add{type="option", id="analysis", name="analysis", options={"on", "off"},
    action=function(val) engine.analysis_on(val) if val==1 then params:set("processing_type", 1) end end}
  
  params:add{type="number", id="fadetime", min=2, max=120, default=30,
    action=function(x) engine.fadetime(x) end}
  
  params:add{type="option", id="processing_type", name="processing_type", options={"---","reverb", "delay", "amp mod", "freeze", "pitchbend", "filter", "cascade"},
    action=function(val) if params:get("analysis")==2 then
      if val==1 then engine.silence(val) end
      if val==2 then engine.reverb(val) end
      if val==3 then engine.delay(val) end
      if val==4 then engine.ampmod(val) end
      if val==5 then engine.freeze(val) end
      if val==6 then engine.pitchbend(val) end
      if val==7 then engine.filter(val) end
      if val==8 then engine.cascade(val) end
      end
    end}
    
  params:add{type="option", id="polarity", name="polarity", default=2, options={"on", "off"},
    action=function(val) engine.polarity(val) end}
  
  params:add_separator()
  
  params:add{type="option", id="evolver", name="evolver", options={"on", "off"},
    action=function(val) engine.tracker_on(val) end}
  
  params:add{type="number", id="time_limit", min=30, max=500, default=100,
    action=function(x) engine.timelimit(x) end}
  
  params:add_separator()
    
  params:add{type="option", id="center", name="center", default=1, options={"silence","reverb", "delay", "amp mod", "freeze", "pitchbend", "filter", "cascade"},
    action=function(val)
      if val==1 then engine.map_quadrant(0,1) end
      if val==2 then engine.map_quadrant(0,3) end
      if val==3 then engine.map_quadrant(0,2) end
      if val==4 then engine.map_quadrant(0,4) end
      if val==5 then engine.map_quadrant(0,8) end
      if val==6 then engine.map_quadrant(0,5) end
      if val==7 then engine.map_quadrant(0,7) end
      if val==8 then engine.map_quadrant(0,6) end
      end}
      
    params:add{type="option", id="quadrant_1", name="quadrant_1", default=3, options={"silence","reverb", "delay", "amp mod", "freeze", "pitchbend", "filter", "cascade"},
    action=function(val)
      if val==1 then engine.map_quadrant(1,1) end
      if val==2 then engine.map_quadrant(1,3) end
      if val==3 then engine.map_quadrant(1,2) end
      if val==4 then engine.map_quadrant(1,4) end
      if val==5 then engine.map_quadrant(1,8) end
      if val==6 then engine.map_quadrant(1,5) end
      if val==7 then engine.map_quadrant(1,7) end
      if val==8 then engine.map_quadrant(1,6) end
      end}
      
    params:add{type="option", id="quadrant_2", name="quadrant_2", default=5, options={"silence","reverb", "delay", "amp mod", "freeze", "pitchbend", "filter", "cascade"},
    action=function(val)
      if val==1 then engine.map_quadrant(2,1) end
      if val==2 then engine.map_quadrant(2,3) end
      if val==3 then engine.map_quadrant(2,2) end
      if val==4 then engine.map_quadrant(2,4) end
      if val==5 then engine.map_quadrant(2,8) end
      if val==6 then engine.map_quadrant(2,5) end
      if val==7 then engine.map_quadrant(2,7) end
      if val==8 then engine.map_quadrant(2,6) end
      end}
      
    params:add{type="option", id="quadrant_3", name="quadrant_3", default=2, options={"silence","reverb", "delay", "amp mod", "freeze", "pitchbend", "filter", "cascade"},
    action=function(val)
      if val==1 then engine.map_quadrant(3,1) end
      if val==2 then engine.map_quadrant(3,3) end
      if val==3 then engine.map_quadrant(3,2) end
      if val==4 then engine.map_quadrant(3,4) end
      if val==5 then engine.map_quadrant(3,8) end
      if val==6 then engine.map_quadrant(3,5) end
      if val==7 then engine.map_quadrant(3,7) end
      if val==8 then engine.map_quadrant(3,6) end
      end}
      
    params:add{type="option", id="quadrant_4", name="quadrant_4", default=4, options={"silence","reverb", "delay", "amp mod", "freeze", "pitchbend", "filter", "cascade"},
    action=function(val)
      if val==1 then engine.map_quadrant(4,1) end
      if val==2 then engine.map_quadrant(4,3) end
      if val==3 then engine.map_quadrant(4,2) end
      if val==4 then engine.map_quadrant(4,4) end
      if val==5 then engine.map_quadrant(4,8) end
      if val==6 then engine.map_quadrant(4,5) end
      if val==7 then engine.map_quadrant(4,7) end
      if val==8 then engine.map_quadrant(4,6) end
      end}
  t:start()
   
end

function draw_screen()
  if screen_number==1 then
  screen.move(0, 24)
  screen.text("amp: ".. amp) 
  screen.move(0, 32)
  screen.text("density: ".. density) 
  screen.move(0, 40)
  screen.text("clarity: ".. clarity) 
  screen.move(0, 48)
  screen.text("X: ".. x_coord) 
  screen.move(32, 48)
  screen.text("Y: ".. y_coord)
  screen.move(0, 58)
  screen.text("Processing: ".. processingtext) 
  end
  if screen_number==0 then
    screen.move(0,18)
    screen.text("C: "..decode(quadrants[1]))
    screen.move(0,26)
    screen.text("1: "..decode(quadrants[2]))
    screen.move(0,34)
    screen.text("2: "..decode(quadrants[3]))
    screen.move(0,42)
    screen.text("3: "..decode(quadrants[4]))
    screen.move(0,50)
    screen.text("4: "..decode(quadrants[5]))
    screen.move(0,60)
    screen.text("P: "..processingtext)
    screen.rect(63,0,32,32)
    screen.level(8)
    screen.stroke()
    screen.rect(95,0,32,32)
    screen.level(8)
    screen.stroke()
    screen.rect(63,32,32,32)
    screen.level(8)
    screen.stroke()
    screen.rect(95,32,32,32)
    screen.level(8)
    screen.stroke()
    screen.rect(convertX(x_coord),convertY(y_coord),2,2)
    screen.level(16)
    screen.stroke()
    end
end

function convertX (val)
  return (val-0)/(1-0) * (124-65) + 65
end

function convertY (val)
  return (val-0)/(1-0) * (2-61) + 61
end

function redraw()
  screen.clear()
  screen.aa(1)
  screen.move(0, 8)
  screen.font_size(8)
  screen.level(15)
  screen.text("SWAY")
  draw_screen()
  screen.update()
end

function decode(num)
  if num==1 then
  return "Silence"
  end
    if num ==2 then
    return "Delay"
    end
      if num ==3 then
      return "Reverb"
      end
        if num ==4 then
        return "Amp Mod"
        end
              if num ==5 then
              return "Pitchbend"
              end
                if num ==6 then
                return "Cascade"
                end
                  if num ==7 then
                  return "Filter"
                  end
                    if num ==8 then
                    return "Freeze"
                    end
end
  
function enc(n, delta)
  if n == 1 then
    mix:delta("output", delta)
  end
end

function key(n,z)
  if n == 2 and z== 1 then
    if screen_number==0 then
    screen_number = 1
    else
      screen_number=0
      end
    end
end