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.
- →BlendMode vs CompositingStrategy: It's Not a Fence, It's a Different CanvasDstIn, SrcIn, and the Offscreen layer this post's masking technique builds on, explained from the blend-formula side.
- →Modifier Order Matters: It's a Wrapper Chain, Not a Property BagWhy clip() has to sit on the outside of background() or border() to actually cut them, the wrapper-chain reasoning this post's clip stack relies on.
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-pathest une frontière géométrique nette, binaire intérieur/extérieur, tandis quemask-imageaccepte 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.masksToBoundsaveccornerRadiusdécoupe selon les limites géométriques propres du calque, binaire, uniquement par forme. Définirlayer.masksur unCAGradientLayerproduit en revanche un véritable fondu alpha, carmasklit 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/ClipOvalpoussent un clip binaire sur le canvas avant de peindre leur enfant.ShaderMaskapplique plutôt unShader(unLinearGradient, par exemple) comme masque alpha sur l'enfant déjà peint via unBlendMode, 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'unshadow(), 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(ouclipPath) 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.



