1---
2title: Erste Effekte
3layout: ../../../layouts/MainLayout.astro
4---
5
6import { MiniRepl } from '../../../docs/MiniRepl';
7import QA from '@components/QA';
8
9# Erste Effekte
10
11import Box from '@components/Box.astro';
12
13## Ein paar grundlegende Effekte
14
15**low-pass filter**
16
17<MiniRepl
18 client:visible
19 tune={`note("<[c2 c3]*4 [bb1 bb2]*4 [f2 f3]*4 [eb2 eb3]*4>/2")
20.sound("sawtooth").lpf(800)`}
21/>
22
23<Box>
24
25lpf = **l**ow **p**ass **f**ilter
26
27- Ändere `lpf` in 200. Hörst du, wie der Bass dumpfer klingt? Es klingt so, als würde die Musik hinter einer geschlossenen Tür spielen 🚪
28- Lass uns nun die Tür öffnen: Ändere `lpf` in 5000. Der Klang wird dadurch viel heller und schärfer ✨🪩
29
30</Box>
31
32**filter automatisieren**
33
34<MiniRepl
35 client:visible
36 tune={`note("<[c2 c3]*4 [bb1 bb2]*4 [f2 f3]*4 [eb2 eb3]*4>/2")
37.sound("sawtooth").lpf("200 1000")`}
38/>
39
40<Box>
41
42- Füg noch mehr `lpf` Werte hinzu
43- Das Pattern in `lpf` ändert nicht den Rhythmus der Basslinie
44
45Später sehen wir, wie man mit Wellenformen Dinge automatisieren kann.
46
47</Box>
48
49**vowel = Vokal**
50
51<MiniRepl
52 client:visible
53 tune={`note("<[c3,g3,e4] [bb2,f3,d4] [a2,f3,c4] [bb2,g3,eb4]>/2")
54.sound("sawtooth").vowel("<a e i o>/2")`}
55/>
56
57**gain = Verstärkung**
58
59<MiniRepl
60 client:visible
61 tune={`stack(
62 sound("hh*8").gain("[.25 1]*2"),
63 sound("bd*2,~ sd:1")
64) `}
65 punchcard
66/>
67
68<Box>
69
70Bei Rhythmen ist die Dynamik (= Veränderungen der Lautstärke) sehr wichtig.
71
72- Entferne `.gain(...)` und achte darauf, wie es viel flacher klingt.
73- Mach es rückgängig (strg+z dann strg+enter)
74
75</Box>
76
77**stacks in stacks**
78
79Lass uns die obigen Beispiele kombinieren:
80
81<MiniRepl
82 client:visible
83 tune={`stack(
84 stack(
85 sound("hh*8").gain("[.25 1]*2"),
86 sound("bd*2,~ sd:1")
87 ),
88 note("<[c2 c3]*4 [bb1 bb2]*4 [f2 f3]*4 [eb2 eb3]*4>/2")
89 .sound("sawtooth").lpf("200 1000"),
90 note("<[c3,g3,e4] [bb2,f3,d4] [a2,f3,c4] [bb2,g3,eb4]>/2")
91 .sound("sawtooth").vowel("<a e i o>/2")
92) `}
93/>
94
95<Box>
96
97Versuche die einzelnen Teile innerhalb von `stack` zu erkennen. Schau dir an wie die Kommas gesetzt sind.
98
99Die 3 Teile (Drums, Bass, Akkorde) sind genau wie vorher, nur in einem `stack`, getrennt durch Kommas.
100
101</Box>
102
103**Den Sound formen mit ADSR-Hüllkurve**
104
105<MiniRepl
106 client:visible
107 tune={`note("<c3 bb2 f3 eb3>")
108.sound("sawtooth").lpf(600)
109.attack(.1)
110.decay(.1)
111.sustain(.25)
112.release(.2)`}
113/>
114
115<Box>
116
117Versuche herauszufinden, was die Zahlen machen. Probier folgendes:
118
119- attack: `.5` vs `0`
120- decay: `.5` vs `0`
121- sustain: `1` vs `.25` vs `0`
122- release: `0` vs `.5` vs `1`
123
124Kannst du erraten, was die einzelnen Werte machen?
125
126</Box>
127
128<QA q="Lösung anzeigen" client:visible>
129
130- attack (anschlagen): Zeit des Aufbaus
131- decay (zerfallen): Zeit des Abfalls
132- sustain (erhalten): Lautstärke nach Abfall
133- release (loslassen): Zeit des Abfalls nach dem Ende
134
135
136
137</QA>
138
139**adsr-Kurznotation**
140
141<MiniRepl
142 client:visible
143 tune={`note("<c3 bb2 f3 eb3>")
144.sound("sawtooth").lpf(600)
145.adsr(".1:.1:.5:.2")
146`}
147/>
148
149**delay = Verzögerung**
150
151<MiniRepl
152 client:visible
153 tune={`stack(
154 note("~ [<[d3,a3,f4]!2 [d3,bb3,g4]!2> ~]")
155 .sound("gm_electric_guitar_muted"),
156 sound("<bd rim>").bank("RolandTR707")
157).delay(".5")`}
158/>
159
160<Box>
161
162Probier verschiedene `delay` Werte zwischen 0 und 1. Übrigens: `.5` ist kurz für `0.5`.
163
164Was passiert, wenn du `.delay(".8:.125")` schreibst? Kannst du erraten, was die zweite Zahl macht?
165
166Was passiert, wenn du `.delay(".8:.06:.8")` schreibst? Kannst du erraten, was die dritte Zahl macht?
167
168</Box>
169
170<QA q="Lösung anzeigen" client:visible>
171
172`delay("a:b:c")`:
173
174- a: Lautstärke des Delays
175- b: Verzögerungszeit
176- c: Feedback (je kleiner, desto schneller verschwindet das Delay)
177
178</QA>
179
180**room aka reverb = Hall**
181
182<MiniRepl
183 client:visible
184 tune={`n("<4 [3@3 4] [<2 0> ~@16] ~>/2")
185.scale("D4:minor").sound("gm_accordion:2")
186.room(2)`}
187/>
188
189<Box>
190
191Spiel mit verschiedenen Werten.
192
193Füg auch ein Delay hinzu!
194
195</Box>
196
197**kleiner Dub-Tune**
198
199<MiniRepl
200 client:visible
201 tune={`stack(
202 note("~ [<[d3,a3,f4]!2 [d3,bb3,g4]!2> ~]")
203 .sound("gm_electric_guitar_muted").delay(.5),
204 sound("<bd rim>").bank("RolandTR707").delay(.5),
205 n("<4 [3@3 4] [<2 0> ~@16] ~>/2")
206 .scale("D4:minor").sound("gm_accordion:2")
207 .room(2).gain(.5)
208)`}
209/>
210
211Für echten Dub fehlt noch der Bass:
212
213<MiniRepl
214 client:visible
215 tune={`stack(
216 note("~ [<[d3,a3,f4]!2 [d3,bb3,g4]!2> ~]")
217 .sound("gm_electric_guitar_muted").delay(.5),
218 sound("<bd rim>").bank("RolandTR707").delay(.5),
219 n("<4 [3@3 4] [<2 0> ~@16] ~>/2")
220 .scale("D4:minor").sound("gm_accordion:2")
221 .room(2).gain(.4),
222 n("<0 [~ 0] 4 [3 2] [0 ~] [0 ~] <0 2> ~>*2")
223 .scale("D2:minor")
224 .sound("sawtooth,triangle").lpf(800)
225)`}
226/>
227
228<Box>
229
230Füg `.hush()` ans Ende eines Patterns im stack...
231
232</Box>
233
234**pan = Panorama**
235
236<MiniRepl
237 client:visible
238 tune={`sound("numbers:1 numbers:2 numbers:3 numbers:4")
239.pan("0 0.3 .6 1")
240.slow(2)`}
241/>
242
243**speed = Geschwindigkeit**
244
245<MiniRepl client:visible tune={`sound("bd rim").speed("<1 2 -1 -2>").room(.2)`} />
246
247**fast and slow = schnell und langsam**
248
249Mit `fast` und `slow` kann man das Tempo eines Patterns außerhalb der Mini-Notation ändern:
250
251<MiniRepl client:visible tune={`sound("bd*2,~ rim").slow(2)`} />
252
253<Box>
254
255Ändere den `slow`-Wert. Ersetze `slow` durch `fast`.
256
257Was passiert, wenn du den Wert automatisierst? z.b. `.fast("<1 [2 4]>")` ?
258
259</Box>
260
261Übrigens, innerhalb der Mini-Notation: `fast` ist `*` und `slow` ist `/`.
262
263<MiniRepl client:visible tune={`sound("[bd*2,~ rim]*<1 [2 4]>")`} />
264
265## Automation mit Signalen
266
267Anstatt Werte schrittweise zu automatisieren, können wir auch sogenannte Signale benutzen:
268
269<MiniRepl client:visible tune={`sound("hh*16").gain(sine)`} punchcard punchcardLabels={false} />
270
271<Box>
272
273Die grundlegenden Wellenformen sind `sine`, `saw`, `square`, `tri` 🌊
274
275Probiere auch die zufälligen Signale `rand` und `perlin`!
276
277Der `gain`-Wert (Verstärkung) wird in der Visualisierung als Transparenz dargestellt.
278
279</Box>
280
281**Bereich ändern mit `range`**
282
283Signale bewegen sich standardmäßig zwischen 0 und 1. Wir können das mit `range` ändern:
284
285<MiniRepl client:visible tune={`sound("hh*8").lpf(saw.range(500, 2000))`} />
286
287`range` ist nützlich wenn wir Funktionen mit einem anderen Wertebereich als 0 und 1 automatisieren wollen (z.b. `lpf`)
288
289<Box>
290
291Was passiert wenn du die beiden Werte vertauschst?
292
293</Box>
294
295Wir können die Geschwindigkeit der Automation mit slow / fast ändern:
296
297<MiniRepl
298 client:visible
299 tune={`note("<[c2 c3]*4 [bb1 bb2]*4 [f2 f3]*4 [eb2 eb3]*4>/2")
300.sound("sawtooth")
301.lpf(sine.range(100, 2000).slow(8))`}
302/>
303
304<Box>
305
306Die ganze Automation braucht nun 8 cycle bis sie sich wiederholt.
307
308</Box>
309
310## Rückblick
311
312| Name | Beispiel |
313| ----- | --------------------------------------------------------------------------------------- |
314| lpf | <MiniRepl client:visible tune={`note("c2 c3").s("sawtooth").lpf("<400 2000>")`} /> |
315| vowel | <MiniRepl client:visible tune={`note("c3 eb3 g3").s("sawtooth").vowel("<a e i o>")`} /> |
316| gain | <MiniRepl client:visible tune={`s("hh*8").gain("[.25 1]*2")`} /> |
317| delay | <MiniRepl client:visible tune={`s("bd rim").delay(.5)`} /> |
318| room | <MiniRepl client:visible tune={`s("bd rim").room(.5)`} /> |
319| pan | <MiniRepl client:visible tune={`s("bd rim").pan("0 1")`} /> |
320| speed | <MiniRepl client:visible tune={`s("bd rim").speed("<1 2 -1 -2>")`} /> |
321| range | <MiniRepl client:visible tune={`s("hh*16").lpf(saw.range(200,4000))`} /> |
322
323Lass uns nun die für Tidal typischen [Pattern-Effekte anschauen](/de/workshop/pattern-effects).
first-effects.mdx