A intuição
Um plano cartesiano da aula de matemática tem y aumentando para cima
e ângulos varrendo no sentido anti-horário a partir do x positivo.
Toda View, Canvas e DrawScope no Android parece esse mesmo plano, com
as mesmas fórmulas x = cx + r·cos(angle), mas não é:
- A origem é o canto superior esquerdo, não o centro.
yaumenta para baixo, não para cima.- Um ângulo positivo em
cos/sinvarre no sentido horário na tela, não anti-horário, porque inverteryinverte a direção em que a rotação é lida.
Nada na matemática muda. sin e cos não sabem nem se importam para
qual lado y aponta. O que muda é em qual direção na sua tela um
determinado ângulo ou fórmula te leva, e é essa parte que a memória
muscular da aula de matemática entende ao contrário.
(0, 0) — column 0, row 0
- →Polar to Cartesian: What cos and sin Are Actually ComputingThe x = cx + r·cos(angle) formula this post's rotation and sweep examples build on, and why the same formula sweeps clockwise instead of counterclockwise once y points down.
- →atan, atan2, and atanhThe reverse direction of the drag case below: turning a (dx, dy) position back into an angle, and why atan alone can't do it.
Exemplo concreto: girando um ponto manualmente
// Cartesiano da aula de matemática: girar (10, 0) em +90° cai em (0, 10),
// "para cima e para a esquerda" no papel, onde y cresce para cima.
val angle = Math.toRadians(90.0)
val rotatedX = 10 * cos(angle)
val rotatedY = 10 * sin(angle)
// Na tela (onde y cresce para baixo), esse mesmo resultado (0, 10)
// fica 10px *abaixo* do centro, não acima. A fórmula não mudou —
// o que mudou foi para qual lado "para cima" aponta.Aplique exatamente a mesma fórmula de rotação com exatamente os mesmos
números em um Canvas de uma View, e o resultado cai na imagem espelhada
de onde cairia no papel quadriculado. A fórmula é idêntica; só o
significado de um y positivo se inverteu por baixo dela.
angle: 90° — rotated point at x 0, y 50
(x, y) = (0, 50)
Math
y increases ↑
Screen
y increases ↓
Direção do ângulo
Modifier.graphicsLayer { rotationZ = 90f } gira um composable no
sentido horário para um ângulo positivo, a mesma lógica de y
para baixo de todos os outros casos aqui: o pivô de rotação da camada
fica em um espaço com y para baixo, então um ângulo positivo também é
lido como horário ali. Não é uma regra especial para graphicsLayer, é
a mesma regra única aparecendo de novo.
rotationZ: 45° — layer rotated 45 degrees
Screen
y increases ↓
Varredura
drawArc(startAngle = 0f, sweepAngle = 90f) varre no sentido
horário das 3 horas às 6 horas. A mesma varredura de 0° a 90°
em um plano cartesiano vai das 3 horas às 12 horas, no sentido
anti-horário, a direção visual oposta para os mesmos números
idênticos.
sweepAngle: 90° — arc swept 90 degrees from startAngle 0
Screen
y increases ↓
Arrastando
Um arrasto só te dá uma posição, especificamente um deslocamento
,
não um ângulo. Transformar isso em um ângulo requer atan2(dy, dx).
Você pode tentar usar arctan(dy/dx) em vez disso, "subida sobre
avanço". Isso falha de duas formas: dx = 0 divide por zero, e a
razão isolada não consegue distinguir (1, 1) de (-1, -1), já que
-1/-1 também é 1, mesmo essas sendo direções opostas. atan2 recebe
dx e dy separadamente em vez de dividi-los antecipadamente, então
consegue ver cada sinal e resolver corretamente as quatro direções.
Esse é também o gatilho mais claro para quando recorrer a ele:
cos/sin vão ângulo entra, posição sai (a fórmula polar da
introdução, x = cx + r·cos(angle)), e atan2 vai no sentido
contrário, posição entra, ângulo sai. Um arrasto te entrega uma
posição, não um ângulo, então não há nada a calcular além de usar
atan2.
É a ferramenta certa para um botão de arrastar-para-girar pela mesma
razão: o dedo não precisa cair exatamente sobre o anel, já que atan2
só lê a direção do centro até o dedo, não a distância. O mesmo truque
também guia qualquer lógica de direção de face, girando um sprite para
coincidir com sua velocidade (dx, dy) por quadro, em vez de uma
posição de dedo.
No papel, arrastar para cima dá um ângulo positivo (anti-horário a
partir do x positivo). Na tela, arrastar para cima diminui y, o
que inverte o sinal que atan2 retorna para o mesmo gesto físico.
atan2(dy, dx): 0° — drag angle 0 degrees
Screen
drag the dot
Rolagem
Uma view rolável deixa isso concreto sem nenhuma trigonometria: um
filho na posição de conteúdo y é renderizado na tela em
y - scrollState.value, onde scrollState é o ScrollState por trás
de Modifier.verticalScroll. Role para baixo, scrollState.value
aumenta, e o conteúdo se move para cima na tela, em direção a y
menores, o mesmo espaço com y para baixo que o post todo vem usando.
Não há nenhuma convenção nova aqui, só a familiar mais uma subtração.
scrollState.value: 0px — scrolled 0 pixels
Screen
screen y = content y − scrollState.value
Listas lazy
LazyColumn aplica exatamente a mesma subtração, mas scrollState.value
não existe lá, porque uma lista lazy nunca mede os itens que ainda não
desenhou. Não há uma altura total de conteúdo previamente calculada
para subtrair.
// ScrollState: todo filho é medido antecipadamente, então um único
// valor acumulado de pixels é suficiente para posicionar todos eles.
val offsetPx = scrollState.value
// LazyListState: itens fora da tela nunca são medidos, então não há
// uma altura total de conteúdo para rastrear. O offset é dividido em
// qual item é o primeiro na tela, mais o quanto você já rolou dentro
// dele.
val firstIndex = lazyListState.firstVisibleItemIndex
val firstItemOffsetPx = lazyListState.firstVisibleItemScrollOffsetA lógica de y - offset ainda ocorre durante o layout, só é calculada
por item visível em relação a firstVisibleItemIndex em vez de contra
um valor global único: o item 0 fica em -firstItemOffsetPx, o item 1
em item0Height - firstItemOffsetPx, e assim por diante. Mesmo espaço
com y para baixo, mesma subtração, só ancorada no item visível mais
próximo em vez de em um total pré-calculado.
O fundamento
Isso é um sistema de coordenadas 2D canhoto (equivalentemente, um
sistema com y para baixo, ou de coordenadas raster/tela), em
contraste com a convenção destro, com y para cima, da matemática.
Inverter o sinal de um eixo inverte a quiralidade do sistema inteiro,
e é exatamente por isso que um ângulo positivo que é lido como
anti-horário em uma convenção é lido como horário na outra. As
identidades trigonométricas nunca mudaram; o eixo contra o qual são
medidas, sim.
Em outros lugares: mesmo fundamento, framework diferente
- HTML5 Canvas: origem no canto superior esquerdo,
ypara baixo,rotate()positivo é horário, convenção idêntica àView/Canvasdo Android, pela mesma razão (ambos herdaram isso das coordenadas de imagens raster, onde a linha 0 é a linha superior). - SwiftUI / Core Animation: o espaço de desenho do
CGContexté superior esquerdo,ypara baixo, assim como oDrawScopedo Compose, mas as próprias APIsCGPoint/CGRectdoUIKittambém assumemypara baixo, deixando SwiftUI e Compose mais próximos entre si aqui do que qualquer um dos dois está da matemática. - Core Graphics / PDF, em contraste:
yaumenta para cima, fiel à convenção matemática, porque o sistema de coordenadas do PDF descende do layout de impressão, não da varredura raster. A mesma família de APIsCGContextse divide entre as duas convenções dependendo de qual delas você está desenhando, o que é a fonte mais comum de bugs do tipo "minha exportação em PDF está de cabeça para baixo". - Coordenadas de dispositivo normalizadas do OpenGL / Metal:
yaumenta para cima, destro, convenção matemática de novo, o que é exatamente por que toda textura carregada de um arquivo de imagem comypara baixo precisa ter sua coordenadavinvertida antes de amostrar corretamente na tela. - Flutter:
Offset/Canvastêmypara baixo, assim como o sistemaViewdo Android, pela mesma linhagem de coordenadas raster, então uma rotação ouatan2portado de umCustomPainterdo Flutter para umDrawScopedo Compose não precisa de nenhuma mudança de sinal, diferente de portar um de código OpenGL derivado da matemática.
atan2 aparece muito além deste único caso de arrasto: botões, menus
circulares, direção de face de sprites, entrada de joystick, cálculos
de rumo, fase de DSP, e mais. O
mergulho profundo em atan2/atan/atanh
cobre a lista completa.
Modelo mental para usar de fato
Antes de confiar em uma fórmula de rotação, ângulo ou direção de
arrasto na tela, pergunte se ela foi derivada para um plano com y
para cima ou com y para baixo; a fórmula é idêntica de qualquer
forma, só sua direção visual se inverte.



