AGSL est conçu pour être largement compatible avec GLSL ES 1.0. Pour plus d'informations, consultez la fonction équivalente Documentation sur le langage de nuance OpenGL ES Lorsque cela est possible, cette documentation tente de souligner les différences entre AGSL et GLSL.
Types
AGSL prend en charge les types GLSL ES 1.0 ainsi qu'un autre moyen de représenter des vecteurs
et les types de matrices. AGSL prend en charge d'autres types short et half pour représenter
avec une précision moyenne.
Types de base
| Type | Description |
|---|---|
void
|
Aucune valeur renvoyée pour la fonction ou paramètre vide liste. Contrairement au GLSL, les fonctions sans vide type renvoyé doit 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) à virgule flottante
scalaire/vecteur |
short, short2, short3, short4
|
équivaut à mediump int signé
Entier/vecteur |
half, half2, half3, half4 |
équivaut à mediump float scalaire/vecteur |
mat2, mat3, mat4 (float2x2, float3x3, float4x4) |
Matrice float 2x2, 3x3, 4x4
|
half2x2, half3x3, half4x4 |
Équivalent aux types de matrices mediump float |
Valeurs minimales de précision et de plage
Il s'agit de la précision et de la plage minimales garanties associées à chaque
basé sur la spécification OpenGL ES 2.0. Puisque la plupart
des appareils
compatibles avec ES 3.0, leur précision/plage highp sera plus garantie et
Plage int mediump. Les modificateurs de précision peuvent être appliqués aux valeurs scalaires, vectorielles et
les variables et paramètres matriciels. Seuls les montants minimaux listés ci-dessous sont garantis.
La précision de lowp n'est pas nécessairement inférieure à celle de mediump, et mediump
n'est pas nécessairement inférieure à celle de highp. AGSL convertit actuellement lowp
à mediump dans la sortie finale.
| Modifier | "float" plage | "float" plage de magnitude | "float" précision | "int" plage |
|---|---|---|---|---|
| haut débit | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Proche: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| médium | \(\left\{-2^{14},2^{14}\right\}\) | \(\left\{2^{-14},2^{14}\right\}\) | Proche: \(2^{-10}\) | \(\left\{-2^{10},2^{10}\right\}\) |
| Lowp | \(\left\{-2,2\right\}\) | \(\left\{2^{-8},2\right\}\) | Absolu: \(2^{-8}\) | \(\left\{-2^{8},2^{8}\right\}\) |
En plus de la syntaxe d'indice numérique de tableau, ex: 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 : permet d'accéder aux vecteurs représentant des points/normales.
vect.rgba : permet d'accéder aux vecteurs représentant des couleurs.
vect.LTRB : à utiliser lorsque le vecteur représente un rectangle (pas en GLSL)
Dans AGSL, 0 et 1 peuvent être utilisés pour produire 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 GLSL, mais AGSL ne prend en charge que à grande échelle.
struct type-name {
members
} struct-name; // optional variable declaration.
Seuls les tableaux unidimensionnels sont compatibles avec une taille de tableau explicite, à l'aide de syntaxe de style C ou GLSL:
<type de base>[<taille du tableau>] (ex. : half[10] x;)
<type de base> nom de la variable [<taille du tableau>] (ex. : half x[10];)
Les tableaux ne peuvent pas être renvoyés à partir d'une fonction, ni être copiés, attribués ou comparés. Les restrictions de tableau se propagent aux structures contenant des tableaux. Les tableaux peuvent ne doivent être indexées qu'à l'aide d'une constante ou d'une variable de boucle.
Matchs de qualification
| Type | Description |
|---|---|
const
|
Constante de compilation ou fonction en lecture seule . |
uniform
|
La valeur ne change pas au cours de la primitive
en cours de traitement.
Les uniformes sont transmis depuis Android à l'aide de
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 d'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 crochets explicite. La déclaration de y dans
l'exemple suivant n'est pas autorisé:
if (condition)
int y = 0;
Principes de base des matrices/structures/tableaux
Exemples de constructeurs matriciels
Lorsqu'une matrice est construite avec une valeur unique, toutes les valeurs présentes
la diagonale reçoit cette valeur, et les autres reçoivent des zéros. float2x2(1.0)
ce qui crée une matrice d'identité 2x2.
Lorsqu'une matrice est construite avec plusieurs valeurs, les colonnes sont remplies en premier (ordre de la colonne majeure).
Notez que, contrairement au GLSL, les constructeurs qui réduisent le nombre de composants d'une
ne sont pas pris en charge, mais vous pouvez utiliser le swizzling pour obtenir
l'effet. Pour construire un vec3 à partir d'un vec4 dans AGSL avec le même comportement que
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 avec une syntaxe d'indice dans le 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 les champs de structure à l'aide de l'opérateur point .. Exemples d'opérateurs:
| Opérateur | Description |
|---|---|
. |
sélecteur de champ |
==, != |
égalité |
= |
attribution |
Éléments de tableau
L'accès aux éléments du tableau est effectué à l'aide de l'opérateur d'indice de tableau [ ]. Exemple :
diffuseColor += lightIntensity[3] * NdotL;
Opérateurs
Numérotés par ordre de priorité. Les concepts relationnels et d'égalité
opérateurs > < <= >= == != évalue une valeur booléenne. Pour comparer des vecteurs
côté composant, utilisez des fonctions telles que lessThan(), equal(), etc.
| Opérateur | Description | Associativité | |
|---|---|---|---|
| 1 | () |
regroupement parenthétique | N/A |
| 2 | [] () . ++ --
|
indice de tableau appel de fonction & structure du constructeur champ ou méthode sélecteur, swizzle incrémentation postfixe et diminuer | De gauche à droite |
| 3 | ++ -- + - !
|
incrément de préfixe et diminuer unaire | 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 | && |
opérateur logique "AND" | De gauche à droite |
| 13 | ^^ |
opérateur logique XOR | De gauche à droite |
| 14 | || |
opérateur logique "OR" | De gauche à droite |
| 15 | ?\:
|
(un ensemble de données opérande) | De gauche à droite |
| 16 | = += -= *= /=
|
arithmétique d'attribution arithmétique d'attribution attribution | 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 opérateurs autres que modulo, si un opérande est un scalaire et que l'autre est un vecteur ou matrice, l'opération est effectuée composante et aboutit même type de vecteur ou de matrice. Si les deux opérations sont des vecteurs de même taille, est effectuée par composantes (et renvoie le même type de vecteur).
| Conditions de fonctionnement | Description |
|---|---|
m = f * m |
Multiplication de la matrice par composante par une valeur scalaire |
v = f * v |
Multiplication de vecteur par composante par une valeur scalaire |
v = v * v |
Multiplication de vecteur par composante par une valeur vectorielle |
m = m + m |
Ajout matriciel au niveau des composants |
m = m - m |
Soustraction matricielle par composante |
m = m * m |
Multiplication algébrique linéaire |
Si un opérande est un vecteur correspondant à la taille de ligne ou de colonne de notre matrice, le L'opérateur de multiplication peut être utilisé pour effectuer une multiplication algébrique de lignes et de 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 multiplication par composante:
| Fonction | Description |
|---|---|
f = dot(v, v) |
Produit scalaire vectoriel |
v = cross(v, v) |
Produit de croisement vectoriel |
m = matrixCompMult(m, m) |
Multiplication par composante |
Contrôle du programme
| Appel de fonction | Appels par valeur/retour |
|---|---|
| Itération | for (<init>;<test>;<next>) { break, continue } |
| Sélection | if ( ) { } if ( ) { } else { } switch () { break, case }
- case par défaut en dernier |
| Sauter | break, continue, return (je n'est pas autorisé à le supprimer) |
| Entrée | half4 main(float2 fragCoord) |
Limites de la boucle For
Semblable à GLSL ES 1.0, "for" les boucles sont assez limitées ; le compilateur doit pouvoir
pour dérouler la boucle. Cela signifie que l'initialiseur, la condition de test et
L'instruction next doit utiliser des constantes pour que tout puisse être calculé au moment de la compilation
en temps réel. 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 opèrent au niveau des composants (la fonction est appliquée par composant). Il est signalé que ce n'est pas le cas.
Angle et fonctions trigonométriques
Les paramètres de fonction spécifiés sous la forme d'un angle sont censés être exprimés en radians. En aucun cas, aucune de ces fonctions n'entraînera une erreur de division par zéro. Si le diviseur d'un ratio est 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)
|
Affiche un angle dont le sinus est x compris dans la plage sur $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
GT acos(GT x)
|
Renvoie un angle dont le cosinus est x dans l' plage de $ \left[0,\pi\right] $ |
GT atan(GT y, GT x)
|
Renvoie un angle dont arc tangente trigonométrique est $ \left[{y\over x}\right] $ dans le plage de $ \left[-\pi,\pi\right] $ |
GT atan(GT y_over_x)
|
Renvoie un angle dont l'angle est trigonométrique
l'arc tangente est y_over_x comprise dans la plage
sur $ \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 de 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) |
Affiche la valeur x comprise entre minVal et maxVal |
GT saturate(GT x) |
Renvoie x compris entre 0,0 et 1,0 |
GT mix(GT x, GT y
GT a) |
Affiche la combinaison linéaire de x et y. |
GT mix(GT x, GT y,
float a) |
Affiche la combinaison linéaire de x et y. |
GT step(GT edge, GT x) |
Renvoie 0,0 si x < Edge, sinon 1.0 |
GT step(float edge,
GT x) |
Renvoie 0,0 si x < Edge, sinon 1.0 |
GT smoothstep(GT edge0,
GT edge1, GT x) |
Effectue une interpolation Hermite compris entre 0 et 1 lorsque le bord 0 < x < bord1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
Effectue une interpolation Hermite compris entre 0 et 1 lorsque le bord 0 < x < bord1 |
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/de moitié dans les tailles 2 à 4.
| Fonction | Description |
|---|---|
float/half length
(GT x) |
Renvoie la longueur du vecteur |
float/half distance(GT
p0, GT p1) |
Affiche la distance entre des points |
float/half dot(GT x,
GT y) |
Affiche le produit scalaire |
float3/half3
cross(float3/half3 x,
float3/half3 y) |
Renvoie un produit croisé |
GT normalize(GT x) |
Normaliser le vecteur sur la longueur 1 |
GT faceforward(GT N,
GT I, GT Nref) |
Renvoie N si dot(Nref, I) < 0, sinon -N. |
GT reflect(GT I, GT N) |
Direction de la réflexion I - 2 * point(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Renvoie le vecteur de réfraction |
Fonctions de matrice
Type mat est 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 l'inverse de m |
Fonctions relationnelles vectorielles
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 des 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 < a |
BV lessThanEqual(T x,
T y) |
x <= y |
BV greaterThan(T x,
T y) |
x > a |
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 non prémultipliée. alpha |
half3 toLinearSrgb(half3
color) |
Transformation de l'espace colorimétrique en SRVB 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 avez besoin pour échantillonner une texture, vous pouvez créer un objet BitmapShader, puis ajoutez-le en tant que uniforme. Vous pouvez le faire pour n'importe quel nuanceur, n'importe quel nuanceur Android sans le transformer en Bitmap, y compris les autres Objets RuntimeShader. Cela permet pour offrir une grande flexibilité, mais les nuanceurs complexes peuvent être coûteux à évaluer, 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 les couleurs, certaines images contiennent des données qui ne sont pas réellement des couleurs, y compris des images stockant des normales, des propriétés matérielles (par exemple, rugosité), des tables de hauteur (heightmaps) ou toute autre des données mathématiques qui sont stockées dans une image. Lorsque vous utilisez ces types d'images dans AGSL, vous pouvez utiliser un BitmapShader comme tampon brut générique en utilisant RuntimeShader#setInputBuffer ; Cela permet d'éviter les transformations et le filtrage de l'espace colorimétrique.