Eine Live-Coding-Musik-App bauen · Teil 13 von 18 der Serie
Teil 13: Filter, Delay, Hall und Verzerrung
Setz Effekte zwischen die Instrumente und die Lautsprecher: einen Filter, ein Delay, dessen Echos dem Tempo folgen, einen Hall aus abklingendem Rauschen und eine Verzerrung, die die Welle verbiegt. Ein Limiter vor den Lautsprechern fängt ab, was zu laut wird.
Eine Live-Coding-Musik-App bauenTeil 13 von 18
Auf dieser Seite
Quest-Ziele
- Vier Effekte auf einer gemeinsamen Basisklasse bauen
- Ein Delay in sich selbst zurückführen und in Schlägen messen
- Einen Raum für den Faltungshall aus abklingendem Rauschen erzeugen
- Eine Welle mit einer Kurve verbiegen und dabei überabtasten
- Den bearbeiteten Klang mit dem unveränderten mischen
- Den Ausgang mit einem Limiter schützen
Bisher geht jedes Instrument des Songs direkt zu den Lautsprechern: kit.to(out). Ein Effekt ist ein Baustein, der auf diesem Weg sitzt. Er nimmt Audio entgegen, verändert es und gibt Audio weiter. Nach diesem Teil lautet eine Zeile des Songs keys.to(delay()).to(reverb()).to(out): die Akkorde, dann ihre Echos, dann ein Raum um beides.
Der Code, der den Song ausführt, muss dafür nicht geändert werden. Seit Teil 9 vergleicht to(), was der eine Baustein gibt und was der andere nimmt, und gibt den Baustein zurück, mit dem es verbunden hat. Deshalb lassen sich die Aufrufe aneinanderhängen. Und die Engine steckt ein Audio-Kabel von jedem Ausgang in jeden Eingang. Es fehlen Bausteine, die beides haben. Dieser Teil baut vier davon, und wie in Teil 12 ist jeder eine Klasse, ein Eintrag im Schema und eine Zeile in der Engine. Zwei Kleinigkeiten kommen dazu: Das Delay muss das Tempo kennen, und die Lautsprecher bekommen einen Limiter.
Was alle Effekte gemeinsam haben
Von außen sehen alle vier gleich aus: ein Gain-Knoten als Eingang, ein Gain-Knoten als Ausgang und ein Ausblenden, wenn der Code sie nicht mehr erzeugt. Das kommt in eine Basisklasse. Lege src/effects.ts an. Die Datei hat fünf Abschnitte, die aufeinander folgen, und das ist der erste:
import { audio } from './audio.ts';
import type { Unit } from './unit.ts';
/** What every effect has in common: an input, an output, and a fade when it goes. */
abstract class Effect {
protected readonly context = audio();
readonly input = this.context.createGain();
readonly output = this.context.createGain();
/** Fades out, and unplugs once nothing is heard any more. */
dispose() {
this.output.gain.setTargetAtTime(0, this.context.currentTime, 0.02);
window.setTimeout(() => this.output.disconnect(), 200);
}
}Die beiden Gain-Knoten tun dem Klang nichts. Sie sind die festen Stellen, an denen Kabel eingesteckt werden, egal was der Effekt dazwischen hat. Für die Engine ist das wichtig: Bei jedem Durchlauf steckt sie den output jedes Bausteins aus und steckt die Kabel neu ein, und disconnect() entfernt alle Kabel, die von einem Knoten wegführen. Mit einem eigenen Gain-Knoten als Ausgang trifft das immer nur die Kabel zu anderen Bausteinen, nie die Verdrahtung im Effekt selbst.
abstract heißt, dass niemand einen Effect selbst erzeugen kann, nur die Klassen, die darauf aufbauen. protected lässt diese Klassen context benutzen. dispose() ist das Ausblenden, das auch die Synths haben: in wenigen Hundertstelsekunden leise, nach 200 Millisekunden ausgesteckt.
Der Filter
Beide Synths haben einen Tiefpassfilter eingebaut. Als eigener Baustein kann ein Filter hinter allem stehen, auch hinter den Drums. Ein Tiefpass dreht alles leiser, was über seinem Cutoff liegt, der Grenzfrequenz, an der er arbeitet. Ein Hochpass dreht alles darunter leiser. Ein Bandpass tut beides und lässt ein Band um den Cutoff übrig. Die Resonanz betont die Frequenzen direkt am Cutoff, und beim Bandpass macht sie das Band schmaler. Unter der Basisklasse, in derselben Datei:
// ---------------------------------------------------------------------------
export type FilterOptions = {
type: BiquadFilterType;
cutoff: number;
resonance: number;
};
/** Turns down what is above the cutoff (lowpass), below it (highpass) or around it (bandpass). */
export class Filter extends Effect implements Unit {
private readonly filter = this.context.createBiquadFilter();
constructor(options: FilterOptions) {
super();
this.input.connect(this.filter).connect(this.output);
this.update(options);
}
update(options: FilterOptions) {
const now = this.context.currentTime;
this.filter.type = options.type;
this.filter.frequency.setTargetAtTime(options.cutoff, now, 0.02);
this.filter.Q.setTargetAtTime(options.resonance, now, 0.02);
}
}input.connect(filter).connect(output) ist der ganze Effekt. update() läuft, wenn der Baustein erzeugt wird und immer dann, wenn ein Durchlauf des Codes seine Optionen ändert. Cutoff und Resonanz gleiten mit setTargetAtTime zu ihren neuen Werten, wie in den Synths, damit eine Änderung nicht knackt. Der Typ ist kein Parameter, der gleiten kann: Er wird sofort gesetzt.
Das Delay
Ein Delay hält den Klang eine Weile zurück und lässt ihn dann heraus: ein Echo. Das Echo soll selbst wieder ein Echo bekommen, jedes Mal etwas leiser. Das ist Feedback: Der Ausgang des Delay-Knotens geht durch einen Gain-Knoten zurück in den Eingang desselben Delay-Knotens. Mit einem Feedback von 0.5 ist jedes Echo halb so laut wie das davor: 0.5, 0.25, 0.125, bis es nicht mehr zu hören ist. Bei 1 würden die Echos nie leiser, und über 1 wäre jedes lauter als das letzte. Das Schema hört bei 0.9 auf.
Das Dry-Signal eines Effekts ist der Klang, wie er hereinkam, das Wet-Signal ist das, was der Effekt daraus gemacht hat. Das Delay lässt das Dry-Signal direkt durch und gibt das Wet-Signal dazu, durch einen Gain-Knoten, den die Option mix einstellt. Bei 0 gibt es keine Echos, bei 1 ist das erste Echo so laut wie der Klang selbst.
Die Zeit zwischen den Echos wird in Schlägen angegeben, nicht in Sekunden. Ein Echo, das bei 124 Schlägen pro Minute im Takt liegt, liegt bei 90 daneben, außer es folgt dem Tempo. Ein Zyklus hat vier Schläge, also sind time Schläge time × cycleSeconds / 4 Sekunden. Der Standardwert 0.75 ist ein Dreiviertelschlag: Die meisten Echos fallen zwischen die Schläge des Songs, nicht darauf.
// ---------------------------------------------------------------------------
export type DelayOptions = {
/** The time between the echoes, in beats. */
time: number;
/** How much of each echo is fed back into the delay: the higher, the more echoes. */
feedback: number;
/** How loud the echoes are next to the sound itself. */
mix: number;
};
/** Echoes in time with the music: the sound, delayed, and fed back into the delay again. */
export class Delay extends Effect implements Unit {
private readonly delay = this.context.createDelay(4);
private readonly feedback = this.context.createGain();
private readonly wet = this.context.createGain();
private options: DelayOptions;
private cycleSeconds = 2;
constructor(options: DelayOptions) {
super();
this.options = options;
// The sound itself goes straight through. Next to it runs the loop of the echoes.
this.input.connect(this.output);
this.input.connect(this.delay).connect(this.wet).connect(this.output);
this.delay.connect(this.feedback).connect(this.delay);
this.update(options);
}
update(options: DelayOptions) {
this.options = options;
const now = this.context.currentTime;
// A beat is a quarter of a cycle.
const seconds = Math.min(4, (options.time * this.cycleSeconds) / 4);
this.delay.delayTime.setTargetAtTime(seconds, now, 0.02);
this.feedback.gain.setTargetAtTime(options.feedback, now, 0.02);
this.wet.gain.setTargetAtTime(options.mix, now, 0.02);
}
tempo(cycleSeconds: number) {
this.cycleSeconds = cycleSeconds;
this.update(this.options);
}
}createDelay(4) erzeugt einen Delay-Knoten, der bis zu vier Sekunden halten kann. Deshalb wird die Zeit bei 4 gekappt. Die drei Zeilen mit connect im Konstruktor sind das Bild von oben: direkt durch, durch das Delay und den Gain-Knoten wet, und in der Schleife durch feedback. Die Web Audio API erlaubt eine Schleife im Graphen, solange ein Delay-Knoten darin liegt.
Das Tempo kann das Delay nicht selbst herausfinden. Es beginnt mit einem Zyklus von zwei Sekunden, das sind 120 Schläge pro Minute, und hat eine Methode tempo(), über die es die tatsächliche Länge erfährt. Dann rechnet es seine Sekunden neu aus. Ergänze diese Methode in src/unit.ts in Unit, nach play:
/** Told the length of a cycle in seconds, after every run of the code. */
tempo?(cycleSeconds: number): void;Das Fragezeichen macht sie optional: Nur Bausteine, die das Tempo etwas angeht, haben sie. Die Engine ruft sie am Ende jedes Durchlaufs auf, für alte und neue Bausteine gleichermaßen. In src/engine.ts bekommt das Ende von apply() eine Zeile zwischen der Zeile, die das Tempo setzt, und dem return:
if (patch.bpm !== this.clock.bpm) this.clock.bpm = patch.bpm;
for (const unit of this.units.values()) unit.tempo?.(this.clock.cycleSeconds);
return count;Der Hall
In einem Raum erreicht dich ein Klang einmal direkt und dann noch tausende Male von den Wänden, dem Boden und der Decke, so dicht hintereinander, dass du keine einzelnen Echos hörst, sondern einen Nachklang, der verebbt. Ein Hall fügt einen solchen Nachklang hinzu.
Das Verfahren hier heißt Faltung. Es geht von der Antwort des Raums auf einen einzelnen Klick aus, den kürzesten Klang, den es gibt. Diese Antwort ist die Impulsantwort des Raums. Digitaler Klang ist eine Reihe von Zahlen, den Abtastwerten, und jeder Abtastwert lässt sich als Klick mit seiner eigenen Lautstärke sehen. Der Faltungsknoten löst für jeden Abtastwert seines Eingangs die ganze Impulsantwort aus, so laut wie dieser Abtastwert, und zählt alle zusammen. Heraus kommt der Klang, wie dieser Raum ihn zurückgeben würde.
Eine Impulsantwort ist normalerweise eine Aufnahme: Jemand klatscht in einem Saal. Diese hier ist ausgedacht. Rauschen, das abklingt, hat das, worauf es bei einer echten ankommt: eine dichte Folge zufälliger Werte, die leiser wird. room() füllt einen Puffer mit Zufallszahlen zwischen -1 und 1 und multipliziert sie mit einer Kurve, die von 1 auf 0 fällt. Die dritte Potenz lässt sie am Anfang schnell und am Ende langsam fallen. Die beiden Kanäle bekommen verschiedene Zufallszahlen, sodass der linke und der rechte Lautsprecher nicht denselben Nachklang bekommen.
// ---------------------------------------------------------------------------
export type ReverbOptions = {
/** How long the room rings, in seconds. */
size: number;
/** How loud the room is next to the sound itself. */
mix: number;
};
/** The sound of a room: every sample of the input sets off the room's whole echo. */
export class Reverb extends Effect implements Unit {
private readonly convolver = this.context.createConvolver();
private readonly wet = this.context.createGain();
private size = 0;
constructor(options: ReverbOptions) {
super();
this.input.connect(this.output);
this.input.connect(this.convolver).connect(this.wet).connect(this.output);
this.update(options);
}
update(options: ReverbOptions) {
this.wet.gain.setTargetAtTime(options.mix, this.context.currentTime, 0.02);
if (options.size === this.size) return;
this.size = options.size;
this.convolver.buffer = this.room(options.size);
}
/** What a clap sounds like in the room: noise that dies away, different on each side. */
private room(seconds: number): AudioBuffer {
const length = Math.floor(seconds * this.context.sampleRate);
const buffer = this.context.createBuffer(2, length, this.context.sampleRate);
for (let channel = 0; channel < 2; channel += 1) {
const data = buffer.getChannelData(channel);
for (let i = 0; i < length; i += 1) {
data[i] = (Math.random() * 2 - 1) * (1 - i / length) ** 3;
}
}
return buffer;
}
}Dry und Wet sind verdrahtet wie im Delay. size ist die Länge des Puffers in Sekunden und damit die Zeit, die der Raum nachklingt. Ein Raum von drei Sekunden besteht aus zwei Kanälen mit jeweils weit über hunderttausend Zahlen, also erzeugt update() nur dann einen neuen, wenn sich die Größe geändert hat. Ändert sich nur mix, bewegt sich ein Gain-Knoten. Der Faltungsknoten skaliert den Puffer, den er bekommt, nach dessen mittlerem Pegel, solange sein normalize nicht abgeschaltet ist. Deshalb dürfen die Zahlen den ganzen Bereich von -1 bis 1 ausfüllen: Ohne die Skalierung käme die Summe so vieler Zahlen viel zu laut heraus.
Die Verzerrung
Ein Waveshaper verändert jeden Abtastwert für sich, ohne auf die daneben zu schauen. Seine Kurve sagt für jeden Pegel, der von -1 bis 1 hereinkommen kann, was hinausgeht. Eine gerade Linie von -1 bis 1 ändert nichts. Die Kurve hier ist in der Mitte steil und zu beiden Enden hin flach: Leise Teile der Welle werden lauter gedreht, und laute Teile werden gegen eine Decke gedrückt, über die sie nicht hinauskommen. Eine runde Welle kommt mit abgeflachten Spitzen heraus, näher an einer Rechteckwelle, die nur zwischen zwei Pegeln springt. Das ist Verzerrung.
Die Funktion mit dieser Form ist tanh. amount streckt den Eingang davor: von 1 bei einem Drive von 0, wo sich die Kurve nur wenig biegt, bis 31 bei einem Drive von 1, wo fast jeder Pegel an der Decke landet. Das Teilen durch tanh(amount) lässt die Kurve genau bei -1 und 1 enden.
// ---------------------------------------------------------------------------
export type DistortionOptions = {
/** How hard the sound is pushed against the ceiling, from 0 to 1. */
drive: number;
};
/** Bends the wave: quiet parts are turned up, loud parts are pressed flat. */
export class Distortion extends Effect implements Unit {
private readonly shaper = this.context.createWaveShaper();
private drive = -1;
constructor(options: DistortionOptions) {
super();
// Bending a wave adds frequencies. Working at four times the rate keeps them clean.
this.shaper.oversample = '4x';
this.input.connect(this.shaper).connect(this.output);
this.update(options);
}
update(options: DistortionOptions) {
if (options.drive === this.drive) return;
this.drive = options.drive;
// The curve says what comes out for every level that goes in, from -1 to 1.
const amount = 1 + options.drive * 30;
const curve = new Float32Array(1024);
for (let i = 0; i < curve.length; i += 1) {
const x = (i / (curve.length - 1)) * 2 - 1;
curve[i] = Math.tanh(x * amount) / Math.tanh(amount);
}
this.shaper.curve = curve;
// What is pressed flat sounds louder: turn it down to make up for it.
this.output.gain.setTargetAtTime(1 / (1 + options.drive * 2), this.context.currentTime, 0.02);
}
}Die Kurve ist eine Liste von 1024 Werten, und der Knoten füllt die Lücken dazwischen auf. Wie der Puffer des Halls wird sie nur neu erzeugt, wenn sich drive geändert hat. Das Feld beginnt bei -1, was kein Drive sein kann, also erzeugt das erste update() immer eine.
Eine Welle mit abgeflachten Spitzen hält sich länger nahe der Decke auf, und ihre leisen Teile wurden lauter gedreht. Sie ist deshalb lauter als das, was hereinkam. Der Gain-Knoten am Ausgang gleicht das aus: Bei vollem Drive steht er auf einem Drittel.
Eine Welle zu verbiegen, fügt Frequenzen über denen hinzu, die sie hatte. Das macht sie rauer. Digitales Audio kann nur Frequenzen bis zur Hälfte seiner Abtastrate halten: 24.000 Hertz bei 48.000 Abtastwerten pro Sekunde. Die neuen Frequenzen hören an dieser Grenze nicht auf, und was dahinter liegt, verschwindet nicht. Es kommt gespiegelt zurück, als tiefere Frequenzen, die mit der Note nichts zu tun haben. Mit oversample = '4x' arbeitet der Waveshaper innen mit der vierfachen Abtastrate, wo viermal so viel Platz ist, und filtert weg, was über der normalen Grenze liegt, bevor er zur normalen Rate zurückkehrt. Das beseitigt die gespiegelten Frequenzen nicht ganz, lässt aber viel weniger davon übrig.
Ins Schema und in die Engine
Das Schema bekommt die vier Typen. Alle nehmen Audio und geben Audio. Ergänze sie in src/schema.ts in UNITS, nach polySynth:
filter: {
doc: 'Turns down what is above the cutoff (lowpass), below it (highpass) or around it (bandpass).',
takes: 'audio',
gives: 'audio',
options: {
type: { doc: 'Which side of the cutoff is turned down.', default: 'lowpass', choices: ['lowpass', 'highpass', 'bandpass'] },
cutoff: { doc: 'The frequency the filter works at, in hertz.', default: 1000, min: 30, max: 18000 },
resonance: { doc: 'How much the filter emphasizes its cutoff.', default: 1, min: 0.1, max: 20 },
},
},
delay: {
doc: 'Echoes in time with the music.',
takes: 'audio',
gives: 'audio',
options: {
time: { doc: 'The time between the echoes, in beats: 0.5 is an eighth note.', default: 0.75, min: 0.0625, max: 4 },
feedback: { doc: 'How much of each echo is fed back: the higher, the more echoes.', default: 0.4, min: 0, max: 0.9 },
mix: { doc: 'How loud the echoes are next to the sound itself.', default: 0.3, min: 0, max: 1 },
},
},
reverb: {
doc: 'The sound of a room.',
takes: 'audio',
gives: 'audio',
options: {
size: { doc: 'How long the room rings, in seconds.', default: 2, min: 0.2, max: 8 },
mix: { doc: 'How loud the room is next to the sound itself.', default: 0.3, min: 0, max: 1 },
},
},
distortion: {
doc: 'Presses the loud parts of the wave flat, which makes the sound rougher.',
takes: 'audio',
gives: 'audio',
options: {
drive: { doc: 'How hard the sound is pushed, from 0 to 1.', default: 0.4, min: 0, max: 1 },
},
},Mehr braucht das Skript nicht: Es erzeugt für jeden Eintrag von UNITS eine Funktion und prüft die Optionen dagegen. filter({ type: 'lowpas' }) antwortet schon jetzt mit type of filter can be lowpass, highpass, bandpass, but not "lowpas". Did you mean lowpass?
Importiere in src/engine.ts Delay, Distortion, Filter und Reverb sowie die Typen DelayOptions, DistortionOptions, FilterOptions und ReverbOptions aus ./effects.ts, und ersetze FACTORIES:
const FACTORIES: Record<string, (options: Options) => Unit> = {
pattern: (options) => new Player(options as PlayerOptions),
drums: (options) => new Drums(options as DrumsOptions),
monoSynth: (options) => new MonoSynth(options as MonoSynthOptions),
polySynth: (options) => new PolySynth(options as PolySynthOptions),
filter: (options) => new Filter(options as FilterOptions),
delay: (options) => new Delay(options as DelayOptions),
reverb: (options) => new Reverb(options as ReverbOptions),
distortion: (options) => new Distortion(options as DistortionOptions),
};Ein Limiter vor den Lautsprechern
Signale, die sich in einem Eingang treffen, werden addiert. Der Ausgang eines Computers trägt Pegel von -1 bis 1, und eine Bassdrum, eine Bassnote, ein Akkord, ihre Echos und zwei Räume im selben Moment können zusammen mehr ergeben. Was außerhalb des Bereichs liegt, wird flach abgeschnitten. Das ist eine Verzerrung, die niemand bestellt hat, und sie trifft alles auf einmal.
Ein Kompressor beobachtet den Pegel und dreht den Klang leiser, solange er über einem Schwellwert liegt. Pegel werden hier in Dezibel gezählt: 0 dB ist der volle Pegel von 1, und je 6 dB weniger sind etwa die Hälfte. Ein Schwellwert von -6 dB ist also etwa der halbe volle Pegel. Ein Verhältnis von 20 heißt, dass von je 20 dB über dem Schwellwert 1 dB übrig bleibt. Ein Knie von 0 lässt ihn genau am Schwellwert einsetzen, nicht allmählich darum herum. Der Attack von 2 Millisekunden bestimmt, wie schnell er leiser dreht, der Release von einer Zehntelsekunde, wie schnell er wieder loslässt. Ein Kompressor, der so fest eingestellt ist, heißt Limiter. Ersetze in src/engine.ts den Konstruktor von Engine:
constructor() {
// `out` is a unit like the others: a gain in front of the speakers. Between them sits
// a limiter: a compressor set to turn down what is too loud, and that firmly.
const out = audio().createGain();
const limiter = audio().createDynamicsCompressor();
limiter.threshold.value = -6;
limiter.knee.value = 0;
limiter.ratio.value = 20;
limiter.attack.value = 0.002;
limiter.release.value = 0.1;
out.connect(limiter).connect(audio().destination);
this.units.set('out', { input: out, update() {}, dispose() {} });
}Effekte im Song
Ersetze src/song.ts durch:
/** The code the editor starts with. */
export const SONG = `bpm(124)
const kit = drums()
pattern('bd*4, ~ cp ~ cp, hh*8?0.2').to(kit)
kit.to(reverb({ size: 0.8, mix: 0.15 })).to(out)
const bass = monoSynth({ cutoff: 300, resonance: 8 })
pattern('a1 a1:a [a2:s c2] <e2:s g2:as>').to(bass)
bass.to(distortion({ drive: 0.3 })).to(out)
const keys = polySynth({ release: 0.6, cutoff: 1800 })
pattern('<[a3,c4,e4] [f3,a3,c4] [c3,e3,g3] [g3,b3,d4]>').to(keys)
keys.to(delay({ time: 0.75, feedback: 0.5 })).to(reverb({ size: 3 })).to(out)
`;Die Drums gehen durch einen kleinen Raum: 0,8 Sekunden, und leise neben den Drums. Der Bass wird ein wenig verzerrt. Die Akkorde gehen zuerst durch das Delay und dann durch den Hall, sodass auch jedes Echo den Raum bekommt. Jeder Aufruf von reverb() erzeugt einen eigenen Baustein: Die beiden Räume haben nichts miteinander zu tun.
Probier es aus
Drück auf Play. Die Drums haben einen kurzen Nachklang. Jeder Akkord kommt einen Dreiviertelschlag später als leiseres Echo zurück, und jedes weitere Echo hat den halben Pegel von dem davor, alles in einem langen Raum. Ändere jetzt den Code und führe ihn mit Strg+Enter aus, während er spielt:
Ändere
feedback: 0.5auf0.85. Die Echos klingen viel langsamer ab: Die eines Akkords liegen noch unter dem nächsten. Stell es zurück.Ändere
bpm(124)aufbpm(90). Die Echos liegen weiter auseinander, und immer noch einen Dreiviertelschlag. Ein Delay-Knoten, dessen Zeit sich ändert, spielt währenddessen das, was er gerade hält, mit anderer Geschwindigkeit ab. Die Echos, die gerade unterwegs sind, können deshalb für einen Moment verbogen klingen.Ändere
drive: 0.3auf1. Jede Bassnote wird flach gegen die Decke gedrückt: Sie wird rauer, und ein Akzent ist kaum noch lauter als die anderen Noten, weil Lautes und Leises mit fast demselben Pegel herauskommt.Setz einen Filter hinter die Verzerrung:
bass.to(distortion({ drive: 0.3 })).to(filter({ type: 'highpass', cutoff: 500 })).to(out). Die Tiefen des Basses sind weg.Nimm
.to(reverb({ size: 3 }))aus der letzten Zeile. Die Zeile unter dem Editor zählt einen entfernten Baustein, und die Akkorde und ihre Echos stehen in keinem Raum mehr.
Um zu hören, was Feedback für sich allein tut, ersetze den ganzen Song durch eine Bassdrum pro Takt:
bpm(120)
const kit = drums()
pattern('bd ~ ~ ~').to(kit)
kit.to(delay({ time: 1, feedback: 0.7, mix: 0.8 })).to(out)Die Bassdrum wird auf dem ersten Schlag gespielt. Was du auf den anderen drei Schlägen hörst, sind ihre Echos: time: 1 legt sie einen Schlag auseinander. Das erste hat 0.8 des Pegels der Bassdrum, das ist mix, und jedes danach hat 0.7 des Pegels von dem davor, das ist feedback.
Ein Eingang addiert alles, was in ihm steckt, also können sich zwei Instrumente einen Effekt teilen. Leg ihn in eine Variable und verbinde beide:
const kit = drums()
pattern('bd*4, ~ cp ~ cp').to(kit)
const keys = polySynth()
pattern('<[a3,c4,e4] [f3,a3,c4]>').to(keys)
const room = reverb({ size: 3 })
kit.to(room)
keys.to(room)
room.to(out)Drums und Akkorde klingen jetzt im selben Raum, und room.to(out) ist das einzige Kabel zu den Lautsprechern.
Kommentare
Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.
Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.