AGSL (Android Graphics Shading Language)
Mantieni tutto organizzato con le raccolte
Salva e classifica i contenuti in base alle tue preferenze.
Android Graphics Shading Language (AGSL) viene utilizzato da Android 13 e versioni successive per definire il comportamento degli oggetti RuntimeShader programmabili. AGSL condivide gran parte della sua sintassi con gli ombreggiatori dei frammenti GLSL, ma funziona all'interno del sistema di rendering della grafica Android per personalizzare la pittura all'interno di Canvas e filtrare i contenuti View.
Teoria del funzionamento
Gli effetti AGSL fanno parte della più ampia pipeline grafica di Android. Quando Android emette un'operazione di disegno con accelerazione GPU, assembla un singolo Shader di frammenti GPU per svolgere il lavoro richiesto. Questo ombreggiatore include in genere diversi pezzi.
Ad esempio:
- Valutare se un pixel cade all'interno o all'esterno della forma disegnata
(o sul bordo, dove potrebbe essere applicato l'anti-aliasing).
- Valutare se un pixel rientra o meno all'interno o all'esterno dell'area di ritaglio (di nuovo, con logica di anti-aliasing possibile per i pixel del bordo).
- Logica per
Shader
sul Paint. Shader può essere in realtà un albero di oggetti (a causa di ComposeShader e di altre funzionalità descritte di seguito).
- Logica simile per
ColorFilter.
- Codice di combinazione (per alcuni tipi di
BlendMode).
- Codice di conversione dello spazio colore, nell'ambito della gestione dei colori di Android.
- Quando
Paint ha un complesso albero di oggetti nei campi Shader, ColorFilter o BlendMode, c'è ancora un solo Shader frammento GPU. Ogni nodo nell'albero crea una singola funzione. Il codice di ritaglio e il codice geometrico
creano ciascuno una funzione. Il codice di combinazione potrebbe creare una funzione.
A questo punto, lo Shader dei frammenti chiama tutte queste funzioni (che potrebbero chiamare altre funzioni, ad esempio nel caso di un albero di Shader).
L'effetto AGSL contribuisce a una funzione (o più funzioni) al fragment Shader della GPU.
Sintassi di base
AGSL (e GLSL) sono lingue specifiche per i domini in stile C. Tipi come bool e
int tracciano molto attentamente i loro equivalenti C; ce ne sono altri tipi per
supportare vettori e matrici che supportano la funzionalità del dominio.
I qualificatori possono essere applicati ai tipi per ottenere suggerimenti di precisione, in modo univoco per le lingue di ombreggiatura. Le strutture di controllo come le istruzioni if-else funzionano in modo molto
come in C; il linguaggio fornisce anche supporto per le istruzioni switch
e i loop for con limitazioni. Alcune strutture di controllo richiedono espressioni costanti che possono essere valutate in fase di compilazione.
AGSL supporta le funzioni; ogni programma Shader inizia con la funzione main.
Le funzioni definite dall'utente sono supportate, senza supporto per la ricorsione di qualsiasi tipo.
Le funzioni utilizzano una convenzione per le chiamate "value-return". I valori trasferiti alle funzioni vengono copiati nei parametri quando la funzione viene chiamata e gli output vengono copiati. Ciò è determinato dai qualificatori in, out e inout.
I campioni di contenuti e codice in questa pagina sono soggetti alle licenze descritte nella Licenza per i contenuti. Java e OpenJDK sono marchi o marchi registrati di Oracle e/o delle sue società consociate.
Ultimo aggiornamento 2025-07-26 UTC.
[null,null,["Ultimo aggiornamento 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."]]
