Recomposed
Canvas

Fase de Onda Viajante: Transformando Posição e Tempo em um Único Ângulo

Oct 18, 2026 · 9 min read

Fase de Onda Viajante: Transformando Posição e Tempo em um Único Ângulo

O que "fase" realmente significa

Imagine um ponteiro de relógio girando lentamente em um mostrador em branco, sem números, nada mais se movendo, começando de onde ele estiver apontando inicialmente. A qualquer instante você pode perguntar "para onde ele está apontando?", e a resposta honesta é um único número: quanto do círculo completo o ponteiro já percorreu desde que começou.

Nenhum percurso ainda é onde ele começou, um quarto de volta é "um quarto do caminho", e voltar completamente ao ponto de partida é "uma volta completa", e então ele começa a contar de novo a partir de zero.

Esse único número, quanto de uma volta completa algo já percorreu, é tudo o que fase sempre significa. Não tem nada a ver especificamente com relógios, e nada a ver com círculos que você pode literalmente ver, qualquer coisa que se repete (uma onda subindo e descendo, um ponteiro girando, um som vibrando) tem uma fase: o mesmo número "até onde estou dentro desta repetição", apenas ligado a um tipo diferente de movimento.

Um ponto balançando para cima e para baixo em uma onda está fazendo exatamente o mesmo percurso que esse ponteiro de relógio, apenas redesenhado como uma altura em vez de uma direção. "Um quarto do caminho em um ciclo completo de subida e descida" é o mesmo tipo de fato, seja um ponteiro apontando para o leste ou um ponto situado no pico de uma onda, fase é o número no qual esse fato é registrado.

Código e matemática não escrevem esse número como "um quarto de volta" ou "90 graus", eles o escrevem em , uma régua de tamanho diferente para a mesma ideia: uma volta completa é 2π radianos em vez de 360°. sin(phase) e cos(phase) são as duas funções cujo único trabalho é ler esse número "quanto já foi percorrido" e transformá-lo em uma posição real, nada mais do que isso.

A intuição

((x + shift) / waveLength) * 2 * Math.PI parece uma pilha arbitrária de operações encaixadas, uma soma, uma divisão, uma multiplicação, em uma ordem que não se explica. Não é arbitrário. Cada parte tem um trabalho específico, e juntas elas formam uma fórmula nomeada e padrão, não um ajuste improvisado de números até a animação parecer certa.

Essa fórmula é o que faz um ponto se mover para cima e para baixo traçando a forma da onda, repetidamente, para sempre. O trabalho é pegar algo que continua subindo, sem teto, e transformá-lo em uma altura que continua entre um topo e uma base, em sincronia com a onda.

Esse valor crescente não é hipotético, é uma linha real do indicador de carregamento ondulado de onde a fórmula deste post foi extraída: shiftAnimatable.value. É uma animação que conta de 0 até waveLength, volta a 0, e conta novamente, em um loop que nunca para. Por si só é apenas um número ficando constantemente maior, não tem noção de que "para cima" e "para baixo" nem existem. Esta fórmula é o que transforma esse único número crescente na altura real do ponto, repetidamente, em sincronia com a onda:

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

Duas partes, cada uma cumprindo um trabalho específico ao transformar "um valor de animação que cresce sem parar" em "fase":

  • startPhase é a fase em si, exatamente o número "quanto de uma volta completa" da analogia do ponteiro de relógio acima, apenas medido para o ciclo desta onda em vez de um ponteiro girando em um mostrador. Uma vez que você sabe startPhase, sin(startPhase) diz exatamente a altura em que o ponto está, da mesma forma que, uma vez que você sabe o ângulo do ponteiro, você sabe exatamente para onde ele está apontando. Nada em startPhase é uma posição em pixels ou um momento no tempo por si só, é puramente "quanto já foi percorrido".
  • 2 * PI é a conversão de unidade, graus de estilo relógio trocados por radianos. shiftAnimatable.value / waveLength é "qual fração de uma repetição completa da onda esta animação já cobriu", exatamente a mesma pergunta que "qual fração do mostrador o ponteiro já percorreu". Multiplicar essa fração por 2π a transforma no ângulo real que sin espera, porque sin sempre completa uma volta a cada 2π, da mesma forma fixa que um mostrador de relógio sempre completa uma volta a cada 360°, não algo que nenhuma das duas fórmulas pode escolher.

Essa é toda a fórmula para um ponto específico na onda, aquele que nunca deriva lateralmente. A maioria dos pontos em uma onda também deriva lateralmente, o que acrescenta um segundo ingrediente a essa mesma soma, abordado em "Mais casos" abaixo.

Exemplo concreto

Este é o cálculo real por trás de um indicador de carregamento ondulado, reduzido a apenas a matemática de fase. Ele também recebe uma posição x, o segundo ingrediente mencionado acima, mantida em 0 abaixo para corresponder à fórmula de ponto único de "A intuição":

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()
}

Percorra shift por um waveLength completo enquanto x permanece em 0, exatamente a situação em que o ponto fixo inicial da onda se encontra:

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 percorrendo um waveLength completo (46 px) faz phase percorrer exatamente um 2π completo, que é exatamente um ciclo completo de sin, topo, meio, base, meio. Isso não é coincidência, é a conversão 2π cumprindo seu único trabalho: fazer "uma distância de waveLength" equivaler a "uma volta de sin". shiftAnimatable então faz exatamente isso, animando de 0 até waveLength em um loop infinito, e é por isso que o ponto continua balançando por essa mesma sequência topo-meio-base-meio para sempre.

Arraste os controles deslizantes abaixo e observe as duas imagens se moverem juntas: a altura do ponto na onda e o ponto traçado no círculo vêm ambos da mesma phase, apenas lidos de duas formas diferentes.

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

Mais casos: um ponto que também deriva lateralmente

A fórmula de "A intuição" é a fórmula real, mas apenas para o ponto que nunca se move lateralmente. Aqui está a linha real, posição e tudo, ao lado desse mesmo ponto fixado em 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
  • Duas coisas diferentes são somadas nesse único número antes de ele se tornar um ângulo: uma posição (startX ou tipX) e shiftAnimatable.value (quanto uma animação independente e sem fim já percorreu, mais próximo de tempo transcorrido). Eles são somados antes que qualquer um dos dois se torne parte do ângulo, então no momento em que sin é executado, ele está olhando para um número combinado único, sem forma de distinguir qual parte veio da posição e qual veio do tempo.
  • O ponto fixado em startX = 0f recebe uma contribuição de fase apenas de shiftAnimatable.value, seu próprio termo na soma é permanentemente zero, exatamente a fórmula simplificada com que "A intuição" começou. É por isso que ele ainda balança mesmo nunca derivando lateralmente: nada no seu x jamais muda, e o ponto balança mesmo assim, 100% por conta de shiftAnimatable.value crescendo.
  • O ponto em tipX recebe contribuições de fase de ambos os termos: sua posição x muda conforme progress cresce, somada ao mesmo crescimento de shiftAnimatable.value por baixo dela. Mesmo mecanismo, agora com duas entradas em movimento em vez de uma.

Mesma função, mesma fórmula, e a única coisa que muda entre os dois pontos é qual argumento é um valor dinâmico e qual é uma constante.

The fundamental

Esta é uma fórmula de fase de onda viajante, a mesma forma que a física escreve como φ(x, t) = k(x + vt), onde k = 2π / wavelength é o número de onda, o fator de conversão fixo de distância para radianos. Posição e tempo transcorrido são duas entradas independentes que são somadas em um único número, a fase, antes que qualquer função oscilante (sin, cos, ou qualquer função periódica) seja executada sobre ela. A função que faz a oscilação não tem forma de separar as duas contribuições de volta, e não precisa, ela só consome a soma.

Em outros lugares: mesmo fundamento, framework diferente

  • Shaders de fragmento (GLSL): um efeito de ondulação de água ou bandeira é quase sempre sin(uv.x * frequency + time * speed), uv.x é o termo de posição, time * speed é o termo de tempo transcorrido, somados antes de sin, exatamente a fórmula deste post com frequency no lugar de 2π / waveLength.
  • Síntese de áudio: um oscilador digital calcula sin(2 * PI * frequency * sampleIndex / sampleRate + phaseOffset) para cada amostra, sampleIndex / sampleRate é o tempo transcorrido em segundos, frequency desempenha o mesmo papel que 1 / waveLength desempenha aqui, e phaseOffset é um termo de deslocamento de fase puro, sem tempo ou posição associado a ele.
  • Física, a fonte original: a equação da onda viajante y(x, t) = A·sin(kx - ωt) é a mesma fórmula que este post vem usando o tempo todo, k = 2π/λ (o número de onda) desempenha o papel que 2π / waveLength desempenha aqui, x é posição, t é tempo. A forma canônica subtrai o termo de tempo; o código deste post o soma em vez disso, mesma ideia, sinal oposto, que é exatamente o caso extremo de direção de deslocamento abaixo.

Casos extremos

Remover o 2π, ou usar a constante errada. sin(distance / waveLength) ainda compila e ainda oscila, apenas completa um ciclo completo a cada 2π * waveLength pixels em vez de a cada waveLength pixels. Nada quebra; a onda apenas silenciosamente deixa de corresponder à constante waveLength que o restante do código assume.

Inverter o sinal entre os termos de posição e tempo. x + shift e x - shift oscilam de forma idêntica em qualquer instante único e congelado, a diferença só aparece ao longo do tempo: +shift faz o padrão da onda parecer deslizar em uma direção conforme shift cresce, -shift o desliza na outra direção. Escolher o sinal errado não quebra a forma, inverte a direção de deslocamento, um bug que é invisível em uma captura de tela e só aparece quando você realmente observa a animação.

Confundir waveLength com a duração da animação. waveLength é uma distância (pixels por repetição); durationMillis na animação shiftAnimatable é uma duração (milissegundos por repetição). Alterar WaveSpeed no código real só muda durationMillis, então a onda rola mais rápido ou mais lento, mas waveLength permanece fixo, então a forma real da onda na tela (quão alta, quão compactada) nunca muda. Velocidade e forma são controladas por duas constantes não relacionadas que por acaso alimentam a mesma fórmula de phase.

Quando recorrer a isso

Sempre que algo precisar parecer que está percorrendo um padrão repetitivo que por si só está em movimento:

  • Efeitos de onda/ondulação com rolagem, um indicador de carregamento, um shader de água, um visualizador de forma de onda de áudio, qualquer lugar onde uma forma precise oscilar no espaço e rolar no tempo ao mesmo tempo.
  • Múltiplos marcadores percorrendo a mesma onda, uma vez que a altura de um ponto é heightAt(x, shift), posicionar N marcadores adicionais é apenas chamar a mesma função com N valores diferentes de x, exatamente como o par de pontos ponta/início acima.
  • Qualquer coisa com uma "frequência espacial" e uma "velocidade temporal" independentes que precisem ser ajustáveis separadamente, waveLength e durationMillis aqui, porque são genuinamente duas constantes diferentes, não dois nomes para a mesma coisa.

O sinal de que este é o fundamento errado a recorrer: se houver apenas uma entrada (só tempo, ou só posição, nunca ambos somados juntos), não há "viagem" em onda viajante, um animateFloat simples alimentando sin diretamente já cobre isso.

Fase nunca é tempo e nunca é posição isoladamente, é o que for somado antes de o resultado ser entregue a sin, e 2π é simplesmente a unidade em que essa soma precisa cair porque é a única unidade que sin entende um ciclo completo.

Keep reading

Related reads

Receba novos posts no seu e-mail