Android Graphics Shading Language (AGSL)
Restez organisé à l'aide des collections
Enregistrez et classez les contenus selon vos préférences.
Le langage AGSL (Android Graphics Shading Language) est utilisé par Android 13 et versions ultérieures pour définir le comportement des objets RuntimeShader programmables. AGSL partage une grande partie de sa syntaxe avec les nuanceurs de fragments GLSL, mais fonctionne dans le système de rendu graphique Android pour personnaliser la peinture dans Canvas et filtrer le contenu View.
Théorie du fonctionnement
Les effets AGSL s'inscrivent dans le pipeline graphique Android plus vaste. Lorsqu'Android lance une opération de dessin accélérée par le GPU, il assemble un seul nuanceur de fragment GPU pour effectuer le travail requis. Ce nuanceur comprend généralement plusieurs éléments.
Voici quelques exemples:
- Évaluer si un pixel se trouve à l'intérieur ou à l'extérieur de la forme dessinée (ou sur la bordure, où il peut appliquer un anticrénelage)
- Évaluer si un pixel se trouve à l'intérieur ou à l'extérieur de la zone de rognage (encore une fois, avec une logique d'anticrénelage possible pour les pixels de bordure).
- Logique de
Shader sur Paint. Le nuanceur peut en fait être une arborescence d'objets (grâce à ComposeShader et à d'autres fonctionnalités décrites ci-dessous).
- Logique similaire pour
ColorFilter.
- Combinaison du code (pour certains types de
BlendMode)
- Code de conversion de l'espace colorimétrique, dans le cadre de la gestion des couleurs d'Android.
- Lorsque
Paint comporte une arborescence complexe d'objets dans les champs Shader, ColorFilter ou BlendMode, il n'existe toujours qu'un seul nuanceur de fragments GPU. Chaque nœud de cette arborescence crée une seule fonction. Le code de découpage et le code géométrique créent chacun une fonction. Le code de combinaison peut créer une fonction.
Le nuanceur de fragments global appelle ensuite toutes ces fonctions (qui peuvent appeler d'autres fonctions, par exemple dans le cas d'une arborescence de nuanceurs).
Votre effet AGSL contribue à une ou plusieurs fonctions dans le nuanceur de fragments du GPU.
Syntaxe de base
AGSL (et GLSL) sont des langages spécifiques au domaine C. Les types tels que bool et int suivent de près leurs équivalents C. Il existe d'autres types pour prendre en charge les vecteurs et les matrices compatibles avec les fonctionnalités du domaine.
Les qualificatifs peuvent être appliqués aux types pour obtenir des indications de précision, d'une manière qui est propre aux langues d'ombrage. Les structures de contrôle telles que les instructions if-else fonctionnent de la même manière qu'en C. Le langage est également compatible avec les instructions switch et les boucles for avec des limites. Certaines structures de contrôle nécessitent des expressions constantes pouvant être évaluées au moment de la compilation.
AGSL est compatible avec les fonctions. Chaque programme de nuanceur commence par la fonction main.
Les fonctions définies par l'utilisateur sont prises en charge, mais aucune récursion n'est prise en charge.
Les fonctions utilisent une convention d'appel de type "valeur-retour". Les valeurs transmises aux fonctions sont copiées dans les paramètres lors de l'appel de la fonction, et les sorties sont copiées. Ce comportement est déterminé par les qualificatifs in, out et inout.
Le contenu et les exemples de code de cette page sont soumis aux licences décrites dans la Licence de contenu. Java et OpenJDK sont des marques ou des marques déposées d'Oracle et/ou de ses sociétés affiliées.
Dernière mise à jour le 2025/07/26 (UTC).
[[["Facile à comprendre","easyToUnderstand","thumb-up"],["J'ai pu résoudre mon problème","solvedMyProblem","thumb-up"],["Autre","otherUp","thumb-up"]],[["Il n'y a pas l'information dont j'ai besoin","missingTheInformationINeed","thumb-down"],["Trop compliqué/Trop d'étapes","tooComplicatedTooManySteps","thumb-down"],["Obsolète","outOfDate","thumb-down"],["Problème de traduction","translationIssue","thumb-down"],["Mauvais exemple/Erreur de code","samplesCodeIssue","thumb-down"],["Autre","otherDown","thumb-down"]],["Dernière mise à jour le 2025/07/26 (UTC)."],[],[],null,["# Android Graphics Shading Language (AGSL) is used by Android 13 and above to\ndefine the behavior of programmable\n[`RuntimeShader`](/reference/android/graphics/RuntimeShader) objects. AGSL\nshares much of its syntax with GLSL fragment shaders, but works within the\nAndroid graphics rendering system to both customize painting within `Canvas`\nand filter `View` content.\n\nTheory of operation\n-------------------\n\nAGSL effects exist as part of the larger Android graphics pipeline. When Android\nissues a GPU accelerated drawing operation, it assembles a single GPU fragment\nshader to do the required work. This shader typically includes several pieces.\nFor example, it might include:\n\n- Evaluating whether a pixel falls inside or outside of the shape being drawn (or on the border, where it might apply anti-aliasing).\n- Evaluating whether a pixel falls inside or outside of the clipping region (again, with possible anti-aliasing logic for border pixels).\n- Logic for the [`Shader`](/reference/android/graphics/Shader) on the [`Paint`](/reference/android/graphics/Paint). The Shader can actually be a tree of objects (due to [`ComposeShader`](/reference/android/graphics/ComposeShader) and other features described below).\n- Similar logic for the [`ColorFilter`](/reference/android/graphics/ColorFilter).\n- Blending code (for certain types of [`BlendMode`](/reference/android/graphics/BlendMode)).\n- Color space conversion code, as part of Android's color management.\n- When the `Paint` has a complex tree of objects in the `Shader`, `ColorFilter`, or `BlendMode` fields, there is still only a single GPU fragment shader. Each node in that tree creates a single function. The clipping code and geometry code each create a function. The blending code might create a function. The overall fragment shader then calls all of these functions (which may call other functions, e.g. in the case of a shader tree).\n\nYour AGSL effect contributes a function (or functions) to the GPU's fragment shader.\n\nBasic syntax\n------------\n\nAGSL (and GLSL) are C-style domain specific languages. Types such as `bool` and\n`int` closely track their C equivalents; there are additional types to\nsupport vectors and matrices that support domain functionality.\n\nQualifiers can be applied to types for precision hints in a way that's unique to shading languages. Control structures such as `if-else` statements work much\nlike they do in C; the language also provides support for `switch` statements\nand `for` loops with limitations. Some control structures require constant expressions that can be evaluated at compile time.\n\nAGSL supports functions; every shader program begins with the `main` function.\nUser defined functions are supported, without support for recursion of any kind.\nFunctions use a \"value-return\" calling convention; values passed to functions are\ncopied into parameters when the function is called, and outputs are copied\nback; this is determined by the `in`, `out`, and `inout` qualifiers."]]
