Ce que « phase » signifie réellement
Imaginez l'aiguille d'une horloge balayant lentement un cadran vide, sans chiffres, rien d'autre en mouvement, partant d'où elle pointait au départ. À n'importe quel instant, on peut demander « où pointe-t-elle ? », et la réponse honnête est un seul nombre : jusqu'où autour du cercle complet l'aiguille a balayé depuis son départ.
Pas encore de balayage, c'est là où elle a commencé, un quart de tour c'est « un quart du chemin autour », et revenir entièrement à son point de départ, c'est « une boucle complète », puis elle recommence à compter depuis zéro.
Ce seul nombre, jusqu'où une chose a parcouru une boucle complète, c'est tout ce que la phase signifie jamais. Cela n'a rien à voir avec les horloges en particulier, ni avec des cercles qu'on peut littéralement voir, tout ce qui se répète (une onde qui monte et descend, un cadran qui balaye, un son qui vibre) a une phase : le même nombre « jusqu'où suis-je dans cette répétition », simplement attaché à un type de mouvement différent.
Un point qui oscille de haut en bas sur une onde effectue exactement le même balayage que cette aiguille d'horloge, simplement redessiné comme une hauteur au lieu d'une direction. « Un quart du chemin dans un cycle de montée-descente » est le même type de fait, que ce soit une aiguille pointant vers l'est ou un point assis au sommet d'une onde, la phase est le nombre sous lequel ce fait est noté.
Le code et les mathématiques n'écrivent pas ce nombre comme « un quart
de tour » ou « 90 degrés », ils l'écrivent en
,
une règle de taille différente pour la même idée : une boucle complète
équivaut à 2π radians au lieu de 360°. sin(phase)
et cos(phase) sont les deux fonctions dont le seul travail est de lire
ce nombre « jusqu'où autour » et de le transformer en une position
réelle, rien de plus.
L'intuition
((x + shift) / waveLength) * 2 * Math.PI ressemble à un tas arbitraire
d'opérations boulonnées ensemble, une addition, une division, une
multiplication, dans un ordre qui ne s'explique pas de lui-même. Ce
n'est pas arbitraire. Chaque élément a un rôle précis, et ensemble ils
forment une formule nommée, standard, pas un bricolage ponctuel de
nombres jusqu'à ce que l'animation ait l'air correcte.
Cette formule est ce qui fait qu'un point se déplace de haut en bas pour tracer la forme de l'onde, encore et encore, à l'infini. Le travail consiste à prendre quelque chose qui ne cesse de grimper, sans plafond, et à le transformer en une hauteur qui continue d' entre un sommet et un creux, au rythme de l'onde.
Cette valeur qui grimpe n'est pas hypothétique, c'est une vraie ligne
tirée de l'indicateur de chargement ondulé dont la formule de cet
article est tirée : shiftAnimatable.value.
C'est une animation qui compte de 0 à waveLength, revient à 0, et
recompte, en boucle, sans jamais s'arrêter. Seule, c'est juste un nombre
qui grossit régulièrement, elle n'a aucune idée que « haut » et « bas »
existent même. Cette formule est ce qui transforme ce seul nombre
grimpant en la hauteur réelle du point, encore et encore, en synchronie
avec l'onde :
val startPhase = (shiftAnimatable.value / waveLength) * 2 * Math.PI
val startY = center.y - amplitude * sin(startPhase)Deux éléments, chacun accomplissant un rôle précis dans la transformation d'« une valeur d'animation qui grimpe sans cesse » en « phase » :
startPhaseest la phase elle-même, exactement le nombre « jusqu'où autour d'une boucle complète » de l'analogie de l'aiguille d'horloge ci-dessus, simplement mesuré pour le cycle de cette onde plutôt que pour une aiguille balayant un cadran. Une foisstartPhaseconnu,sin(startPhase)indique exactement à quelle hauteur se trouve le point, de la même façon qu'une fois l'angle de l'aiguille connu, on sait exactement où elle pointe. Rien dansstartPhasen'est une position en pixels ou un instant dans le temps en soi, c'est purement « jusqu'où autour ».2 * PIest la conversion d'unité, les degrés façon horloge échangés contre des radians.shiftAnimatable.value / waveLengthest « quelle fraction d'une répétition complète de l'onde cette animation a-t-elle couverte », exactement la même question que « quelle fraction du cadran l'aiguille a-t-elle balayée ». Multiplier cette fraction par2πla transforme en l'angle réel attendu parsin, carsincomplète toujours une boucle tous les2π, de la même façon fixe qu'un cadran d'horloge complète toujours une boucle tous les360°, ce n'est pas quelque chose que l'une ou l'autre formule peut choisir.
C'est toute la formule pour un point précis de l'onde, celui qui ne dérive jamais latéralement. La plupart des points d'une onde dérivent aussi latéralement, ce qui ajoute un second ingrédient à cette même somme, traité dans « Autres cas » ci-dessous.
- →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.
Exemple concret
Voici le calcul réel derrière un indicateur de chargement ondulé, réduit
au seul calcul de phase. Il prend aussi une position x, le second
ingrédient mentionné ci-dessus, maintenue à 0 ci-dessous pour
correspondre à la formule à point unique de « L'intuition » :
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()
}Faites parcourir à shift un waveLength complet tandis que x reste
à 0, exactement la situation dans laquelle se trouve le point fixe de
départ de l'onde :
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 startshift parcourant un waveLength complet (46 px) fait parcourir à
phase exactement un 2π complet, ce qui correspond exactement à un
cycle complet de sin : sommet, milieu, creux, milieu. Ce n'est pas une
coïncidence, c'est la conversion 2π qui accomplit son unique rôle :
faire en sorte qu'« une distance d'un waveLength » équivale à « un
tour complet de sin ». shiftAnimatable fait alors exactement cela,
animant de 0 à waveLength en boucle infinie, c'est pourquoi le point
continue d'osciller à l'infini selon cette même séquence
sommet-milieu-creux-milieu.
Faites glisser les curseurs ci-dessous et observez les deux images se
déplacer ensemble : la hauteur du point sur l'onde et le point tracé sur
le cercle proviennent tous deux de la même phase, simplement lue de
deux façons différentes.
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
Autres cas : un point qui dérive aussi latéralement
La formule de « L'intuition » est la vraie formule, mais seulement pour
le point qui ne se déplace jamais latéralement. Voici la ligne réelle,
position comprise, à côté de ce même point fixé à 0 :
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- Deux choses différentes sont additionnées en ce seul nombre avant
qu'il ne devienne un angle : une position (
startXoutipX) etshiftAnimatable.value(jusqu'où une animation indépendante, en boucle infinie, a avancé, plus proche d'un temps écoulé). Elles sont additionnées avant que l'une ou l'autre ne devienne partie de l'angle, donc au moment oùsins'exécute, elle regarde un seul nombre combiné, sans aucun moyen de distinguer quelle part venait de la position et laquelle venait du temps. - Le point fixé à
startX = 0freçoit une contribution de phase venant uniquement deshiftAnimatable.value, son propre terme dans la somme est permanentement nul, exactement la formule simplifiée avec laquelle « L'intuition » a commencé. C'est pourquoi il continue d'osciller même s'il ne dérive jamais latéralement : rien dans sonxne change jamais, et le point oscille quand même, à 100 % grâce àshiftAnimatable.valuequi grimpe. - Le point à
tipXreçoit des contributions de phase venant des deux termes : sa position en x change à mesure queprogressgrimpe, en plus de ce mêmeshiftAnimatable.valuequi grimpe en dessous. Même mécanisme, mais avec deux entrées mobiles au lieu d'une seule.
Même fonction, même formule, et la seule chose qui change entre les deux points est quel argument est une valeur vivante et lequel est une constante.
Le fondamental
Ceci est la formule de phase d'une onde progressive, la même forme
que la physique écrit φ(x, t) = k(x + vt), où k = 2π / wavelength
est le nombre d'onde, le facteur de conversion fixe de la distance
vers les radians. Position et temps écoulé sont deux entrées
indépendantes qui sont additionnées en un seul nombre, la phase, avant
que toute fonction oscillante (sin, cos, ou n'importe quoi de
périodique) ne s'exécute sur lui. La fonction qui oscille n'a aucun
moyen de séparer les deux contributions, et n'en a pas besoin, elle ne
fait que consommer la somme.
Ailleurs : même fondamental, framework différent
- Shaders de fragments (GLSL) : un effet d'ondulation d'eau ou de
drapeau est presque toujours
sin(uv.x * frequency + time * speed),uv.xest le terme de position,time * speedest le terme de temps écoulé, additionnés avantsin, exactement la formule de cet article avecfrequencyjouant le rôle de2π / waveLength. - Synthèse audio : un oscillateur numérique calcule
sin(2 * PI * frequency * sampleIndex / sampleRate + phaseOffset)pour chaque échantillon,sampleIndex / sampleRateest le temps écoulé en secondes,frequencyjoue le même rôle que1 / waveLengthjoue ici, etphaseOffsetest un terme de décalage de phase pur, sans aucun temps ni position attaché. - La physique, la source originale : l'équation de l'onde
progressive
y(x, t) = A·sin(kx - ωt)est la même formule que cet article utilise depuis le début,k = 2π/λ(le nombre d'onde) joue le rôle que joue ici2π / waveLength,xest la position,test le temps. La forme canonique soustrait le terme de temps ; le code de cet article l'additionne à la place, même idée, signe opposé, ce qui correspond exactement au cas particulier de direction de déplacement ci-dessous.
Cas particuliers
Supprimer le 2π, ou utiliser la mauvaise constante. sin(distance / waveLength) compile toujours et oscille toujours, elle complète
simplement un cycle complet tous les 2π * waveLength pixels au lieu
de tous les waveLength pixels. Rien ne plante ; l'onde cesse
simplement, silencieusement, de correspondre à la constante
waveLength que le reste du code suppose.
Inverser le signe entre les termes de position et de temps. x + shift et x - shift oscillent tous deux de façon identique à n'importe
quel instant figé unique, la différence n'apparaît qu'au fil du temps :
+shift fait apparaître le motif de l'onde comme glissant dans une
direction à mesure que shift grimpe, -shift le fait glisser dans
l'autre direction. Choisir le mauvais signe ne casse pas la forme, il
inverse la direction du déplacement, un bug invisible sur une capture
d'écran et qui n'apparaît qu'une fois qu'on regarde réellement
l'animation.
Confondre waveLength avec la durée de l'animation. waveLength
est une distance (pixels par répétition) ; durationMillis sur
l'animation shiftAnimatable est une durée (millisecondes par
répétition). Changer WaveSpeed dans le code réel ne change que
durationMillis, donc l'onde défile plus vite ou plus lentement, mais
waveLength reste fixe, donc la forme réelle de l'onde à l'écran
(hauteur, densité) ne change jamais. Vitesse et forme sont contrôlées
par deux constantes indépendantes qui alimentent toutes deux la même
formule de phase.
Quand y recourir
Chaque fois que quelque chose doit sembler suivre un motif répétitif qui est lui-même en mouvement :
- Effets d'onde/ondulation défilants, un indicateur de chargement, un shader d'eau, un visualiseur de forme d'onde audio, partout où une forme doit osciller dans l'espace et défiler dans le temps simultanément.
- Plusieurs marqueurs suivant la même onde, une fois que la hauteur
d'un point est
heightAt(x, shift), placer N marqueurs supplémentaires revient simplement à appeler la même fonction avec N valeurs dexdifférentes, exactement comme la paire de points tip/start ci-dessus. - Tout ce qui a une « fréquence spatiale » et une « vitesse
temporelle » indépendantes qui doivent être réglables séparément,
waveLengthetdurationMillisici, car il s'agit réellement de deux constantes différentes, pas de deux noms pour la même chose.
Le signal indiquant qu'il ne s'agit pas du bon fondamental à utiliser :
s'il n'y a qu'une seule entrée (seulement le temps, ou seulement la
position, jamais les deux additionnés), il n'y a pas de « progressive »
dans onde progressive, un simple animateFloat pilotant directement
sin couvre déjà le cas.
La phase n'est jamais le temps et jamais la position prise
isolément, c'est ce qui est additionné avant que le résultat ne soit
transmis à sin, et 2π est simplement l'unité dans laquelle cette
somme doit tomber parce que c'est la seule unité dans laquelle sin
comprend un cycle complet.



