Die Intuition
Eine kartesische Ebene aus dem Matheunterricht hat y, das nach oben
zunimmt, und Winkel, die gegen den Uhrzeigersinn von positivem x aus
verlaufen. Jede View, jedes Canvas und jeder DrawScope auf Android sieht
aus wie dieselbe Ebene, mit denselben Formeln x = cx + r·cos(angle),
aber das ist es nicht:
- Der Ursprung liegt in der oberen linken Ecke, nicht in der Mitte.
ynimmt nach unten zu, nicht nach oben.- Ein positiver Winkel in
cos/sinverläuft auf dem Bildschirm im Uhrzeigersinn, nicht gegen den Uhrzeigersinn, weil das Umkehren vonyauch die Richtung umkehrt, in der eine Rotation gelesen wird.
An der Mathematik selbst ändert sich nichts. sin und cos wissen oder
kümmern sich nicht darum, in welche Richtung y zeigt. Was sich ändert,
ist, in welche Richtung auf deinem Bildschirm ein gegebener Winkel oder
eine Formel landet, und genau das ist der Teil, bei dem das Muskelgedächtnis
aus dem Matheunterricht in die falsche Richtung zeigt.
(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.
Konkretes Beispiel: einen Punkt per Hand rotieren
// Math-class Cartesian: rotating (10, 0) by +90° lands at (0, 10),
// "up and to the left" on paper, where y grows upward.
val angle = Math.toRadians(90.0)
val rotatedX = 10 * cos(angle)
val rotatedY = 10 * sin(angle)
// On screen (y grows downward instead), that same (0, 10) result
// is 10px *down* from center, not up. The formula didn't change —
// which way "up" points did.Gib derselben Rotationsformel auf dem Canvas einer View exakt dieselben
Zahlen, und das Ergebnis landet im Spiegelbild von dem, wo es auf
Millimeterpapier landen würde. Die Formel ist identisch; nur die Bedeutung
eines positiven y hat sich darunter umgekehrt.
angle: 90° — rotated point at x 0, y 50
(x, y) = (0, 50)
Math
y increases ↑
Screen
y increases ↓
Winkelrichtung
Modifier.graphicsLayer { rotationZ = 90f } dreht ein Composable bei
einem positiven Winkel im Uhrzeigersinn, dieselbe y-nach-unten-Logik
wie in jedem anderen Fall hier: Der Rotationspunkt des Layers befindet
sich in einem y-nach-unten-Raum, also liest sich ein positiver Winkel
auch dort im Uhrzeigersinn. Das ist keine Sonderregel für
graphicsLayer, es ist dieselbe eine Regel, die hier erneut auftaucht.
rotationZ: 45° — layer rotated 45 degrees
Screen
y increases ↓
Sweep
drawArc(startAngle = 0f, sweepAngle = 90f) verläuft im Uhrzeigersinn
von 3 Uhr bis 6 Uhr. Derselbe Sweep von 0° bis 90° auf einer
kartesischen Ebene verläuft von 3 Uhr bis 12 Uhr, gegen den
Uhrzeigersinn, die entgegengesetzte visuelle Richtung für identische
Zahlen.
sweepAngle: 90° — arc swept 90 degrees from startAngle 0
Screen
y increases ↓
Ziehen (Dragging)
Ein Drag gibt dir nur eine Position, genauer gesagt einen
Offset, keinen Winkel. Um daraus einen Winkel zu machen, braucht man
atan2(dy, dx).
Man könnte stattdessen zu arctan(dy/dx) greifen, "Steigung über
Strecke" ("rise over run"). Das bricht an zwei Stellen: dx = 0 führt zu
einer Division durch null, und das Verhältnis allein kann (1, 1) nicht
von (-1, -1) unterscheiden, da -1/-1 ebenfalls 1 ist, obwohl das
entgegengesetzte Richtungen sind. atan2 nimmt dx und dy getrennt
entgegen, statt sie vorab zu dividieren, sodass es jedes Vorzeichen sehen
und alle vier Richtungen korrekt auflösen kann.
Das ist auch der klarste Auslöser dafür, wann man dazu greift: cos/sin
gehen Winkel rein, Position raus (die Polarformel aus der Einleitung,
x = cx + r·cos(angle)), und atan2 geht den anderen Weg, Position
rein, Winkel raus. Ein Drag liefert dir eine Position, keinen Winkel,
also gibt es nichts anderes zu berechnen als mit atan2.
Aus demselben Grund ist es das richtige Werkzeug für einen
Drag-zum-Rotieren-Regler: Der Finger muss nicht exakt auf dem Ring
landen, da atan2 nur die Richtung vom Mittelpunkt zum Finger liest,
nicht die Entfernung. Derselbe Trick treibt auch jede
Blickrichtungs-Logik an, etwa das Drehen eines Sprites passend zu seiner
(dx, dy)-Geschwindigkeit pro Frame statt zu einer Fingerposition.
Auf Papier ergibt ein Drag nach oben einen positiven Winkel (gegen den
Uhrzeigersinn von positivem x aus). Auf dem Bildschirm verringert
ein Drag nach oben y, was das Vorzeichen umkehrt, das atan2 für
dieselbe physische Geste zurückgibt.
atan2(dy, dx): 0° — drag angle 0 degrees
Screen
drag the dot
Scroll
Eine scrollbare View macht das ganz konkret, ganz ohne Trigonometrie:
Ein Kind an der Inhaltsposition y wird auf dem Bildschirm bei
y - scrollState.value gerendert, wobei scrollState der ScrollState
hinter Modifier.verticalScroll ist. Scrollt man nach unten, nimmt
scrollState.value zu, und der Inhalt bewegt sich auf dem Bildschirm
nach oben, Richtung kleineres y, derselbe y-nach-unten-Raum, den der
ganze Beitrag bisher verwendet hat. Es gibt hier keine neue Konvention,
nur die bekannte plus eine Subtraktion.
scrollState.value: 0px — scrolled 0 pixels
Screen
screen y = content y − scrollState.value
Lazy-Listen
LazyColumn wendet exakt dieselbe Subtraktion an, aber scrollState.value
existiert dort nicht, weil eine Lazy-Liste niemals die Elemente misst, die
sie noch nicht gezeichnet hat. Es gibt keine einzelne, von vornherein
bekannte Gesamt-Inhaltshöhe, von der man abziehen könnte.
// ScrollState: every child is measured up front, so one cumulative
// pixel value is enough to place all of them.
val offsetPx = scrollState.value
// LazyListState: items off-screen are never measured, so there's no
// total content height to track. The offset is split into which item
// is first on screen, plus how far into that item you've scrolled.
val firstIndex = lazyListState.firstVisibleItemIndex
val firstItemOffsetPx = lazyListState.firstVisibleItemScrollOffsetDie y - offset-Logik läuft weiterhin während des Layouts, sie wird nur
pro sichtbarem Element relativ zu firstVisibleItemIndex berechnet statt
gegen einen einzigen globalen Wert: Element 0 sitzt bei -firstItemOffsetPx,
Element 1 bei item0Height - firstItemOffsetPx, und so weiter. Derselbe
y-nach-unten-Raum, dieselbe Subtraktion, nur verankert am nächstgelegenen
sichtbaren Element statt an einer vorausberechneten Gesamtsumme.
Das Grundprinzip
Dies ist ein linkshändiges 2D-Koordinatensystem (gleichbedeutend ein y-nach-unten- oder Raster-/Bildschirm-Koordinatensystem), im Gegensatz zur rechtshändigen, y-nach-oben-Konvention der Mathematik. Das Umkehren des Vorzeichens einer Achse kehrt die Händigkeit des gesamten Systems um, und genau deshalb liest sich ein positiver Winkel, der in einer Konvention gegen den Uhrzeigersinn verläuft, in der anderen im Uhrzeigersinn. Die trigonometrischen Identitäten haben sich nie geändert; die Achse, gegen die sie gemessen werden, hat sich geändert.
Anderswo: dasselbe Grundprinzip, anderes Framework
- HTML5 Canvas: Ursprung oben links,
ynach unten,rotate()ist bei positiven Werten im Uhrzeigersinn, identische Konvention zu AndroidsView/Canvas, aus demselben Grund (beide haben es von Raster-Bildkoordinaten übernommen, wo Zeile 0 die oberste Zeile ist). - SwiftUI / Core Animation: Der Zeichenraum von
CGContextliegt oben links,ynach unten, genau wie ComposesDrawScope, aber auchUIKits eigeneCGPoint/CGRect-APIs setzen y-nach-unten voraus, was SwiftUI und Compose hier näher zueinander bringt, als jedes der beiden zur Mathematik steht. - Core Graphics / PDF hingegen:
ynimmt nach oben zu, treu zur mathematischen Konvention, weil das Koordinatensystem von PDF von Druck-Layout abstammt, nicht von Raster-Scanning. DieselbeCGContext-API-Familie spannt sich über beide Konventionen, je danach, in welche man zeichnet, was die mit Abstand häufigste Ursache für "mein PDF-Export ist auf dem Kopf"-Bugs ist. - OpenGL / Metal normalisierte Gerätekoordinaten:
ynimmt nach oben zu, rechtshändig, wieder mathematische Konvention, und genau deshalb muss bei jeder Textur, die aus einer y-nach-unten-Bilddatei geladen wird, diev-Koordinate umgedreht werden, bevor sie auf dem Bildschirm richtig herum abgetastet wird. - Flutter:
Offset/Canvassind y-nach-unten, genauso wie AndroidsView-System, aus derselben Raster-Koordinaten-Abstammung, sodass eine Rotation oderatan2, die von einem Flutter-CustomPainterin einen Compose-DrawScopeportiert wird, überhaupt keine Vorzeichenänderungen braucht, anders als beim Portieren aus mathematisch abgeleitetem OpenGL-Code.
atan2 taucht weit über diesen einen Drag-Fall hinaus auf: Regler,
Pie-Menüs, Sprite-Blickrichtung, Joystick-Eingabe,
Peilungsberechnungen, DSP-Phase und mehr. Der
atan2/atan/atanh-Deep-Dive
deckt die vollständige Liste ab.
Mentales Modell für die Praxis
Bevor du einer Rotations-, Winkel- oder Drag-Richtungsformel auf dem Bildschirm vertraust, frage dich, ob sie für eine y-nach-oben- oder eine y-nach-unten-Ebene abgeleitet wurde; die Formel ist in beiden Fällen identisch, nur ihre visuelle Richtung kehrt sich um.



