// Vorbereiten des SC Servers:

s.options.sampleRate = 44100;			// oder eine andere Samplingrate
s.options.device = "MOTU Traveler"; 		// oder ein anderes Interface bzw. nil fuer das im System voreingestellte Interface

// Starten des Servers:
s.boot									// geht auch durch klick auf den Boot-Button des Server-Windows

// ein "Hello World"-Prograemmchen:

"Hallo SC!".postln						// zum Evaluieren Cursor in die Zeile bringen und [Shift + RETURN]

// ein klingendes "Hello World":
{ SinOsc.ar(440, 0, 0.2) }.play

// Soundausgabe abbrechen mit [CMD+.]

// andere Frequenz, andere Phase, andere Amplitude (bzw. mul):
{ SinOsc.ar(1000, 1.5, 0.5) }.play

{ SinOsc.ar(1000, 0, 0.5) }.play

// Hilfe zum UnitGenerator SinOsc bekommt man durch Selektieren (Markieren) des Wortes SinOsc und dann [CMD+D]

// statt konstanter Frequenz und Amplitude hier Maussteuerung:
{ SinOsc.ar( MouseY.kr(100, 2000) , 0, MouseX.kr(0, 1)) }.play

// lineare Aenderungen der Amplitude sind zur Lautstaerkensteuerung nicht geeignet,
// da die Wahrnehmung auch im Bereich des Schalldrucks (annaehernd) logarithmisch argebeitet

// siehe http://de.wikipedia.org/wiki/Lautstärke,  http://de.wikipedia.org/wiki/Schalldruckpegel

// deshalb wird hier die lineare Amplitude zur dritten Potenz erhoben:
{ SinOsc.ar( MouseY.kr(100, 2000) , 0, MouseX.kr(0, 1).cubed) }.play

// Vibrato-Effekt durch sinusfoermige Modulation der Frequenz:
{ SinOsc.ar( SinOsc.kr(5, 0, 10, 440), 0, 1) }.play

// sinnvoller ist zunaechst die Berechung des Vibratohubs in Halbtonschritten
// anschliessend muessen diese in eine Frequenz umgerechnet werden:
{ SinOsc.ar( SinOsc.kr(4, 0, 1, 69).midicps, 0, 1) }.play

// midicps und cpsmidi sowie dbamp und ampdb sind nuetzliche Konverter:
69.midicps
440.cpsmidi

// ein zufaellige Frequenz:
{ SinOsc.ar( rrand(200.0, 2000.0), 0, 0.1) }.play  // diesen Code mehrmals evaluieren und stoppen!

// rrand(min, max) erzeugt einmalig eine Zufallszahl:
rrand(10, 100)

// zufaellige Positionierung des Sinustons im Stereopanorama:
{ Pan2.ar(SinOsc.ar(rrand(200.0, 2000.0),0,0.1), rrand(-1.0, 1.0)) }.play

// automatisiertes Stereopanning:
{ Pan2.ar(SinOsc.ar(rrand(200.0, 2000.0),0,0.1), SinOsc.kr(0.5)) }.play

// ein Levelmeter fuer den Server_
s.meter

// zufaellige Amplitudenschwankungen:
{ SinOsc.ar( 1000, 0, LFNoise2.kr(3, 0.5, 0.5).cubed ) }.play

// statische Zufallsfrequenz, statische Zufallsposition, dynamische Amplitudenfluktuationen:
{ Pan2.ar( SinOsc.ar(rrand(200.0, 2000.0),0, LFDNoise3.kr(0.3, 0.3, 0.3).pow(5)), rrand(-1.0, 1.0)) }.play

// diesen Code mehrmals evaluieren ohne zwischendurch zu stoppen!

// mit Hilfe einer do-Schleife kann die mehrfache Evaluation auch automatisiert werden:
50.do { { Pan2.ar( SinOsc.ar(rrand(36.0, 96.9).midicps,0, LFDNoise3.kr(0.2, 0.5, 0.5).pow(5) * 0.2), rrand(-1.0, 1.0)) }.play }

// mit PanAz kann jeder Sinuston auf einem Kreis aus beliebig vielen Lautsprechern positioniert werden,
// hier sind es 8 Kanaele,
// ausserdem werden hier nun 150 Sinustoene erzeugt:
150.do { { PanAz.ar(8, SinOsc.ar(rrand(36.0, 120).midicps,0, LFDNoise3.kr(0.3, 0.5, 0.5).pow(10) * 0.1), rrand(-1.0, 1.0)) }.play }

// hier wird mit Hilfe der Iterationsvariablen i eine regulaere Obertonreihe ueber 100 Hertz erzeugt:
200.do { arg i; { Pan2.ar( SinOsc.ar( 100 * (i+1),0, LFDNoise3.kr(1).exprange(0.001, 0.8) / (i+1)), rrand(-1.0, 1.0)) }.play }

// ein Obertonreihe wie diese:
110, 220, 330, 440, 550, ...

// ist eine arithmetische Reihe:
110 * 1, 110 * 2, 110 * 3

// und kann in SC z.B. einfacher so formuliert werden:
110 * [1,2,3,4,5,6,7,8]

// oder noch kompakter so:
110 * (1 .. 8)

110 * (1 .. 50)

// siehe dazu auch Helpfile Syntax-Shortcuts 

// weiter mit der Datei "overview_examples.rtf" ...

// Vorrangregeln in SC:

3 + 4 * 5		// ergibt 35 und NICHT 23, weil in SC die Operatoren immer von links nach rechts abgearbeitet werden!

3 + (4 * 5)	// durch Klammerung kann diese Vorrangregeln umgangen werden

3 + 4.sqrt * 5	// nur die receiver.message-Operation hat immer Vorrang!

// die 10. Primzahl:
10.nthPrime

// die ersten 21 Primzahlen (die Nullte Primzahl ist 2 !)
(0 .. 20).nthPrime

// Multichannel Expansion durch Angabe mehrerer Werte anstelle eines einzigen:
{ SinOsc.ar( [300, 777] ) }.play		// links: 300 Hz, rechts: 777 Hz

{ Impulse.ar( [3, 4] ) }.play			// links 3 Impulse, rechts 4 Impulse pro Sekunde

{ Impulse.ar( [4, 5, 6, 7, 8, 9, 10, 11].scramble ) }.play // 8 Impulsefolgen auf 8 Kanaelen

// siehe auch Helpfile MultiChannel
	
// mit .sum koennen mehrkanalige Signal wieder zu einem zusammengemischt werden:
{ Impulse.ar( ( 4 .. 11 )).sum }.play

// beschleunigte Impulsefolge:
{ Impulse.ar( XLine.kr(1, 100, 10) ) }.play

// ein komplexeres Beispiel für nichtlineare Klangsynthese durch Verkettung von UGens:
{ SinOsc.ar([20, 23.7]*3).sqrt.thresh(LFNoise0.ar(11.3)).scaleneg(WhiteNoise.ar(0.5)).ring2(Impulse.ar([12.7, 10.1])) }.play

// hier in Einzelschritten dargestellt:
// zunaechst zwei tiefe Sinustoene:
{ SinOsc.ar( [20, 23.7] * 3 ) }.play

// ... diese werden durch die Quadratwurzel nichtlinear verzerrt:
{ SinOsc.ar( [20, 23.7] * 3 ).sqrt }.play
// siehe Helpfile sqrt

// ... anschliessend durchlaufen sie ein dynamisches "Noisegate"
{ SinOsc.ar( [20, 23.7] * 3 ).sqrt.thresh(LFNoise0.ar(11.3)) }.play
// siehe Helpfile thresh

// ... und dann werden die negativen Signalanteile mit weissem Rauschen multipliziert:
{ SinOsc.ar( [20, 23.7] * 3 ).sqrt.thresh(LFNoise0.ar(11.3)).scaleneg(WhiteNoise.ar(0.3)) }.play
// siehe Helpfile scaleneg

// ...  schliesslich wird das Ganze mit Impulsen rigmoduliert:
{ SinOsc.ar( [20, 23.7] * 3 ).sqrt.thresh(LFNoise0.ar(11.3)).scaleneg(WhiteNoise.ar(0.3)).ring2(Impulse.ar([12.7, 10.1])) }.play
// siehe Helpfile ring2

// verschiedene Signale auf verschiedene Ausgänge durch Platzierung in einem Array:
{ [Saw.ar(50, 0.2), PinkNoise.ar(0.2) ] }.play    

// gleichzeitige Evaluation verschiedener Syntheseprozesse (SynthDefs!):
(
{ Impulse.ar( [4, 5, 6, 7, 8, 9, 10, 11].scramble ) }.play;
{ [Saw.ar(50, 0.2), PinkNoise.ar(0.3) ] }.play;
{ SinOsc.ar( SinOsc.kr(5, 0, 10, 440), 0, 1) }.play;
)

// Einblenden eines Klangs per Huellkurve:
a = {arg gate=1; WhiteNoise.ar(0.5 * Linen.kr(gate, 1, 1, 2, doneAction: 2)) }.play

// und wieder ausblenden:
a.release

// 20 Zufallszahlen zwischen 10 und 100, gesammelt in einem Array:
Array.rand(20, 10, 100)

// ein Stream von leicht korrelierten Zufallszahlen (random walk) per Pattern:
Pbrown(10, 100, 7).asStream.nextN(20)

// Signal vom Eingang 1 der Soundkarte (Mikrofon?) spielen:
{ SoundIn.ar(0) }.play

// ein bestimmtes Soundfile lesen:
b = Buffer.read(s, "sounds/a11wlk01.wav");
b.play

// ein Soundfile per Filedialog bestimmen und lesen (ACHTUNG: nur unkomprimierte WAV oder AIFF !, keine mp3, ogg usw.!):
b = Buffer.loadDialog(s)
b.query
b.play

// einfaches Abspielen im Loop:
{ PlayBuf.ar(1, b.bufnum, 1, loop: 1) }.play

// 20% der Originalgeschwindigkeit:
{ PlayBuf.ar(1, b.bufnum, 0.2, loop: 1) }.play

// Mausgesteuerte Abspielgeschwindigkeit:
{ PlayBuf.ar(1, b.bufnum, MouseY.kr(-1,1), loop: 1) }.play

// 8 verschieden schnelle Kopieen des Soundfiles spielen -> 8 Ausgaenge!
{ PlayBuf.ar(1, b.bufnum, Array.rand(8, 0.98, 1.01), loop: 1) }.play
// Stereoversion:
{ Pan2.ar(PlayBuf.ar(1, b.bufnum, Array.rand(8, 0.98, 1.01), loop: 1), Array.series(8, -1, 1/4), 0.2).sum }.play

// 8 tieftransponierte Versionen des Soundfiles ab zufaelligen Startpositionen spielen
{ PlayBuf.ar(1, b.bufnum, Array.rand(8, 0.98, 1.01)*0.1, startPos: {b.numFrames.rand} ! 8, loop: 1) }.play
// Stereoversion:
{ Pan2.ar(PlayBuf.ar(1, b.bufnum, Array.rand(8, 0.98, 1.01) * 0.1, startPos: {b.numFrames.rand} ! 8, loop: 1), Array.series(8, -1, 1/4), 0.2).sum }.play

/*
Tipps zum Weiterlernen:

- die zentrale Hilfedatei: Help (auch uebers Help-Menue erreichbar)
- das Tutorial "Getting Started With SC" (ueber Help erreichbar)
- ein Ueberblick ueber viele (nicht alle!) Unit Generators: Tour_of_UGens 
- ein Ueberblick ueber Operatoren: Operators ,  BinaryOpUGen und UnaryOpUGen
- zum Verstaendnis von UGens, Synths und SynthDefs: UGens-and-Synths 
- zum Thema GUI: GUI-Overview und GUI-Classes
- zum Thema MIDI: UsingMIDI  

- meine Kursdateien im Ordner "Material/tutorial_examples/"

- die zahlreichen Beispiele im Ordner "examples" der Application SuperCollider, 
insbesondere unter "examples/pieces/", "examples/GUI examples/", "examples/demonstrations/"

*/