Recomposed
Canvas

Fondamentaux du clipping : pile de clip du Canvas vs masque de calque + contour

Oct 18, 2026 · 6 min read

Fondamentaux du clipping : pile de clip du Canvas vs masque de calque + contour

L'intuition

Il est tentant de traiter le clipping et le masquage comme la même opération avec deux API différentes : les deux « coupent la partie de ce contenu que je ne veux pas ». C'est le bon résultat pour le cas simple, et le mauvais modèle mental dès que le bord devient plus intéressant qu'une ligne nette.

  • Un clip est un test oui/non : pour chaque pixel qu'un appel de dessin essaie de toucher, la pile de clip demande « ce point est-il à l'intérieur de la forme », et la réponse est binaire. Il n'existe pas de pixel « clippé à 60% ».
  • Un masque est une multiplication d'alpha : il prend ce qui est déjà rendu et met à l'échelle son alpha par l'alpha d'une seconde image, pixel par pixel. Cette seconde image peut porter n'importe quelle valeur d'alpha entre 0 et 1, un dégradé, un flou, la luminance propre d'une photo, pas seulement « forme » ou « pas forme ».
  • Le clipping est résolu avant qu'un appel de dessin ne peigne quoi que ce soit, comme une restriction sur l'endroit où il est autorisé à écrire. Le masquage est résolu comme une fusion, contre un contenu déjà entièrement peint.

Ces deux mécanismes produisent par hasard des pixels identiques dans un cas précis : une forme opaque avec un bord net. Ce chevauchement est exactement la raison pour laquelle on les traite comme interchangeables, jusqu'au jour où l'on a besoin d'un bord doux et où l'on découvre que l'un des deux ne peut structurellement pas le fournir.

Exemple concret : faire disparaître progressivement le bord d'une photo

On se tourne d'abord vers clipPath, car c'est l'outil évident pour « découper ceci selon une forme » :

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

Réduire progressivement fadeLine ne produit pas un fondu, cela produit une coupure nette plus petite. Un bord de clip peut être précisément au seul bord qu'il dessine, mais il ne peut pas rendre les 40px avant ce bord progressivement plus transparents, car « progressivement transparent » n'est tout simplement pas un concept de pile de clip. Le masquage, lui, le permet :

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

Même objectif visuel, couper le bas d'une photo, mais la version masque peut exprimer quelque chose que la version clip ne peut structurellement pas : une région partiellement visible.

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.

Le fondamental

Le clipping restreint où un appel de dessin est autorisé à écrire : un test binaire intérieur/extérieur contre une frontière géométrique, résolu avant que le moindre dessin n'ait lieu.

Le masquage est une étape de compositing alpha, généralement BlendMode.DstIn/SrcIn contre un calque déjà rendu, qui multiplie les pixels existants par le canal alpha d'une seconde image. L'alpha d'un masque peut varier de façon continue ; la réponse d'un clip ne peut jamais être que oui ou non.

Modifier.clip(shape) est le raccourci intégré pour le cas binaire. Il évite de gérer clipPath à la main, mais reste un clip : lui demander un bord doux ne mène à rien, la forme n'a pas de canal alpha à nuancer.

Cette même asymétrie se retrouve dans ce que chacun prend en entrée. La frontière d'un clip est toujours un Path (ou le contour d'une Shape, qui se compile en un Path) ; il n'existe pas d'autre façon de décrire un test géométrique intérieur/extérieur.

La source d'un masque n'a pas cette contrainte. C'est simplement ce qui a été rendu dans ce calque : un rectangle rempli d'un dégradé, un cercle flouté, les pixels propres d'une photo. Un Path n'est qu'une des nombreuses choses que vous auriez pu y dessiner.

Ailleurs : même fondamental, framework différent

  • CSS : clip-path est une frontière géométrique nette, binaire intérieur/extérieur, tandis que mask-image accepte un dégradé ou un PNG avec un alpha partiel et s'estompe en conséquence, car il lit des valeurs d'alpha, pas un test d'appartenance à une forme.
  • SVG : <clipPath> réunit ses formes enfants en un seul test binaire intérieur/extérieur. <mask> est explicitement graduable par conception : les pixels blancs dans le contenu du masque signifient entièrement visible, le noir signifie entièrement caché, et le gris signifie partiellement visible, un continuum qu'un <clipPath> n'a aucun moyen d'exprimer.
  • CoreAnimation (iOS) : layer.masksToBounds avec cornerRadius découpe selon les limites géométriques propres du calque, binaire, uniquement par forme. Définir layer.mask sur un CAGradientLayer produit en revanche un véritable fondu alpha, car mask lit le canal alpha du calque de masque plutôt que de tester une frontière.
  • SwiftUI : .clipShape(RoundedRectangle(cornerRadius: 16)) est la découpe géométrique binaire, comme partout ailleurs. .mask(LinearGradient( colors: [.black, .clear], startPoint: .top, endPoint: .bottom)) lit plutôt l'alpha de la vue du dégradé, l'astuce SwiftUI classique pour faire disparaître progressivement le bord d'une vue défilante, et c'est le même mécanisme en forme de DstIn que l'exemple Compose ci-dessus, juste exprimé comme un modificateur de vue.
  • Flutter : ClipRRect/ClipPath/ClipOval poussent un clip binaire sur le canvas avant de peindre leur enfant. ShaderMask applique plutôt un Shader (un LinearGradient, par exemple) comme masque alpha sur l'enfant déjà peint via un BlendMode, le même fondu continu de style DstIn.

Cas d'usage : lequel choisir réellement

  • Avatar ou miniature arrondie : clip. Le bord est une forme géométrique fixe sans rien à estomper, exactement le cas binaire pour lequel le clip est conçu. Modifier.clip(CircleShape).
  • Faire disparaître progressivement le bord haut/bas d'une liste défilante pour que les lignes ne paraissent pas tranchées en plein milieu : masque. Le bord doit passer d'entièrement opaque à entièrement transparent sur une plage de pixels, quelque chose que seul un dégradé alpha continu peut exprimer, pas un test de frontière.
  • Texte en creux découpé dans une photo (l'effet « trou en forme de texte ») : masque, via BlendMode.DstOut, car on efface une partie d'un calque déjà peint en se basant sur l'alpha d'une autre forme, pas en restreignant où un appel de dessin est autorisé à atterrir.
  • Recadrer une photo selon un cadre à rapport d'aspect fixe : clip. Le bord du cadre est une frontière géométrique fixe, il n'y a rien à estomper, les pixels à l'extérieur ne devraient simplement pas exister.
  • Vignette douce autour du bord d'une photo : masque, avec un dégradé radial comme source alpha, le même mécanisme DstIn que l'exemple de fondu ci-dessus, simplement radial au lieu de linéaire.

Cas particuliers

  • Découper sa propre ombre par accident. clip() ne prévoit pas d'exception pour « le contenu censé déborder ». Il applique le même test binaire intérieur/extérieur à chaque appel de dessin imbriqué à l'intérieur, y compris le flou propre d'un shadow(), si bien qu'une ombre imbriquée dans un clip se retrouve silencieusement coupée exactement à la frontière qu'elle était censée dépasser :

    // 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))

    Ce n'est pas un problème de masquage à corriger avec DstIn, c'est un rappel que le clip est inconditionnel : tout ce que vous ne voulez pas voir aplati contre cette frontière doit être dessiné entièrement en dehors de la portée clippée, pas à l'intérieur avec un rayon plus grand.

  • Les clips imbriqués , ils ne se remplacent pas. Deux portées clipRect (ou clipPath) imbriquées ne permettent pas à la portée intérieure de remplacer la frontière de la portée extérieure, la pile de clip les combine avec un ET :

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

    Si vous attendiez que le clip le plus intérieur définisse la zone visible finale à lui seul, voici la surprise : la visibilité est toujours l'intersection de tous les clips actuellement sur la pile, jamais juste le plus récent.

Modèle mental à retenir

Le clip répond à une question oui/non (ce point est-il à l'intérieur de la forme) ; le masque répond à une question de degré (multiplier l'alpha de ce pixel par celui-là). Tournez-vous vers le clip quand le bord est vraiment une ligne géométrique nette, et vers un masque dès qu'une partie de ce bord doit être autre chose qu'entièrement dedans ou entièrement dehors.

Keep reading

Related reads

Recevez les nouveaux articles par e-mail