Recomposed
Canvas

Clipping-Grundlagen: Canvas-Clip-Stack vs. Layer + Outline-Mask

Oct 18, 2026 · 6 min read

Clipping-Grundlagen: Canvas-Clip-Stack vs. Layer + Outline-Mask

Die Intuition

Es ist verlockend, Clipping und Masking als denselben Vorgang mit zwei verschiedenen APIs zu behandeln: beide "schneiden den Teil des Inhalts weg, den ich nicht will." Das ist das richtige Ergebnis für den einfachen Fall, aber das falsche mentale Modell in dem Moment, in dem die Kante interessanter wird als eine harte Linie.

  • Ein Clip ist ein Ja/Nein-Test: Für jeden Pixel, den ein Zeichenaufruf berühren will, stellt der Clip-Stack die Frage "liegt dieser Punkt innerhalb der Form," und die Antwort ist binär. Es gibt keinen Pixel, der zu 60% geclippt ist.
  • Eine Maske ist eine Alpha-Multiplikation: Sie nimmt das, was bereits gerendert wurde, und skaliert dessen Alpha-Wert mit dem Alpha-Wert eines zweiten Bildes, Pixel für Pixel. Dieses zweite Bild kann jeden Alpha-Wert zwischen 0 und 1 tragen, einen Verlauf, eine Unschärfe, die eigene Leuchtdichte eines Fotos, nicht nur "Form" oder "keine Form."
  • Clipping wird bevor ein Zeichenaufruf überhaupt etwas malt aufgelöst, als Einschränkung, wo er schreiben darf. Masking wird als Blend aufgelöst, gegen Inhalt, der bereits vollständig gemalt wurde.

Diese beiden Mechanismen erzeugen zufällig in einem ganz bestimmten Fall identische Pixel: eine undurchsichtige Form mit einer harten Kante. Diese Überschneidung ist genau der Grund, warum sie als austauschbar behandelt werden, bis zu dem Punkt, an dem man eine weiche Kante braucht und entdeckt, dass einer von beiden strukturell keine liefern kann.

Konkretes Beispiel: die Kante eines Fotos ausblenden

Greife zuerst zu clipPath, weil es das naheliegende Werkzeug für "schneide das auf eine Form zu" ist:

// Canvas clip stack: clipPath pushes a binary stencil onto the canvas.
// Every pixel inside the path is fully visible, every pixel outside it
// is fully gone. There is no third option, so the bottom edge of the
// photo just stops, hard, at whatever line you draw.
Canvas(Modifier.size(240.dp)) {
    val fadeLine = size.height * 0.7f
    clipRect(bottom = fadeLine) {
        drawImage(photo, dstSize = IntSize(size.width.toInt(), size.height.toInt()))
    }
}

fadeLine schrittweise zu verkleinern erzeugt kein Ausblenden, sondern nur einen kleineren harten Schnitt. Eine Clip-Grenze kann genau an der einen Kante, die sie zeichnet, werden, aber sie kann die 40px vor dieser Kante nicht schrittweise transparenter machen, weil "schrittweise transparent" überhaupt kein Konzept des Clip-Stacks ist. Masking schon:

// Layer + mask: draw the photo into its own layer, then composite a
// gradient on top with DstIn. DstIn keeps dst (the photo, already
// rendered) scaled by src's alpha (the gradient), and the gradient's
// alpha runs continuously from 1 to 0, so the photo fades instead of
// cutting off.
Box(
    Modifier
        .size(240.dp)
        .graphicsLayer { compositingStrategy = CompositingStrategy.Offscreen }
        .drawWithContent {
            drawContent()
            drawRect(
                brush = Brush.verticalGradient(
                    0.6f to Color.Black,
                    1f to Color.Transparent,
                ),
                blendMode = BlendMode.DstIn,
            )
        },
) {
    Image(photo, contentDescription = null, modifier = Modifier.fillMaxSize())
}

Gleiches visuelles Ziel, das untere Ende eines Fotos abzuschneiden, aber die Masken-Version kann etwas ausdrücken, das die Clip-Version strukturell nicht kann: einen Bereich, der teilweise sichtbar ist.

Drag the line. Everything past it is just gone, no partial values. Clip mode: the boundary is a hard yes or no test, nothing past the line is visible, with no gradual fade.

Die Grundlage

Clipping schränkt ein, wo ein Zeichenaufruf schreiben darf: ein binärer Innen/Außen-Test gegen eine geometrische Grenze, aufgelöst bevor überhaupt gemalt wird.

Masking ist ein Alpha-Compositing-Schritt, meist BlendMode.DstIn/ SrcIn gegen eine bereits gerenderte Ebene, der bestehende Pixel mit dem Alpha-Kanal eines zweiten Bildes multipliziert. Der Alpha-Wert einer Maske kann kontinuierlich variieren; die Antwort eines Clips kann immer nur Ja oder Nein sein.

Modifier.clip(shape) ist die eingebaute Abkürzung für den binären Fall. Sie erspart einem, clipPath von Hand zu verwalten, aber es bleibt ein Clip: bittet man ihn um eine weiche Kante, gibt es nichts zu fragen, die Form hat keinen Alpha-Kanal, den man abstufen könnte.

Dieselbe Asymmetrie zeigt sich auch darin, was beide als Eingabe akzeptieren. Die Grenze eines Clips ist immer ein Path (oder die Outline einer Shape, die zu einem solchen kompiliert); es gibt keine andere Möglichkeit, einen geometrischen Innen/Außen-Test zu beschreiben.

Die Quelle einer Maske muss das nicht sein. Es ist einfach das, was in diese Ebene gerendert wurde: ein mit Verlauf gefülltes Rechteck, ein unscharfer Kreis, die eigenen Pixel eines Fotos. Ein Path ist nur eines von vielen Dingen, die man dort hätte zeichnen können.

Anderswo: dieselbe Grundlage, anderes Framework

  • CSS: clip-path ist eine harte geometrische Grenze, binär innen/außen, während mask-image einen Verlauf oder ein PNG mit partiellem Alpha akzeptiert und entsprechend ausblendet, weil es Alpha-Werte liest, nicht die Zugehörigkeit zu einer Form testet.
  • SVG: <clipPath> vereinigt seine Kind-Formen zu einem binären Innen/Außen-Test. <mask> ist per Design explizit abgestuft: weiße Pixel im Masken-Inhalt bedeuten vollständig sichtbar, Schwarz bedeutet vollständig verborgen, und Grau bedeutet teilweise sichtbar, ein Kontinuum, das ein <clipPath> nicht ausdrücken kann.
  • CoreAnimation (iOS): layer.masksToBounds mit cornerRadius clippt auf die geometrischen Grenzen der eigenen Ebene, binär, nur Form. Setzt man stattdessen layer.mask auf ein CAGradientLayer, entsteht ein echter Alpha-Verlauf, weil mask den Alpha-Kanal der Masken-Ebene liest statt eine Grenze zu testen.
  • SwiftUI: .clipShape(RoundedRectangle(cornerRadius: 16)) ist der binäre geometrische Schnitt, genau wie überall sonst. .mask(LinearGradient( colors: [.black, .clear], startPoint: .top, endPoint: .bottom)) liest stattdessen den Alpha-Wert der Verlaufs-View, der Standardtrick in SwiftUI, um die Kante einer Scroll-View auszublenden, und es ist derselbe DstIn-artige Mechanismus wie im Compose-Beispiel oben, nur als View-Modifier geschrieben.
  • Flutter: ClipRRect/ClipPath/ClipOval legen einen binären Clip auf das Canvas, bevor ihr Kind gezeichnet wird. ShaderMask wendet stattdessen einen Shader (etwa einen LinearGradient) als Alpha-Maske über das bereits gemalte Kind an, via eines BlendMode, derselbe kontinuierliche DstIn-artige Verlauf.

Anwendungsfälle: wozu man tatsächlich greift

  • Runder Avatar oder Thumbnail: Clip. Die Kante ist eine feste geometrische Form ohne etwas zum Ausblenden, genau der binäre Fall, für den Clip gebaut ist. Modifier.clip(CircleShape).
  • Die obere/untere Kante einer scrollbaren Liste ausblenden, damit Zeilen nicht mitten in der Zeile abgeschnitten aussehen: Maske. Die Kante muss über eine Pixelspanne von vollständig opak zu vollständig transparent übergehen, etwas, das nur ein kontinuierlicher Alpha-Verlauf ausdrücken kann, kein Grenztest.
  • Knockout-Text, der in ein Foto eingeschnitten ist (der textförmige-Loch-Look): Maske, via BlendMode.DstOut, weil man einen Teil einer bereits gemalten Ebene auf Basis des Alpha-Werts einer anderen Form löscht, nicht einschränkt, wo ein Zeichenaufruf landen darf.
  • Ein Foto auf einen festen Seitenverhältnis-Rahmen zuschneiden: Clip. Die Kante des Rahmens ist eine feste geometrische Grenze, es gibt nichts auszublenden, die Pixel außerhalb sollten einfach nicht existieren.
  • Weiche Vignette um den Rand eines Fotos: Maske, mit einem radialen Verlauf als Alpha-Quelle, derselbe DstIn-Mechanismus wie im Ausblend-Beispiel oben, nur radial statt linear.

Grenzfälle

  • Den eigenen Schatten wegclippen. clip() macht keine Ausnahme für "Inhalt, der absichtlich überlaufen soll." Es wendet denselben binären Innen/Außen-Test auf jeden darin verschachtelten Zeichenaufruf an, einschließlich der eigenen Unschärfe eines shadow(), sodass ein Schatten, der innerhalb eines Clips verschachtelt ist, still und leise genau an der Grenze abgeschnitten wird, über die er eigentlich hinausreichen sollte:

    // clip is outside shadow here, so shadow is nested inside the clip
    // scope. The clip stack doesn't know "that draw call was a shadow,"
    // it just sees a draw call outside its geometric bounds and discards it.
    Modifier
        .clip(RoundedCornerShape(16.dp))
        .shadow(8.dp, RoundedCornerShape(16.dp))

    Das ist kein Masking-Problem, das man mit DstIn beheben müsste, sondern eine Erinnerung daran, dass Clip bedingungslos ist: Alles, was man nicht gegen diese Grenze abgeflacht haben möchte, muss vollständig außerhalb des geclippten Bereichs gezeichnet werden, nicht innerhalb mit einem größeren Radius.

  • Verschachtelte Clips , sie überschreiben sich nicht. Zwei verschachtelte clipRect- (oder clipPath-) Bereiche erlauben es dem inneren nicht, die Grenze des äußeren zu ersetzen, der Clip-Stack verknüpft sie mit UND:

    // Outer clip keeps only the left 80% of the canvas. Inner clip asks
    // for the right 80%. They overlap in the middle 60%, and that's all
    // that's actually visible, even though the inner clip's own bounds
    // reach further right than the outer clip allows.
    clipRect(right = size.width * 0.8f) {
        clipRect(left = size.width * 0.2f) {
            drawImage(photo, dstSize = IntSize(size.width.toInt(), size.height.toInt()))
        }
    }

    Wer erwartet hatte, dass der innerste Clip den finalen sichtbaren Bereich allein bestimmt, erlebt hier die Überraschung: Sichtbarkeit ist immer die Schnittmenge aller aktuell auf dem Stack liegenden Clips, niemals nur des zuletzt hinzugefügten.

Mentales Modell für die Praxis

Clip beantwortet eine Ja/Nein-Frage (liegt dieser Punkt innerhalb der Form); Maske beantwortet eine Wie-viel-Frage (multipliziere den Alpha-Wert dieses Pixels mit jenem dort). Greife zu Clip, wenn die Kante wirklich eine harte geometrische Linie ist, und greife zu einer Maske in dem Moment, in dem irgendein Teil dieser Kante etwas anderes als vollständig drin oder vollständig draußen sein muss.

Keep reading

Related reads

Neue Beiträge direkt in dein Postfach