Escolar Documentos
Profissional Documentos
Cultura Documentos
Sumrio
I
O BSICO
1 Ol Mundo
2 Servidor e Linguagem
2.1 Iniciando o Servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
4
4 Mensagens de erro
5 Mudando parmetros
6 Comentrios
7 Precedncia
10
9 Blocos de cdigo
11
12
12
12 Variveis
12.1 "Global"vs. Local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12.2 Reatribuio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
13
14
16
II
17
PATTERNS
13 A famlia Pattern
13.1 Conhea o Pbind . . . . . . . . . . . . .
13.2 Pseq . . . . . . . . . . . . . . . . . . . .
13.3 Deixe seu cdigo mais legvel . . . . . .
13.4 Quatro maneiras de especificar alturas .
13.5 Mais palavras-chave: amplitude e legato
13.6 Prand . . . . . . . . . . . . . . . . . . .
13.7 Pwhite . . . . . . . . . . . . . . . . . . .
13.8 Expandindo seu vocabulrio de Patterns
14 Mais truques com Patterns
14.1 Acordes . . . . . . . . . . . . . . . .
14.2 Escalas . . . . . . . . . . . . . . . . .
14.3 Transposio . . . . . . . . . . . . .
14.4 Microtons . . . . . . . . . . . . . . .
14.5 Andamento . . . . . . . . . . . . . .
14.6 Pausas . . . . . . . . . . . . . . . . .
14.7 Tocando dois ou mais Pbinds juntos
.
.
.
.
.
.
.
ii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
17
17
18
19
20
22
23
24
26
.
.
.
.
.
.
.
30
30
30
31
32
32
33
33
36
37
38
39
40
III
43
43
45
18 Aninhamento
46
19 Fechamentos
19.1 Aspas duplas
19.2 Parnteses . .
19.3 Colchetes . .
19.4 Chaves . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
50
50
50
51
51
52
21 Funes
55
58
59
iii
60
60
61
23 Obtendo Ajuda
62
IV
65
24 UGens
24.1 Controle do Mouse: Theremin instantneo . . . . . . . . . . . . . . . . . . . . . .
24.2 Dente-de-serra e onda quadrada; grfico e osciloscpio . . . . . . . . . . . . . . .
65
66
67
67
69
26 Argumentos de UGen
70
27 Redimensionando mbitos
27.1 Redimensione com o mtodo range . . . . . . . . . . . . . . . . . . . . . . . . . .
27.2 Redimensionando com mul e add . . . . . . . . . . . . . . . . . . . . . . . . . . .
27.3 linlin e sua turma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
71
72
73
73
75
29 A mensagem set
75
iv
76
76
31 Entrada de Microfone
79
32 Expanso Multicanal
80
33 O objeto Bus
82
34 Pan
83
35 Mix e Splay
85
87
37 Ns de sintetizador
37.1 O glorioso doneAction: 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
88
89
38 Envelopes
38.1 Env.perc . . . . . . . .
38.2 Env.triangle . . . . . .
38.3 Env.linen . . . . . . .
38.4 Env.pairs . . . . . . .
38.4.1 Envelopesno
38.5 Envelope ADSR . . . .
38.6 EnvGen . . . . . . . .
90
91
92
92
92
93
94
96
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . .
s para amplitude
. . . . . . . . . . .
. . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
39 Definies de sintetizador
96
39.1 SynthDef e Synth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
39.2 Exemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
39.3 Nos bastidores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
40 Pbind pode tocar sua SynthDef
101
41 Canais de Controle
104
41.1 asMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
42 Ordem de Execuo
107
42.1 Grupos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
E AGORA?
111
43 MIDI
111
44 OSC
114
44.1 Mandando OSC para um outro computador . . . . . . . . . . . . . . . . . . . . . 115
44.2 Mandando OSC de um smartphone . . . . . . . . . . . . . . . . . . . . . . . . . . 116
45 Quarks e plug-ins
116
46 Referncias Extra
117
vi
Parte I
O BSICO
1
Ol Mundo
Tudo pronto para criar seu primeiro programa em SuperCollider? Assumindo que voc tem o SC
aberto e funcionando sua frente, abra um novo documento (menu FileNew ("ArquivoNovo")
ou o atalho [ctrl+N]) e digite a seguinte linha:
1
"Ol Mundo".postln;
Posicione o cursor em qualquer lugar desta linha (no importa se incio, meio ou fim). Pressione [ctrl+Enter] para executar o cdigo. "Ol Mundo"aparece no seu Post window ("Janela
de postagem"). Parabns! Este foi seu primeiro programa em SuperCollider.
Servidor e Linguagem
O SuperCollider, na realidade, composto de dois aplicativos distintos: o servidor e a linguagem. O servidor responsvel por fazer sons. A linguagem (tambm chamada cliente ou interpretador ) usada para controlar o servidor. O primeiro chamado scsynth ("SC-synthesizer")
e o segundo, sclang ("SC-language"). A Barra de Status diz o status (ligado/desligado) de cada
um destes dois componentes.
No se preocupe se esta distino no faz muito sentido para voc agora. As duas coisas
principais que voc precisa saber por enquanto so:
1. Tudo o que voc digita no SuperCollider est na linguagem do SuperCollider (o cliente):
onde voc escreve e executa comandos, vendo os resultados na Post window.
2. Todo som que o SuperCollider faz est vindo do servidoro "motor sonoro", por assim
dizer, controlado por voc atravs da linguagem do SuperCollider.
2.1
Iniciando o Servidor
Seu programa "Ol Mundo"no produziu som algum: tudo aconteceu na linguagem e o servidor
nem chegou a ser usado. O prximo exemplo produzir som, ento precisamos ter certeza de que
o Servidor est ligado e funcionando.
O jeito mais fcil de iniciar o servidor com o atalho [ctrl+B]. Alternativamente, voc pode
clicar nos zeros da Barra de Status: no menu que aparece, escolha a opo "Boot Server"("Iniciar
Servidor"). Voc observar alguma atividade na Post Window enquanto o servidor est iniciando.
Depois que voc tiver iniciado o servidor com sucesso, os nmeros na Barra de Status vo ficar
verdes. Voc ter de fazer isso todas as vezes que iniciar o SC, mas apenas uma vez por sesso.
"Ol Mundo" tradicionalmente o primeiro programa que as pessoas criam quando esto aprendendo uma nova linguagem de programao. Voc j fez isso no SuperCollider.
Criar uma onda senoidal simples talvez seja o "Ol Mundo"das linguagens de programao para msica. Vamos direto senoide ento. Digite e execute a seguinte linha de cdigo.
Cuidadoo volume pode ser alto. Abaixe todo o volume do seu computador, execute a linha e
aumente o volume devagar.
1
{SinOsc.ar}.play;
Trata-se de uma senoide bela, suave, contnua e talvez um pouco entediante. Voc pode parar
o som com [ctrl+.] (ou seja, a tecla control junto com a tecla de ponto final ). Memorize esta
combinao de teclas, porque voc a utilizar muito para interromper todo e qualquer som no
SC.
DICA: Em uma linha separada, digite e execute s.volume.gui se voc quiser um slider grfico para controlar o volume da sada do SuperCollider.
Agora vamos tornar esta senoide um pouco mais interessante. Digite isto:
1
Lembre-se, basta deixar o cursor em qualquer lugar da linha e apertar [ctrl+Enter] para
executar. Ou, se preferir, voc pode tambm selecionar toda a linha antes de execut-la.
Mensagens de erro
No saiu nenhum som quando voc rodou o ltimo exemplo? Se isso aconteceu, provavelemente
seu cdigo tem um erro de digitao: um caracter errado, uma vrgula ou um parntese a menos,
etc. Quando algo acontece de errado no seu cdigo, a Post window mostra uma mensagem de
erro. Mensagens de erro podem ser longas e obscuras, mas no entre em pnico: com o tempo
voc aprender a l-las. Veja abaixo um exemplo de uma mensagem de erro curta:
ERROR: Class not defined.
in file selected text
line 1 char 19:
{SinOsc.ar(LFNoiseO.kr(12).range(400, 1600), mul: 0.01)}.play;
----------------------------------nil
Esta mensagem de erro diz "Class not defined"(Classe no definida) e aponta a localizao
aproximada do erro ("line 1 char 19", ou seja: linha 1, caracter 19). Classes no SC so aquelas
palavras azuis que comeam com uma letra maiscula (como SinOsc e LFNoise0). O que causou
6
o erro nesse exemplo foi que a pessoa digitou LFNoiseO com uma letra "O"maiscula ao final.
A classe correta LFNoise0, com o nmero zero ao final. Parece at pegadinha de vestibular,
mas verdade. Como voc pode ver, ateno aos detalhes crucial.
Se voc tem um erro no seu cdigo, revise-o, mude o que for necessrio e tente novamente
at que ele esteja corrigido. Se voc ainda no cometeu nenhum erro, experimente introduzir um
para que voc possa ver como uma mensagem de erro (por exemplo, remova um ponto ou uma
vrgula de um dos exemplos das senoides).
DICA: Aprender SuperCollider como aprender uma outra lngua como Alemo, Ingls ou
Japons. . . voc tem que praticar fal-la o mximo possvel, esforce-se em expandir seu vocabulrio, preste ateno na gramtica e na sintaxe e aprenda com seus erros. A pior coisa que
pode acontecer voc travar o SuperCollider, o que bem menos ruim do que pegar um nibus errado em Nova Iorque por culpa de um erro de pronncia na hora de pedir informaes.
Mudando parmetros
Wilson, S. and Cottle, D. and Collins, N. (Editors). The SuperCollider Book, MIT Press, 2011, p. 5. Diversas
coisas neste tutorial foram emprestadas, adaptadas ou inspiradas pelo excelente "Beginners Tutorial"de David
Cottle, que o primeiro captulo do livro, masdiferentemente deleaqui assumimos que o leitor tenha pouca
familiaridade com computao musical, e apresentamos a famlia de Patterns como eixo principal da abordagem
pedaggica.
Pare o som, mude alguns nmeros e rode novamente. Por exemplo, o que acontece quando
voc substitui os nmeros 12 e 15 por valores mais baixos, entre 1 e 5? Depois de LFNoise1, que
tal se em vez de 0.3 e 0.2 voc tentasse algo como 1 ou 2? Mude um de cada vez. Compare o
novo som com o som anterior, escute as diferenas. Veja se voc consegue entender qual nmero
est controlando o qu. Esta uma maneira divertida de explorar o SuperCollider: pegue um
trecho de cdigo que faa algo interessante e experimente com os parmetros para criar variaes.
Mesmo se voc no entender completamente a funo exata de cada nmero, ainda assim pode
encontrar resultados sonoros interessantes.
DICA: Como qualquer software, lembre-se de salvar frequentemente o seu trabalho com
[ctrl+S]! Quanto estiver trabalhando em tutoriais como esse, voc muitas vezes vai chegar a
sons interessantes experimentando com os exemplos fornecidos. Quando voc quiser guardar
algo que gostou, copie o cdigo em um novo documento e salve-o. Repare que todo arquivo
do SuperCollider tem a extenso .scd, que quer dizer "SuperCollider Document".
Comentrios
Todo o texto que aparece em vermelho no seu cdigo um comentrio. Se voc novo em
linguagens de programao, comentrios so bastante teis para documentar o seu cdigo, tanto
para voc mesmo, quanto para outros que tenham de l-lo depois. Qualquer linha comeando
com uma barra dupla um comentrio. Voc pode escrever comentrios logo depois de uma
linha vlida de cdigo, pois a parte do comentrio ser ignorada quando voc rodar. No SC,
usamos um ponto-e-vrgula para indicar o fim de um enunciado vlido.
1
2
3
Voc pode rodar uma linha mesmo que o seu cursor estiver no meio de um comentrio depois
desta linha. A parte do comentrio ignorada. Os prximos dois pargrafos sero escritos como
"comentrios"apenas como exemplo.
1
2
3
4
5
6
7
8
// Se voc escrever um comentrio beeeem longo (uma nica linha longa), seu texto
vai ser quebrado em vrias "linhas" que no vo comear com barra dupla. No
entanto, tudo isso ainda conta como uma s linha de comentrio.
/* Use "barra + asterisco" para comear um comentrio longo com diversas linhas.
Feche o trecho de comentrio com "asterisco + barra". O atalho mencionado
anteriormente tambm funciona para grandes trechos: simplesmente selecione as
linhas de cdigo que voc quer "comentar" ("comment out", em ingls) e pressione
[ctrl+/]. O mesmo serve para descomentar ("uncomment").*/
Precedncia
Um detalhe pequeno mas til para se entender: o SuperCollider tem como padro sempre postar
na Post window o resultado de qualquer operao que tenha sido a ltima coisa a ser executada.
Isso explica porque o seu cdigo "Ol Mundo"imprime duas vezes quando voc o executa. Digite
as prximas linhas em um novo documento, depois selecione tudo com [ctrl+A] e rode todas as
linhas de uma vez:
1
2
3
4
5
"Primeira linha".postln;
"Segunda linha".postln;
(2 + 2).postln;
3 + 3;
"Fim".postln;
10
Blocos de cdigo
um pouco chato ter que ficar selecionando vrias linhas de um cdigo toda vez antes de rod-lo.
Uma maneira muito mais fcil de rodar uma poro de cdigo ao mesmo tempo criar um bloco
de cdigo: simplesmente coloque dentro de parnteses todas as linhas de cdigo que voc quer
rodar juntas. Aqui est um exemplo:
1
2
3
4
5
6
7
(
// Um pequeno poema
"Hoje domingo".postln;
"P de cachimbo".postln;
"O cachimbo de ouro".postln;
"Bate no touro".postln;
)
Os parnteses nas linhas 1 e 7 delimitam o bloco de cdigo. Desde que que o cursor esteja
em qualquer lugar dentro dos parnteses, um nico [ctrl+Enter] rodar as linhas para voc (elas
sero executadas em ordem de cima para baixo, mas isso to rpido que parece simultneo).
Usar blocos de cdigo poupa o trabalho de ter que selecionar todas as linhas novamente
a cada vez que voc quiser mudar algo e rodar novamente. Por exemplo, mude algumas das
palavras entre aspas e pressione [ctrl+Enter] logo aps fazer a mudana. Todo o bloco de cdigo
rodado sem que voc tenha que selecionar manualmente todas as linhas. Ao rodar o bloco,
o SuperCollider mostra a seleo por um momento para dar uma indicao visual do que est
sendo executado.
11
10
Este um comando to til para manacos por limpeza que merece uma seo s pra ele:
[ctrl+shift+P]. Execute esta linha e experimente limpar a Post window em seguida:
1
11
Logo voc vai querer comear a gravar a sada de som dos seus patches de SuperCollider. Eis
um jeito rpido:
1
2
3
4
5
6
7
8
9
// GRAVAO RPIDA
// Comear a gravar:
s.record;
// Faa algum som bacana:
{Saw.ar(LFNoise0.kr([2, 3]).range(100, 2000), LFPulse.kr([4, 5]) * 0.1)}.play;
// Pare de gravar:
s.stopRecording;
// Opcional: GUI com boto de gravao, controle de volume, boto de mudo.
s.makeWindow;
A Post window mostra o caminho para a pasta onde o arquivo foi salvo. V at o arquivo,
abra-o no Audacity ou um programa similar e verifique se o arquivo foi mesmo gravado. Para
mais informaes, veja o arquivo de Ajuda de "Server"(role para baixo at "Recording Support").
Tambm online em http://doc.sccode.org/Classes/Server.html.
12
12
Variveis
Voc pode guardar nmeros, palavras, unidades geradoras, funes ou blocos inteiros de cdigo
em variveis. Variveis podem ser letras minsculas simples ou palavras escolhidas por voc.
Usamos o sinal de igual (=) para "atribuir"variveis. Rode estas linhas uma de cada vez e
observe a Post window:
1
2
3
4
5
6
x = 10;
y = 660;
y; // confira o que est aqui dentro
x;
x + y;
y x;
A primeira linha atribui o nmero 10 varivel x. A segunda linha coloca 660 na varivel
y. As prximas duas linhas provam que estas letras agora "contm"estes nmeros (os dados).
Finalmente, as duas ltimas linhas mostram que podemos usar as variveis para fazer qualquer
operao com os dados guardados nelas.
Letras minsculas de a a z podem ser utilizadas a qualquer momento como variveis no
SuperCollider. A nica letra simples que comumente no se usa s, que por conveno
reservada para representar o Servidor. Qualquer coisa pode entrar em uma varivel:
1
2
3
4
5
6
7
a = "Ol Mundo";
b = [0, 1, 2, 3,
c = Pbind(\note,
adiante, no
// ...e agora voc pode utilizlas como voc utilizaria os dados originais:
a.postln; // postea
b + 100; // faa contas
13
8
9
Muitas vezes far mais sentido dar nomes melhores para suas variveis, para ajudar a lembrar
o que elas representam no seu cdigo. Voc pode usar um (til) para declarar uma varivel
com um nome mais longo. Note que no h espao entre o til e o nome da varivel.
1
2
3
4
Nomes de variveis devem comear com letras minsculas depois do til. Voc pode usar
nmeros, underscores e letras maisculas no meio do nome, somente no como primeiro caracter.
Todos os caracteres tm de ser contguos (sem espaos ou pontuao). Resumindo, atenha-se a
letras e nmeros e underscores ocasionais, evitando todos os outros caracteres ao nomear suas
variveis. minhasFreqs, aMelhorSenoide e banana_3 so nomes vlidos. MinhasFreqs,
aMelhor&*#Senoide e banana!!! vo estragar o seu dia.
H dois tipos de variveis que voc pode criar: variveis "globais"e variveis locais.
12.1
"Global"vs. Local
As variveis que vimos at agora (letras minsculas de a a z e aquelas comeando com o caracter
til ()) so genericamente chamadas "variveis globais", porque uma vez declaradas, funcionaro
"globalmente"em qualquer lugar no patch, em outros patches e mesmo em outros documentos
do SC, at que voc saia do SuperCollider.
Tecnicamente falando, variveis comeando com um til so chamadas variveis de Ambiente ("Environment")
e variveis de letras minsculas (de a a z) so chamadas variveis do Interpretador. Iniciantes no SuperCollider
14
Variveis locais, por outro lado, so declaradas com a palavra-chave especfica var no incio de
uma linha. Voc pode atribuir um valor inicial para uma varivel no momento de sua declarao
(var tangerina = 4). Variveis locais apenas existem dentro do escopo de seu bloco de cdigo.
Aqui est um exemplo simples comparando os dois tipos de variveis. Execute linha a linha
e observe a Post window.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Variveis de Ambiente
~abacates = 4;
~laranjas = 5;
~tangerinas = 2;
~bananas = 1;
["Ctricos", ~laranjas + ~tangerinas];
["NoCtricos", ~bananas + ~abacates];
// Variveis locais: vlidas apenas dentro do bloco de cdigo.
// Execute o bloco uma vez e observe o Post window:
(
var jacas = 4, laranjas = 3, tangerinas = 8, bananas = 10;
["Frutas ctricas", laranjas + tangerinas].postln;
["Frutas Noctricas", bananas + jacas].postln;
"Fim".postln;
)
~abacates; // varivel ainda existe
jacas; // varivel no existe mais
no precisam se preocupar com estas distines, mas mantenha-as em mente para o futuro. O Captulo 5 do The
SuperCollider Book explica a diferena em detalhes.
15
12.2
Reatribuio
Uma ltima coisa til de se entender sobre variveis que elas podem ser reatribudas: voc
pode dar-lhes um novo valor a qualquer momento.
1
2
3
4
5
Uma prtica muito comum que pode parecer um pouco confusa para iniciantes quando a
prpria varivel usada na sua prpria reatribuio. D uma olhada neste exemplo:
1
2
3
A maneira mais fcil de entender essa ltima linha l-la da seguinte forma: "pegue o valor
atual da varivel x, adicione 1 a ela e atribua este novo resultado varivel x". No fundo, no
to complicado e voc ver mais tarde como isso pode ser til.
Este exemplo claramente demonstra que o sinal de igual, em programao, no o mesmo sinal de igual
que voc aprendeu em matemtica. Em matemtica, x = x + 1 impossvel (um nmero no pode ser igual
a si mesmo mais um). J em uma linguagem de programao como o SuperCollider, o sinal de igual pode ser
entendido como um tipo de ao: pegue o resultado da expresso direita do smbolo e o "atribua" varivel ao
lado esquerdo.
16
Parte II
PATTERNS
13
A famlia Pattern
Vamos experimentar algo diferente agora. Digite e rode esta linha de cdigo:
1
13.1
Conhea o Pbind
Pbind(\degree, 0).play;
A nica coisa que esta linha de cdigo faz na vida tocar a nota d central, uma vez por
segundo. A palavra-chave \degree se refere a graus de uma escala e o nmero 0 representa o
primeiro grau da escala (uma escala de D Maior subentendida, ento esta a prpria nota
d). Note que o SuperCollider comea a contar as coisas do 0 e no do 1. Em uma linha simples
como esta acima, as notas d, r, mi, f, sol. . . seriam representadas pelos nmeros 0, 1, 2, 3,
4. . . Tente mudar o nmero e perceba como a nota muda quando voc reexecuta. Voc tambm
pode escolher notas abaixo do d central (por exemplo, -2 a nota l abaixo do d central).
Resumindo, apenas imagine que o d central do piano 0 e conte teclas brancas para cima ou
para baixo (nmeros positivos ou negativos) para obter qualquer outra nota.
17
Agora brinque um pouco com a durao das notas. Pbind usa a palavra-chave \dur para
especificar duraes em segundos:
1
Claro que isso ainda muito rgido e inflexvelsempre a mesma nota, sempre a mesma
durao. No se preocupe: as coisas vo esquentar logo, logo.
13.2
Pseq
Vamos agora tocar vrias notas em sequncia, como uma escala. Vamos tambm diminuir a
durao das notas para 0.2 segundos.
1
Esta linha introduz um novo membro da famlia Pattern: Pseq. Como o nome sugere, este
Pattern lida com sequncias. Tudo que um Pseq precisa para tocar uma sequncia :
uma lista de itens entre colchetes []
um nmero de repeties.
No exemplo, a lista [0, 1, 2, 3, 4, 5, 6, 7] e o nmero de repeties 1. Este Pseq
simplesmente diz: "toque todos os itens da lista, na sequncia, uma vez". Repare que estes dois
elementos, lista e nmero de repeties, esto dentro dos parnteses que pertencem ao Pseq e
so separados por uma vrgula.
Veja tambm onde o Pseq aparece no interior do Pbind: colocado como valor de \degree.
Isso importante: em vez de fornecer um nmero nico e fixo para o grau da escala (como
no nosso primeiro Pbind simples), estamos fornecendo todo um Pseq: uma receita para uma
sequncia de nmeros. Com isto em mente, podemos facilmente expandir esta ideia e usar outro
Pseq para controlar tambm as duraes.
18
13.3
Voc deve ter percebido que a linha de cdigo acima um tanto longa. De fato, ela to longa
que quebra em uma nova linha, mesmo que tecnicamente se trate de um enunciado nico. Linhas
de cdigo longas podem ser confusas de ler. Para evitar isso, uma prtica comum quebrar o
19
cdigo em vrias linhas indentadas; com o objetivo de torn-lo o mais claro e inteligvel possvel.
O mesmo Pbind pode ser escrito assim:
1
2
3
4
5
6
(
Pbind(
\degree, Pseq([0, 1, 2, 3, 4, 5, 6, 7], 5),
\dur, Pseq([0.2, 0.1, 0.1, 0.2, 0.2, 0.35], inf)
).play;
)
De agora em diante, adquira o hbito de escrever seus Pbinds deste jeito. Escrever cdigo
com uma aparncia arrumada e bem organizada vai ajud-lo bastante no aprendizado do SuperCollider.
Alm disso, perceba que envolvemos este Pbind dentro de parnteses para criar um bloco de
cdigo (lembra-se da seo 9?): como ele no est mais em uma nica linha, precisamos fazer
isso para conseguir rod-lo todo de uma vez. Lembre-se que o cursor precisa estar em algum
lugar no interior do bloco antes de execut-lo.
13.4
Pbind(\degree, 5).play;
Pbind(\note, 9).play;
Pbind(\midinote, 69).play;
Pbind(\freq, 440).play;
DICA: Lembre-se que cada maneira de especificar alturas requer nmeros em mbitos diferentes. Uma lista de nmeros como [-1, 0, 1, 3] faz sentido para \degree e \note, mas
no faz sentido para \midinote ou \freq. A tabela abaixo compara alguns valores usando o
teclado do piano como referncia.
21
\degree
\note
\midinote
\freq
13.5
d 4
0
0
60
261.6
l 4
5
9
69
440
d 5
7
12
72
523.2
d 8
21
48
108
4186
O novo exemplo introduz duas novas palavras-chave: \amp e \legato, que definem a amplitude
dos eventos e a quantidade de legato entre as notas. Perceba como o cdigo fica bem mais fcil
de ler, graas a uma boa indentao e distribuio em vrias linhas. Parnteses externos (no
topo e embaixo) so usados para delimitar um bloco de cdigo a ser executado de uma vez.
1
2
3
4
5
6
7
8
(
Pbind(
\degree, Pseq([0, 1, 2, 3, 4, 3, 7, 11, 4, 2, 0, 3], 5),
\dur, Pseq([0.2, 0.1, 0.1], inf),
\amp, Pseq([0.7, 0.5, 0.3, 0.2], inf),
\legato, 0.4
).play;
)
Pbind tem muitas destas palavras-chave pr-definidas e, com o tempo, voc aprender mais
delas. Por agora, vamos nos centrar em apenas algumasuma para altura (com as opes
de \degree, \note, \midinote ou \freq), uma para duraes (\dur), uma para amplitude
(\amp) e uma para legato (\legato). Duraes esto em tempos (neste caso, 1 batida por
segundo, que o padro); a amplitude deve estar entre 0 e 1 (0 = silncio, 1 = muito alto); e
o legato funciona melhor com valores entre 0.1 e 1 (se voc no tem certeza o que o legato faz,
22
simplesmente experimente o exemplo acima com 0.1, depois 0.2, depois 0.3, at chegar no 1 e
oua os resultados).
Tome o ltimo exemplo como um ponto de partida e crie novos Pbinds. Mude a melodia.
Introduza novas listas de duraes e amplitudes. Experimente usar \freq para alturas. Lembrese, voc sempre pode usar um nmero fixo para qualquer um destes parmetros, se quiser. Por
exemplo, se voc quer que todas as notas da sua melodia tenham 0.2 segundos de durao, no h
porque escrever Pseq[0.2, 0.2, 0.2, 0.2..., nem mesmo Pseq([0.2], inf)simplesmente
remova toda a estrutura do Pseq e escreva 0.2 no lugar.
13.6
Prand
Prand um parente prximo do Pseq. Ele tambm aceita uma lista e um nmero de repeties.
Mas em vez de ir tocando a lista na sequncia, Prand escolhe um item aleatrio da lista a cada
vez. Experimente:
1
2
3
4
5
6
7
8
(
Pbind(
\degree, Prand([2, 3, 4, 5, 6], inf),
\dur, 0.15,
\amp, 0.2,
\legato, 0.1
).play;
)
Substitua Prand pelo Pseq e compare os resultados. Agora experimente usar Prand para
duraes, amplitudes e legato.
23
13.7
Pwhite
(
Pbind(
\freq, Pwhite(100, 500),
\dur, Prand([0.15, 0.25, 0.3], inf),
\amp, 0.2,
\legato, 0.3
).trace.play;
)
O exemplo acima tambm mostra outro truque til: a mensagem trace logo antes de play.
Isso imprime na Post window os valores selecionados em cada evento. Muito til para corrigir
problemas ou simplesmente para entender o que est acontecendo!
Preste ateno nas diferenas entre Pwhite e Prand: mesmo que ambos tenham a ver com
aleatoriedade, eles aceitam argumentos distintos e fazem coisas diferentes. Dentro dos parnteses
do Pwhite voc s precisa fornecer um limite mnimo e mximo: Pwhite(mnimo, mximo).
Nmeros aleatrios sero escolhidos no interior deste mbito. Prand, por outro lado, aceita uma
lista de itens (necessariamente entre colchetes) e um nmero de repeties: Prand([lista, de,
itens], repeties). Itens aleatrios sero escolhidos desta lista.
Explore ambos e confirme que voc entendeu completamente a diferena.
24
DICA: Um Pwhite com dois nmeros inteiros vai gerar somente nmeros inteiros. Por exemplo, Pwhite(100, 500) vai gerar nmeros como 145, 568, 700, mas no 145.6, 450.32, etc. Se
voc quer incluir nmeros decimais no resultado, escreva Pwhite(100, 500.0). Isso muito
til para, digamos, amplitudes: se voc escreve Pwhite(0, 1) vai obter apenas 0 ou 1, mas
escreva Pwhite(0, 1.0) e voc ter todos os resultados intermedirios.
Tente as seguintes perguntas para testar seu novo conhecimento:
a) Qual a diferena entre os resultados de Pwhite(0, 10) e Prand([0, 4, 1, 5, 9, 10, 2,
3], inf)?
b) Se voc precisa de um fluxo de nmeros inteiros escolhidos aleatoriamente entre 0 e 100, voc
poderia usar um Prand?
c) Qual a diferena entre os resultados de Pwhite(0, 3) e Prand([0, 1, 2, 3], inf)? E se
voc escrever Pwhite(0, 3.0)?
d) Rode os exemplos abaixo. Usamos \note em vez de \degree para tocar uma escala de d
menor (que inclui teclas pretas). A lista [0, 2, 3, 5, 7, 8, 11, 12] tem oito nmeros
dentro dela, correspondendo s notas d, r, mi[, f, sol, l[, si, d, mas quantos eventos cada
exemplo realmente toca? Por qu?
1
2
3
4
5
6
7
// Pseq
(
Pbind(
\note, Pseq([0, 2, 3, 5, 7, 8, 11, 12], 4),
\dur, 0.15;
).play;
)
25
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Pseq
(
Pbind(
\note, Prand([0, 2, 3, 5, 7, 8, 11, 12], 4),
\dur, 0.15;
).play;
)
// Pwhite
(
Pbind(
\note, Pseq([0, 2, 3, 5, 7, 8, 11, 12], 4),
\dur, Pwhite(0.15, 0.5);
).play;
)
13.8
A partir de agora, voc j deve ser capaz de escrever Pbinds simples por conta prpria. Voc
sabe especificar alturas, duraes, amplitudes, valores de legato e voc sabe como embutir outros
Patterns (Pseq, Prand, Pwhite) para gerar mudanas interessantes de parmetros.
26
Esta seo ir expandir um pouco seu vocabulrio de Patterns. Os exemplos abaixo introduzem seis novos membros da famlia Pattern. Tente descobrir por voc mesmo o que eles fazem.
Use as seguintes estratgias:
Escute a melodia resultante; descreva e analise o que voc ouve;
Olhe para o nome do Pattern: ele sugere algo? (por exemplo, Pshuf pode lembr-lo da
palavra "shuffle", embaralhar);
Olhe para os argumentos (nmeros) dentro do novo Pattern;
Use .trace.play como vimos antes para observar os valores sendo impressos na Post
window;
Finalmente, confirme suas especulaes consultando os arquivos de Ajuda (selecione o nome
do Pattern e aperte [ctrl+D] para abrir o arquivo de Ajuda correspondente).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
27
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
28
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
Pratique usar estes Patternsvoc pode fazer muitas coisas com eles. Pbinds so como receitas para partituras musicais, com a vantagem que voc no est limitado a escrever sequncias
fixas de notas e ritmos: voc pode descrever processos de parmetros musicais em constante
mudana (s vezes isto chamado "composio algortmica"). E isso apenas um aspecto das
capacidades poderosas da famlia Pattern.
No futuro, quando voc sentir a necessidade de mais objetos Pattern, consulte o "Practical
Guide to Patterns"de James Harkins, disponvel nos arquivos de Ajuda do SC.
29
14
14.1
Acordes
Quer escrever acordes dentro de Pbinds? Escreva-os como listas (valores separados por vrgula
entre colchetes):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
(
Pbind(
\note, Pseq([[0, 3, 7], [2, 5, 8], [3, 7, 10], [5, 8, 12]], 3),
\dur, 0.15
).play;
)
// Mais um recurso legal: "strum" ("dedilhar")
(
Pbind(
\note, Pseq([[7, 3, 7, 10], [0, 3, 5, 8]], 2),
\dur, 1,
\legato, 0.4,
\strum, 0.1 // experimente 0, 0.1, 0.2, etc
).play;
)
14.2
Escalas
Quando estiver usando \degree ("grau") para especificar alturas, voc pode acrescentar uma
linha com a palavra-chave \scale ("escala") para escolher a escala (nota: isso s funciona em
conjuno com \degree, no com \note, \midinote ou \freq):
1
2
(
Pbind(
30
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
\scale, Scale.harmonicMinor,
\degree, Pseq([0, 1, 2, 3, 4, 5, 6, 7], 1),
\dur, 0.15;
).play;
)
// Execute esta linha para ver uma lista de todas as escalas disponveis:
Scale.directory;
// Se voc precisa de uma nota cromtica entre dois graus da escala, faa assim:
(
Pbind(
\degree, Pseq([0, 1, 2, 3, 3.1, 4], 1),
).play;
)
// O 3.1 acima quer dizer um passo cromtico sobre o grau 3 da escala (neste caso,
// f# acima do f). Note que quando voc no especifica
// explicitamente uma escala \scale, Scale.major subentendida.
14.3
Transposio
Use a palavra-chave \ctranspose para realizar uma transposio cromtica. Isso funciona em
conjunto com \degree, \note e \midinote, mas no com \freq.
1
2
3
4
5
6
(
Pbind(
\note, Pser([0, 2, 3, 5, 7, 8, 11, 12], 11),
\ctranspose, 12, // transpor oitava acima (= 12 semitons)
\dur, 0.15;
).play;
31
14.4
Microtons
14.5
Andamento
Os valores que voc fornece para a palavra-chave \dur de um Pbind esto em nmero de tempos,
isto , 1 significa um tempo, 0.5 significa meio tempo e assim por diante. A no ser que voc
especifique outra coisa, o tempo padro 60 BPM (batidas por minuto). Para tocar em um
andamento diferente, simplesmente crie um novo TempoClock. Aqui est um Pbind tocando a
120 batidas por minuto (BPM):
1
2
3
4
5
(
Pbind(\degree, Pseq([0, 0.1, 1, 2, 3, 4, 5, 6, 7]),
\dur, 1;
).play(TempoClock(120/60)); // 120 batidas em 60 segundos: 120 BPM
)
Por acaso, voc percebeu que o Pseq recebeu um nico argumento (a lista)? Onde est o valor
repeats que sempre veio aps a lista? Voc pode ouvir que o exemplo toca a sequncia apenas
uma vez, mas por qu? Est uma propriedade comum a todos os Patterns (e tambm de muitos
outros objetos dentro do SuperCollider): se voc omite um argumento, ser utilizado um valor
32
padro que j vem embutido. Neste caso, o repeats padro para Pseq 1. Lembra-se do seu
primeiro Pbind ridiculamente simples? Era um mero Pbind(\degree, 0).play e ele somente
sabia tocar uma nota. Voc no forneceu nenhuma informao para durao, amplitude, legato,
etc. Nestes casos, o Pbind simplesmente usa os valores padro.
14.6
Pausas
Veja abaixo como escrever pausas. O nmero dentro de Rest a durao da pausa em tempos.
Pausas podem estar em qualquer lugar no Pbind, no somente na linha \dur.
1
2
3
4
5
6
(
Pbind(
\degree, Pwhite(0, 10),
\dur, Pseq([0.1, 0.1, 0.3, 0.6, Rest(0.3), 0.25], inf);
).play;
)
14.7
Para disparar alguns Pbinds simultaneamente, simplesmente ponha todos eles em um nico bloco
de cdigo:
1
2
3
4
5
6
7
8
33
9
10
11
12
13
14
15
16
17
18
19
Para tocar Pbinds de uma maneira temporalmente ordenada (em vez de simplesmente executlos manualmente um aps o outro), voc pode usar { }.fork [N.T.: "garfo", uma maneira
abreviada de criar rotinas de programao]:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
34
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
\dur, 1/6,
\amp, Pseq([0.05, 0.03], inf)
).play(t);
2.wait;
Pbind(
\note, Pseq([[25, 13, 1], [20, 8, 4], \rest], 3),
\dur, Pseq([1, 1, Rest(1)], inf),
\amp, 0.1,
\legato, Pseq([0.4, 0.7, \rest], inf)
).play(t);
2.75.wait;
Pbind(
\note, Pseq([23, 21, 25, 23, 21, 20, 18, 16, 20, 21, 23, 21], inf),
\dur, Pseq([0.25, 0.75, 0.25, 1.75, 0.125, 0.125, 0.80, 0.20, 0.125,
0.125, 1], 1),
\amp, 0.1,
\legato, 0.5
).play(t);
}.fork(t);
)
35
14.8
Usando variveis
Na seo anterior, "Expandindo seu vocabulrio de Patterns", voc percebeu quantas vezes teve
que digitar a mesma lista de notas [0, 2, 3, 5, 7, 8, 11, 12] em vrios Pbinds? No muito
eficiente ficar copiando a mesma coisa mo, certo? Em programao, sempre que voc se vir
fazendo a mesma tarefa repetidas vezes, provavelmente hora de adotar uma estratgia mais
eficiente para chegar ao mesmo objetivo. Neste caso, podemos usar variveis. Como voc deve
se lembrar, variveis permitem que voc se refira a qualquer conjunto de dados de uma maneira
flexvel e concisa (releia a seo 12 se necessrio). Aqui est um exemplo:
1
2
3
4
5
6
7
Outro exemplo para praticar o uso de variveis: digamos voc queira tocar dois Pbinds
simultaneamente. Um deles toca uma escala maior ascendente e o outro toca uma escala maior
descedente uma oitava acima. Ambos usam a mesma lista de duraes. Eis um jeito de escrever
isso:
1
2
3
4
5
6
7
8
36
9
10
11
12
13
Pbind(
\degree, Pseq(~escala.reverse + 7),
\dur, Pseq(~durs)
).play;
)
15
Est uma dvida muito comum que surge com Pbinds, especialmente os que rodam para sempre
com inf: como posso parar e iniciar Pbinds quando eu quiser? A resposta envolver o uso de
variveis e veremos um exemplo completo em breve, mas antes de chegarmos l, precisamos
entender um pouco melhor o que acontece quando voc toca um Pbind.
37
15.1
Voc pode imaginar o Pbind como uma espcie de partitura musical: uma receita para fazer
sons, um conjunto de instrues para realizar uma passagem musical. Para que a partitura se
torne msica, voc precisa entreg-la a um intrprete: algum que vai ler a partitura e fazer sons
com base nessas instrues. Vamos separar conceitualmente estes dois momentos: a definio da
partitura e a performance da mesma.
1
2
3
4
5
6
7
8
9
10
// Defina a partitura
(
p = Pbind(
\midinote, Pseq([57, 62, 64, 65, 67, 69], inf),
\dur, 1/7
); // sem .play aqui!
)
// Pea que a partitura seja tocada
p.play;
38
15.2
EventStreamPlayer
Limpe a Post window com [ctrl+shift+P] (no absolutamente necessrio, mas por que no?)
e rode p.play novamente. Olhe para a Post window e voc ver que o resultado algo chamado
EventStreamPlayer ("Tocador de fluxo de eventos"). Toda vez que voc chama um .play em
um Pbind, o SuperCollider cria um tocador que realiza aquela ao: o EventStreamPlayer
isso. como ter um pianista se materializando na sua frente toda vez que voc disser "Eu quero
que esta partitura seja tocada agora". Legal, n?
Bem, sim, exceto pelo fato de que depois que este tocador virtual annimo aparece e comea
seu trabalho, voc no tem mais como se dirigir a eleele no tem nome. Em termos ligeiramente
mais tcnicos, voc criou um objeto, mas voc no tem como se referir a este objeto depois.
Talvez neste ponto voc j possa entender porque p.stop no funciona: como tentar falar com
a partitura em vez de falar com o tocador. A partitura (o Pbind armazenado na varivel p) no
sabe nada sobre comear ou parar: ela s uma receita. O tocador quem sabe ler a partitura,
toc-la, parar, "por favor volte pro comeo", etc. Em outras palavras, voc tem que falar com
o EventStreamPlayer. Tudo que voc precisa fazer dar um nome a ele, ou seja, armanzen-lo
em uma varivel:
1
2
3
4
5
6
7
15.3
Exemplo
Aqui temos um exemplo mais complexo para finalizar esta seo. A melodia principal emprestada do "lbum para a Juventude"de Tchaikovsky e uma melodia mais grave adicionada em
contraponto. A figura 3 mostra a passagem em notao musical.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Defina a partitura
(
var minhasDurs = Pseq([Pn(1, 5), 3, Pn(1, 5), 3,
inf) * 0.4;
~melodiaSuperior = Pbind(
\midinote, Pseq([69, 74, 76, 77, 79, 81,
82, 81, 79, 77, 76, 74, 74], inf),
\dur, minhasDurs
);
~melodiaInferior = Pbind(
\midinote, Pseq([57, 62, 61, 60, 59, 58,
55, 53, 52, 53, 55, 57, 58, 61, 62,
\dur, minhasDurs
);
)
// Toque as duas juntas:
(
~tocador1 = ~melodiaSuperior.play;
~tocador2 = ~melodiaInferior.play;
)
// Pareos separadamente:
~tocador1.stop;
~tocador2.stop;
// Outras mensagens disponveis
~tocador1.resume; // retomar
~tocador1.reset; // voltar do incio
40
24
25
~tocador1.play;
~tocador1.start; // mesmo que .play
44
4
4
superior e a este tocador dado o nome tocador1. A mesma ideia vale para o tocador2.
Graas a isso, podemos falar com cada tocador e pedi-lo para parar, iniciar, retomar, etc.
Mesmo correndo o risco de sermos chatos, vamos reiterar uma ltima vez:
Um Pbind s uma receita para fazer som, como uma partitura musical;
Quando voc chama a mensagem play em um Pbind, um objeto EventStreamPlayer
criado;
Se voc armazena este EventStreamPlayer em uma varivel, voc pode acess-lo mais
tarde para usar comandos como stop e resume.
42
Parte III
SuperCollider uma linguagem de programao orientada a objetos, como Java ou C++. Est
alm do escopo deste tutorial explicar o que isso significa, ento deixaremos voc pesquisar isso
na internet se tiver curiosidade. Aqui vamos apenas explicar alguns conceitos bsicos que voc
precisa saber para entender melhor esta nova linguagem que voc est aprendendo.
Tudo no SuperCollider um objeto. Mesmo simples nmeros so objetos no SC. Diferentes
objetos se comportam de diferentes maneiras e armazenam diferentes tipos de informao. Voc
pode solicitar uma informao ou ao de um objeto enviando uma mensagem para ele. Quando
voc escreve algo como 2.squared, a mensagem squared est sendo enviada para o objeto 2, que
a recebe (por isso vamos cham-lo de "objeto recebedor", traduo do ingls "receiver object").
O ponto entre o objeto e a mensagem faz a conexo entre os dois. A propsito, mensagens
tambm so chamadas mtodos.
Objetos so especificados hierarquicamente em classes. O SuperCollider vem com uma imensa
coleo de classes pr-definidas, cada uma com seu prprio conjunto de mtodos.
Eis uma analogia pra ajudar a entender isso. Imaginemos que h uma classe abstrata de
objetos chamada Animal. A classe Animal define alguns mtodos (mensagens) comuns a todos
os animais. Mtodos como mover, comer, dormir fariam o Animal realizar uma ao especfica.
Da poderamos imaginar duas subclasses de Animal: uma chamada Domstico outra chamada
Selvagem. Cada uma destas subclasses poderia ter ainda mais subclasses derivadas destas (como
Cachorro e Gato, derivados de Domstico). Subclasses herdam todos os mtodos de suas classesme e implementam novos mtodos prprios para atributos especializados. Por exemplo, tanto
43
[1, 2, 3, "uau"].reverse;
"al".dup(4);
3.1415.round(0.1); // note que o primeiro ponto a separao decimal de 3.1415 [N.T
.: Ateno: o SC separa casas decimais com ponto! Vrgulas tm outros usos.]
100.rand; // rode esta linha diversas vezes;
// Encadear mensagens divertido:
100.0.rand.round(0.01).dup(4);
44
17
H mais de uma maneira de escrever expresses no SuperCollider. A que vimos acima chamada
notao de objeto recebedor ("receiver notation"): 100.rand, na qual um ponto conecta o Objeto
100 mensagem rand. Alternativamente, a mesmssima coisa pode ser escrita assim: rand(100).
Isso chamado notao funcional ("functional notation").
Voc pode escrever das duas formas. Eis como isso funciona quando uma mensagem recebe
dois ou mais argumentos.
1
2
3
4
45
Nos exemplos acima, voc pode ler dup(5, 20) como "faa duplicatas do nmero 5 vinte
vezes"e round(3.1415, 0.1) como "arredonde o nmero 3.1415 para uma casa decimal". Por
sua vez, as verses em notao de objeto recebedor podem ser lidas como "Nmero 5, faa
duplicatas de si mesmo vinte vezes!"(para 5.dup(20)) e "Nmero 3.1415, arredonde-se para
uma casa decimal! (para 3.1415.round(0.1)).
Resumindo: Recebedor.mensagem(argumento) equivalente a mensagem(Recebedor, argumento).
Escolher um estilo de escrita em vez do outro uma questo de preferncia pessoal e conveno. s vezes um mtodo pode ser mais claro que o outro. Qualquer que seja o estilo que
voc acabe preferindo (e tudo bem mistur-los), o importante ser consistente. Uma conveno que muito difundida entre usurios de SuperCollider que classes (palavras que comeam
com letras maisculas) so quase sempre escritas como Recebedor.mensagem(argumento). Por
exemplo, voc sempre ver SinOsc.ar(440), mas quase nunca ver ar(SinOsc, 440), embora
ambas estejam corretas.
Exerccio: reescreva a seguinte sentena usando apenas notao funcional:
100.0.rand.round(0.01).dup(4);
Soluo ao final.4
18
Aninhamento
A soluo do ltimo exerccio levou voc a aninhar coisas uma dentro da outra, isso , voc
colocou o rand dentro do round que por sua vez foi pra dentro do dup. David Cottle tem
uma explicao excelente para aninhamento no The SuperCollider Book, ento simplesmente o
citaremos aqui.
Cottle, D. Beginners Tutorial. The SuperCollider Book, MIT Press, 2011, pp. 8-9.
46
47
Quando o aninhamento tem diversos nveis, podemos usar novas linhas e indentaes para uma maior clareza. Algumas mensagens e argumentos podem permanecer
na mesma linha, enquanto outras mensagens e argumentos podem distribudos um
em cada linhao que quer seja mais claro. Cada nvel de indentao deve indicar
um nvel de aninhamento. (Note que voc pode ter qualquer quantidade de espao em
branconovas linhas, tabulaes e espaosentre trechos de cdigo.)
[No exemplo do jantar,] agora pede-se ao programa de refeies que ele lave a alface
em gua por 10 minutos e pique o tomate em pequenos pedaos antes de mistur-los
na travessa da salada e salpic-los com queijo. Voc tambm especificou onde pegar
o peixe e pediu para ass-lo a 200 graus por 20 minutos antes de servir, e assim por
diante. Para "ler"este estilo de cdigo, voc comea da mensagem aninhada mais
interna e vai seguindo para fora camada por camada. Aqui est um exemplo alinhado
de maneira a mostrar como a mensagem mais interna aninhada dentro das outras
mensagens.
1
2
3
4
exprand(1.0,
dup({exprand(1.0,
sort(dup({exprand(1.0,
round(sort(dup({exprand(1.0,
1000.0);
1000.0)}, 100);
1000.0)}, 100));
1000.0)}, 100)), 0.01);
48
4
5
6
7
8
9
10
11
12
13
14
15
CombN.ar(
SinOsc.ar(
midicps(
LFNoise1.ar(3, 24,
LFSaw.ar([5, 5.123], 0, 3, 80)
)
),
0, 0.4
),
1, 0.3, 2)
}.play;
)
49
19
Fechamentos
19.1
Aspas duplas
Aspas duplas so usadas para definir uma sequncia de caracteres (incluindo espaos) como uma
coisa nica. Estas so chamadas Strings ("cadeias"). Aspas simples criam Smbolos ("Symbols"), que so ligeiramente diferentes de Strings. Smbolos tambm podem ser criados com uma
barra invertida imediatamente antes do texto. Portanto, queSimbolo and \queSimbolo so
equivalentes.
1
2
19.2
Parnteses
19.3
Colchetes
Colchetes definem uma coleo de itens, como [1, 2, 3, 4, "oi"]. Estas so normalmente
chamadas Arrays. Um array pode conter qualquer coisa: nmeros, strings, funes, Patterns,
etc. Arrays entendem mensagens como reverse ("inverter"), scramble ("embaralhar"), mirror
("espelhar"), choose ("escolher"), para dar alguns exemplos. Voc tambm pode fazer operaes
matemticas em arrays.
1
2
3
4
5
[1, 2, 3, 4, "oi"].scramble;
[1, 2, 3, 4, "oi"].mirror;
[1, 2, 3, 4].reverse + 10;
// converter notas MIDI para frequncias em Hz
[60, 62, 64, 65, 67, 69, 71].midicps.round(0.1);
19.4
Chaves
Chaves definem funes. Funes encapsulam algum tipo de operao ou tarefa que ser provavelmente reutilizada mltiplas vezes, possivelmente retornando diferentes resultados a cada vez.
O exemplo abaixo do The SuperCollider Book:
1
2
exprand(1, 1000.0);
{exprand(1, 1000.0)};
51
David Cottle nos explica passo a passo esse exemplo: "a primeira linha seleciona um nmero
aleatrio, que mostrado na Post window. A segunda linha imprime um resultado bastante
diferente: uma funo. O que essa funo faz? Ela seleciona um nmero aleatrio. Como
pode esta diferena afetar o cdigo? Considere as linhas abaixo. A primeira escolhe um nmero
aleatrio e o duplica. A segunda executa cinco vezes a funo-seletora-de-nmeros-aleatrios e
coleta os resultados em um array."
1
2
3
4
5
Mais sobre funes em breve. Por ora, aqui est um resumo de todos os fechamentos possveis:
Colees [lista, de, itens]
Funes { operaes a serem executadas }
Strings "palavras entre aspas"
Smbolos aspasSimples ou precedidas de uma \barraInvertida
20
Se estiver chovendo, saio com um guarda-chuva. Se estiver sol, saio com meus culos escuros.
Nosso dia-a-dia est repleto desse tipo de tomada de deciso. Em programao, estes so os
Cottle, D. Beginners Tutorial. The SuperCollider Book, MIT Press, 2011, p. 13.
52
momentos em que o seu cdigo tem de testar alguma condio e realizar aes diferentes dependendo do resultado do teste (verdadeiro ou falso). H muitos tipos de estruturas condicionais.
Vamos dar uma olhada em dois casos simples: if/else ("se/seno") e case ("no caso de").
A sintaxe de um if/else no SC : if(condition, {true action}, {false action}). A condio um teste booleano, ou seja, precisa retornar um true ("verdadeiro") ou false ("falso").
Se o teste retorna verdadeiro, a primeira funo executada. Se no for verdadeiro, roda-se a
segunda. Experimente:
1
2
// if / else
if(100 > 50, { "muito verdadeiro".postln }, { "muito falso".postln });
A tabela abaixo, emprestada do The SuperCollider Book , apresenta alguns operadores booleanos comuns que podem ser usados. Note a distino entre um sinal de igual simples (x = 10)
e o sinal de igual duplo (x == 10). O simples significa "atribua 10 varivel x,"ao passo que o
duplo significa " x igual a 10? "Digite e rode alguns exemplos da coluna de verdadeiro ou falso
e voc ver parecerem os resultados true ou false aparecerem na Post window.
53
Smbolo
==
!=
>
<
>=
<=
odd
even
isInteger
isFloat
and
or
Significado
igual a?
diferente de?
maior que?
menor que?
maior ou igual a?
menor ou igual a?
mpar?
par?
um nmero inteiro?
um nmero decimal?
ambas as condies
uma das condies
Exemplo verdadeiro
10 == 10
10 != 99
10 > 5
10 < 99
10 >= 10, 10 >= 3
10 <= 99, 10 <= 10
15.odd
22.even
3.isInteger
3.1415.isFloat
11.odd.and(12.even)
or(1.odd, 1.even)
Exemplo falso
10 == 99
10 != 10
10 > 99
10 < 5
10 >= 99
10 <= 9
16.odd
21.even
3.1415.isInteger
3.isFloat
11.odd.and(13.even)
or(2.odd, 1.even)
As ltimas duas linhas (and, or) mostram como escrever as expresses mais longas tanto em
notao de objeto recebedor quanto em notao funcional.
Outra estrutura til case. Ela funciona definindo pares de funes a serem executadas em
ordem at que um dos testes retorne verdadeiro:
case
{teste1} {ao1}
{teste2} {ao2}
{teste3} {ao3}
...
{testeN} {aoN};
A expresso dentro de cada teste tem de retornar ou true ou false. Se o teste1 retorna
falso, o programa ignora a ao1 e segue para o teste2. Se teste2 for um falso de novo, ao2
54
tambm ignorada e seguimos para o teste3. Se este for verdadeiro, ento a ao3 executada
e o case se encerra ali (mais nenhum teste ou ao executado). Note que no h vrgulas entre
as funes. Simplesmente use um ponto-e-vrgula no fim para marcar o final do enunciado case.
1
2
3
4
5
6
7
8
9
10
// case
(
~num = 2;
case
{~num == 0} {"UAU".postln}
{~num == 1} {"UM!".postln}
{~num < 0} {"nmero negativo!".postln}
{true} {"em ltimo caso".postln};
)
Tente modificar o cdigo acima para obter todos os resultados possveis. Perceba o truque til
(e opcional) na ltima linha de case no exemplo acima: como true sempre retorna verdadeiro,
pode-se definir uma ao para acontecer "em ltimo caso"que vai sempre ocorrer, mesmo no caso
de todas as condies anteriores serem falsas.
Para saber mais, verifique o arquivo de ajuda de Control Structures ("Estruturas de Controle").
21
Funes
Quando voc se pegar repetindo a mesma tarefa diversas vezes, talvez seja um bom momento
para criar uma funo reutilizvel. Uma funo, como voc aprendeu na seo de Fechamentos,
algo escrito entre chaves. David Touretzky introduz a ideia de funo da seguinte forma: "pense
na funo como uma caixa atravs da qual os dados passam. Essa funo opera sobre os dados
55
f = { 2 + 2 }; // define a funo
f.value; // pe a funo para trabalhar
A funo acima no l muito til, pois sabe fazer uma coisa s (somar 2 e 2). Normalmente
a gente quer definir funes que possam dar diferentes resultados dependendo dos argumentos
de entrada fornecidos. Ns usamos a palavra-chave arg para especificar as entradas que uma
funo vai aceitar. O exemplo abaixo mais parecido com o desenho da figura 5.
1
2
3
4
5
6
7
8
f = {arg a, b; ["a mais b", a+b, "a vezes b", a*b].postln}; // define funo
f.value(3, 7); // fornea dois nmeros quaisquer como argumentos para a funo
f.value(10, 14);
// Compare:
~aleaTonto = rrand(0, 10); // no uma funo
~aleaTonto.value; // execute diversas vezes
~aleaTonto2 = {rrand(0, 10)}; // uma funo
Touretzky, David. COMMON LISP: A Gentle Introduction to Symbolic Computation. The Benjamin/Cummings Publishing Company, Inc, 1990, p. 1. Este o livro que inspirou o ttulo original em ingls deste
tutorial.
56
17
18
19
20
21
22
// Use esta funo para decidir como passar seus dias de vero
(
~oQueFazer = {
var hoje, nomeDoDia, acoes;
hoje = Date.getDate.dayOfWeek;
nomeDoDia =
case
{hoje==0} {"Domingo"}
{hoje==1} {"Segunda"}
{hoje==2} {"Tera"}
{hoje==3} {"Quarta"}
{hoje==4} {"Quinta"}
{hoje==5} {"Sexta"}
{hoje==6} {"Sbado"};
acoes = ["jogar bumerangue", "queda de brao", "subir escadas", "jogar
xadrez", "basquete subaqutico", "arremesso de ervilhas", "longa soneca"
];
"Ah, " ++ nomeDoDia ++ "...! " ++ "Que timo dia para " ++ acoes.choose;
};
)
// Execute pela manh
~oQueFazer.value;
DICA: Outra notao comum para declarar argumentos no incio de uma Funo : f =
{|a, b| a + b}. Isso equivalente a f = {arg a, b; a + b}
57
22
Arrays [N.T.: em computao, o termo "array"pode ser traduzido como "vetor", mas comum
mant-lo no original] so o tipo mais comum de coleo no SuperCollider. Toda vez que voc
escreve uma coleo de itens entre colchetes, como [0, 1, 2], cria uma instncia da classe
Array. Frequentemente, voc se ver manipulando arrays de diversas formas. Aqui est uma
pequena seleo de mtodos interessantes que arrays entendem:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Criar um array
a = [10, 11, 12, 13, 14, 15, 16, 17];
a.reverse; // inverter
a.scramble; // embaralhar
a.choose; // escolher um elemento ao acaso
a.size; // retorna o tamanho do array
a.at(0); // recupera um item na posio especificada
a[0]; // o mesmo que acima
a.wrapAt(9); // recupera item na posio especificada, relendo do incio se > a.size
["wow", 99] ++ a; // concatena dois arrays em uma novo
a ++ \oi; // um Smbolo entendido como um nico caracter
a ++ 'oi'; // o mesmo que acima
a ++ "oi"; // uma cadeia ("String") entendida como uma coleo de caracteres
a.add(44); // cria um novo array adicionando o novo elemento ao final
a.insert(5, "uau"); // insere "uau" na posio 5, empurra itens seguintes para a
frente (retorna um novo array)
a; // rode isso e veja que nenhuma das operaes acima mudou o array original
a.put(2, "oops"); // colocar "oops" no ndice 2 (destrutivo; volte a rodar a linha
acima para verificar)
a.permute(3); // permutar: item na posio 3 vai para a posio zero, e viceversa
a.mirror; // faz um palndromo
a.powerset; // retorna todas as possveis combinaes dos elementos do array
58
[1, 2, 3, 4, 5] + 10;
[1, 2, 3, 4, 5] * 10;
([1, 2, 3, 4, 5] / 7).round(0.01); // note o uso de parnteses para precedncia
x = 11; y = 12; // experimente algumas variveis
[x, y, 9] * 100;
// mas garanta que voc s faa contas com nmeros de verdade
[1, 2, 3, 4, "oops", 11] + 10; // resultado estranho
22.1
Aqui h algumas maneiras de usar a classe Array para criar novas colees:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
59
17
18
19
20
22.2
s uma questo de tempo at que voc veja algo como 30!4 no cdigo de algum. Essa notao
abreviada simplesmente cria uma array contendo o mesmo item um determinado nmero de vezes:
1
2
3
4
5
6
7
8
9
// Notao abreviada:
30!4;
"al" ! 10;
// D o mesmo resultado que o seguinte:
30.dup(4);
"al".dup(10);
// ou
Array.fill(4, 30);
Array.fill(10, "al");
22.3
Aqui est mais uma sintaxe abreviada muito usada para criar arrays.
1
2
3
4
5
6
60
7
8
9
10
11
12
Note que cada comando implica um jeito de pensar ligeiramente diferente. O (50..79)
permite que voc pense assim: "me d um array de 50 a 79."Voc no precisa necessariamente
pensar a quantidade de itens que a lista vai conter. Por outro lado, Array.series permite
pensar: "me d um array com 30 itens no total, comeando a partir do 50."Voc no precisa
necessariamente pensar qual ser o ltimo nmero da srie.
Tambm note que o atalho usa parnteses, no colchetes. O array resultante, naturalmente,
vir entre colchetes.
22.4
Muitas vezes voc vai precisar realizar alguma operao com cada um dos itens de uma coleo.
Voc pode usar o mtodo do ("faa") para isso:
1
2
3
4
5
6
7
8
9
61
10
~minhasFreqs.squared;
Em resumo: quando voc processa um array com "do", voc fornece uma funo. A mensagem
"do" vai cuidar de executar a funo uma vez para cada item constante do array. A funo pode
receber dois argumentos por definio: o item da vez propriamente dito, e um contador que vai
registrando o nmero de iteraes j realizadas. Os nomes destes argumentos podem ser o que
voc quiser, mas estaro sempre nesta ordem: item, contador.
Veja tambm o mtodo collect, que muito similar ao do, mas retorna uma nova coleo
com todos os resultados intermedirios.
23
Obtendo Ajuda
Aprenda a usar bem os arquivos da Ajuda ("Help"). Muitas vezes, ao final de cada pgina da
Ajuda, h exemplos teis sobre o tpico em questo. Role a pgina para baixo para conferi-los,
mesmo que (ou especialmente se) voc no tenha entendido completamente as explicaes do
texto. Voc pode rodar os exemplos diretamente de pgina de Ajuda do SuperCollider, ou voc
pode copiar e colar o cdigo em uma nova janela para fuar e experimentar mais com ele.
Selecione qualquer classe ou mtodo vlidos no seu cdigo de SuperCollider (um duplo-clique
na palavra ir selecion-la) e aperte [ctrl+D] para abrir o arquivo de Help correspondente. Se
voc selecionar o nome de uma classe (por exemplo, MouseX), voc ser direcionado para o arquivo
de Ajuda da classe. Se voc selecionar um mtodo, voc ser direcionado a uma lista de todas
as classes que entendem aquele mtodo (por exemplo, pea ajuda do mtodo scramble).
Ateno: O SuperCollider vai mostrar em azul qualquer palavra que comea com uma letra maiscula. Isso
significa que a cor azul no garante que a palavra esteja livre de erros: por exemplo, se voc digitar Sinosc (com
o "o"minsculo incorreto), ainda assim a palavra aparece em azul.
62
Outro atalho: se voc quiser explicitamente nomear seus argumentos (como SinOsc.ar(freq:
890)), experimente apertar a tecla Tab logo depois de abrir o parntese. O SC vai autocompletar
para voc com o nome do argumento correto, na ordem, medida que voc digita (aperte Tab
depois da vrgula para os nomes dos argumentos subsequentes).
DICA: Crie uma pasta com seus prprios "arquivos pessoais de ajuda". Sempre que voc
descobrir um novo truque ou aprender um novo objeto, escreva um exemplo simples com explicaes em suas prprias palavras e salve-o para o futuro. Pode apostar que esses arquivos pessoais vo ser muito teis depois de um ms ou um ano, quando voc precisar lembrar
como funciona tal ou qual objeto ou mensagem.
Os arquivos de Ajuda podem ser tambm consultados online: http://doc.sccode.org/.
64
Parte IV
24
UGens
Voc j viu algumas Unidades Geradoras (UGens) em ao nas sees 3 e 18. O que uma
UGen? Uma unidade geradora um objeto que gera sinais sonoros ou sinais de controle. Estes
sinais so sempre calculados no servidor. H muitas classes de unidades geradoras, todas elas
derivando da classe UGen. SinOsc e LFNoise0 so exemplos de UGens. Para mais detalhes, veja
os arquivos de Ajuda chamados "Unit Generators and Synths"e "Tour of UGens".
Quando voc tocou seus Pbinds uns captulos atrs, o som padro era sempre o mesmo: um
sintetizador simples semelhante a um piano. Este sintetizador feito de uma combinao de
unidades geradoras. Voc aprender como combinar unidades geradoras para criar todo tipo
A maioria dos tutoriais comea diretamente com as UGens; nesta introduo ao SC, no entanto, escolhemos
primeiro enfatizar a famlia Pattern (Pbind e sua turma) para uma abordagem pedaggica diferente.
Como voc usou Pbinds at aqui para fazer som no SuperCollider, pode ser tentador pensar: "Entendi, ento
o Pbind uma Unidade Geradora!" No o caso. Pbind no uma Unidade Geradoraele apenas uma receita
65
de instrumentos com sons sintticos e processados. O prximo exemplo parte da nossa primeira
senoide para criar um instrumento eletrnico que voc pode tocar ao vivo com o mouse.
24.1
Aqui est um sintetizador simples que voc pode tocar em tempo real. uma simulao do
Theremin, um dos mais antigos instrumentos eletrnicos:
1
Se voc no sabe o que um Theremim, por favor pare tudo que est fazendo e procure por
"Clara Rockmore Theremin"no YouTube. Depois volte aqui e tente tocar "O Cisne"com o seu
Theremin de SuperCollider.
SinOsc, MouseX e MouseY so UGens. SinOsc est gerando o som da onda senoidal. Os
outros dois esto captando o movimento do seu cursor na tela (X para o movimento horizontal
e Y para o movimento vertical) e usando os nmeros para alimentar os valores de frequncia e
amplitude da senoide. Bem simples, mas j bem divertido!
para fazer eventos musicais (partitura). "Ento o EventStreamPlayer, a coisa que aparece quando eu chamo play
em um Pbind, ISSO deve ser uma UGen!" A resposta ainda no. O EventStreamPlayer apenas o tocador,
como um pianista, e o pianista no gera som. Continuando com esta comparao didtica, o instrumento piano
a coisa que realmente vibra e produz som. Est uma analogia mais adequada para a UGen: no a partitura,
no o tocador: o instrumento. Quando voc fez msica com Pbinds antes, o SC criava um EventStreamPlayer
para tocar sua partitura com seu sintetizador de piano embutido. Voc no tinha de se preocupar em criar o
piano ou algo assimo SuperCollider fez todo o trabalho nos bastidores para voc. Aquele sintetizador de piano
escondido feito de uma combinao de algumas Unidades Geradoras.
66
24.2
O Theremin acima usou um oscilador senoidal. H outras formas de onda que voc pode usar
para fazer som. Rode as linhas abaixoelas usam o conveniente mtodo plot ("grfico")
para olhar a forma do SinOsc e compar-lo com Saw e Pulse. As linhas abaixo no produzem
somelas apenas permitem que voc visualize um trecho da forma de onda.
1
2
3
Agora reescreva sua linha de Theremin, substituindo SinOsc por Saw, depois por Pulse.
Escute como eles soam diferente. Finalmente, experimente .scope em vez de .play no seu
cdigo de Theremin e voc poder ver uma representao da forma de onda em tempo real
(abrir uma janela "Stethoscope", que na realidade um osciloscpio).
25
bastante fcil identificar uma UGen em um cdigo de SuperCollider: elas so quase sempre
seguidas pelas mensagens .ar ou .kr. Estas letras querem dizer Audio Rate ("taxa de udio")
e Control Rate ("taxa de controle"). Vamos ver o que isso significa.
Do arquivo de ajuda "Unit Generators and Synths"("Unidades geradoras e Sintetizadores"):
Uma unidade geradora criada ao se enviar uma mensagem ar ou kr para um
objeto da classe da respectiva unidade geradora. A mensagem ar cria uma UGen
que executada na velocidade da taxa de udio. A mensagem kr cria uma UGen
executada na velocidade da taxa de controle. UGens de controle so usados para
sinais de controle de baixa frequncia ou que mudam lentamente. UGens de controle
67
produzem uma nica amostra por ciclo de controle e, por isso, utilizam menos poder
de processamento que UGens de udio.
Em outras palavras: quando voc escreve SinOsc.ar, voc est mandando a mensagem "taxa
de udio"para a UGen SinOsc UGen. Assumindo que seu computador esteja rodando na taxa de
amostragem comum de 44100 Hz, este oscilador senoidal vai gerar 44100 amostras por segundo
para serem enviadas ao alto-falante. Ento escutamos uma onda senoidal.
Reflita por um momento sobre o que voc acabou de ler: quando voc manda a mensagem
ar para uma UGen, voc esta pedindo que que ela gere quarenta e quatro mil e cem nmeros por
segundo. Uma verdadeira enxurrada de nmeros. Voc escreve {SinOsc.ar}.play na linguagem
e a linguagem comunica seu pedido ao servidor. O verdadeiro trabalho de gerar todas estas
amostras feito pelo servidor, o "motor sonoro"do SuperCollider.
Agora, quando voc usa kr em vez de ar, o trabalho tambem feito pelo servidor, mas h
algumas diferenas:
1. A quantidade de nmeros gerados por segundo com .kr muito menor. {SinOsc.ar}.play
gera 44100 nmeros por segundo, enquanto {SinOsc.kr}.play produz perto de 700 nmeros por segundo (se voc tiver curiosidade, a quantidade exata 44100 / 64, sendo que 64
o chamado "perodo de controle".)
2. O sinal gerado com kr no vai para os alto-falantes. Em vez disso, normalmente utilizado
para controlar parmetros de outros sinaispor exemplo, o MouseX.kr no seu theremim
estava controlando a frequncia de um SinOsc.
OK, ento UGens so geradores de nmeros incrivelmente velozes. Alguns destes nmeros
se tornam sinais sonoros; outros se tornam sinais de controle. At a, tudo bem. Mas que
http://doc.sccode.org/Guides/UGens-and-Synths.html
68
25.1
O mtodo poll
Vale a pena examinar a sada de algumas UGens para esclarecer isso. No uma boa ideia pedir
pro SuperCollider imprimir milhares de nmeros por segundo na Post window, mas podemos
pedir que ele imprima algumas dezenas deles, s para termos uma ideia. Digite e rode as seguintes
linhas, uma de cada vez (confirme que seu servidor esteja rodando), e observe a Post window:
1
2
3
4
Os exemplos no produzem som algum porque estamos usando kro resultado um sinal de
controle, ento nada enviado para os alto-falantes. O objetivo aqui apenas observar a sada
tpica de algumas UGens. A mensagem poll pega 10 nmeros por segundo da sada do SinOsc
e as imprime na Post window. O argumento 1 a frequncia da senoide, o que quer dizer que
a onda senoidal vai demorar um segundo para completar um ciclo inteiro. Baseado no que voc
observou, o SinOsc unipolar ou bipolar? E o LFPulse?6
Abaixe todo o volume antes de rodar a prxima linha, depois aumente-o devagar. Voc vai
ouvir uns cliques suaves.
69
{LFNoise0.ar(1).poll}.play;
Como mandamos uma mensagem ar para esta Ugen, ela est enviando 44100 amostras por
segundo para a sua placa de som um sinal de udio. LFNoise0 um gerador de rudo de
baixa frequncia ("Low Frequency Noise"). Cada amostra um nmero aleatoriamente escolhido
entre -1 e +1 (ento uma UGen bipolar). Com poll voc est vendo somente dez deles por
segundo. LFNoise0.ar(1) escolhe um novo nmero aleatrio a cada segundo. Tudo isto feito
pelo servidor.
Pare os cliques com [ctrl+.] e experimente mudar a frequncia de LFNoise0. Tente nmeros
como 3, 5, 10 e depois mais altos. Observe os nmeros produzidos e oua os resultados.
26
Argumentos de UGen
Quase sempre voc vai precisar especificar os argumentos das UGens que voc estiver usando.
Voc j viu isso antes: quando escrevemos {SinOsc.ar(440)}.play, o nmero 440 um argumento para o SinOsc.ar; ele especifica a frequncia que voc vai ouvir. Voc pode nomear
os argumentos explicitamente, assim: {SinOsc.ar(freq: 440, mul: 0.5)}.play. Os nomes
dos argumentos so freq e mul (note os dois pontos imediatamente aps as palavras no cdigo).
O mul quer dizer "multiplicador"e essencialmente a amplitude da forma de onda. Se voc no
prover nenhum valor para mul, o SuperCollider usa o valor padro de 1 (amplitude mxima).
Um valor como mul: 0.5 significa multiplicar a forma de onda por meio, em outras palavras,
ela vai tocar com metade da amplitude mxima.
No cdigo do seu theremin, os argumentos freq e mul do SinOsc foram explicitamente
nomeados. Voc deve lembrar que MouseX.kr(300, 2500) foi usado para controlar a frequncia
do theremin. Nesse caso, o MouseX.kr recebeu dois argumentos: um limite mnimo e um mximo
para seu mbito de sada (300 e 2500, respectivamente). O mesmo vale para o MouseY.kr(0, 1),
70
27
Redimensionando mbitos
A verdadeira festa comea quando voc usa UGens para controlar os parmetros de outras UGens.
O exemplo do theremin fez exatamente isto. Agora voc tem todas as ferramentas para entender
exatamente o que est acontecendo em um dos exemplos da seo 3. As trs ltimas linhas do
exemplo demonstram passo a passo como o LFNoise0 usado para controlar a frequncia:
71
1
2
3
4
5
6
27.1
27.2
Agora voc j sabe redimensionar a sada de UGens no servidor usando o mtodo .range. A
mesma coisa pode ser obtida em um nvel mais fundamental usando os argumentos mul e add,
que quase todas as UGens tm. O cdigo abaixo mostra a equivalncia entre as abordagens com
range e de mul/add, ambos com uma UGen bipolar e uma UGen unipolar.
1
2
3
4
5
6
7
8
9
// Isto aqui:
{SinOsc.kr(1).range(100, 200).poll}.play;
// ... o mesmo que:
{SinOsc.kr(1, mul: 50, add: 150).poll}.play;
// Isto aqui:
{LFPulse.kr(1).range(100, 200).poll}.play;
// ...d na mesma que:
{LFPulse.kr(1, mul: 50, add: 100).poll}.play;
A figura 7 ajuda a visualizar como mul e add trabalham juntos redimensionando as sadas de
UGens (um SinOsc usado como demonstrao).
27.3
Para qualquer outro redimensionamento arbitrrio de mbitos, voc pode usar os prticos mtodos linlin, linexp, explin e expexp. Os nomes nos mtodos do uma dica do que eles fazem:
converter um mbito linear em outro mbito linear (linlin), linear para exponencial (linexp),
etc.
1
2
3
4
// Um punhado de nmeros
a = [1, 2, 3, 4, 5, 6, 7];
// Redimensione para 0127, linear para linear
a.linlin(1, 7, 0, 127).round(1);
73
Para uma reviso acerca de linear e exponencial, procure online a diferena entre progresses
aritmticas e geomtricas. Brevemente, sequncias lineares (aritmticas) so como "1, 2, 3, 4,
5, 6"or "3, 6, 9, 12, 15", etc; e sequncias exponenciais (geomtricas) so como "1, 2, 4, 8, 16,
32"or "3, 9, 27, 81, 243", etc.
74
28
Eis um jeito bastante comum de iniciar diversos sintetizadores e ser capaz de interromp-los
separadamente. O exemplo autoexplicativo:
1
2
3
4
5
6
7
8
// Rode uma linha de cada vez (no pare o som entre elas):
a = { Saw.ar(LFNoise2.kr(8).range(1000, 2000), mul: 0.2) }.play;
b = { Saw.ar(LFNoise2.kr(7).range(100, 1000), mul: 0.2) }.play;
c = { Saw.ar(LFNoise0.kr(15).range(2000, 3000), mul: 0.1) }.play;
// Pare os sintetizadores individualmente:
a.free;
b.free;
c.free;
29
A mensagem set
Assim como com qualquer funo (reveja a seo 21), argumentos especificados no incio da sua
funo de sintetizador ficam acessveis ao usurio. Isso permite que voc modifique parmetros
em tempo real (enquanto o sintetizador est rodando). A mensagem set ("definir") usada para
este fim. Exemplo simples:
1
2
3
4
5
um bom hbito fornecer valores pr-definidos (como 440 e 0.1 acima), de outra forma o
sintetizador no vai tocar at que voc defina um valor apropriado para os parmetros vazios.
75
30
Canais de udio ("audio buses") so usados para rotear sinais de udio. como se fossem os
canais de uma mesa de som. O SuperCollider tem 128 canais de udio como padro. Tambm
existem canais de controle (para sinais de controle), mas por enquanto vamos nos concentrar s
nos canais de udio.
Pressione [ctrl+M] para abrir a janela Meter ("Medidor"). Ela mostra os nveis de todas as
entradas e sadas. A figura 8 mostra uma captura de tela dessa janela e sua correspondncia
com os canais padro do SuperCollider. No SC, canais de udio so numerados de 0 a 127. Os
primeiros oito (0-7) so por definio reservados para serem os canais de sada da sua placa de
som. Os prximos oito (8-15) so reservados para as entradas da sua placa de som. Todos os
outros (16 a 127) esto livres para serem utilizados como se desejar, por exemplo, quando voc
precisa rotear sinais de udio de uma UGen para outra.
30.1
As UGensOut e In
76
77
Voc deve ouvi-la somente no seu alto-falante direito (ou seu ouvido direito, se estiver usando
fones de ouvido).
Com a janela Meter aberta e visvel, v ao cdigo e mude o primeiro argumento de Out.ar:
tente qualquer nmero entre 0 e 7. Observe os medidores. Voc ver que o sinal vai para qualquer
lugar que voc mand-lo.
DICA: bastante provvel que voc tenha uma placa de som que s pode tocar dois canais
(esquerdo e direito), ento voc somente escutar a senoide quando mand-la para o canal
0 ou 1. Se voc envi-la para outros canais (3 a 7), voc ainda poder ver o medidor correspondente mostrando o sinal: o SC est de fato mandando som para aquele canal, mas a menos que voc tenha uma placa de som de 8 canais, voc no poder ouvir a sada dos canais
3-7.
Um exemplo simples de um canal de udio sendo usado para um efeito mostrado abaixo.
1
2
3
4
// iniciar o efeito
f = {Out.ar(0, BPF.ar(in: In.ar(55), freq: MouseY.kr(1000, 5000), rq: 0.1))}.play;
// iniciar a fonte sonora
n = {Out.ar(55, WhiteNoise.ar(0.5))}.play;
somente produzir som quando mandarmos algum audio para o canal 55, que o que acontece
na segunda linha.
A segunda linha cria um sintetizador e o armazena na varivel n. Este sintetizador simplesmente gera rudo branco e o envia no diretamente para os alto-falantes, mas sim para o canal
de audio 55. Este precisamente o canal que nosso sintetizador de filtro est escutando, ento
assim que voc rodar a segunda linha, voc deve comear a ouvir o rudo branco sendo filtrado
pelo sintetizador f.
Em resumo, o roteamento tem a seguinte configurao:
sintetizador de rudo canal 55 sintetizador de filtro
A ordem de execuo importante. O exemplo anterior no funcionar se voc rodar a fonte
antes do efeito. Isso ser discutido em mais detalhe na seo 42, "Ordem de Execuo".
Uma ltima coisa: quando em exemplos anteriores voc escreveu sintetizadores como {
SinOsc.ar(440) }.play, internamente o SC estava de fato executando { Out.ar(0, SinOsc.ar(440))
}.play: se nada for dito, o SC assume que voc queria mandar som para o canal 0, ento ele
automaticamente embute (ou "aninha") a primeira UGen em uma UGen Out.ar(0, ...). Na
realidade, h mais algumas coisas acontecendo nos bastidores, mas voltaremos a isso mais tarde
(seo 39).
31
Entrada de Microfone
O exemplo abaixo mostra como voc pode facilmente acessar a entrada da sua placa de som com
a UGen SoundIn.
Sabendo que In.ar l o sinal de qualquer canal indicado, e sabendo que as entradas da sua placa de som
so por padro assinaladas para os canais 8-15 do SC, voc poderia escrever In.ar(8) para obter som do seu
microfone. Isso funciona perfeitamente bem, mas SoundIn.ar uma opo mais conveniente.
79
1
2
3
4
5
6
7
8
32
Expanso Multicanal
duplicatas so enviadas para tantos canais adjacentes quantos forem necessrios, comeando pelo
primeiro canal especificado como primeiro argumento de Out.ar.
No exemplo acima, temos Out.ar(0, ... ). O freq da onda dente-de-serra ("Saw") um
array de dois itens: [440, 570]. O que o SC faz? Ele "expande multicanal", criando duas
cpias de todo o patch. A primeira cpia uma onda dente-de-serra com uma frequncia de 440
Hz, enviada para o canal 0 (canal esquerdo); a segunda cpia uma dente-de-serra com uma
frequncia de 570 Hz, enviada para o canal 1 (canal direito)!
Vamos l, verifique voc mesmo. Mude estas duas frequncias para qualquer outros valores
que voc quiser. Escute os resultados. Um vai para o canal esquerdo e o outro vai para o direito.
V alm e adicione uma terceira frequncia para a lista (digamos, [440, 570, 980]). Observe
a janela Meter. Voc ver que as trs primeiras sadas esto iluminadas (mas voc s conseguir
ouvir a terceira se tiver uma placa de som multicanal).
Alm disso: voc pode usar arrays adicionais em outros argumentos da mesma UGen ou em
argumentos de outras UGens no mesmo sintetizador. O SuperCollider vai tomar conta de tudo
direitinho e gerar sintetizadores que usem todos os valores corretamente. Por exemplo: agora
ambas as frequncias [440, 570] esto crescendo suavemente ("fade in") de 0 a 1 em 10 segundos.
Mas mude o cdigo para Line.kr(0, 1, [1, 15]) e voc far com que o som de 440 Hz demore
1 segundo para crescer e o de 570 Hz leve 15 segundos. Experimente.
Exerccio: escute esta simulao de um "sinal de ocupado"de um telefone antigo. Ela usa a
expanso multicanal para criar dois osciladores senoidais, cada um tocando uma frequncia em
um canal diferente. Faa o canal esquerdo pulsar 2 vezes por segundo e o canal direito pulsar 3
vezes por segundo.7
1
2
81
33
O objeto Bus
Aqui est um exemplo que utiliza tudo o que voc aprendeu nas duas sees anteriores: canais
de udio e expanso multicanal.
1
2
3
4
5
6
// Rode isso primeiro ('ligar reverb' inicialmente voc no vai ouvir nada)
r = {Out.ar(0, FreeVerb.ar(In.ar(55, 2), mix: 0.5, room: 0.9, mul: 0.4))}.play;
// Agora rode isto em seguida ('envie o som para o canal de reverb')
a = {Out.ar(55, SinOsc.ar([800, 880], mul: LFPulse.ar(2)))}.play;
a.free;
Graas expanso multicanal, o som usa dois canais. Quando (no sintetizador a) enviamos
o sinal para o canal 55, na verdade, dois canais esto sendo utilizadoso nmero 55 e o canal
imediatamente adjacente, 56. No reverb (sintetizador r), indicamos com In.ar(55, 2) que
queremos ler 2 canais, comeando pelo canal 55, de modo que tanto 55 quanto 56 vo entrar no
reverb. A sada do reverb tambm expandida para dois canais, de maneira que o sintetizador
r manda som para os canais 0 e 1 (canais esquerdo e direito da sua placa de som).
Esta escolha de canal (nmero 55) para conectar uma fonte sonora a um efeito foi arbitrria:
poderia ter sido qualquer outro nmero entre 16 e 127 (lembre-se, canis 0-15 so reservados para
a as sadas e entradas da placa de som). Seria muito inconveniente ter que ficar escolhendo
e lembrando de nmeros assim a todo momento. Quando os patches comearem a ficar mais
complexos, imagine que pesadelo: "Qual foi mesmo o canal que escolhi para o reverb? Era 59
ou 95? E o canal do meu delay? Ser que era 27? No lembro..."e assim por diante.
O SuperCollider toma conta disso para voc com objetos Bus. Nos exemplos acima, ns
s definimos manualmente o tal do canal 55 como forma de demonstrao. No dia-a-dia com
o SuperCollider, voc pode simplesmente usar o objeto Bus. O objeto Bus faz o trabalho de
escolher um canal disponvel para voc e monitor-lo. Eis como us-lo:
82
1
2
3
4
5
6
7
8
// Criar o bus
~meuBus = Bus.audio(s, 2);
// Ligar o reverb: ler de ~meuBus (fonte sonora)
r = {Out.ar(0, FreeVerb.ar(In.ar(~meuBus, 2), mix: 0.5, room: 0.9, mul: 0.4))}.play;
// Alimente o ~meuBus com o som
b = {Out.ar(~meuBus, SinOsc.ar([800, 880], mul: LFPulse.ar(2)))}.play;
// Libere ambos os sintetizadores
r.free; b.free;
34
Pan
No arquivo de Ajuda do Pan2, vemos que o argumento pos ("posio") requer um nmero entre
-1 (esquerda) e +1 (direita), 0 sendo o centro. por isso que voc pode utilizar um SinOsc
Para pan multicanal, d uma olhada em Pan4 e PanAz. Usurios avanados podem se interessar pelos plug-ins
de SuperCollider para Ambisonics.
83
diretamente neste argumento: o oscilador senoidal uma UGen bipolar, ento ela gera nmeros
entre -1 e +1 por definio.
Agora vamos analisar um exemplo mais elaborado. Uma onda dente-de-serra passa por
um filtro passa-banda muito estreito (rq: 0.01). Note o uso de variveis locais para tornar
modulares diferentes partes do cdigo. Analise e tente entender o mximo que voc puder no
exemplo. Depois responda as perguntas a seguir.
1
2
3
4
5
6
7
8
9
10
11
12
13
(
x = {
var lfn = LFNoise2.kr(1);
var saw = Saw.ar(
freq: 30,
mul: LFPulse.kr(
freq: LFNoise1.kr(1).range(1, 10),
width: 0.1));
var bpf = BPF.ar(in: saw, freq: lfn.range(500, 2500), rq: 0.01, mul: 20);
Pan2.ar(in: bpf, pos: lfn);
}.play;
)
x.free;
Perguntas:
(a) A varivel lfn usada em dois lugares diferentes. Por qu? (Qual o resultado?)
(b) O que acontece se voc mudar o argumento mul: do BPF de 20 para 10, 5 ou 1? Por que um
nmero grande como 20 foi usado?
(c) Qual parte do cdigo est controlando o ritmo?
Respostas ao final do livro.8
84
35
Mix e Splay
Este um truque bacana. Voc pode usar expanso multicanal para gerar sons complexos e
depois mix-los todos para mono ou estreo com Mix ou Splay:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Voc consegue ver a expanso multicanal em ao neste ltimo exemplo de Splay? A nica
diferena que o array primeiro armazenado em uma varivel (harmonicos) antes de ser
85
utilizada nas UGens. O array harmonicos tem 9 items, ento o sintetizador ir se expandir para
9 canais. Ento, um pouco antes de .play, Splay recebe o array de 9 canais e os mixa em
estreo, distribuindo os canais uniformemente da esquerda para a direita.
Mix tem um outro truque interessante: o mtodo fill. De uma s vez, ele cria um array de
sintetizadores e os mixa em mono.
1
2
3
4
5
6
7
8
9
10
11
12
13
Voc fornece duas coisas para o Mix.fill: o tamanho do array e uma funo (entre chaves)
que ser utilizada para preencher o array. No primeiro exemplo acima, Mix.fill executa a
funo 16 vezes. Note que a funo inclui um componente varivel: a frequncia do oscilador
senoidal poder ser qualquer nmero entre 100 e 3000. Dezesseis senoides sero criadas, cada
uma com uma frequncia aleatria diferente. Todas elas sero mixadas em mono e voc ouvir
o resultado no seu canal esquerdo. O segundo exemplo mostra que a funo pode receber um
A ltima linha antes do .play poderia ser explicitamente escrita como Out.ar(0, Splay.ar(som)). Lembrese que o SuperCollider est gentilmente preenchendo as lacunas e inserindo a um Out.ar(0...) assim que o
sintetizador sabe que deve tocar nos canais esquerdo (bus 0) e direito (bus 1).
86
36
Primeiro, voc tem que carregar o arquivo de som em um buffer (uma espcie de "continer").
O segundo argumento para Buffer.read o caminho ("path"), entre aspas duplas, indicando
onde o seu arquivo de som est salvo. Esse caminho deve apontar para um arquivo WAV ou
AIFF no seu computador. Depois que o buffer carregado, simplesmente use a UGen PlayBuf
para toc-lo de diversas maneiras.
DICA: Um jeito rpido de obter o caminho correto para um arquivo de som no seu computador arrastar o arquivo para um documento em branco do SuperCollider. O SC fornecer
automaticamente o caminho completo, j entre aspas duplas!
1
2
3
4
5
6
7
8
9
10
11
87
12
13
14
15
16
17
18
19
20
21
37
Ns de sintetizador
Nos exemplos anteriores com PlayBuf, voc teve que apertar [ctrl+.] depois de cada linha
para parar o som. Em outros exemplos, voc atribuiu o sintetizador a uma varivel (como x =
{WhiteNoise.ar}.play) para que voc pudesse par-lo diretamente com x.free.
Toda vez que voc cria um sintetizador no SuperCollider, voc sabe que ele roda no servidor, nosso "motor sonoro". Cada sintetizador que est rodando no servidor representado por
um node ("n"ou "ndulo"). Podemos dar uma espiada nesta rvore de ns com o comando
s.plotTree. Experimente. Uma janela chamada NodeTree ("rvore de ns") vai abrir.
1
2
3
4
5
6
7
// abra a GUI
s.plotTree;
// rode estes um por um (no pare o
w = { SinOsc.ar(60.midicps, 0, 0.1)
x = { SinOsc.ar(64.midicps, 0, 0.1)
y = { SinOsc.ar(67.midicps, 0, 0.1)
z = { SinOsc.ar(71.midicps, 0, 0.1)
88
8
9
10
11
w.free;
x.free;
y.free;
z.free;
Cada retngulo que voc v na Node Tree um n de sintetizador. Cada sintetizador ganha
um nome temporrio (algo como temp_101, temp_102, etc.) e fica ali enquanto estiver rodando.
Experimente agora tocar novamente as quatro senoides e aperte [ctrl+.] (observe a janela Node
Tree). O atalho [ctrl+.] impiedosamente interrompe todos os ns que esto rodando no servidor.
Por outro lado, com o mtodo .free, voc pode ser mais sutil e liberar ns especficos, um de
cada vez.
Uma coisa importante de se perceber que sintetizadores podem continuar a rodar no servidor
mesmo que eles estejam gerando apenas silncio. Eis um exemplo. A amplitude desta UGen
WhiteNoise ir de 0.2 a 0 em dois segundos. Depois disso, no escutaremos nada. Mas voc v
que o n do sintetizador ainda est ali e no desaparecer at que voc o libere.
1
2
3
37.1
O glorioso doneAction: 2
Felizmente, h uma maneira de criar sintetizadores mais espertos neste sentido: por exemplo,
no seria timo se pudssemos pedir ao Line.kr para notificar o sintetizador quando ele tiver
terminado seu trabalho (a rampa de 0.2 a 0), e ento o sintetizador se liberasse automaticamente?
Insira o argumento doneAction: 2 para resolver todos os nossos problemas.
Toque os exemplos abaixo e compare como eles se comportam com e sem doneAction: 2.
Continue observando a Node Tree enquanto voc roda as linhas.
89
1
2
3
4
5
6
7
// sem doneAction: 2
{WhiteNoise.ar(Line.kr(0.2, 0, 2))}.play;
{PlayBuf.ar(1, ~buf1)}.play; // PS.: isso presume que voc anda tem seu arquivo de
som carregado no ~buf1 da seo anterior
// com doneAction: 2
{WhiteNoise.ar(Line.kr(0.2, 0, 2, doneAction: 2))}.play;
{PlayBuf.ar(1, ~buf1, doneAction: 2)}.play;
38
Envelopes
At agora, a maioria dos nossos exemplos foi de sons contnuos. J est na hora de aprender a
modelar o envelope de amplitude de um som. Um bom exemplo para comear um envelope
percussivo. Imagine um ataque em um prato suspenso. O tempo que o som leva para ir do
silncio amplitude mxima muito curtoalguns milissegundos talvez. Isto chamado tempo
de ataque. O tempo que leva para o som do prato diminuir da mxima amplitude de volta
ao silncio (zero) um pouco mais longo, talvez alguns segundos. Isto chamado o tempo de
repouso.
Pense em um envelope de amplitude simplesmente como um nmero que muda ao longo
do tempo e pode ser utilizado como o multiplicador (mul) de qualquer UGen que produz som.
Estes nmeros devem estar entre 0 (silncio) e 1 (amplitude mxima), porque assim que o
SuperCollider entende a amplitude. Talvez agora voc se d conta de que o ltimo exemplo j
90
38.1
Env.perc
Env.perc uma maneira prtica de se obter um envelope percussivo. Ele aceita quatro argumentos: attackTime, releaseTime, level e curve (que podemos traduzir como: "tempoDeAtaque,
tempoDeRepouso, nvel e curva". No caso de envelopes de amplitude, "nvel" como se fosse
o "volume mximo"que o seu envelope pode alcanar). Vejamos algumas formas tpicas, ainda
fora de qualquer sintetizador.
1
2
3
4
Tudo o que voc tem de fazer adicionar .kr(doneAction: 2) logo depois de Env.perc
e pronto. Na verdade, neste caso voc pode at remover a declarao explcita do argumento
91
doneAction e simplesmente ficar com .kr(2). O .kr est esta dizendo para o SC rodar este
envelope na velocidade da taxa de controle (como outros sinais de controle que vimos antes).
38.2
Env.triangle
// Vejao:
Env.triangle.plot;
// Ouao:
{SinOsc.ar([440, 442], mul: Env.triangle.kr(2))}.play;
// Alis, um envelope pode ser um multiplicador em qualquer lugar do seu cdigo:
{SinOsc.ar([440, 442]) * Env.triangle.kr(2)}.play;
38.3
Env.linen
Env.linen descreve um envelope linear com ataque, poro de sustentao e repouso. Voc
tambm pode especificar o nvel de amplitude e tipo de curva. Exemplo:
1
2
3
4
// Vejao:
Env.linen.plot;
// Ouao:
{SinOsc.ar([300, 350], mul: Env.linen(0.01, 2, 1, 0.2).kr(2))}.play;
38.4
Env.pairs
Quer algo ainda mais flexvel? Com Env.pairs voc pode ter envelopes com qualquer forma e
durao que quiser. Env.pairs recebe dois argumentos: uma lista (array) de pares de [tempo,
nvel] e um tipo de curva (veja na Ajuda de Env todos os tipos de curva disponveis).
92
1
2
3
4
5
6
7
(
{
var env = Env.pairs([[0, 0], [0.4, 1], [1, 0.2], [1.1, 0.5], [2, 0]], \lin);
env.plot;
SinOsc.ar([440, 442], mul: env.kr(2));
}.play;
)
Nada impede voc de usar as estas mesmas formas para controlar algo que no seja amplitude
do som. Voc s precisa redimension-las para o mbito numrico desejado. Por exemplo, voc
pode criar um envelope para controlar a mudana de frequncias ao longo do tempo:
1
2
3
4
5
6
(
{
var freqEnv = Env.pairs([[0, 100], [0.4, 1000], [0.9, 400], [1.1, 555], [2,
440]], \lin);
SinOsc.ar(freqEnv.kr, mul: 0.2);
}.play;
)
93
38.5
Envelope ADSR
Todos os envelopes vistos at agora tm uma coisa em comum: eles tm uma durao fixa, prdefinida. H situaes, no entanto, em que este tipo de envelope no adequado. Por exemplo,
imagine que voc est tocando em um teclado MIDI. O ataque da nota disparado quando voc
pressiona a tecla. O repouso, quando voc tira seu dedo da tecla. Mas a quantidade de tempo que
voc permanece com o dedo pressionando a tecla no conhecido de antemo. O que precisamos
neste caso de um "envelope sustentado". Em outras palavras, depois da poro de ataque, o
envelope precisa segurar a nota por uma quantidade de tempo indefinida e apenas disparar a
poro de repouso depois de algum sinal, ou mensagem isto , o momento em que voc "solta
a tecla".
Um envelope ASR (Ataque, Sustentao, Repouso) se encaixa perfeitamente nesse caso. Uma
variao mais popular o envelope ADSR (Ataque, Decaimento, Sustentao, Repouso). Vamos
dar uma olhada nos dois.
1
2
3
4
5
6
7
8
9
10
// ASR
// Toque nota ('aperte tecla')
// attackTime: 0.5 seconds, sustainLevel: 0.8, releaseTime: 3 seconds
x = {arg gate = 1, freq = 440; SinOsc.ar(freq: freq, mul: Env.asr(0.5, 0.8, 3).kr(
doneAction: 2, gate: gate))}.play;
// Pare nota ('tirar dedo da tecla' ativar a poro de repouso)
x.set(\gate, 0); // uma alternativa x.release
// ADSR (ataque, decaimento, sutentao, repouso)
// Toque nota:
(
94
11
12
13
14
15
16
17
18
19
d = {arg gate = 1;
var snd, env;
env = Env.adsr(0.01, 0.4, 0.7, 2);
snd = Splay.ar(BPF.ar(Saw.ar((32.1, 32.2..33)), LFNoise2.kr(12).range(100,
1000), 0.05, 10));
Out.ar(0, snd * env.kr(doneAction: 2, gate: gate));
}.play;
)
// Pare nota:
d.release; // isto equivalente a d.set(\gate, 0);
Conceitos-chave:
Ataque ("Attack") O tempo (em segundos) que leva para ir do silncio (zero) at o pico de
amplitude
Decaimento ("Decay") O tempo (em segundos) que leva para ir do pico de amplitude para
a amplitude de sustentao
Sustentao ("Sustain") A amplitude (entre 0 e 1) na qual a nota sustentada (importante:
isto no tem nada a ver com tempo)
Repouso ("Release") O tempo (em segundos) que leva para ir do nvel de sustentao para
o zero (silncio).
Como envelopes sustentados no tem uma durao total conhecida de antemo, eles precisam
de uma notificao tanto de quando comear (disparar o ataque) e quando parar (disparar o
repouso). Esta notificao chamada um gate ("porto"). O gate o que diz para que o
envelope se abra (1) ou se feche (0), portanto comeando e terminando a nota.
95
Para que um envelope ASR ou ADSR funcione no seu sintetizador, voc precisa declarar
um argumento gate. Normalmente, o padro gate = 1 porque voc quer que o sintetizador
comece a tocar assim que for instanciado (ativado). Quando voc quer que o sintetizador pare,
simplesmente mande uma mensagem .release ou .set(\gate, 0): a poro de repouso do
envelope ser ento disparada. Por exemplo, se seu tempo de repouso 3, a nota vai levar trs
segundos para se extinguir completamente a partir do momento em que voc enviou a mensagem
.set(\gate, 0).
38.6
EnvGen
Vale registrar que a construo que voc aprendeu nesta seo para gerar envelopes um atalho,
como mostrado no cdigo abaixo.
1
2
3
4
// Isso:
{ SinOsc.ar * Env.perc.kr(doneAction: 2) }.play;
// ... um atalho disso:
{ SinOsc.ar * EnvGen.kr(Env.perc, doneAction: 2) }.play;
EnvGen a UGen que de fato toca os envelopes segmentados ("breakpoint envelopes") definidos por Env. Para todos os propsitos prticos, voc pode continuar a usar o atalho. Mas til
saber que estas notaes so equivalentes, j que voc muitas vezes ver EnvGen sendo utilizado
nos arquivos de Ajuda e outros exemplos online.
39
Definies de sintetizador
At aqui, sem dificuldade alguma, pudemos definir sintetizadores e faz-los tocar imediatamente.
Alm disso, a mensagem .set nos deu alguma flexibilidade para alterar os controles do sintetizador em tempo real. No entanto, h situaes em que voc pode querer definir seus sintetizadores
96
antes (sem toc-los imediatamente) e toc-los somente depois. Em essncia, isso significa que
temos de separar o momento de escrever a receita (a definio de sintetizador) do momento de
assar o bolo (criar o som).
39.1
SynthDef e Synth
SynthDef o que usamos para "escrever a receita"de um sintetizador. Depois voc pode toc-lo
com Synth. Aqui est um exemplo simples.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
O primeiro argumento para a SynthDef um nome para o sintetizador definido pelo usurio.
O segundo argumento uma funo na qual voc especifica um grfico de UGens (assim
97
chamada uma combinao de UGens). Note que voc tem de usar Out.ar explicitamente para
indicar para qual canal voc quer enviar o sinal. Finalmente, a SynthDef recebe a mensagem
.add ao final, que diz que voc est a adicionando a uma coleo de sintetizadores que o SC
conhece. Isso fica valendo at a hora que voc fechar o SuperCollider.
Depois que voc criar uma ou mais definies de sintetizador com SynthDef, voc pode toclas com Synth: o primeiro argumento o nome do sintetizador que voc quer usar e o segundo
argumento (opcional) uma array com quaisquer parmetros que voc queira especificar (freq,
amp, etc.)
39.2
Exemplo
Eis um exemplo mais longo. Depois que a SynthDef adicionada, ns utilizamos um truque com
uma array para criar um acode de 6 notas com alturas e amplitudes aleatrias. Cada sintetizador
armazenado em uma das posies da array, para que possamos deslig-los individualmente.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Criar SynthDef
(
SynthDef("uau", {arg freq = 60, amp = 0.1, gate = 1, uaurelease = 3;
var chorus, fonte, filtromod, env, som;
chorus = Lag.kr(freq, 2) * LFNoise2.kr([0.4, 0.5, 0.7, 1, 2, 5, 10]).range
(1, 1.02);
fonte = LFSaw.ar(chorus) * 0.5;
filtromod = SinOsc.kr(1/16).range(1, 10);
env = Env.asr(1, amp, uaurelease).kr(2, gate);
som = LPF.ar(in: fonte, freq: freq * filtromod, mul: env);
Out.ar(0, Splay.ar(som))
}).add;
)
// Observe a Node Tree
98
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
s.plotTree;
// Criar um acorde de 6 notas
a = Array.fill(6, {Synth("uau", [\freq, rrand(40, 70).midicps, \amp, rrand(0.1, 0.5)
])}); // tudo em uma nica linha
// Encerrar notas uma por uma
a[0].set(\gate, 0);
a[1].set(\gate, 0);
a[2].set(\gate, 0);
a[3].set(\gate, 0);
a[4].set(\gate, 0);
a[5].set(\gate, 0);
// AVANADO: rode o acorde de 6 notas novamente e depois execute esta linha.
// Voc consegue imaginar o que est acontecendo?
SystemClock.sched(0, {a[5.rand].set(\freq, rrand(40, 70).midicps); rrand(3, 10)});
Como um atributo extra, note que freq est empacotado em um Lag.kr. Sempre que uma
nova frequncia alimenta o Synth, a UGen Lag simplesmente cria uma rampa entre o valor
velho e o valor novo. O "lag time"(durao da rampa), neste caso, 2 segundos. Isso o
que causa o efeito de glissando que voc ouve aps rodar a ltima linha do exemplo.
A fonte sonora LFSaw.ar recebe a varivel chorus como sua frequncia. Em um exemplo
concreto: para um valor freq de 60 Hz, a varivel chorus resultaria em uma expresso
como
60 [1.01, 1.009, 1.0, 1.02, 1.015, 1.004, 1.019]
na qual os nmeros da lista estariam constantemente subindo e descendo de acordo com
as velocidades de cada LFNoise2. O resultado final uma lista de sete frequncias sempre
deslizando entre 60 e 61.2 (60 * 1.02). Isso chamado efeito chorus, por isso o nome da
varivel.
Quando a varivel chorus usada como freq de LFSaw.ar, acontece expanso multicanal:
temos agora sete ondas dentes-de-serra com frequncias ligeiramente diferentes.
A varivel filtromod s um oscilador senoidal movendo-se muito lentamente (1 ciclo a
cada 16 segundos), com seu mbito de sada escalonado para 1-10. Isso ser usado para
modular a frequncia de corte do filtro passa-baixa.
A varivel som contm o filtro passa-baixa (LPF), que recebe fonte como entrada e atenua
todas as frequncias acima de sua frequncia de corte. Este corte no um valor fixo: ele
a expresso freq * filtromod. Ento no exemplo, ao assumir freq = 60, isso torna-se
um nmero entre 60 e 600. Lembre-se que filtromod um nmero oscilando entre 1 e 10,
de maneira que a multiplicao seria 60 * (1 a 10).
100
LPF tambm expande multicanal para sete cpias. O envelope de amplitude env tambm
aplicado neste ponto.
Finalmente, Splay pega essa array de sete canais e mixa em estreo.
39.3
Nos bastidores
Este processo em duas etapas de primeiro criar o SynthDef (com um nome prprio) e depois
chamar um Synth o que o SC faz o tempo todo quando voc escreve comandos simples como
{SinOsc.ar}.play. SuperCollider desdobra isso em (a) criar um SynthDef temporrio e (b) toclo imediatamente (essa a razo dos nomes temp_01, temp_02 que voc v na Post window).
Tudo isso nos bastidores, para sua convenincia.
1
2
3
4
5
6
7
8
9
10
40
Uma das belezas de se criar seus sintetizadores como SynthDefs que voc pode usar Pbind para
toc-los.
101
Assumindo que a SynthDef "uau" ainda esteja armazenado na memria (deveria estar, a no
ser que voc tenha fechado e reaberto o SC depois do ltimo exemplo), experimente os Pbinds
abaixo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
(
Pbind(
\instrument, "uau",
\degree, Pwhite(7, 7),
\dur, Prand([0.125, 0.25], inf),
\amp, Pwhite(0.5, 1),
\uaurelease, 1
).play;
)
(
Pbind(
\instrument, "uau",
\scale, Pstutter(8, Pseq([
Scale.lydian,
Scale.major,
Scale.mixolydian,
Scale.minor,
Scale.phrygian], inf)),
\degree, Pseq([0, 1, 2, 3, 4, 5, 6, 7], inf),
\dur, 0.2,
\amp, Pwhite(0.5, 1),
\uaurelease, 4,
\legato, 0.1
).play;
)
Ao usar Pbind para tocar um das suas SynthDefs personalizados, esteja atento aos seguintes
102
pontos:
Use a chave ("key") \instrument do Pbind para declarar o nome da sua SynthDef.
Todos os argumentos da sua SynthDef so controlveis a partir do Pbind: simplesmente
use-os como chaves do Pbind. Por exemplo, repare no argumento chamado \uaurelease
utilizado acima. Esta no uma das chaves padro entendidas pelo Pbindela s existe
na definio do sintetizador uau (o nome bobo foi escolhido de propsito).
Para utilizar todas as facildades de converso de alturas do Pbind (as chaves \degree,
\note e \midinote), tenha certeza de que sua SynthDef tem um argumento de entrada
freq (tem que ser escrito exatamente assim). Pbind far os clculos para voc.
Se for usar um envelope sustentado como Env.adsr, garanta que seu sintetizador tenha o
argumento padro gate = 1 (gate tem que ser excrito exatamente assim, porque o Pbind
o utiliza nos bastidores para parar as notas nos momentos certos).
Se voc no estiver usando um envelope sustentado, tenha certeza que sua SynthDef inclui
um doneAction: 2 em uma UGen apropriada, para liberar automaticamente os ns de
sintetizador no servidor.
Exerccio: escreva um ou mais Pbinds para tocar a SynthDef "pluck" fornecida abaixo. Para
o argumento cordaAbafada, tente valores entre 0.1 e 0.9. Faa com que seu Pbind toque uma
sequncia lenta de acordes. Tente arpejar os acordes com \strum.
1
2
3
4
(
SynthDef("pluck", {arg amp = 0.1, freq = 440, decaimento = 5, cordaAbafada = 0.1;
var env, som;
env = Env.linen(0, decaimento, 0).kr(doneAction: 2);
103
5
6
7
8
9
10
11
12
13
14
som = Pluck.ar(
in: WhiteNoise.ar(amp),
trig: Impulse.kr(0),
maxdelaytime: 0.1,
delaytime: freq.reciprocal,
decaytime: decaimento,
coef: cordaAbafada);
Out.ar(0, [som, som]);
}).add;
)
41
Canais de Controle
Em uma seo anterior deste tutorial, falamos sobre canais de udio ("Audio Buses") (seo 30)
e o objeto Bus (seo 33). Naquele momento, escolhemos deixar de lado o tpico dos Canais de
Controle ("Control Buses") para nos focarmos no conceito de roteamento de udio.
Canais de controle no SuperCollider so para o roteamento de sinais de controle, no de
udio. Exceto por esta diferena, no h nenhuma outra distino prtica ou conceitual entre
canais de udio de de controle. Voc cria e gerencia um canal de controle da mesma maneira que
voc faz com os canais de udio, simplesmente usando .kr em vez de .ar. O SuperCollider tem
4096 canais de controle como padro.
A primeira parte do exemplo abaixo usa um nmero de canal arbitrrio apenas com a finalidade de demonstrao. A segunda parte usa o objeto Bus, que a maneira recomendada de
criar canais.
1
2
3
104
4
5
6
7
8
9
{In.kr(55).poll}.play;
// Usando o objeto Bus
~meuCanalDeControle = Bus.control(s, 1);
{Out.kr(~meuCanalDeControle, LFNoise0.kr(5).range(440, 880))}.play;
{SinOsc.ar(freq: In.kr(~meuCanalDeControle))}.play;
O prximo exemplo mostra um nico sinal de controle sendo utilizado para modular dois
sintetizadores diferentes ao mesmo tempo. No sintetizador Blip, o sinal de controle redimensionado para controlar o nmero de harmnicos entre 1 e 10. No segundo sintetizador, o mesmo
sinal de controle redimensionado para modular a frequncia do oscilador Pulse.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
105
20
21
22
23
24
25
26
27
28
41.1
asMap
No prximo exemplo, o mtodo asMap ("como mapa") usado para mapear um canal de controle diretamente para um n de um sintetizador que esteja rodando. Desta maneira, voc no
precisara sequer de um In.kr na definio do sintetizador.
1
2
3
4
5
6
7
8
9
10
11
12
13
106
42
Ordem de Execuo
"filter" um filtro passa-banda que toma como entrada o canal de efeitos, e envia o som
processado para o canal master;
"masterOut" pega o sinal do canal master, aplica um controle de volume simples, e envia
o som final (com volume ajustado) para os alto-falantes.
Observe a janela Node Tree conforme voc roda os synths em ordem.
Executar as linhas certas na ordem correta um mtodo adequado em muitos casos, mas
pode ser que isso fique um pouco complicado conforme o seu cdigo v ficando mais complexo.
Para simplificar a tarefa, o SuperCollider permite que voc defina explicitamente onde colocar
os synths na janela Node Tree. Para tanto, usamos os argumentos target e addAction.
1
2
3
Agora, no importa em que ordem voc rodar as linhas acima, voc pode ter certeza que os
ns de cada synth vo ser colocados no lugar certo. O synth "noise" est sendo explicitamente
adicionado na cabea (topo) da janela Node Tree; o "masterOut" adicionado na cauda (embaixo
de todos os outros); e o filter explicitamente adicionado logo depois do n (o synth de rudo).
42.1
Grupos
Conforme voc comear a usar um monte de synthsalguns como fontes sonoras, outros para
processamento, efeitos, seja l o que voc precisar, pode ser uma boa ideia organiz-los em
grupos. Aqui est um exemplo simples:
1
2
3
4
5
6
7
8
9
10
11
109
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
Para mais informaes sobre ordem de execuo, consulte os arquivos de ajuda Synth,
Order of Execution e Group.
110
Parte V
E AGORA?
Se voc leu e mais ou menos entendeu tudo neste tutorial at agora, voc j no mais um
iniciante em SuperCollider! Cobrimos um monte de material, e daqui pra frente voc tem todas
as ferramentas bsicas necessrias para comear a desenvolver seus projetos pessoais, e continuar
a aprender mais por conta prpria. As sees a seguir fornecem uma breve introduo a alguns
tpicos comuns de dificuldade intermediria. A ltima seo oferece uma lista concisa de outros
tutoriais e fontes de aprendizado.
43
MIDI
Uma apresentao aprofundada dos conceitos e truques de MIDI est alm do escopo deste tutorial. Os exemplos abaixo assumem alguma familiaridade com dispositivos MIDI e so fornecidos
apenas como uma introduo.
1
2
3
4
5
6
7
8
9
10
11
12
111
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
Uma dvida frequente como administrar mensagens de "nota ligada"e "nota desligada"("note
on"e "note off") para notas sustentadas. Em outras palavras, quando voc utiliza um envelope
ADSR, voc quer que cada nota seja sustentada enquanto a tecla estiver pressionada. O estgio
112
de repouso ("release") inicia apenas quando o dedo solta a tecla correspondente (revise a seo
sobre envelopes ADSR se necessrio).
Para fazer isso, o SuperCollider simplesmente precisa monitorar qual n de sintetizador corresponde a cada tecla. Podemos usar uma array para este fim, como demonstrado no exemplo
abaixo.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
113
44
OSC
OSC (Open Sound Control ou "Controle de Som Aberto") uma excelente maneira de comunicar
qualquer tipo de mensagem entre diferentes programas ou diferentes computadores em uma rede.
Em muitos caos, uma alternativa muito mais flexvel s mensagens MIDI. No temos espao
114
para explicar isso em mais detalhes aqui, mas o exemplo abaixo deve servir como um bom ponto
de partida.
O objetivo desta demonstrao mandar mensagens OSC de um smartphone para seu computador ou de um computador para outro computador.
No computador receptor, rode este fragmento simples de cdigo:
1
2
3
4
5
6
(
OSCdef(
key: \seiLa,
func: {arg ...args; args.postln},
path: '/coisas')
)
44.1
Para esta demonstrao, partimos do princpio que ambos os computadores estejam rodando o
SuperCollider e conectados mesma rede. Descubra o endereo IP do computador receptor e
rode as seguintes linhas no computador emissor:
1
2
3
4
115
44.2
45
Quarks e plug-ins
Voc pode aumentar a funcionalidade do SuperCollider adicionando classes e UGens criados por
outros usurios. Quarks so pacotes de classes de SuperCollider, expandindo o que voc pode
fazer na linguagem do SuperCollider. UGen plug-ins so extenses para o servidor de sntese de
udio do SuperCollider.
Visite http://supercollider.github.io/ para obter informaes atualizadas sobre como
adicionar plug-ins e quarks sua instalao do SuperCollider. O arquivo de Ajuda "Using
Quarks" tambm um bom ponto de partida: http://doc.sccode.org/Guides/UsingQuarks.
html. De qualquer documento do SuperCollider voc pode rodar Quarks.gui para ver uma lista
de todos os quarks disponveis (ela abre em uma nova janela).
116
46
Referncias Extra
Chegamos ao fim desta introduo ao SuperCollider. Algumas referncias extra para estudo
esto listadas aqui. Aproveite!
Uma excelente srie de tutoriais no YouTube por Eli Fieldsteel: http://www.youtube.
com/playlist?list=PLPYzvS8A_rTaNDweXe6PX4CXSGq4iEWYC.
O tutorial padro para comear no SC com Scott Wilson e James Harkins, disponvel online
e includo nos arquvos de Help: http://doc.sccode.org/Tutorials/Getting-Started/
00-Getting-Started-With-SC.html
Tutorial online de Nick Collins: http://composerprogrammer.com/teaching/supercollider/
sctutorial/tutorial.html
A lista de e-mails oficial do SuperCollider a melhor maneira de conseguir uma ajuda amistosa de um grande grupo de usurios. Iniciantes so muito bem vindos para fazer perguntas
nesta lista. Voc pode se inscrever aqui: http://www.birmingham.ac.uk/facilities/
BEAST/research/supercollider/mailinglist.aspx
Descubra um grupo local de SuperCollider na sua cidade. A lista oficial de usurios do SC
a melhor maneira de descobrir se existe uma onde voc mora. Se no h um grupo na
sua rea, comece um!
Muitos exemplos interessantes de cdigos podem ser encontrados aqui: http://sccode.
org/. Crie uma conta e compartilhe seus cdigos tambm.
Grupo brasileiro de SuperCollider no Facebook: https://www.facebook.com/groups/
630981953617449/.
117
118
Notes
1
Primeira pergunta: quando voc usa o nmero 1 em vez de inf como o argumento repeats do segundo Pseq,
o Pbind para depois que 6 notas foram tocadas (isto , depois que uma sequncia completa de valores de durao
foi tocada). Segunda questo: para fazer o Pbind tocar para sempre, simplesmente use inf como valor para
repeats em todos os Patterns internos.
2
a) Pwhite(0, 10) vai gerar qualquer nmero entre 0 e 10. Prand([0, 4, 1, 5, 9, 10, 2, 3], inf) vai escolher
apenas nmeros que esto contidos na lista; note que essa lista tem alguns nmeros entre 0 e 10, mas no todos
(6, 7, 8 no esto l, ento nunca vo aparecer neste Prand).
b) Tecnicamente voc poderia usar um Prand se voc fornecer uma lista com todos os nmeros entre 0 e 100, mas
faz mais sentido usar um Pwhite para esta tarefa: Pwhite(0, 100).
c) Prand([0, 1, 2, 3], inf) escolhe itens da lista aleatoriamente. Pwhite(0, 3) chega ao mesmo resultado
por outros meios: ele gera aleatoriamente nmeros inteiros entre 0 e 3, o que acaba dando o mesmo leque de
opes que o Prand acima. No entanto, se voc escrever Pwhite(0, 3.0), o resultado ser diferente: como um dos
argumentos de entrada do Pwhite est escrito como um decimal (3.0), esse Pwhite produzir qualquer nmero
decimal entre 0 e 3, como 0.154, 1.0, 1.45, 2.999.
d) O primeiro Pbind toca 32 notes (4 vezes a sequncia de 8 notas). O segundo Pbind toca apenas 4 notas:
quatro escolhas aleatrias retiradas da lista (lembre-se que o Prand, diferentemente do Pseq, no tem a obrigao
de tocar todas as notas da lista: ele vai simplesmente escolher tantos nmeros aleatrios quanto voc pedir). O
terceiro e ltimo Pbind toca 32 notas, como o primeiro.
3
Primeira linha: o Array [1, 2, 3, "uau"] o objeto recebedor; reverse a mensagem. Segunda linha: a
String "al" o objeto recebedor; dup a mensagem; 4 o argumento para dup. Terceira linha: 3.1415 o objeto
recebedor; round a mensagem; 0.1 o argumento para round. Quarta linha: 100 o objeto recebedor, rand
a mensagem. ltima linha: 100.0 o recebedor da mensagem rand, o resultado do qual um nmero aleatrio
entre 0 e 100. Este nmero se torna o recebedor da mensagem round com o argumento 0.01, assim o nmero
aleatrio arredondado em duas casas decimais. Da este resultado se torna o objeto recebedor da mensagem dup
com o argumento 4, que cria uma lista com quatro duplicatas daquele nmero.
4
Reescrevendo usando apenas notao funcional: dup(round(rand(100.0), 0.01), 4);
5
Respostas:
a) 24
119
SinOsc bipolar porque produz nmeros entre 1- e +1. LFPulse unipolar porque o mbito de sada
0-1 (repare que no caso do LFPulse em particular, somente "zeros"e "uns"so gerados, sem nenhum nmero
intermedirio)
7
Soluo: a = {Out.ar(0, SinOsc.ar(freq: [800, 880], mul: LFPulse.ar([2, 3])))}.play;
8
(a) A varivel lfn simplesmente armazena um LFNoise2. O papel do LFNoise2 gerar aleatoriamente um
novo nmero (entre -1 e +1) a cada segundo e deslizar at ele a partir do ltimo nmero (diferentemente do
LFNoise0, que salta para o novo nmero imediatamente). O primeiro uso desta varivel lfn no argumento freq
do BPF: lfn.range(500, 2500). Isso pega os nmeros entre -1 e +1 e os redimensiona para o mbito 500-2500.
Estes nmeros so ento usados como a frequncia central do filtro. Estas frequncias so as alturas que escutamos
deslizando para cima e para baixo. Finalmente, lfn usada novamente para controlar a posio do pan Pan2.
Ela usada diretamente (sem uma mensagem .range) porque os nmeros j esto no mbito que queremos (de
-1 a +1). O resultado interessante disso que associamos a mudana de frequncia com a mudana de posio.
Como? A cada segundo, LFNoise2 comea a deslizar em direo a um novo nmero aleatrio e isso se torna uma
mudana sincronizada na frequncia do filtro e na posio de pan. Se tivssemos dois LFNoise2 diferentes, um
em cada lugar, as mudanas no teriam relao entre si (o que poderia ser bom tambm, mas o resultado sonoro
distinto).
(b) Um mul: de 1 soaria fraco demais. Como o filtro bastante estreito, ele retira tanto do sinal original que a
amplitude sofre uma queda exagerada. Precisamos ento aumentar o sinal de volta para um mbito razoavelmente
audvel, ento por isso que temos mul: 20 ao final da linha do BPF.
(c) O ritmo controlado pelo LFPulse que o argumento mul: do Saw. A frequncia do LFPulse (quantos pulsos
por segundo) controlada por um LFNoise1 que produz nmeros de 1 a 10 (interpolando entre eles). Tais nmeros
so as "quantas notas por segundo"deste patch.
120