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:
startPhaseist 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 dustartPhasekennst, sagt dirsin(startPhase)genau, wie hoch der Punkt sitzt, genauso wie du, sobald du den Winkel des Zeigers kennst, genau weißt, wohin er zeigt. AnstartPhaseist nichts eine Position in Pixeln oder ein Zeitpunkt für sich allein, es ist rein „wie weit herum".2 * PIist die Einheitenumrechnung, uhrzeigerartige Grad gegen Radiant eingetauscht.shiftAnimatable.value / waveLengthbeantwortet 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 mit2πzu multiplizieren verwandelt ihn in den tatsächlichen Winkel, densinerwartet, dennsinvollendet immer eine Umdrehung pro2π, genauso fest wie ein Zifferblatt immer eine Umdrehung pro360°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".
- →Polar to Cartesian: What cos and sin Are Actually ComputingThe same '2π per cycle' idea, but spent on an angle around a circle instead of a distance along a line.
- →animate*AsState vs Animatable: Animation Is Just an Interpolated ValueWhat shiftAnimatable.value and infiniteRepeatable are actually doing on every frame, underneath this post's formula.
- →Screen Coordinate Systems Aren't Cartesian: Y Points Down, Not UpWhy this post's formula subtracts amplitude * sin(phase) from center.y instead of adding it.
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 startWenn 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: 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
(
startXodertipX) undshiftAnimatable.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, sodasssin, 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 = 0ffestgehaltene Punkt erhält seinen Phasenbeitrag nur vonshiftAnimatable.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 seinemxändert sich nie etwas, und der Punkt schwingt trotzdem, zu 100 % durch das Ansteigen vonshiftAnimatable.value. - Der Punkt bei
tipXerhält Phasenbeiträge von beiden Termen: seine x-Position ändert sich, währendprogressansteigt, zusätzlich zu demselben darunterliegenden Ansteigen vonshiftAnimatable.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.xist der Positionsterm,time * speedist der Term für die verstrichene Zeit, zusammen addiert vorsin, genau die Formel dieses Beitrags, wobeifrequencyfür2π / waveLengthsteht. - Audiosynthese: ein digitaler Oszillator berechnet
sin(2 * PI * frequency * sampleIndex / sampleRate + phaseOffset)für jedes Sample,sampleIndex / sampleRateist die verstrichene Zeit in Sekunden,frequencyspielt dieselbe Rolle, die hier1 / waveLengthspielt, undphaseOffsetist 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 hier2π / waveLengthspielt,xist Position,tist 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 unterschiedlichenx-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
waveLengthunddurationMillis, 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.



