AGSL est conçu pour être largement compatible avec GLSL ES 1.0. Pour en savoir plus, consultez la fonction équivalente dans la documentation OpenGL ES Shading Language. Dans la mesure du possible, cette documentation tente de mettre en évidence les différences entre AGSL et GLSL.
Types
AGSL est compatible avec les types GLSL ES 1.0, ainsi qu'un moyen supplémentaire de représenter les types de vecteur et de matrice. AGSL accepte d'autres types short et half pour représenter une précision moyenne.
Types de base
| Type | Description |
|---|---|
void
|
Aucune valeur renvoyée par la fonction ou liste de paramètres vide. Contrairement au GLSL, les fonctions sans type renvoyé vide doivent renvoyer une valeur. |
bool, bvec2, bvec3, bvec4 (bool2, bool3, bool4). |
Valeur scalaire/vecteur booléenne |
int, ivec2, ivec3, ivec4 (int2, int3, int4) |
Entier/vecteur signé : highp
|
float, vec2, vec3, vec4 (float2, float3, float4)
|
highp (précision simple) scalaire/vecteur à virgule flottante |
short, short2, short3, short4
|
équivaut à mediump int
un entier/vectoriel signé |
half, half2, half3, half4 |
équivaut à mediump float scalaire/vecteur |
mat2, mat3, mat4 (float2x2, float3x3, float4x4) |
Matrice float 2 x 2, 3 x 3 et 4 x 4
|
half2x2, half3x3, half4x4 |
Équivalent aux types de matrices mediump float |
Précision et valeurs minimales de plage
Il s'agit de la précision et de la plage minimales garanties associées à chaque modificateur en fonction de la spécification OpenGL ES 2.0. Comme la plupart des appareils sont compatibles avec ES 3.0, la précision/plage de highp et la portée int mediump seront plus garanties. Les modificateurs de précision peuvent être appliqués aux variables et paramètres scalaires, vectoriels et matriciels. Seuls les minimums listés ci-dessous sont garantis. lowp n'est pas nécessairement une précision inférieure à mediump, et mediump n'est pas nécessairement une précision inférieure à highp. AGSL convertit actuellement lowp en mediump dans le résultat final.
| Modifier | Plage "float" | Plage de magnitudes "float" | Précision de la valeur "float" | Plage "int" |
|---|---|---|---|---|
| Highp | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Proche: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| moyen | \(\left\{-2^{14},2^{14}\right\}\) | \(\left\{2^{-14},2^{14}\right\}\) | Proche: \(2^{-10}\) | \(\left\{-2^{10},2^{10}\right\}\) |
| fausse | \(\left\{-2,2\right\}\) | \(\left\{2^{-8},2\right\}\) | Valeur absolue: \(2^{-8}\) | \(\left\{-2^{8},2^{8}\right\}\) |
En plus de la syntaxe d'indice numérique de tableau, par exemple var[num], names of vector
components for vectors of length 2 - 4 are denoted by a single letter. Components
can be swizzled and replicated. ex:vect.yx,vect.yy`
vect.xyzw : à utiliser lors de l'accès à des vecteurs qui représentent des points/normal.
vect.rgba : à utiliser lors de l'accès à des vecteurs qui représentent des couleurs.
vect.LTRB : à utiliser lorsque le vecteur représente un rectangle (pas en GLSL).
Dans AGSL, les valeurs 0 et 1 permettent de générer une constante 0 ou 1 dans ce canal.
Ex. : vect.rgb1 == vec4(vect.rgb,1)
Structures et tableaux
Les structures sont déclarées avec la même syntaxe que le langage GLSL, mais AGSL n'accepte que les structures ayant un champ d'application global.
struct type-name {
members
} struct-name; // optional variable declaration.
Seuls les tableaux unidimensionnels sont compatibles avec une taille de tableau explicite, à l'aide d'une syntaxe de style C ou GLSL:
nom de la variable <type de base>[<taille du tableau>] – Exemple: half[10] x;
nom de variable <type de base>[<taille du tableau>] – Ex. : half x[10];
Les tableaux ne peuvent pas être renvoyés à partir d'une fonction, copiés, attribués ou comparés. Les restrictions de tableau se propagent dans les structures contenant des tableaux. Les tableaux ne peuvent être indexés qu'à l'aide d'une constante ou d'une variable de boucle.
Matchs de qualification
| Type | Description |
|---|---|
const
|
Constante compile-time ou paramètre de fonction en lecture seule. |
uniform
|
La valeur ne change pas au cours de la primitive en cours de traitement.
Les uniformes sont transmis à partir d'Android à l'aide des méthodes RuntimeShader pour setColorUniform, setFloatUniform, setIntUniform, setInputBuffer et setInputShader. |
in
|
Pour les paramètres de fonction transmis. Ce paramètre est la valeur par défaut. |
out
|
Pour les paramètres de fonction transmis. Doit utiliser la même précision que la définition de la fonction. |
inout
|
Pour les paramètres transmis à la fois dans et depuis une fonction. Doit utiliser la même précision que la définition de la fonction. |
Déclaration de variable
Les déclarations doivent se trouver dans un champ d'application entre accolades explicite. La déclaration de y dans l'exemple suivant n'est pas autorisée:
if (condition)
int y = 0;
Principes de base des matrices, structures et tableaux
Exemples de constructeurs matriciels
Lorsqu'une matrice est construite avec une seule valeur, toutes les valeurs de la diagonale reçoivent cette valeur, tandis que les autres reçoivent des zéros. float2x2(1.0) crée donc une matrice d'identité de 2x2.
Lorsqu'une matrice est construite avec plusieurs valeurs, les colonnes sont remplies en premier (ordre principal des colonnes).
Notez que, contrairement au GLSL, les constructeurs qui réduisent le nombre de composants d'un vecteur transmis ne sont pas pris en charge, mais vous pouvez utiliser le swizzling pour obtenir le même effet. Pour construire un vec3 à partir d'un vec4 en AGSL avec le même comportement que le GLSL, spécifiez vec3 nv = quadVec.xyz.
Exemple de constructeur de structure
struct light { float intensity; float3 pos; };
// literal integer constants auto-converted to floating point
light lightVar = light(3, float3(1, 2, 3.0));
Composants de la matrice
Accédez aux composants d'une matrice à l'aide d'une syntaxe d'indice de tableau.
float4x4 m; // represents a matrix
m[1] = float4(2.0); // sets second column to all 2.0
m[0][0] = 1.0; // sets upper left element to 1.0
m[2][3] = 2.0; // sets 4th element of 3rd column to 2.0
Champs de structure
Sélectionnez des champs de structure à l'aide de l'opérateur de point .. Les opérateurs incluent:
| Opérateur | Description |
|---|---|
. |
sélecteur de champ |
==, != |
égalité |
= |
attribution |
Éléments de tableau
Les éléments de tableau sont accessibles à l'aide de l'opérateur d'indice de tableau [ ]. Par exemple :
diffuseColor += lightIntensity[3] * NdotL;
Opérateurs
Numéroées par ordre de priorité. Les opérateurs relationnels et d'égalité > < <= >= == != évaluent une valeur booléenne. Pour comparer des vecteurs au niveau des composants, utilisez des fonctions telles que lessThan(), equal(), etc.
| Opérateur | Description | Associativité | |
|---|---|---|---|
| 1 | () |
regroupement entre parenthèses | N/A |
| 2 | [] () . ++ --
|
tableau indice appel de fonction et structure de constructeur champ ou sélecteur de méthode | De gauche à droite |
| 3 | ++ -- + - !
|
incrémenter et décrémenter un préfixe | De droite à gauche |
| 4 | * / |
multiplier et diviser | De gauche à droite |
| 5 | + - |
additionner et soustraire | De gauche à droite |
| 7 | < > <= >= |
relationnel | De gauche à droite |
| 8 | == != |
égalité/inégalité | De gauche à droite |
| 12 | && |
logique AND | De gauche à droite |
| 13 ans | ^^ |
logique XOR | De gauche à droite |
| 14 | || |
opérateur logique "OR" | De gauche à droite |
| 15 | ?\:
|
(un opérande entier). | De gauche à droite |
| 16 | = += -= *= /=
|
attribution arithmétique affectation arithmétique affectation arithmétique | De gauche à droite |
| 17 | , |
sequence | De gauche à droite |
Opérations matricielles et vectorielles
Lorsqu'ils sont appliqués à des valeurs scalaires, les opérateurs arithmétiques donnent un résultat scalaire. Pour les opérateurs autres que modulo, si un opérande est scalaire et que l'autre est un vecteur ou une matrice, l'opération est effectuée au niveau de la composante et donne le même type de vecteur ou de matrice. Si les deux opérations sont des vecteurs de même taille, l'opération est effectuée au niveau de la composante (et renvoie le même type de vecteur).
| Conditions de fonctionnement | Description |
|---|---|
m = f * m |
Multiplication de matrice par composant par une valeur scalaire |
v = f * v |
Multiplication de vecteur par composant par une valeur scalaire |
v = v * v |
Multiplication de vecteur par composant par une valeur vectorielle |
m = m + m |
Addition par composant matriciel |
m = m - m |
Soustraction par composante de la matrice |
m = m * m |
Multiplier algébrique linéaire |
Si un opérande est un vecteur correspondant à la taille de ligne ou de colonne de notre matrice, l'opérateur de multiplication peut être utilisé pour effectuer une multiplication algébrique des lignes et des colonnes.
| Conditions de fonctionnement | Description |
|---|---|
m = v * m |
Vecteur de ligne * multiplication algébrique linéaire matricielle |
m = m * v |
Matrice * multiplication algébrique linéaire à vecteur de colonne |
Utilisez les fonctions intégrées pour le produit scalaire vectoriel, le produit croisé et la multiplication par composant:
| Fonction | Description |
|---|---|
f = dot(v, v) |
Produit scalaire vectoriel |
v = cross(v, v) |
Produit vectoriel vectoriel |
m = matrixCompMult(m, m) |
Multiplier par composant |
Contrôle du programme
| Appel de fonction | Appel par valeur/retour |
|---|---|
| Itération | for (<init>;<test>;<next>) { break, continue } |
| Sélection | if ( ) { } if ( ) { } else { } switch () { break, case } (en dernier) la casse par défaut |
| Sauter | break, continue, return (la suppression n'est pas autorisée) |
| Entrée | half4 main(float2 fragCoord) |
Limites de la boucle For
Comme dans GLSL ES 1.0, les boucles "for" sont assez limitées. Le compilateur doit être capable de les dérouler. Cela signifie que l'initialiseur, la condition de test et l'instruction next doivent utiliser des constantes pour que tout puisse être calculé au moment de la compilation. L'instruction next est en outre limitée à l'utilisation de ++, --, +=, or -=.
Fonctions intégrées
GT (type générique) est float, float2, float3, float4 ou half, half2, half3, half4.
La plupart de ces fonctions s'exécutent au niveau de chaque composant (la fonction est appliquée par composant). C'est noté lorsque ce n'est pas le cas.
Fonctions d'angle et trigonométriques
Les paramètres de fonction spécifiés sous la forme d'un angle sont censés être exprimés en radians. L'une de ces fonctions n'entraînera en aucun cas une erreur de division par zéro. Si le diviseur d'un ratio est de 0, les résultats ne sont pas définis.
| Fonction | Description |
|---|---|
GT radians(GT degrees) |
Convertit des degrés en radians |
GT degrees(GT radians) |
Convertit des radians en degrés |
GT sin(GT angle) |
Sinus standard |
GT cos(GT angle) |
Cosinus standard |
GT tan(GT angle) |
Tangente standard |
GT asin(GT x)
|
Renvoie un angle dont le sinus est x dans la plage $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
GT acos(GT x)
|
Renvoie un angle dont le cosinus est x dans la plage $ \left[0,\pi\right] $ |
GT atan(GT y, GT x)
|
Renvoie un angle dont l'arc tangente trigonométrique est $ \left[{y\over x}\right] $ dans la plage $ \left[-\pi,\pi\right] $ |
GT atan(GT y_over_x)
|
Renvoie un angle dont l'arc tangente
trigonométrique est y_over_x dans la plage $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
Fonctions exponentielles
| Fonction | Description |
|---|---|
GT pow(GT x, GT y) |
Renvoie $ x^y $ |
GT exp(GT x) |
Renvoie $ e^x $ |
GT log(GT x) |
Renvoie $ ln(x) $ |
GT exp2(GT x) |
Renvoie $ 2^x $ |
GT log2(GT x) |
Renvoie $ log_2(x) $ |
GT sqrt(GT x) |
Renvoie $ \sqrt{x} $ |
GT inversesqrt(GT x) |
Renvoie $ 1\over{\sqrt{x}} $ |
Fonctions courantes
| Fonction | Description |
|---|---|
GT abs(GT x) |
Valeur absolue |
GT sign(GT x) |
Renvoie -1.0, 0.0 ou 1.0 en fonction du signe x. |
GT floor(GT x) |
Entier le plus proche <= x |
GT ceil(GT x) |
Entier le plus proche >= x |
GT fract(GT x) |
Affiche la partie fractionnaire de x. |
GT mod(GT x, GT y) |
Affiche la valeur de x modulo y |
GT mod(GT x, float y) |
Affiche la valeur de x modulo y |
GT min(GT x, GT y) |
Affiche la valeur minimale de x ou y |
GT min(GT x, float y) |
Affiche la valeur minimale de x ou y |
GT max(GT x, GT y) |
Affiche la valeur maximale de x ou y. |
GT max(GT x, float y) |
Affiche la valeur maximale de x ou y. |
GT clamp(GT x, GT
minVal, GT maxVal) |
Renvoie x, compris entre minVal et maxVal. |
GT clamp(GT x, float
minVal, float maxVal) |
Renvoie x, compris entre minVal et maxVal |
GT saturate(GT x) |
Renvoie la valeur x, comprise entre 0,0 et 1,0 |
GT mix(GT x, GT y
GT a) |
Affiche une combinaison linéaire de x et y |
GT mix(GT x, GT y,
float a) |
Affiche une combinaison linéaire de x et y |
GT step(GT edge, GT x) |
Renvoie 0.0 si x < bord, sinon 1.0 |
GT step(float edge,
GT x) |
Renvoie 0.0 si x < bord, sinon 1.0 |
GT smoothstep(GT edge0,
GT edge1, GT x) |
Effectue une interpolation Hermite entre 0 et 1 lorsque l'arête 0 < x < edge1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
Effectue une interpolation Hermite entre 0 et 1 lorsque l'arête 0 < x < edge1 |
Fonctions géométriques
Ces fonctions opèrent sur des vecteurs en tant que vecteurs, et non au niveau de la composante. GT est un vecteur flottant/demi-vecteur pour les tailles 2 à 4.
| Fonction | Description |
|---|---|
float/half length
(GT x) |
Renvoie la longueur du vecteur |
float/half distance(GT
p0, GT p1) |
Renvoie la distance entre des points |
float/half dot(GT x,
GT y) |
Affiche un produit scalaire |
float3/half3
cross(float3/half3 x,
float3/half3 y) |
Renvoie un produit croisé |
GT normalize(GT x) |
Normaliser le vecteur à la longueur 1 |
GT faceforward(GT N,
GT I, GT Nref) |
Renvoie N si point(Nref, I) < 0, sinon -N. |
GT reflect(GT I, GT N) |
Direction du reflet I - 2 * point(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Renvoie un vecteur de réfraction |
Fonctions de matrice
"type Mat" correspond à n'importe quel type de matrice carrée.
| Fonction | Description |
|---|---|
mat matrixCompMult(mat
x, mat y) |
Multiplier x par y au niveau de la composante |
mat inverse(mat m) |
Affiche la valeur inverse de m. |
Fonctions vectorielles relationnelles
Comparez x et y au niveau des composants. Les tailles des vecteurs d'entrée et de retour pour un appel particulier doivent correspondre. T est l'union de types de vecteurs entiers et à virgule flottante. "BV" est un vecteur booléen qui correspond à la taille des vecteurs d'entrée.
| Fonction | Description |
|---|---|
BV lessThan(T x, T y) |
x < y |
BV lessThanEqual(T x,
T y) |
x <= y |
BV greaterThan(T x,
T y) |
x > y |
BV greaterThanEqual(T
x, T y) |
x >= y |
BV equal(T x, T y) |
x == y |
BV equal(BV x, BV y) |
x == y |
BV notEqual(T x, T y) |
x != y |
BV notEqual(BV x,
BV y) |
x != y |
bool any(BV x) |
true si l'un des composants de x est true. |
bool all(BV x) |
true si tous les composants de x sont true. |
BV not(BV x) |
complément logique de x |
Fonctions de couleur
| Fonction | Description |
|---|---|
vec4 unpremul(vec4
color) |
Convertit la valeur de couleur en valeur alpha non prémultipliée. |
half3 toLinearSrgb(half3
color) |
Transformation de l'espace colorimétrique en SRGB linéaire |
half3 fromLinearSrgb(half3
color) |
Transformation de l'espace colorimétrique |
Échantillonnage du nuanceur (évaluation)
Les types d'échantillonneurs ne sont pas acceptés, mais vous pouvez évaluer d'autres nuanceurs. Si vous devez échantillonner une texture, vous pouvez créer un objet BitmapShader et l'ajouter en tant qu'uniforme. Vous pouvez le faire pour n'importe quel nuanceur, ce qui signifie que vous pouvez évaluer directement n'importe quel nuanceur Android sans d'abord le transformer en Bitmap, y compris d'autres objets RuntimeShader. Cela offre une grande flexibilité, mais l'évaluation des nuanceurs complexes peut être coûteuse, en particulier dans une boucle.
uniform shader image;
image.eval(coord).a // The alpha channel from the evaluated image shader
Échantillonnage de tampon brut
Bien que la plupart des images contiennent des couleurs qui doivent être gérées par couleur, certaines d'entre elles contiennent des données qui ne sont pas réellement des couleurs, y compris des images stockant des normales, des propriétés du matériau (par exemple, rugosité), des plans de hauteur ou toute autre donnée purement mathématiques qui est stockée dans une image. Lorsque vous utilisez ce type d'images dans AGSL, vous pouvez utiliser un BitmapShader comme tampon brut générique à l'aide de RuntimeShader#setInputBuffer. Cela évitera les transformations et le filtrage de l'espace colorimétrique.