SuperCollider: Unidades generadoras

TUTORIAL DE SUPERCOLLIDER 3 - PARTE 3
Rodrigo F. Cadiz, basado en apuntes de Gary S. Kendall
Northwestern University

(
	Server.default = Server.internal;
	s = Server.default;
	s.boot;
)

Unidades generadoras (UGen)
- Objetos que procesan o generan sonidos
- Pueden tener muchas entradas, pero una sola salida
- Canales multiples se pueden hacer mediante arreglos de unidades generadoras
 
Creacion, tasa de audio, tasa de control
- Se crean a traves de los mensajes ar o kr

FSinOsc.ar(800, 0.0, 0.2); // crear un oscilador sinusoidal a 800 Hz, fase 0.0, amplitud 0.2

Argumentos
- Pueden ser otras UGen, escalares (numeros) o arreglos de UGen o escalares
- Por convencion, los ultimos dos argumentos de la mayoria de las UGen son mul (multiplicador) y add (suma)
- Valores por defecto de mul=1.0 y add=0.0
- Usar mul y add es mas eficiente que escribir expresiones con multiplicaciones y adiciones

Notacion funcional

	{ SinOsc.ar(440, 0, 0.2) }.play;

- Objeto se espefica entre { y } y se llama al metodo play
- Como no se especifica servidor, se usa el por defecto (variable "s"). 
- Tampoco se almaceno nada en una variable, por lo que no se puede reusar.

(
	{ 				// Abrir la funcion
		SinOsc.ar(	// Crear un objeto SinOsc a tasa de audio
			440, 	// frecuencia de 440 Hz, LA
			0, 		// fase inicial 0
			0.2) 	// mul (amplitud) of 0.2
	}.play;			// cerrar la funcion y llamar 'play' sobre ella
)
	
Otro ejemplo,

(
	{ var ampOsc;		// Abrir la funcion y declarar una variable
		ampOsc = SinOsc.kr(0.5, 1.5pi, 0.5, 0.5);	// Crear un objeto SinOsc a tasa de control
					// asignar su resultado a una variable
		SinOsc.ar(440, 0, ampOsc);	// crear un objecto SinOsc a tasa de audio
					// y usar la variable para controlar amplitud
	}.play;
)


Conceptos basicos de osciladores
 
Forma mas facil de generar sonido

	{ SinOsc.ar(800, 0, 0.1) }.play;

Que pasa en caso de errores

	{ SinOsc.ar(800, 0, 0.1) },.play;

Ejemplo de ruido browniano:

	{ BrownNoise.ar(0.1) }.play;

Server, BrownNoise y SinOsc son objetos

play, y ar son mensajes 

800, 0, y 0.1 son literales


Ejemplo con aliasion (alasing o foldover)

{ SinOsc.ar(Line.kr(1,43000,6), 0, 0.1) }.play;


Frecuencia lineal versus tono (pitch)

Line crea una interpolacion lineal entre dos puntos
XLine crea una interpolacion exponenial, usualmente usada para frecuencia
	
ar es tasa de audio
kr es tasa de control

{ SinOsc.ar(Line.kr(400,4000,5), 0, 0.3) }.play;  // Suena como una curva

{ SinOsc.ar(XLine.kr(400,4000,5), 0, 0.3) }.play;  //  Suena lineal


freq, phase, mul, and add are the names of arguments

Otros ejemplos:

	{ SinOsc.ar(freq: 440, phase: 0, mul: 0.4, add: 0) }.play;

	{ SinOsc.ar(phase: 0, freq: 440, add: 0, mul: 0.4) }.play;

	{ SinOsc.ar(freq: 440, mul: 0.4) }.play;

freq:440 es un ejemplo de argumento clave


SC tiene muchos otros objetos que son osciladores:

Por ejemplo:
	SinOsc		FSinOsc		Osc			Buffer	OscN
	
Tambien son utiles:	
	Impulse		Blip			Pulse		LFPulse
	Saw			LFSaw	
	Klang		Formant	
	VOsc		VOsc3
	
Algunos un poco mas complicados:
	SyncSaw	VarSaw
	LFPar		LFCub	
	Gendy1		Gendy2		Gendy3	
	
	
	

TUTORIAL DE SUPERCOLLIDER 3 - PARTE 4
Rodrigo F. Cadiz, basado en apuntes de Gary S. Kendall
Northwestern University

(
Server.internal.boot;
Server.default = Server.internal;
s = Server.default;
)



Mas sobre generadores de senal

Sumar sinusoides es ineficiente:

({ 
	var f=200;
	a = SinOsc.ar(f,0,0.1);
	b = SinOsc.ar(2*f,0,0.1);
	c = SinOsc.ar(3*f,0,0.1);
	d = SinOsc.ar(4*f,0,0.1);
	e = SinOsc.ar(5*f,0,0.1);
	a+b+c+d+e;
}.play;
)


Look at the Help pages for the following:
	SinOsc		FSinOsc		Osc			Buffer			OscN
	
These are also useful:	
	Impulse		Blip			Pulse		LFPulse
	Saw			LFSaw	
	Klang			Formant	
	VOsc			VOsc3



Generadores de senal de banda limitada

SinOsc, FSinOsc, Blip, Saw, Pulse, Formant no produciran aliasion.


SinOsc, FSinOsc
arguments:  frequency, phase, mul, add

{ SinOsc.ar(800,0,0.5) }.play;

{ FSinOsc.ar(800,0,0.5) }.play;


Saw
argumentos:  frequency, mul, add

{ Saw.ar(800, 0.5) }.play;
{ Saw.ar(XLine.kr(200,20000,6),0.5) }.play;  // no aliasing


Blip
argumentos:  frequency, numHarmonics, mul, add

{ Blip.ar(800, 10, 0.5) }.play;
{ Blip.ar(XLine.kr(200,20000,6),10,0.5) }.play; // no aliasing
// modular el numero de armonicos
{ Blip.ar(400,Line.kr(1,30,20),0.2) }.play;
//  a traves de un fitro pasa bajos resonante
{ RLPF.ar(Blip.ar(400,30,0.5), XLine.kr(400,8000,5), 0.1) }.play;


Pulse
argumentos:  frequency, width, mul, add

{ Pulse.ar(800,0.3, 0.5) }.play;
{ Pulse.ar(XLine.kr(200,20000,6),0.3,0.5) }.play;
// modulate pulse width
{ Pulse.ar(400, Line.kr(0.01,0.99,8), 0.5) }.play;


Klang - banco sinusoidal de osciladores
argumentos:  `[ frequencies, amplitudes, phases ], mul, add

{ Klang.ar(`[ [800, 1000, 1200],[0.3, 0.3, 0.3],[pi,pi,pi] ], 1, 0) * 0.4}.play;
// 8 frecuencias aleatorias
{ Klang.ar(`[ {exprand(400, 2000)}.dup(8), nil, nil ], 1, 0) * 0.04 }.play;

Formant			oscilador de formante
argumentos: kfundfreq, kformfreq, kwidthfreq, mul, add

Generates un set de armonicos sobre una frecuencia de formante, dada una frecuencia fundamental
kfundfreq - fundamental frequency in Hertz.
kformfreq - formant frequency in Hertz.
kwidthfreq - pulse width frequency in Hertz. Controla el ancho de banda del formante.

// modula frec fund, frec.formantes constante
{ Formant.ar(XLine.kr(400,1000, 8), 2000, 800, 0.125) }.play;

// modula frec formante, frec fundamental constante
{ Formant.ar(200, XLine.kr(400, 4000, 8), 200, 0.125) }.play;

// modula mediante frecuencia, otras quedan constantes
{ Formant.ar(400, 2000, XLine.kr(800, 8000, 8), 0.125) }.play;



Generadores de senal basados en tablas


Osc, COsc, VOsc, VOsc3

Es necesario usar un buffer alocado en el servidor
(
	// allocate buffer with server, size, numChans, bufferNumber
	b = Buffer.alloc(s, 2048, 1, bufnum: 80);
	// fill buffer with array of amplitudes, 3 * true (default)
	b.sine1([1,0.5,0.33,0.25,0.2], true, true, true);
)

// se puede escribir tambien cmo
	b.sine1(1.0/[1,2,3,4,5], true, true, true);
// o:
	b.sine1(1.0/(1..12));
	b.sine1(1.0/(1..24));
	b.sine1(1.0/(1..32));
	
	
Osc
argumentos: buffer number, frequency, phase, mul, add.

{ Osc.ar(b.bufnum, 400, 0, 0.5) }.play;

COsc - dos osciladores, detuned
argumentos: buffer number, frequency, beat frequency, mul, add.

{ COsc.ar(b.bufnum, 200, 0.4, 0.3) }.play;
// change buffer as above.

{ COsc.ar(b.bufnum, 200, MouseX.kr(0.0,20.0,'linear'), 0.3) }.play;


VOsc - oscilador crossface de multiples wavetables
argumentos: buffer number, frequency, phase, mul, add.

(
	// allocar buffers 80 a 87
	b = Array.new(8);
	8.do {arg i; b = b.add(Buffer.alloc(s, 2048, 1, bufnum: 80+i))};
)

(
	// llenar buffers 80 a 87
	8.do({arg i;
		var n, a;
		// generar arreglo de amplitudes armonicas
		n = (i+1)**2; // armonicos: [1,4,9,16,25,36,49,64]
		a = {arg j; ((n-j)/n).squared }.dup(n);
		// llenar tabla
		b[i].sine1(a);
	});
)

// go!
{ VOsc.ar(MouseX.kr(80,87), 120, 0, 0.5) }.play;



VOsc3 - tres VOscs sumados.
argumentos: buffer number, freq1, freq2, freq3, beat frequency, mul, add.

// chorusing
{ VOsc3.ar(MouseX.kr(80,87), 120, 121.04, 119.37, 0.2) }.play;

// acordes
{ VOsc3.ar(MouseX.kr(80,87), 120, 151.13, 179.42, 0.2) }.play;


Generadores de baja frecuencia (LF)

LFTri, Impulse, LFSaw, LFPulse, VarSaw, SyncSaw

Formas de onda geometricas, no limitados en banda

LFTri, LFSaw, Impulse
argumentos:  frequency, phase, mul, add

{ LFTri.ar(200,0,0.5) }.play;
{ LFSaw.ar(200,0,0.5) }.play;
{ Impulse.ar(200,0,0.5) }.play;

 // aliasion?
{ LFTri.ar(XLine.kr(200,20000,6), 0, 0.5) }.play;


LFPulse, VarSaw
argumentos:  frequency, phase, width, mul, add

{ LFPulse.ar(200,0,0.3,0.5) }.play;
{ VarSaw.ar(200,0,0.3,0.5) }.play;
// pulso con modulacion
{ LFPulse.ar(200,0,MouseX.kr(0,1),0.5) }.play;
{ VarSaw.ar(200,0,MouseX.kr(0,1),0.5) }.play;


SyncSaw
argumentos:  syncFreq, sawFreq, mul, add
Onda diente de sierra vinculada con una frecuencia fundamental.
Efecto similar a formantes que se mueven o puls con modulacion.

{ SyncSaw.ar(100, MouseX.kr(100, 1000), 0.1) }.play;