Recomposed
Canvas

Phase der Wanderwelle: Wie Position und Zeit zu einem Winkel werden

Oct 18, 2026 · 8 min read

Phase der Wanderwelle: Wie Position und Zeit zu einem Winkel werden

Was „Phase" eigentlich bedeutet

Stell dir einen Uhrzeiger vor, der sich langsam um ein leeres Zifferblatt dreht, ohne Zahlen darauf, sonst bewegt sich nichts, und er startet dort, wo er zufällig zuerst hinzeigt. Zu jedem Zeitpunkt kannst du fragen „Wohin zeigt er gerade?", und die ehrliche Antwort ist eine einzige Zahl: wie weit der Zeiger sich seit dem Start um den vollen Kreis bewegt hat.

Noch keine Bewegung bedeutet „dort, wo er gestartet ist", eine Vierteldrehung ist „ein Viertel des Weges herum", und der ganze Weg zurück zum Startpunkt ist „eine volle Umdrehung" – dann beginnt die Zählung wieder bei null.

Diese eine Zahl, wie weit sich etwas um eine volle Umdrehung bewegt hat, ist alles, was Phase jemals bedeutet. Sie hat nichts speziell mit Uhren zu tun und nichts mit Kreisen, die man tatsächlich sehen kann, alles, was sich wiederholt (eine Welle, die steigt und fällt, ein Zeiger, der sich dreht, ein Ton, der schwingt), hat eine Phase: dieselbe Zahl „wie weit bin ich in dieser einen Wiederholung", nur an eine andere Art von Bewegung geknüpft.

Ein Punkt, der auf einer Welle auf- und abschwingt, macht genau dieselbe Bewegung wie dieser Uhrzeiger, nur als Höhe statt als Richtung dargestellt. „Ein Viertel eines Auf-und-Ab-Zyklus" ist dieselbe Art von Tatsache, egal ob ein Zeiger nach Osten zeigt oder ein Punkt auf dem Gipfel einer Welle sitzt, Phase ist die Zahl, als die diese Tatsache festgehalten wird.

Code und Mathematik schreiben diese Zahl nicht als „eine Vierteldrehung" oder „90 Grad", sie schreiben sie in , einem anders skalierten Lineal für dieselbe Idee: eine volle Umdrehung sind 2π Radiant statt 360°. sin(phase) und cos(phase) sind die zwei Funktionen, deren einzige Aufgabe es ist, diese „wie weit herum"-Zahl zu lesen und sie in eine tatsächliche Position zu verwandeln, nichts weiter.

Die Intuition

((x + shift) / waveLength) * 2 * Math.PI sieht aus wie ein willkürlicher Haufen zusammengeschraubter Operationen, eine Addition, eine Division, eine Multiplikation, in keiner Reihenfolge, die sich selbst erklärt. Das ist sie nicht. Jeder Teil hat eine konkrete Aufgabe, und zusammen ergeben sie eine benannte Standardformel, kein einmaliges Herumschieben von Zahlen, bis die Animation gut aussah.

Diese Formel ist es, die einen Punkt auf und ab bewegt, um die Form der Welle immer wieder, für immer, nachzuzeichnen. Die Aufgabe besteht darin, etwas, das ständig weiter ansteigt, ohne Obergrenze, in eine Höhe zu verwandeln, die ständig zwischen einem oberen und einem unteren Punkt , im Takt mit der Welle.

Dieser ansteigende Wert ist nicht hypothetisch, er ist eine echte Zeile aus dem wellenförmigen Ladeindikator, aus dem die Formel dieses Beitrags stammt: shiftAnimatable.value. Es ist eine Animation, die von 0 bis waveLength hochzählt, zurück auf 0 springt und wieder hochzählt, in einer Schleife, die nie stoppt. Für sich allein ist das nur eine Zahl, die stetig größer wird, sie hat keine Ahnung, dass „oben" und „unten" überhaupt existieren. Diese Formel ist es, die diese eine ansteigende Zahl immer wieder, im Takt mit der Welle, in die tatsächliche Höhe des Punkts verwandelt:

val startPhase = (shiftAnimatable.value / waveLength) * 2 * Math.PI
val startY = center.y - amplitude * sin(startPhase)

Zwei Teile, jeder mit einer konkreten Aufgabe, um aus „einem ständig ansteigenden Animationswert" eine „Phase" zu machen:

  • startPhase ist die Phase selbst, genau die Zahl „wie weit um eine volle Umdrehung" aus der Uhrzeiger-Analogie oben, nur gemessen für den Zyklus dieser Welle statt für einen Zeiger, der sich um ein Zifferblatt dreht. Sobald du startPhase kennst, sagt dir sin(startPhase) genau, wie hoch der Punkt sitzt, genauso wie du, sobald du den Winkel des Zeigers kennst, genau weißt, wohin er zeigt. An startPhase ist nichts eine Position in Pixeln oder ein Zeitpunkt für sich allein, es ist rein „wie weit herum".
  • 2 * PI ist die Einheitenumrechnung, uhrzeigerartige Grad gegen Radiant eingetauscht. shiftAnimatable.value / waveLength beantwortet die Frage „welchen Anteil einer vollen Wellenwiederholung hat diese Animation bereits zurückgelegt", genau dieselbe Frage wie „welchen Anteil des Zifferblatts hat der Zeiger überstrichen". Diesen Anteil mit 2π zu multiplizieren verwandelt ihn in den tatsächlichen Winkel, den sin erwartet, denn sin vollendet immer eine Umdrehung pro 2π, genauso fest wie ein Zifferblatt immer eine Umdrehung pro 360° vollendet, das kann sich keine der beiden Formeln aussuchen.

Das ist die gesamte Formel für einen bestimmten Punkt auf der Welle, denjenigen, der nie seitwärts wandert. Die meisten Punkte auf einer Welle wandern aber auch seitwärts, was eine zweite Zutat in dieselbe Summe einfließen lässt, behandelt weiter unten unter „Weitere Fälle".

Konkretes Beispiel

Das ist die echte Berechnung hinter einem wellenförmigen Ladeindikator, reduziert auf die reine Phasen-Mathematik. Sie nimmt auch eine Position x entgegen, die oben erwähnte zweite Zutat, die unten bei 0 gehalten wird, um zur Einzelpunkt-Formel aus „Die Intuition" zu passen:

val waveLength = 46f // px, one full wave repeat
val amplitude = 6f   // px
 
fun heightAt(x: Float, shift: Float): Float {
    val phase = ((x + shift) / waveLength) * 2 * Math.PI
    return (center.y - amplitude * sin(phase)).toFloat()
}

Lass shift einmal komplett durch eine volle waveLength laufen, während x bei 0 bleibt, genau die Situation, in der sich der feste Startpunkt der Welle befindet:

heightAt(x = 0f, shift = 0f)     // phase = 0        → sin = 0     → center.y
heightAt(x = 0f, shift = 11.5f)  // phase = π/2       → sin = 1     → center.y - amplitude (top)
heightAt(x = 0f, shift = 23f)    // phase = π         → sin = 0     → center.y
heightAt(x = 0f, shift = 34.5f)  // phase = 3π/2      → sin = -1    → center.y + amplitude (bottom)
heightAt(x = 0f, shift = 46f)    // phase = 2π        → sin = 0     → center.y, back to the start

Wenn shift eine volle waveLength (46 px) durchläuft, legt phase exakt ein volles 2π zurück, was genau einem vollen sin-Zyklus entspricht: oben, Mitte, unten, Mitte. Das ist kein Zufall, das ist die 2π-Umrechnung, die ihre eine Aufgabe erfüllt: „eine waveLength an Distanz" gleich „eine Runde sin" zu machen. shiftAnimatable tut dann genau das, animiert von 0 zu waveLength in einer Endlosschleife, weshalb der Punkt immer wieder durch dieselbe Abfolge oben-Mitte-unten-Mitte schwingt.

Zieh die Schieberegler unten und beobachte, wie sich beide Darstellungen gemeinsam bewegen: die Höhe des Punkts auf der Welle und der Punkt, der auf dem Kreis nachgezeichnet wird, stammen beide aus derselben phase, nur auf zwei verschiedene Arten gelesen.

phase

phase: 92.6° sin(phase): 1

((0 + 18) / 70) × 2π = 1.6 rad — x 0, shift 18, phase 92.6 degrees, sin of phase 1

Weitere Fälle: ein Punkt, der auch seitwärts wandert

Die Formel aus „Die Intuition" ist die echte, aber nur für den Punkt, der sich nie seitwärts bewegt. Hier ist die tatsächliche Zeile, mit Position und allem, neben demselben Punkt, der bei 0 festgehalten wird:

val startX = 0f                     // never moves
val startPhase = ((startX + shiftAnimatable.value) / waveLength) * 2 * Math.PI
 
val tipX = size.width * progress()  // a second point, moves as progress animates
val tipPhase = ((tipX + shiftAnimatable.value) / waveLength) * 2 * Math.PI
  • Zwei unterschiedliche Dinge werden zu dieser einen Zahl aufsummiert, bevor sie zu einem Winkel wird: eine Position (startX oder tipX) und shiftAnimatable.value (wie weit eine unabhängige, endlos wiederholende -Animation bereits gelaufen ist, näher an verstrichener Zeit). Sie werden addiert, bevor eines der beiden Teil des Winkels wird, sodass sin, wenn es ausgeführt wird, auf eine einzige kombinierte Zahl blickt, ohne erkennen zu können, welcher Teil von der Position und welcher von der Zeit stammt.
  • Der bei startX = 0f festgehaltene Punkt erhält seinen Phasenbeitrag nur von shiftAnimatable.value, sein eigener Term in der Summe ist permanent null, genau die vereinfachte Formel, mit der „Die Intuition" eröffnet hat. Deshalb schwingt er trotzdem, obwohl er nie seitwärts wandert: An seinem x ändert sich nie etwas, und der Punkt schwingt trotzdem, zu 100 % durch das Ansteigen von shiftAnimatable.value.
  • Der Punkt bei tipX erhält Phasenbeiträge von beiden Termen: seine x-Position ändert sich, während progress ansteigt, zusätzlich zu demselben darunterliegenden Ansteigen von shiftAnimatable.value. Derselbe Mechanismus, nun mit zwei sich bewegenden Eingaben statt einer.

Dieselbe Funktion, dieselbe Formel, und das Einzige, was sich zwischen den beiden Punkten ändert, ist, welches Argument ein lebender Wert ist und welches eine Konstante.

Das Grundprinzip

Das ist die Phasenformel einer Wanderwelle, dieselbe Form, die die Physik als φ(x, t) = k(x + vt) schreibt, wobei k = 2π / wavelength die Wellenzahl ist, der feste Umrechnungsfaktor von Distanz zu Radiant. Position und verstrichene Zeit sind zwei unabhängige Eingaben, die zu einer Zahl, der Phase, aufsummiert werden, bevor irgendeine oszillierende Funktion (sin, cos, oder irgendetwas Periodisches) jemals darauf läuft. Die oszillierende Funktion hat keine Möglichkeit, die beiden Beiträge wieder zu trennen, und muss es auch nicht, sie verarbeitet immer nur die Summe.

Anderswo: dasselbe Grundprinzip, anderes Framework

  • Fragment-Shader (GLSL): ein Wasser- oder Fahnen-Wellen-Effekt ist fast immer sin(uv.x * frequency + time * speed), uv.x ist der Positionsterm, time * speed ist der Term für die verstrichene Zeit, zusammen addiert vor sin, genau die Formel dieses Beitrags, wobei frequency für 2π / waveLength steht.
  • Audiosynthese: ein digitaler Oszillator berechnet sin(2 * PI * frequency * sampleIndex / sampleRate + phaseOffset) für jedes Sample, sampleIndex / sampleRate ist die verstrichene Zeit in Sekunden, frequency spielt dieselbe Rolle, die hier 1 / waveLength spielt, und phaseOffset ist ein reiner Phasenverschiebungs-Term, an den überhaupt keine Zeit oder Position geknüpft ist.
  • Physik, die ursprüngliche Quelle: die Wanderwellengleichung y(x, t) = A·sin(kx - ωt) ist dieselbe Formel, die dieser Beitrag die ganze Zeit verwendet hat, k = 2π/λ (die Wellenzahl) spielt die Rolle, die hier 2π / waveLength spielt, x ist Position, t ist Zeit. Die kanonische Form subtrahiert den Zeitterm; der Code dieses Beitrags addiert ihn stattdessen, dieselbe Idee, umgekehrtes Vorzeichen, was genau dem Grenzfall der Bewegungsrichtung weiter unten entspricht.

Grenzfälle

Das 2π weglassen oder die falsche Konstante verwenden. sin(distance / waveLength) kompiliert trotzdem und oszilliert trotzdem, es vollendet nur einen vollen Zyklus alle 2π * waveLength Pixel statt alle waveLength Pixel. Nichts stürzt ab; die Welle stimmt nur stillschweigend nicht mehr mit der waveLength-Konstante überein, die der Rest des Codes annimmt.

Das Vorzeichen zwischen Positions- und Zeitterm vertauschen. x + shift und x - shift oszillieren an jedem einzelnen eingefrorenen Zeitpunkt identisch, der Unterschied zeigt sich erst über die Zeit: +shift lässt das Wellenmuster so aussehen, als würde es in eine Richtung gleiten, während shift ansteigt, -shift gleitet in die andere Richtung. Das falsche Vorzeichen zu wählen zerstört nicht die Form, es kehrt die Bewegungsrichtung um, ein Bug, der in einem Screenshot unsichtbar ist und sich erst zeigt, wenn man es tatsächlich animiert sieht.

waveLength mit der Dauer der Animation verwechseln. waveLength ist eine Distanz (Pixel pro Wiederholung); durationMillis der shiftAnimatable-Animation ist eine Dauer (Millisekunden pro Wiederholung). Das Ändern von WaveSpeed im echten Code ändert nur durationMillis, sodass die Welle schneller oder langsamer scrollt, aber waveLength bleibt fest, sodass sich die tatsächliche Form der Welle auf dem Bildschirm (wie hoch, wie dicht gepackt) nie ändert. Geschwindigkeit und Form werden von zwei unabhängigen Konstanten gesteuert, die zufällig beide in dieselbe phase-Formel einfließen.

Wann man darauf zurückgreift

Immer dann, wenn etwas so aussehen muss, als würde es auf einem sich wiederholenden Muster reiten, das sich selbst bewegt:

  • Scrollende Wellen-/Rippel-Effekte, ein Ladeindikator, ein Wasser-Shader, ein Audio-Wellenform-Visualisierer, überall dort, wo eine Form gleichzeitig im Raum oszillieren und über die Zeit scrollen muss.
  • Mehrere Markierungen, die auf derselben Welle reiten, sobald die Höhe eines Punkts heightAt(x, shift) ist, bedeutet das Platzieren von N weiteren Markierungen nur, dieselbe Funktion mit N unterschiedlichen x-Werten aufzurufen, genau wie beim Tip/Start-Punktpaar oben.
  • Alles mit einer unabhängigen „räumlichen Frequenz" und „zeitlichen Geschwindigkeit", die getrennt einstellbar sein müssen, hier waveLength und durationMillis, weil es wirklich zwei unterschiedliche Konstanten sind, nicht zwei Namen für dasselbe.

Das Signal, dass dies das falsche Grundprinzip für die Situation ist: Wenn es nur eine Eingabe gibt (nur Zeit oder nur Position, nie beide zusammen addiert), steckt kein „Wandern" in der Wanderwelle, ein einfaches animateFloat, das sin direkt treibt, deckt das bereits ab.

Phase ist niemals Zeit und niemals Position allein, sondern das, was zusammen aufsummiert wird, bevor das Ergebnis an sin übergeben wird, und 2π ist einfach die Einheit, in der diese Summe landen muss, weil das die einzige Einheit ist, in der sin einen vollen Zyklus versteht.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach