Recomposed
Canvas

La phase d'une onde progressive : transformer position et temps en un seul angle

Oct 18, 2026 · 9 min read

La phase d'une onde progressive : transformer position et temps en un seul angle

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 » :

  • startPhase est 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 fois startPhase connu, 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 dans startPhase n'est une position en pixels ou un instant dans le temps en soi, c'est purement « jusqu'où autour ».
  • 2 * PI est la conversion d'unité, les degrés façon horloge échangés contre des radians. shiftAnimatable.value / waveLength est « 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 par 2π la transforme en l'angle réel attendu par sin, car sin complète toujours une boucle tous les 2π, de la même façon fixe qu'un cadran d'horloge complète toujours une boucle tous les 360°, 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.

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 start

shift 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

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 (startX ou tipX) et shiftAnimatable.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ù sin s'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 = 0f reçoit une contribution de phase venant uniquement de shiftAnimatable.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 son x ne change jamais, et le point oscille quand même, à 100 % grâce à shiftAnimatable.value qui grimpe.
  • Le point à tipX reçoit des contributions de phase venant des deux termes : sa position en x change à mesure que progress grimpe, en plus de ce même shiftAnimatable.value qui 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.x est le terme de position, time * speed est le terme de temps écoulé, additionnés avant sin, exactement la formule de cet article avec frequency jouant le rôle de 2π / waveLength.
  • Synthèse audio : un oscillateur numérique calcule sin(2 * PI * frequency * sampleIndex / sampleRate + phaseOffset) pour chaque échantillon, sampleIndex / sampleRate est le temps écoulé en secondes, frequency joue le même rôle que 1 / waveLength joue ici, et phaseOffset est 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 ici 2π / waveLength, x est la position, t est 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 de x diffé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, waveLength et durationMillis ici, 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.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail