Pit Stop 6

Panning

Multifonia

//====================================================================

// Espansione multicanale

//====================================================================

s.boot;
s.scope(8);
s.meter(8,8);

// Un Array di UGens oppure di argomenti di una UGen genera tante istanze di segnale quanto il numero di items.
// Ognuno è scritto su un bus audio differente in ordine crescente rispetto a quelllo specificato come primo.

// ------------------------------ Array di UGens:

(
SynthDef(\multi, {var sig;
                      sig = [SinOsc.ar(440),
                             SinOsc.ar(550),
                             SinOsc.ar(660),
                             SinOsc.ar(880)];
	               Out.ar(0,sig) // 4 segnali che escono su 4 canali differenti e contigui
	               }).add;

{~synth = Synth(\multi)}.defer(0.1)
)



// ------------------------------ Array di argomenti come valori:

(
SynthDef(\multi, {var sig;
                      sig = SinOsc.ar([440,550,660,880]);
	              Out.ar(0,sig)
	              }).add;

{~synth = Synth(\multi)}.defer(0.1)
)

// ------------------------------ Array di argomenti come segnali:

(
SynthDef(\multi, {var sig;
                      sig = SinOsc.ar([440,550,660,880],
                                       0,
                                       SinOsc.kr([1,0.5,0.2,0.4]).unipolar);
	              Out.ar(0,sig)
	              }).add;

{~synth = Synth(\multi)}.defer(0.1)
)

// ------------------------------ Visualizzazione

// Inviluppi

(
a = Env.perc([0.1,0.5,0.7],2,0.7).test;
a.plot(name:"plot 1", bounds:300@200, minval:0, maxval:1)
)

// Segnali

{SinOsc.ar([440,1200,3000], mul:0.1)}.plot

//====================================================================

// Implosione multicanale

//====================================================================

{SinOsc.ar([600,800,1000,1200,1500], mul:0.1)}.scope;          // multicanale
{Mix.new(SinOsc.ar([600,800,1000,1200,1500], mul:0.1))}.scope; // mono

(
SynthDef(\envi, {arg t_trig = 0;
                 var freq,env,sig;
                     freq = #[200,974,1500,1800];
                     env  = Env.perc([0.1,0.2,0.3,0.4],[0.4,0.3,0.2,0.1]).kr(gate:t_trig);
                     sig  = SinOsc.ar(freq, mul:env); // multicanale
                     sig  = Mix(sig);                 // mono
                Out.ar(0,sig*0.3)
                }
        ).add;

{~synth = Synth(\envi)}.defer(0.1);

)

~synth.set(\t_trig,1);

Monofonia

// ------------------------------ Mono

(
SynthDef(\mono,
    	      {arg bus=0;
               var sig;
                   sig = SinOsc.ar;
               Out.ar(bus, sig*0.2)}
         ).add;

{~synth = Synth(\mono)}.defer(0.1);
)

~synth.set(\bus,rand(8));

// ------------------------------ Dual Mono

(
SynthDef(\dual_mono,
    	      {arg bus=0;
               var sig;
		           sig = SinOsc.ar([456,678],0,0.5);
               Out.ar(bus, sig*0.2)}
         ).add;

{~synth = Synth(\dual_mono)}.defer(0.1);
)

~synth.set(\bus,rand(7));

Stereofonia

Client side

//====================================================================

// Strumento

(
var xO=0,yO=1;                  // operazioni di init

// ------------------------------ SynthDef e Synth

SynthDef(\stereo_gui,
              {arg amp=1,pos=0.0,lev=1,smt=0.2;
               var sig,pan;
                   sig = SinOsc.ar(Rand(400,2000));
                   pan = Pan2.ar(sig,
                                 pos.lag(smt), 
                                 lev.lag(smt));
               Out.ar(0,pan*amp)
               }
        ).add;
	
{~synth = Synth(\stereo_gui)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 200@220);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;e.free;c.free});

b = NumberBox.new(w, Rect(40,195,50,20)).value_(0.5);  // NumberBox X
c = NumberBox.new(w, Rect(120,195,50,20)).value_(0.5); // NumberBox Y
d = StaticText.new(w, Rect(25,198,180,15))             // Static text
 .string_("X:                  Y:");
e = Slider2D.new(w, Rect(10, 10, 180, 180))            // Slider2D
 .x_(0.5).y_(0.5);
	
// ------------------------------ Operazioni di basso livello

~ksynth = {arg x=0,y=1, dur=1,defId=0.01,smth=0.02;          
           var range,nPassi,xPasso,yPasso,dPasso;
               range  = abs(xO-x);
               nPassi = 1/defId;
               xPasso = Array.interpolation(nPassi,0,1) // Passaggi di x
                             .normalize(xO,x);
               yPasso = Array.interpolation(nPassi,0,1) // Passaggi di y
                             .normalize(yO,y);   
               dPasso = dur/nPassi;

Routine.new({                                                
             xPasso.do({arg item,id;
                        ~synth.set(\pos,item,\lev,(yPasso[id]).sqrt); // al Synth  
                        {b.value_(item);                              // al NumberBox X (+/-1)
                         c.value_((yPasso[id]).sqrt);                 // al NumberBox Y (1/0)
                         e.x_(item.linlin(-1,1,0,1))                  // allo Slider2D  (0/1)
                          .y_((1-yPasso[id]).sqrt)
                        }.defer(0);

                         xO = item;                                   // resetta all'ultimo valore
                         yO = yPasso[id];
                         dPasso.wait  
                        })
             }).play;
};
	
e.action_({arg i;
           ~synth.set(\pos,i.x.linlin(0,1,-1,1), //  al Synth
                      \lev, (1-i.y).sqrt); 
          {b.value_(i.x.linlin(0,1,-1,1));       // al Number Box X
           c.value_(1-i.y)}.defer(0);            // al Number Box Y
           });
	
MIDIIn.connectAll;                                
MIDIdef.cc(\knob, {arg val;                  
                   ~synth.set(\pos,val.linlin(0,127,-1,1)); // al Synth
                   {b.value_(val.linlin(0,127,-1,1));       // al NumberBox X (+/-1)
                    e.x_(val.linlin(0,127,0,1))             // allo Slider2D  (0/1)
                    }.defer(0)
                   }, 16);                                  // dal cc 16
MIDIdef.cc(\slid, {arg val;                  
                   ~synth.set(\lev,val.linlin(0,127,1,0));  // al Synth
                   {c.value_(1-(val/127));                  // al NumberBox Y (1/0)
                    e.y_(val.linlin(0,127,0,1))             // allo Slider2D  (0/1)
                    }.defer(0)
                   }, 0);                                   // dal cc 0

OSCdef.new(\notam, {arg msg;                                   // Interazione OSC
                    ~synth.set(\pos,msg[1].linlin(0,127,-1,1), // posizione
                               \lev,msg[2].linlin(0,127,1,0)); // distanza
                    {b.value_(msg[1].linlin(0,127,-1,1));      // alla GUI
                     e.x_(msg[1].linlin(0,127,-1,1));
                     c.value_(1-(msg[2]/127));
                     e.y_(msg[2].linlin(0,127,0,1))
                     }.defer(0)},      
                    '/pan', NetAddr.new("127.0.0.1",58027));
)

//====================================================================

// Controlli

// ------------------------------ Singolo valore

~ksynth.value(x:0.6,y:0.3,dur:0.4);    // tutti i parametri
~ksynth.value(rand2(1.0),rand(1.0),rand(2.0)); 
~ksynth.value(rand2(1.0),rand(1.0),0); // cambio immediato (in relazione al parametro di smoothing)

// ------------------------------ Sequencing

// Deterministico

(
var pos;
    pos = [[0,1,1],[-0.4,0.6,0.3],[0.6,0.3,2],[0,0.5,0.4],[1,0.7,3],[-1,1,5]]; // [x,y,dur]

h = Routine.new({
                 pos.do({arg i;
                         ~ksynth.value(i[0],i[1],i[2]);
                         i[2].wait
                         })
                 }).reset.play;
)

h.stop; ~ksynth.value(y:0,dur:0.2);

// Non deterministico

(
var x,y,dur;

h = Routine.new({
                 inf.do({x = rand2(1.0);  // valori tra 0.0 e 1.0 ampliano o restringono il fronte stereo
                         y = rand(1.0);
                         dur = rrand(0.01,3);
                         ~ksynth.value(x,y,dur); 
                         dur.wait                       
                         })
                  }).reset.play
)

h.stop;~ksynth.value(y:0);

// ------------------------------ Rota

(
var ciclo;
    ciclo = 3; // tempo di un'andata e ritorno in secondi

h = Routine.new({

                 inf.do({var dur = ciclo*0.5;  // pos
                         ~ksynth.value(1,1,dur);
                         dur.wait;
                         ~ksynth.value(-1,1,dur);
                         dur.wait;
                         })

                 }).reset.play
)

h.stop;~ksynth.value(y:0);

// ------------------------------ Spreading

(
var rng,dur,smt;
    rng = [-0.5,0.3];
    dur = 0.02;
    smt = 0.02;  // prova a cambiare

~ksynth.value(smt:smt);

h = Routine.new({
                 inf.do({var x,y;
                         x = rrand(rng[0],rng[1]);
                         y = 1;
                         ~ksynth.value(x,y,dur);
                         dur.wait
                         })
                 }).reset.play
)

h.stop;~ksynth.value(y:0);

// ------------------------------ Interazione MIDI

// Utilizza un Knob sul cc 16 per la psozione sul fronte stereo e un fader sul cc 0 per la distanza

// ------------------------------ Interazione OSC

// • Monitorare i messaggi OSC:

OSCFunc.trace(true);  
OSCFunc.trace(false); 

// • Copiare il numero della porta in ingresso ('recvPort:57120') come output
//   del device che utilizziamo.
// • Inviare dei messaggi OSC dal device e copiare il numero di address 
//   ('address: a NetAddr("127.0.0.1", 58027)' e sostituirlo all'interno di
//   'OSCdef'
// • Eseguire il codice dello strumento e della GUI ed inviare messaggi dal device

Server side

Segnali di controllo

// vel: Hz
// sprd: 0/1
// initpos: 0      = parte dal centro e va verso 1
//          pi     = parte dal centro e va verso -1
//          0.5pi  = parte da 1 e va verso -1
//          -0.5pi = parte da -1 e va verso 1

(
var w,a,b,c,d;                  // variabili locali

// ------------------------------ SynthDef e Synth

SynthDef(\stereo_sig,
              {arg tipo=0,vel=1,sprd=1,initpos=0,dist=1,smt=0.2;
               var sig,ksigs,pos,pan;
                   sig = SinOsc.ar(Rand(400,2000));
                   pos = Select.kr(tipo,[LFTri.kr(vel,initpos,sprd),
                                         SinOsc.kr(vel,initpos,sprd),
                                         LFNoise0.kr(vel,sprd),
                                         LFNoise1.kr(vel,sprd),
                                         LFNoise2.kr(vel,sprd)]);
                   pos.scope;                                 // visualizza ksig
                   SendReply.kr(Impulse.kr(50), '/pos', pos); // Invia valori al Client
                   pan = Pan2.ar(sig,pos,dist.lag(smt));
               Out.ar(0,pan)
               }
        ).add;

{~synth = Synth(\stereo_sig)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 255@130);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;e.free;c.free});

a = PopUpMenu(w,Rect.new(10,10,100,20));
a.items = ["Triangolo","Sinusoide","Random 1","Random 2","Random 3"];
b = NumberBox.new(w,Rect.new(115,10,40,20))
 .value_(1);
c = NumberBox.new(w,Rect.new(180,10,40,20))
 .value_(1);
StaticText.new(w, Rect.new(158, 12, 20, 20))
          .string_("Vel");
StaticText.new(w, Rect.new(222, 12, 20, 20))
          .string_("Dist");
StaticText.new(w, Rect(10, 40, 255, 15))
          .string_("-1                          0                         1");
d = Slider.new(w, Rect(10, 55, 230, 50)); // Slider orizzontale

// ------------------------------ Operazioni di basso livello

a.action_({arg tipo;
	       ~synth.set(\tipo,tipo.value)
	       });
b.action_({arg vel;
	  	   ~synth.set(\vel, vel.value)
	       });
c.action_({arg dist;
	  	   ~synth.set(\dist, dist.value)
	       });

OSCFunc.new({arg msg; defer{d.value_(\pan.asSpec.unmap(msg[3]))}},'/pos', s.addr)
)

Inviluppi

(
s.waitForBoot{
var w,b,d;     // variabili locali

// ------------------------------ SynthDef e Synth

SynthDef(\penvi,
              {arg t_gate=0;
               var sig,envpos,envdist,pan;
                   sig     = SinOsc.ar;
                   envpos  = Env.new([0,-1,0.7,0],[0.3,0.2,2],\lin).kr(0,t_gate);
                   envdist = Env.new([1,0.01,1],[3,3],\cub).kr(0,t_gate);
                   pan     = Pan2.ar(sig,envpos,envdist);
                   SendReply.kr(Impulse.kr(50), '/pos', envpos);
                   SendReply.kr(Impulse.kr(50), '/dis', envdist); 
               Out.ar(0,pan)
               }
          ).add;


{~synth = Synth(\penvi)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 255@130);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;e.free;c.free});
	
StaticText.new(w, Rect(86, 12, 255, 15))
          .string_("Dist");
b = NumberBox.new(w,Rect.new(115,10,40,20));

StaticText.new(w, Rect(10, 40, 255, 15))
          .string_("-1                         0                         1");
d = Slider.new(w, Rect(10, 55, 230, 50)); // Slider orizzontale

// ------------------------------ Operazioni di basso livello

OSCFunc.new({arg msg; defer{d.value_(\pan.asSpec.unmap(msg[3]))}},'/pos', s.addr);
OSCFunc.new({arg msg; defer{b.value_(\pan.asSpec.unmap(msg[3]))}},'/dis', s.addr);
}
)

// ------------------------------ Sequencing

~synth.set(\t_gate,1);

Mouse

(
SynthDef(\pmouse,
              {var sig,pos,dist,pan;
                   sig  = SinOsc.ar;
                   pos  = MouseX.kr(-1,1);
                   dist = MouseY.kr(1,0.001); // vicino in basso
                   pan  = Pan2.ar(sig,pos,dist);
               Out.ar(0,pan)
               }
          ).add;


{a = Synth(\pmouse)}.defer(0.1);
)

Quadrifonia

Client side

//====================================================================

// Strumento

(
var xO=0,yO=0;                  // operazioni di init

// ------------------------------ SynthDef e Synth

SynthDef(\stereo_gui,
              {arg amp=1,x=0,y=0,lev=1,smt=0.2;
               var sig,pan;
                   sig = SinOsc.ar(Rand(400,2000));
                   pan = Pan4.ar(sig,
                                 x.lag(smt), 
                                 y.lag(smt));
               Out.ar(0,pan*amp)
               }
        ).add;
	
{~synth = Synth(\stereo_gui)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 200@220);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;e.free;c.free});

b = NumberBox.new(w, Rect(40,195,50,20)).value_(0);  // NumberBox X
c = NumberBox.new(w, Rect(120,195,50,20)).value_(0); // NumberBox Y
d = StaticText.new(w,Rect(25,198,180,15))            // Static text
 .string_("X:                  Y:");
e = Slider2D.new(w,  Rect(10, 10, 180, 180))         // Slider2D
 .x_(0.5).y_(0.5);
	
// ------------------------------ Operazioni di basso livello

~ksynth = {arg x=0,y=1, dur=1,defId=0.01,smth=0.02;          
           var range,nPassi,xPasso,yPasso,dPasso;
               range  = abs(xO-x);
               nPassi = 1/defId;
               xPasso = Array.interpolation(nPassi,0,1) // Passaggi di x
                             .normalize(xO,x);
               yPasso = Array.interpolation(nPassi,0,1) // Passaggi di y
                             .normalize(yO,y);   
               dPasso = dur/nPassi;

Routine.new({                                                
             xPasso.do({arg item,id;
                        ~synth.set(\x,item,\y,yPasso[id]);  // al Synth (+/-1)  
                         {b.value_(item);                   // al NumberBox X (+/-1)
                          c.value_(yPasso[id]);             // al NumberBox Y (+/-1)
                          e.x_(item.linlin(-1,1,0,1))       // allo Slider2D  (0/1)
                           .y_(yPasso[id].linlin(-1,1,0,1))
                         }.defer(0);

                         xO = item;                         // resetta all'ultimo valore
                         yO = yPasso[id];
                         dPasso.wait  
                        })
             }).play;
};
	
e.action_({arg i;
           ~synth.set(\x,i.x.linlin(0,1,-1,1),            //  al Synth (+/-1)
                      \y,i.y.linlin(0,1,-1,1)); 
          {b.value_(i.x.linlin(0,1,-1,1));                // al Number Box X (+/-1)
           c.value_(i.y.linlin(0,1,-1,1))}.defer(0);      // al Number Box Y (+/-1)
           });
	
MIDIIn.connectAll;                                
MIDIdef.cc(\knob, {arg val;                  
                   ~synth.set(\x,val.linlin(0,127,-1,1)); // al Synth (+/-1)
                   {b.value_(val.linlin(0,127,-1,1));     // al NumberBox X (+/-1)
                    e.x_(val.linlin(0,127,0,1))           // allo Slider2D  (0/1)
                    }.defer(0)
                   }, 16);                                // dal cc 16
MIDIdef.cc(\slid, {arg val;                  
                   ~synth.set(\y,val.linlin(0,127,-1,1)); // al Synth
                   {c.value_(val.linlin(0,127,-1,1));     // al NumberBox Y (1/0)
                    e.y_(val.linlin(0,127,0,1))           // allo Slider2D  (0/1)
                    }.defer(0)
                   }, 0);                                 // dal cc 0

OSCFunc.new({arg msg;
             ~synth.set(\x, msg[1].linlin(0,127,-1,1),  // al Synth
                        \y, msg[2].linlin(0,127,-1,1));
             {e.x_(msg[1]/127);                         // all'interfaccia
              e.y_(msg[2]/127);
			  b.value_(msg[1].linlin(0,127,-1,1));                
              c.value_(msg[2].linlin(0,127,-1,1))
		}.defer(0);
	         },'/pos', NetAddr.new("127.0.0.1",57876))
)

//====================================================================

// Controlli

// ------------------------------ Singolo valore

~ksynth.value(0,0,0.5);// centro
~ksynth.value(x:-1,y:1,dur:2); // L1 - bus 0     
~ksynth.value(0,1,2);  // centro al fondo
~ksynth.value(1,1,2);  // L2 - bus 1
~ksynth.value(1,0,2);  // centro a destra
~ksynth.value(1,-1,2); // L4 - bus 3
~ksynth.value(0,-1,2); // centro di fronte
~ksynth.value(-1,-1,2);// L3 - bus 2
~ksynth.value(-1,0,2); // centro a sinistra

~ksynth.value(0,0,0.5);// centro
~ksynth.value(rand2(1.0),rand2(1.0),rrand(0.1,2))

// ------------------------------ Sequencing

// Deterministico

(
var pos;
    pos = [[0,1,1],[-0.4,0.4,0.3],[0.6,-0.3,2],[0,0.4,1],[1,0,3],[-1,1,5]]; // [x,y,time]

h = Routine.new({
                 pos.do({arg i;
                         ~ksynth.value(i[0],i[1],i[2]);
                         i[2].wait
                         })
                 }).reset.play;
)

h.stop;

// Non deterministico

(
var x,y,dur;

h = Routine.new({
                 inf.do({x = rand2(1.0);  
                         y = rand2(1.0);
                         dur = rrand(0.01,3);
                         ~ksynth.value(x,y,dur);
                         dur.wait                
                         })
                  }).reset.play
)

h.stop;

// ------------------------------ Rota

// Senso orario
(
var ciclo;
    ciclo = 4; // tempo di giro in secondi

h = Routine.new({

                 inf.do({var dur = ciclo*0.25;  // pos
                         ~ksynth.value(-1,1,dur);
                         dur.wait;
                         ~ksynth.value(1,1,dur);
                         dur.wait;
		                 ~ksynth.value(1,-1,dur);
		                 dur.wait;
				         ~ksynth.value(-1,-1,dur);
		                 dur.wait;
                         })

                 }).reset.play
)

h.stop;

// Senso antiorario
(
var ciclo;
    ciclo = 4; // tempo di giro in secondi

h = Routine.new({

                 inf.do({var dur = ciclo*0.25;  // pos
                         ~ksynth.value(-1,1,dur);
                         dur.wait;
                         ~ksynth.value(-1,-1,dur);
                         dur.wait;
		                 ~ksynth.value(1,-1,dur);
		                 dur.wait;
				         ~ksynth.value(1,1,dur);
		                 dur.wait;
                         })

                 }).reset.play
)

h.stop;

// ------------------------------ Spreading

(
var rx,ry,dur,smt;
    rx = [-1,0];
    ry = [1,0];
    dur = 0.1;
    smt = 0.1;  // prova a cambiare

~ksynth.value(smt:smt);

h = Routine.new({
                 inf.do({var x,y;
                         x = rrand(rx[0],rx[1]);
                         y = rrand(ry[0],ry[1]);
                         ~ksynth.value(x,y,dur);
                         dur.wait
                         })
                 }).reset.play
)

h.stop;

// ------------------------------ Interazione MIDI

// Utilizza un Knob sul cc 16 per la psozione sull'asse x e un fader sul cc 0 per l'a distanza'asse y

// ------------------------------ Interazione OSC

// • Monitorare i messaggi OSC:

OSCFunc.trace(true);  
OSCFunc.trace(false); 

// • Copiare il numero della porta in ingresso ('recvPort:57120') come output
//   del device che utilizziamo.
// • Inviare dei messaggi OSC dal device e copiare il numero di address 
//   ('address: a NetAddr("127.0.0.1", 58027)' e sostituirlo all'interno di
//   'OSCdef'
// • Eseguire il codice dello strumento e della GUI ed inviare messaggi dal device

Server side

Segnali di controllo

(
var w,d,a;                  // variabili locali

// ------------------------------ SynthDef e Synth

SynthDef(\quad_sig,
              {arg tipoX=1,velX=0.5,sprdX=1,initposX= 0,
                   tipoY=1,velY=0.5,sprdY=1,initposY= 0.5pi,
                   smt=0.2;
               var sig,ksigs,x,y,pan;
                   sig = SinOsc.ar(Rand(400,2000));
                   x   = Select.kr(tipoX,[LFTri.kr(velX,initposX,sprdX),
                                          SinOsc.kr(velX,initposX,sprdX),
                                          LFNoise0.kr(velX,sprdX),
                                          LFNoise1.kr(velX,sprdX),
                                          LFNoise2.kr(velX,sprdX),
			                              ]);
                   y   = Select.kr(tipoY,[LFTri.kr(velY,initposY,sprdY),
                                          SinOsc.kr(velY,initposY,sprdY),
                                          LFNoise0.kr(velY,sprdY),
                                          LFNoise1.kr(velY,sprdY),
                                          LFNoise2.kr(velY,sprdY),
			                              ]);
                   SendReply.kr(Impulse.kr(50), '/pos', [x,y]); // Invia Slider2D
                   pan = Pan4.ar(sig,x,y);
               Out.ar(0,pan)
               }
        ).add;

{~synth = Synth(\quad_sig)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 210@210);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;d.free;a.free});

d = Slider2D.new(w, Rect(5, 5, 200, 200));          // Slider2D

OSCFunc.new({arg msg;
             {d.x_(msg[3].linlin(-1,1,0,1));     // solo all'interfaccia
              d.y_(msg[4].linlin(-1,1,0,1))}.defer(0);
              },'/pos', s.addr);
)

//====================================================================

// ------------------------------ Movimenti

~synth = Synth(\quad_sig,[\tipoX, 3, \tipoY, 3]).run;        // Random
~synth.run(false);
~synth = Synth(\quad_sig,[\initposX,0,\initposY,0.5pi]).run; // Senso orario
~synth.run(false);
~synth = Synth(\quad_sig,[\initposX,0.5pi,\initposY,0]).run; // Senso anti-orario
~synth.run(false);
~synth.set(\tipoX,rand(4),\tipoY,rand(4)).run;               // Combinazioni di segnali
~synth.run(false);
~synth.set(\tipoX,1,\tipoY,1,\velX,rrand(0.2,1),\velY,rrand(0.2,1)).run; // Combinazioni di velocità

//====================================================================

// ------------------------------ Controllo da GUI

(
var w,d,a;                  // variabili locali

// ------------------------------ SynthDef e Synth
	
SynthDef(\quad_sig,
              {arg tipoX=1,velX=0.5,sprdX=1,initposX= 0,
                   tipoY=1,velY=0.5,sprdY=1,initposY= 0.5pi,
                   smt=0.2;
               var sig,ksigs,x,y,pan;
                   sig = SinOsc.ar(Rand(400,2000));
                   x   = Select.kr(tipoX,[LFTri.kr(velX,initposX,sprdX),
                                          SinOsc.kr(velX,initposX,sprdX),
                                          LFNoise0.kr(velX,sprdX),
                                          LFNoise1.kr(velX,sprdX),
                                          LFNoise2.kr(velX,sprdX),
			                              ]);
                   y   = Select.kr(tipoY,[LFTri.kr(velY,initposY,sprdY),
                                          SinOsc.kr(velY,initposY,sprdY),
                                          LFNoise0.kr(velY,sprdY),
                                          LFNoise1.kr(velY,sprdY),
                                          LFNoise2.kr(velY,sprdY),
			                              ]);
                   SendReply.kr(Impulse.kr(50), '/pos', [x,y]); // Invia Slider2D
                   pan = Pan4.ar(sig,x,y);
               Out.ar(0,pan)
               }
        ).add;

{~synth = Synth(\quad_sig)}.defer(0.1);

// ------------------------------ GUI
		
w = Window.new("Pan", 270@210);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;b.free;c.free;d.free});

b = Knob.new(w,     Rect(210, 5, 50, 50));   // Knob
c = Slider.new(w,   Rect(210, 55, 50, 150)); // Slider
d = Slider2D.new(w, Rect(5, 5, 200, 200));   // Slider2D
	
// ------------------------------ Operazioni di basso livello

b.action_({arg i; ~synth.set(\velX,i.value.linlin(0,1,0.1,5),  // solo al Synth
                             \velY,i.value.linlin(0,1,0.1,5))});
c.action_({arg i; ~synth.set(\sprdX,i.value,\sprdY,i.value)});
	
OSCFunc.new({arg msg;
                    {d.x_(msg[3].linlin(-1,1,0,1));            // solo all'interfaccia
                     d.y_(msg[4].linlin(-1,1,0,1))}.defer(0);
                     },'/pos', s.addr);
	
MIDIIn.connectAll;                                
MIDIdef.cc(\knob, {arg val;                  
                   ~synth.set(\velX,val.linlin(0,127,0.1,5),  // al Synth
                              \velY,val.linlin(0,127,0.1,5)); 
                   {b.value_(val.linlin(0,127,0,1))}.defer(0) // al Knob                 
                   }, 16);                                    // dal cc 16
MIDIdef.cc(\slid, {arg val;                  
                   ~synth.set(\sprdX,val.linlin(0,127,0,1),   // al Synth
                              \sprdY,val.linlin(0,127,0,1));
                   {c.value_(val.linlin(0,127,0,1))}.defer(0) // allo Slider
                   }, 0);                                     // dal cc 0
)

Inviluppi

(
var w,b,d;     // variabili locali

// ------------------------------ SynthDef e Synth

SynthDef(\penvi,
              {arg t_gate=0;
               var sig,x,xbpf,xsenv,y,ybpf,ysenv,pan;
                   sig = SinOsc.ar;

                   x   = Env.newClear(4);          // Crea un inviluppo vuoto di 4 nodi
                   xbpf= \x.kr(x.asArray);         // Crea un controllo dell'inviluppo
                   xsenv= EnvGen.kr(xbpf, t_gate); // Genera l'inviluppo

                   y   = Env.newClear(4);
                   ybpf= \y.kr(y.asArray);
                   ysenv= EnvGen.kr(ybpf, t_gate);

                   pan = Pan4.ar(sig,xsenv,ysenv);
			       SendReply.kr(Impulse.kr(50), '/pos', [xsenv,ysenv]);
               Out.ar(0,pan)
               }
          ).add;


{~synth = Synth(\penvi)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 210@210);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;d.free;a.free});

d = Slider2D.new(w, Rect(5, 5, 200, 200)); // Slider2D

OSCFunc.new({arg msg;
                    {d.x_(msg[3].linlin(-1,1,0,1));            
                     d.y_(msg[4].linlin(-1,1,0,1))}.defer(0);
                     },'/pos', s.addr);
)

// ------------------------------ Sequencing

(
h = 2;                                     // Definiamo una durata
u = {[{rand2(1.0)}!4, {rand(0.5)}!3]}!2;   // generiamo i valori di x e y
u.postln;                                  // stampa i valori
x = Env.new(u[0][0],u[0][1]).duration_(h); 
y = Env.new(u[1][0],u[1][1]).duration_(h); 
[x,y].plot;                               // Plotter
~synth.set(\x, x, \y, y, \t_gate,1);      // li inviamo al Synth
)

Mouse

(
SynthDef(\pmouse,
              {var sig,x,y,pan;
                   sig = SinOsc.ar;
                   x   = MouseX.kr(-1,1);
                   y   = MouseY.kr(-1,1); // vicino in basso
                   pan = Pan4.ar(sig,x,y);
               Out.ar(0,pan)
               }
          ).add;

{a = Synth(\pmouse)}.defer(0.1);
)

Sistemi circolari

Client side

//====================================================================

// Strumento

s.boot;
s.scope(6);
s.meter(6,6);

(
var w,b,c,d,e,f,g,thetaO=0,rhoO=1;             // variabili locali

// ------------------------------ SynthDef e Synth

SynthDef(\esaf,
              {arg pos= 0,lev=1,dist=1,orient=0.5,smt=0.2;
               var nchans=6,sig,pan;
                   sig = SinOsc.ar(Rand(400,2000));
                   pan = PanAz.ar(nchans,
                                  sig,
                                  pos.lag(smt),
                                  lev.lag(smt),
                                  dist.linexp(0,1,nchans,2).lag(smt),
                                  orient);
               Out.ar(0,pan)
               }
        ).add;

{~synth = Synth(\esaf)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 250@220);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;b.free;c.free;d.free;e.free;f.free;g.free});

b = NumberBox.new(w, Rect(48, 195, 50, 20)).value_(0);   // NumberBox theta
c = NumberBox.new(w, Rect(140, 195, 50, 20)).value_(0);  // NumberBox rho
d = StaticText.new(w, Rect(10, 198, 180, 15))            // Static text
 .string_("theta:                  rho:");
e = Slider2D.new(w, Rect(10, 10, 180, 180))              // Slider2D
 .x_(0.5).y_(1);
f = Knob.new(w, Rect.new(195,10,50,50));
g = Slider.new(w, Rect.new(195,90,50,100));

// ------------------------------ Operazioni di basso livello

~ksynth = {arg theta=0, rho=1, dur=1,defId=0.01,smth=0.2;
           var range,nPassi,thetaPasso,rhoPasso,dPasso;
               range  = abs(thetaO-theta);
               nPassi = 1/defId;
               thetaPasso = Array.interpolation(nPassi,0,1) // Passaggi di theta
                                 .normalize(thetaO,theta);
               rhoPasso = Array.interpolation(nPassi,0,1)   // Passaggi di rho
                               .normalize(rhoO,rho);
               dPasso = dur/nPassi;

Routine.new({
             thetaPasso.do({arg item,id;
                            ~synth.set(\pos,item,\dist,rhoPasso[id]);  // al Synth (+/-1)
                             {b.value_(item);                          // alle diverse GUI
                              c.value_(rhoPasso[id]);                  

                              e.x_((rhoPasso[id] * cos(item -0.5* -pi)).linlin(-1,1,0,1)) 
                               .y_((rhoPasso[id] * sin(item -0.5* -pi)).linlin(-1,1,0,1));
                              f.value_(item);
                              g.value_(rhoPasso[id]);
                              }.defer(0);
				
                             thetaO = item;                         // resetta all'ultimo valore
                             rhoO   = rhoPasso[id];
                             dPasso.wait
                            })
             }).play
           };

f.action_({arg val;
           thetaO = val.value;
           ~synth.set(\pos,thetaO*2-1);                      // al Synth
           {b.value_(thetaO*2-1);                            // alle diverse GUI
            c.value_(rhoO);
            e.x_((rhoO * cos(thetaO*2-1 -0.5* -pi)).linlin(-1,1,0,1));
            e.y_((rhoO * sin(thetaO*2-1 -0.5* -pi)).linlin(-1,1,0,1))
            }.defer(0)
           });

g.action_({arg val;
          rhoO = 1-val.value;
          ~synth.set(\dist,rhoO);                           // al Synth
          {b.value_(thetaO*2-1);                            // alle diverse GUI
           c.value_(rhoO);
           e.x_((rhoO * cos(thetaO*2-1 -0.5* -pi)).linlin(-1,1,0,1));
           e.y_((rhoO * sin(thetaO*2-1 -0.5* -pi)).linlin(-1,1,0,1))
           }.defer(0)
          });

MIDIIn.connectAll;
MIDIdef.cc(\knob, {arg val;
                   thetaO = val;
                   ~synth.set(\pos,thetaO/127*2-1);         // al Synth
                   {b.value_(thetaO/127*2-1);               // alle diverse GUI
                    c.value_(rhoO/127);
                    e.x_((rhoO/127 * cos(thetaO/127*2-1 -0.5* -pi)).linlin(-1,1,0,1));
                    e.y_((rhoO/127 * sin(thetaO/127*2-1 -0.5* -pi)).linlin(-1,1,0,1));
                    f.value_(thetaO/127);
                    }.defer(0)
                   }, 16);                                  // dal cc 16

MIDIdef.cc(\slid, {arg val;
                   rhoO = val;
                   ~synth.set(\dist,rhoO/127);              // al Synth
                   {b.value_(thetaO/127*2-1);               // alle diverse GUI
                    c.value_(rhoO/127);
                    e.x_((rhoO/127 * cos(thetaO/127*2-1 -0.5* -pi)).linlin(-1,1,0,1));
                    e.y_((rhoO/127 * sin(thetaO/127*2-1 -0.5* -pi)).linlin(-1,1,0,1));
                    g.value_(rhoO/127);
                    }.defer(0)
                   }, 0);                                   // dal cc 0
)
//====================================================================

// Controlli

// ------------------------------ Singolo valore

~ksynth.value(0.00,1,1);
~ksynth.value(0.25,1,1);
~ksynth.value(0.50,1,1);
~ksynth.value(0.75,1,1);
~ksynth.value(1.00,1,1);
~ksynth.value(1.25,1,1);
~ksynth.value(1.50,1,1);
~ksynth.value(1.75,1,1);
~ksynth.value(2.00,1,1);

~ksynth.value(0,0,1);
~ksynth.value(rand2(1.0),rand(1.0),rrand(0.1,2))

// ------------------------------ Sequencing

// Deterministico

(
var pos;
    pos = [[0,1,1],[-0.4,0.4,0.3],[-0.6,0.3,2],[0,0.4,1],[1,0,3],[-1,1,5]]; // [x,y,time]

h = Routine.new({
                 pos.do({arg i;
                         ~ksynth.value(i[0],i[1],i[2]);
                         i[2].wait
                         })
                 }).reset.play;
)

h.stop;

// Non deterministico

(
var theta,rho,dur;

h = Routine.new({
                 inf.do({theta = rand2(1.0);  
                         rho = rand(1.0);
                         dur = rrand(0.01,3);
                         ~ksynth.value(theta,rho,dur);
                         dur.wait                
                         })
                  }).reset.play
)

h.stop;

// ------------------------------ Rota

// Senso orario
(
var dur, valO;
    dur  = 1;    // tempo di giro in secondi
    valO = 0;   // posizione iniziale   
h = Routine.new({
                 inf.do({
		                 valO = valO+2;
		                 ~ksynth.value(valO,1,dur);
		                 dur.wait;
                         })

                 }).reset.play;
)

h.stop;
h.reset.play;

// Senso antiorario
(
var dur, valO;
    dur  = 1;    // tempo di giro in secondi
    valO = 0;   // posizione iniziale   
h = Routine.new({
                 inf.do({
		                 valO = valO-2;
		                 ~ksynth.value(valO,1,dur);
		                 dur.wait;
                         })

                 }).reset.play;
)

h.stop;
h.reset.play;

// ------------------------------ Spreading

(
var rth,rrh,dur,smt;
    rth = [0,0.5];
    rrh = [1,0.5];
    dur = 0.1;
    smt = 0.1;  // prova a cambiare

~ksynth.value(smt:smt);

h = Routine.new({
                 inf.do({var theta,rho;
                         theta = rrand(rth[0],rth[1]);
                         rho = rrand(rrh[0],rrh[1]);
                         ~ksynth.value(theta,rho,dur);
                         dur.wait
                         })
                 }).reset.play
)

h.stop;

// ------------------------------ Interazione MIDI

// Utilizza un Knob sul cc 16 per la psozione sull'asse x e un fader sul cc 0 per l'a distanza'asse y

Server side

Segnali di controllo

(
var w,d,a;                  // variabili locali

// ------------------------------ SynthDef e Synth

SynthDef(\circ_sig,
              {arg tipoS=0,velS=1,sprdS=1,initpoS= 0,
                   lev = 1,
                   tipoD=0,velD=1,sprdD=1,initpoD=1,
                   orient=0.5,
                   smt=0.2;
               var nchans=6,sig,pos,dist,pan;
                   sig = SinOsc.ar(Rand(400,2000));
                   pos   = Select.kr(tipoS,[LFSaw.kr(velS,initpoS,sprdS),    // orario
                                            LFSaw.kr(velS,initpoS,sprdS)* -1,// antiorario
                                            SinOsc.kr(velS,initpoS,sprdS),
                                            LFNoise1.kr(velS,sprdS),
                                            LFNoise2.kr(velS,sprdS)
                                           ]);
                   dist = Select.kr(tipoD,[initpoD.lag(smt),              // fissa
                                           LFTri.kr(velD,initpoD,sprdD),
                                           SinOsc.kr(velD,initpoD,sprdD),
                                           LFNoise1.kr(velD,sprdD),
                                           LFNoise2.kr(velD,sprdD),
			                              ]);
                   SendReply.kr(Impulse.kr(50), '/pos', [pos,dist]);
                   pan = PanAz.ar(nchans, sig, pos, lev.lag(smt),
                                  dist.linexp(0,1,nchans,2),             // riscalato
                                  orient);
               Out.ar(0,pan)
               }
        ).add;

{~synth = Synth(\circ_sig)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 270@210);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;b.free;c.free;d.free});

b = Knob.new(w,     Rect(210, 5, 50, 50));   // Knob
c = Slider.new(w,   Rect(210, 55, 50, 150)); // Slider
d = Slider2D.new(w, Rect(5, 5, 200, 200));   // Slider2D

// ------------------------------ Operazioni di basso livello

b.action_({arg i; ~synth.set(\velS,i.value.linlin(0,1,0.1,5),  // solo al Synth
                             \velD,i.value.linlin(0,1,0.1,5))});
c.action_({arg i; ~synth.set(\tipoD,0,\initpoS,i.value,\initpoD,i.value)});

OSCFunc.new({arg msg;

           {b.value_(msg[3]);                                 // alle diverse GUI
            c.value_(msg[4]);
            d.x_((msg[4] * cos(msg[3] -0.5* -pi)).linlin(-1,1,0,1));
            d.y_((msg[4] * sin(msg[3] -0.5* -pi)).linlin(-1,1,0,1))
            }.defer(0)

            },'/pos', s.addr);

MIDIIn.connectAll;
MIDIdef.cc(\knob, {arg val;
                   ~synth.set(\velS,val.linlin(0,127,0.1,5),
                              \velD,val.linlin(0,127,0.1,5));
                   {b.value_(val.linlin(0,127,0,1))}.defer(0) // al Knob
                   }, 16);                                    // dal cc 16
MIDIdef.cc(\slid, {arg val;
                   ~synth.set(\tipoD,0,                       // al Synth
                              \initpoS,val.linlin(0,127,0,1),
                              \initpoD,val.linlin(0,127,0,1));
                   {c.value_(val.linlin(0,127,0,1))}.defer(0) // allo Slider
                   }, 0);                                     // dal cc 0
)

Inviluppi

(
var w,d;                  // variabili locali

// ------------------------------ SynthDef e Synth

SynthDef(\circ_sig,
              {arg t_gate,
                   lev = 1,
                   orient=0.5,
                   smt=0.2;
               var nchans=6,sig,
                   pos,posbpf,posEnv,
                   dist,distbpf,distEnv,
                   pan;

                   sig = SinOsc.ar(Rand(400,2000));

                   pos   = Env.newClear(4);           // Crea un inviluppo vuoto di 4 nodi
                   posbpf= \pos.kr(pos.asArray);      // Crea un controllo dell'inviluppo
                   posEnv= EnvGen.kr(posbpf, t_gate); // Genera l'inviluppo
  
                   dist = Env.newClear(4);
                   distbpf= \dist.kr(dist.asArray);
                   distEnv= EnvGen.kr(distbpf, t_gate);

                   SendReply.kr(Impulse.kr(50), '/pos', [posEnv,distEnv]);
                   pan = PanAz.ar(nchans,
                                  sig,
                                  posEnv,
                                  lev.lag(smt),
                                  distEnv.linexp(0,1,nchans,2),
                                  orient);
               Out.ar(0,pan)
               }
        ).add;

{~synth = Synth(\circ_sig)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 210@210);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;b.free;c.free;d.free});

d = Slider2D.new(w, Rect(5, 5, 200, 200));   // Slider2D

// ------------------------------ Operazioni di basso livello

OSCFunc.new({arg msg;
             {d.x_((msg[4] * cos(msg[3] -0.5* -pi)).linlin(-1,1,0,1));
              d.y_((msg[4] * sin(msg[3] -0.5* -pi)).linlin(-1,1,0,1))}.defer(0)
             },'/pos', s.addr)
)

// ------------------------------ Sequencing

(
var pos,dist;
h = 2;                                         // Definiamo una durata
p = [{rand2(1.0)}!4, {rand(0.5)}!3];           // generiamo i valori di pos
d = [{rand2(1.0)}!4, {rand(0.5)}!3];           // generiamo i valori di dist
pos  = Env.new(p[0],p[1]).duration_(h);
dist = Env.new(d[0],d[1]).duration_(h);
[pos,dist].plot;                               // Plotter
~synth.set(\pos, pos, \dist, dist, \t_gate,1); // li inviamo al Synth
)

Mouse

(
var w,d;                  // variabili locali

// ------------------------------ SynthDef e Synth
SynthDef(\pmouse,
              {var nchans=6,sig,pos,dist,pan;
                   sig = SinOsc.ar;
                   pos  = MouseX.kr(-5,5);    // numero di giri sull'asse x
                   dist = MouseY.kr(0,1);
                   SendReply.kr(Impulse.kr(50), '/pos', [pos,dist]);
                   pan = PanAz.ar(nchans,sig,pos,1,dist.linexp(0,1,nchans,2));
               Out.ar(0,pan)
               }
          ).add;

{a = Synth(\pmouse)}.defer(0.1);

// ------------------------------ GUI

w = Window.new("Pan", 210@210);
w.alwaysOnTop;
w.front;
w.onClose_({~synth.free;w.free;b.free;c.free;d.free});

d = Slider2D.new(w, Rect(5, 5, 200, 200));   // Slider2D

// ------------------------------ Operazioni di basso livello

OSCFunc.new({arg msg;
             {d.x_((msg[4] * cos(msg[3] -0.5* -pi)).linlin(-1,1,0,1));
              d.y_((msg[4] * sin(msg[3] -0.5* -pi)).linlin(-1,1,0,1))}.defer(0)
             },'/pos', s.addr)
)

SplayAz

(
SynthDef(\stereo,
              {arg sprd,ctr=0;
               var nchans=6,sig,width,lev=1,orient=0.5,pan;
		           sig = [SinOsc.ar(800),Saw.ar(1000),WhiteNoise.ar];
		           width = MouseX.kr(2,6);
		           sprd = MouseX.kr(0,1);
                   pan = SplayAz.ar(nchans, // numero di canali del sistema
                                    sig,    // Array di canali mono
                                    sprd,   // spread 0 = tutti al centro
                                    lev,    // ampiezza globale (0. / 1.)
                                    width,  // su quanti canali i segnali sono distribuiti
                                    ctr,    // shift dal centro
                                    orient, // orientazione
                                    true);  // limiter...
               Out.ar(0,pan)
               }
        ).add;

{~synth = Synth(\stereo)}.defer(0.1);
)