Référence rapide AGSL

AGSL est conçu pour être largement compatible avec GLSL ES 1.0. Pour en savoir plus, consultez la fonction équivalente dans la documentation du langage de nuanceur OpenGL ES. Lorsque cela est 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'avec une autre méthode de représentation des types de vecteurs et de matrices. AGSL accepte des types short et half supplémentaires pour représenter une précision moyenne.

Types de base

Précision et plage minimales

Il s'agit de la précision et de la plage minimales garanties associées à chaque modificateur, conformément à la spécification OpenGL ES 2.0. Étant donné que la plupart des appareils sont compatibles avec ES 3.0, ils bénéficient d'une précision/portée highp et d'une plage int mediump plus garanties. Les modificateurs de précision peuvent être appliqués aux variables et aux paramètres scalaires, vectoriels et matriciels. Seuls les minima listés ci-dessous sont garantis. lowp n'est pas nécessairement moins précis que mediump, et mediump n'est pas nécessairement moins précis que highp. AGSL convertit actuellement lowp en mediump dans la sortie finale.

En plus de la syntaxe de sous-scripte 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 lorsque vous accédez à des vecteurs représentant des points/des normales

vect.rgba : à utiliser lorsque vous accédez à des vecteurs représentant des couleurs

vect.LTRB : à utiliser lorsque le vecteur représente un rectangle (pas en GLSL)

En AGSL, 0 et 1 peuvent être utilisés pour produire un 0 ou un 1 constant dans ce canal. Ex. : vect.rgb1 == vec4(vect.rgb,1)

Structures et tableaux

Les structures sont déclarées selon la même syntaxe que GLSL, mais AGSL n'accepte que les structures de portée globale.

struct type-name {
 members
} struct-name; // optional variable declaration.

Seules les matrices à une dimension sont acceptées avec une taille de matrice explicite, à l'aide de la syntaxe de style C ou GLSL:

<type de base>[<taille de tableau>] nom de la variable (par exemple, half[10] x;)

<type de base> nom de la variable[<taille de l'array>] (par exemple: half x[10];)

Les tableaux ne peuvent pas être renvoyés à partir d'une fonction, copiés, attribués ni comparés. Les restrictions de tableau se propagent aux 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

Déclaration de variable

Les déclarations doivent se trouver dans un champ d'application explicite entre crochets. 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 de matrices

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éerait donc une matrice d'identité 2x2.

Lorsqu'une matrice est construite avec plusieurs valeurs, les colonnes sont remplies en premier (ordre par colonne).

Notez que, contrairement à GLSL, les constructeurs qui réduisent le nombre de composants d'un vecteur transmis ne sont pas acceptés, mais vous pouvez utiliser le mélange pour obtenir le même effet. Pour créer un vec3 à partir d'un vec4 en 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 à l'aide de la 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 les champs de structure à l'aide de l'opérateur de période .. Les opérateurs incluent les suivants:

Éléments de tableau

Pour accéder aux éléments d'un tableau, utilisez l'opérateur d'indice de tableau [ ]. Exemple :

diffuseColor += lightIntensity[3] * NdotL;

Opérateurs

Numérotés par ordre de priorité. Les opérateurs relationnels et d'égalité > < <= >= == != renvoient une valeur booléenne. Pour comparer des vecteurs par composante, utilisez des fonctions telles que lessThan(), equal(), etc.

Opérations matricielles et vectorielles

Lorsqu'ils sont appliqués à des valeurs scalaires, les opérateurs arithmétiques génèrent un scalaire. Pour les opérateurs autres que le modulo, si un opérande est un scalaire et l'autre un vecteur ou une matrice, l'opération est effectuée par composant et donne le même type de vecteur ou de matrice. Si les deux opérations sont des vecteurs de la même taille, l'opération est effectuée par composant (et renvoie le même type de vecteur).

Si un opérande est un vecteur correspondant à la taille des lignes ou des colonnes de notre matrice, l'opérateur de multiplication peut être utilisé pour effectuer une multiplication algébrique des lignes et des colonnes.

Utilisez les fonctions intégrées pour le produit scalaire, le produit vectoriel et la multiplication par composante:

Contrôle du programme

Limites des boucles For

Comme dans GLSL ES 1.0, les boucles "for" sont assez limitées. Le compilateur doit pouvoir dérouler la boucle. Cela signifie que l'initialiseur, la condition de test et l'instruction next doivent utiliser des constantes afin que tout puisse être calculé au moment de la compilation. L'instruction next est également 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 fonctionnent par composant (la fonction est appliquée par composant). Il est indiqué que ce n'est pas le cas.

Angles et fonctions trigonométriques

Les paramètres de fonction spécifiés en tant qu'angle sont supposés être exprimés en radians. Aucune de ces fonctions ne provoquera une erreur de division par zéro. Si le diviseur d'un ratio est égal à 0, les résultats sont indéterminés.

Fonctions exponentielles

Fonctions courantes

Fonctions géométriques

Ces fonctions s'appliquent aux vecteurs en tant que vecteurs, et non par composante. GT correspond aux vecteurs float/half de tailles 2 à 4.

Fonctions de matrice

Le type mat correspond à n'importe quel type de matrice carrée.

Fonctions relationnelles vectorielles

Comparez les composants X et Y. Les tailles des vecteurs d'entrée et de retour d'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.

Fonctions de couleur

Échantillonnage de nuanceurs (é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 le convertir d'abord en Bitmap, y compris les autres objets RuntimeShader. Cela offre une flexibilité énorme, 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 du tampon brut

Bien que la plupart des images contiennent des couleurs qui doivent être gérées, certaines images contiennent des données qui ne sont pas réellement des couleurs, y compris les images stockant des normales, des propriétés de matériaux (par exemple, la rugosité), des cartes de hauteur ou toute autre donnée purement mathématique stockée dans une image. Lorsque vous utilisez ces types d'images en AGSL, vous pouvez utiliser un BitmapShader comme tampon brut générique à l'aide de RuntimeShader#setInputBuffer. Cela évite les transformations et le filtrage de l'espace colorimétrique.