AGSL è progettato per essere ampiamente compatibile con GLSL ES 1.0. Per saperne di più, consulta la funzione equivalente nella documentazione del linguaggio di shading OpenGL ES. Ove possibile, questa documentazione tenta di evidenziare le differenze tra AGSL e GLSL.
Tipi
AGSL supporta i tipi GLSL ES 1.0, oltre a un modo aggiuntivo per rappresentare i tipi di vettori e matrici. AGSL supporta tipi aggiuntivi di short e half per rappresentare la precisione media.
Tipi di base
| Digitazione | Descrizione |
|---|---|
void
|
Nessun valore restituito dalla funzione o elenco di parametri vuoto. A differenza di GLSL, le funzioni senza un tipo di valore vuoto devono restituire un valore. |
bool, bvec2, bvec3, bvec4 (bool2, bool3, bool4). |
Scalare/vettore booleano |
int, ivec2, ivec3, ivec4 (int2, int3, int4) |
highp numero intero/vettore con segno
|
float, vec2, vec3, vec4 (float2, float3, float4)
|
Scalare/vettore in virgola mobile highp (precisione singola) |
short, short2, short3, short4
|
equivalente a mediump int intero/vettore con segno |
half, half2, half3, half4 |
equivalente a scalare/vettore mediump float |
mat2, mat3, mat4 (float2x2, float3x3, float4x4) |
Matrice float 2x2, 3x3, 4x4
|
half2x2, half3x3, half4x4 |
Equivalente ai tipi di matrici mediump float |
Precisione e intervalli minimi
Si tratta della precisione e dell'intervallo minimi garantiti associati a ogni modificatore in base alla specifica OpenGL ES 2.0. Poiché la maggior parte dei dispositivi supporta ES 3.0, avranno una precisione/un intervallo highp e un intervallo int mediump più garantiti. I modificatori di precisione possono essere applicati a parametri e variabili scalari, vettoriali e matriciali. Sono garantiti solo i valori minimi elencati di seguito.lowp non ha necessariamente una precisione inferiore a mediump e mediump non ha necessariamente una precisione inferiore a highp. Al momento AGSL converte lowp
in mediump nell'output finale.
| Modificatore | Intervallo "float" | Intervallo di grandezza "float" | Precisione "float" | Intervallo "int" |
|---|---|---|---|---|
| highp | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Relativo: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| mediump | \(\left\{-2^{14},2^{14}\right\}\) | \(\left\{2^{-14},2^{14}\right\}\) | Relativo: \(2^{-10}\) | \(\left\{-2^{10},2^{10}\right\}\) |
| lowp | \(\left\{-2,2\right\}\) | \(\left\{2^{-8},2\right\}\) | Assoluto: \(2^{-8}\) | \(\left\{-2^{8},2^{8}\right\}\) |
Oltre alla sintassi dell'indice numerico dell'array, ad esempio 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: da utilizzare quando si accede a vettori che rappresentano punti/nordie
vect.rgba: da utilizzare quando si accede a vettori che rappresentano i colori
vect.LTRB: da utilizzare quando il vettore rappresenta un rettangolo (non in GLSL)
In AGSL, 0 e 1 possono essere utilizzati per produrre un valore costante 0 o 1 in quel canale.
Esempio: vect.rgb1 == vec4(vect.rgb,1)
Strutture e array
Le strutture vengono dichiarate con la stessa sintassi di GLSL, ma AGSL supporta solo le strutture a livello globale.
struct type-name {
members
} struct-name; // optional variable declaration.
Sono supportati solo gli array unidimensionali con una dimensione esplicita, utilizzando la sintassi in stile C o GLSL:
Nome della variabile <base type>[<array size>] - es: half[10] x;
<tipo base> nome variabile[<dimensione array>] - es: half x[10];
Gli array non possono essere restituiti da una funzione, copiati, assegnati o confrontati. Le limitazioni degli array si propagano alle strutture contenenti array. Gli array possono essere indicizzati solo utilizzando una costante o una variabile di loop.
Qualificazioni
| Digitazione | Descrizione |
|---|---|
const
|
Costante di compilazione o parametro di funzione di sola lettura. |
uniform
|
Il valore non cambia nella primitiva
in fase di elaborazione.
Le uniformi vengono passate da Android utilizzando metodi
RuntimeShader
per setColorUniform, setFloatUniform,
setIntUniform, setInputBuffer e
setInputShader. |
in
|
Per i parametri della funzione passati. Questa è l'impostazione predefinita. |
out
|
Per i parametri della funzione passati. Deve utilizzare la stessa precisione della definizione della funzione. |
inout
|
Per i parametri che vengono passati sia all'interno sia all'esterno di una funzione. Deve utilizzare la stessa precisione della definizione della funzione. |
Dichiarazione di variabili
Le dichiarazioni devono trovarsi in un ambito esplicito tra parentesi graffe. La dichiarazione di y nel
seguente esempio non è consentita:
if (condition)
int y = 0;
Nozioni di base su matrici/strutture/array
Esempi di costruttori di matrici
Quando una matrice viene costruita con un singolo valore, a tutti i valori lungo la diagonale viene assegnato quel valore, mentre al resto vengono assegnati zeri. float2x2(1.0) creerebbe quindi una matrice di identità 2x2.
Quando una matrice viene costruita con più valori, le colonne vengono riempite per prime (ordine di colonna principale).
Tieni presente che, a differenza di GLSL, i costruttori che riducono il numero di componenti di un vettore passato non sono supportati, ma puoi utilizzare lo svuotamento per ottenere lo stesso effetto. Per creare un vec3 da un vec4 in AGSL con lo stesso comportamento di GLSL, specifica vec3 nv = quadVec.xyz.
Esempio di costruttore di strutture
struct light { float intensity; float3 pos; };
// literal integer constants auto-converted to floating point
light lightVar = light(3, float3(1, 2, 3.0));
Componenti della matrice
Accedi ai componenti di una matrice con la sintassi di sottoindice dell'array.
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
Campi di struttura
Seleziona i campi della struttura utilizzando l'operatore punto .. Gli operatori includono:
| Operatore | Descrizione |
|---|---|
. |
selettore di campi |
==, != |
uguaglianza |
= |
compito |
Elementi array
Per accedere agli elementi dell'array viene utilizzato l'operatore di indice dell'array [ ]. Ad esempio:
diffuseColor += lightIntensity[3] * NdotL;
Operatori
Numerati in ordine di precedenza. Gli operatori di relazione e uguaglianza > < <= >= == != restituiscono un valore booleano. Per confrontare i vettori
componente per componente, utilizza funzioni come lessThan(), equal() e così via.
| Operatore | Descrizione | Associatività | |
|---|---|---|---|
| 1 | () |
raggruppamento tra parentesi | N/D |
| 2 | [] () . ++ --
|
indice array chiamata funzione e struttura del costruttore selettore di campo o metodo, swizzle incremento e decremento postfisso | Da sinistra verso destra |
| 3 | ++ -- + - !
|
prefisso incremento e decremento unario | Da destra verso sinistra |
| 4 | * / |
moltiplicare e dividere | Da sinistra verso destra |
| 5 | + - |
addizione e sottrazione | Da sinistra verso destra |
| 7 | < > <= >= |
relazionale | Da sinistra verso destra |
| 8 | == != |
uguaglianza/diseguaglianza | Da sinistra verso destra |
| 12 | && |
AND logico | Da sinistra verso destra |
| 13 | ^^ |
OR logico | Da sinistra verso destra |
| 14 | || |
OR logico | Da sinistra verso destra |
| 15 | ?\:
|
selezione (un intero operando) | Da sinistra verso destra |
| 16 | = += -= *= /=
|
compito aritmetica compito aritmetica compito | Da sinistra verso destra |
| 17 | , |
sequence | Da sinistra verso destra |
Operazioni su matrici e vettori
Se applicati a valori scalari, gli operatori aritmetici generano un valore scalare. Per gli operatori diversi da modulo, se un operando è scalare e l'altro è un vettore o una matrice, l'operazione viene eseguita componente per componente e genera lo stesso tipo di vettore o matrice. Se entrambe le operazioni sono vettori della stessa dimensione, l'operazione viene eseguita componente per componente (e restituisce lo stesso tipo di vettore).
| Funzionamento | Descrizione |
|---|---|
m = f * m |
Moltiplicazione di una matrice per componente per un valore scalare |
v = f * v |
Moltiplicazione di un vettore per componente per un valore scalare |
v = v * v |
Moltiplicazione vettoriale componente per componente per un valore vettore |
m = m + m |
Somma componente per componente della matrice |
m = m - m |
Sottrazione componente per componente della matrice |
m = m * m |
Moltiplicazione algebrica lineare |
Se un operando è un vettore che corrisponde alle dimensioni di righe o colonne della nostra matrice, l'operatore di moltiplicazione può essere utilizzato per eseguire la moltiplicazione algebrica di righe e colonne.
| Funzionamento | Descrizione |
|---|---|
m = v * m |
Vettore riga * moltiplicazione algebrica lineare della matrice |
m = m * v |
Moltiplicazione algebrica lineare di una matrice per un vettore colonna |
Utilizza le funzioni integrate per il prodotto scalare, il prodotto incrociato e la moltiplicazione componente per componente dei vettori:
| Funzione | Descrizione |
|---|---|
f = dot(v, v) |
Prodotto scalare di vettori |
v = cross(v, v) |
Prodotto vettoriale |
m = matrixCompMult(m, m) |
Moltiplicazione componente per componente |
Controllo del programma
| Chiamata di funzione | Chiamata per valore restituito |
|---|---|
| Iterazione | for (<init>;<test>;<next>) { break, continue } |
| Selezione | if ( ) { } if ( ) { } else { } switch () { break, case }
- default case last |
| Salta | break, continue, return (l'eliminazione non è consentita) |
| Voce | half4 main(float2 fragCoord) |
Limitazioni del ciclo For
Come in GLSL ES 1.0, i cicli "for" sono piuttosto limitati; il compilatore deve essere in grado di svolgere il ciclo. Ciò significa che l'inizializzatore, la condizione di test e l'istruzionenext devono utilizzare costanti in modo che tutto possa essere calcolato in fase di compilazione. L'istruzione next è ulteriormente limitata all'utilizzo di ++, --, +=, or -=.
Funzioni integrate
GT (tipo generico) è float, float2, float3, float4 o
half, half2, half3, half4.
La maggior parte di queste funzioni opera a livello di componente (la funzione viene applicata per componente). Viene indicato quando non è così.
Angoli e funzioni trigonometriche
Si presume che i parametri della funzione specificati come angolo siano in unità di radianti. In nessun caso nessuna di queste funzioni genera un errore di divisione per zero. Se il divisore di una proporzione è 0, i risultati non saranno definiti.
| Funzione | Descrizione |
|---|---|
GT radians(GT degrees) |
Converte i gradi in radianti |
GT degrees(GT radians) |
Converte i radianti in gradi |
GT sin(GT angle) |
Seno standard |
GT cos(GT angle) |
Coseno standard |
GT tan(GT angle) |
Tangente standard |
GT asin(GT x)
|
Restituisce un angolo il cui seno è x nell'intervallo di $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
GT acos(GT x)
|
Restituisce un angolo il cui coseno è x nell'intervallo $ \left[0,\pi\right] $ |
GT atan(GT y, GT x)
|
Restituisce un angolo la cui arctangente trigonometrica è $ \left[{y\over x}\right] $ nell'intervallo $ \left[-\pi,\pi\right] $ |
GT atan(GT y_over_x)
|
Restituisce un angolo la cui arctangente trigonometrica è y_over_x nell'intervallo
di $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
Funzioni esponenziali
| Funzione | Descrizione |
|---|---|
GT pow(GT x, GT y) |
Restituisce $ x^y $ |
GT exp(GT x) |
Restituisce $ e^x $ |
GT log(GT x) |
Restituisce $ ln(x) $ |
GT exp2(GT x) |
Restituisce 2^x |
GT log2(GT x) |
Restituisce $ log_2(x) $ |
GT sqrt(GT x) |
Restituisce $ \sqrt{x} $ |
GT inversesqrt(GT x) |
Restituisce $ 1\over{\sqrt{x}} $ |
Funzioni comuni
| Funzione | Descrizione |
|---|---|
GT abs(GT x) |
Valore assoluto |
GT sign(GT x) |
Restituisce -1.0, 0.0 o 1.0 in base al segno di x |
GT floor(GT x) |
Numero intero più vicino <= x |
GT ceil(GT x) |
Numero intero più vicino >= x |
GT fract(GT x) |
Restituisce la parte frazionaria di x |
GT mod(GT x, GT y) |
Restituisce il valore del modulo di x per y |
GT mod(GT x, float y) |
Restituisce il valore del modulo di x per y |
GT min(GT x, GT y) |
Restituisce il valore minimo di x o y |
GT min(GT x, float y) |
Restituisce il valore minimo di x o y |
GT max(GT x, GT y) |
Restituisce il valore massimo di x o y |
GT max(GT x, float y) |
Restituisce il valore massimo di x o y |
GT clamp(GT x, GT
minVal, GT maxVal) |
Restituisce x clampato tra minVal e maxVal. |
GT clamp(GT x, float
minVal, float maxVal) |
Restituisce x compreso tra minVal e maxVal |
GT saturate(GT x) |
Restituisce x clampato tra 0,0 e 1,0 |
GT mix(GT x, GT y,
GT a) |
Restituisce la combinazione lineare di x e y |
GT mix(GT x, GT y,
float a) |
Restituisce la combinazione lineare di x e y |
GT step(GT edge, GT x) |
Restituisce 0,0 se x < edge, altrimenti 1,0 |
GT step(float edge,
GT x) |
Restituisce 0,0 se x < edge, altrimenti 1,0 |
GT smoothstep(GT edge0,
GT edge1, GT x) |
Esegue l'interpolazione Hermite tra 0 e 1 quando bordo0 < x < bordo1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
Esegue l'interpolazione Hermite tra 0 e 1 quando bordo0 < x < bordo1 |
Funzioni geometriche
Queste funzioni operano sui vettori come vettori, non per componenti. GT è costituito da vettori float/half nelle dimensioni 2-4.
| Funzione | Descrizione |
|---|---|
float/half length
(GT x) |
Restituisce la lunghezza del vettore |
float/half distance(GT
p0, GT p1) |
Restituisce la distanza tra i punti |
float/half dot(GT x,
GT y) |
Restituisce il prodotto scalare |
float3/half3
cross(float3/half3 x,
float3/half3 y) |
Restituisce il prodotto incrociato |
GT normalize(GT x) |
Normalizza il vettore in modo che abbia una lunghezza pari a 1 |
GT faceforward(GT N,
GT I, GT Nref) |
Restituisce N se dot(Nref, I) < 0, altrimenti -N. |
GT reflect(GT I, GT N) |
Direzione di riflessione I - 2 * dot(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Restituisce il vettore di rifrazione |
Funzioni di matrice
Il tipo mat è un tipo di matrice quadrata.
| Funzione | Descrizione |
|---|---|
mat matrixCompMult(mat
x, mat y) |
Moltiplicare x per y componente per componente |
mat inverse(mat m) |
Restituisce l'inverso di m |
Funzioni relazionali vettoriali
Confronta x e y componente per componente. Le dimensioni dei vettori di input e di ritorno per una determinata chiamata devono corrispondere. T è l'unione dei tipi di vettori interi e in virgola mobile. BV è un vettore booleano che corrisponde alle dimensioni dei vettori di input.
| Funzione | Descrizione |
|---|---|
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 se un componente di x è true |
bool all(BV x) |
true se tutti i componenti di x sono true. |
BV not(BV x) |
complemento logico di x |
Funzioni di colore
| Funzione | Descrizione |
|---|---|
vec4 unpremul(vec4
color) |
Converte il valore del colore in alpha non premoltiplicato |
half3 toLinearSrgb(half3
color) |
Trasformazione dello spazio colore in sRGB lineare |
half3 fromLinearSrgb(half3
color) |
Trasformazione dello spazio colore |
Campionamento degli shader (valutazione)
I tipi di sampler non sono supportati, ma puoi valutare altri shader. Se devi campionata una texture, puoi creare un oggetto BitmapShader e aggiungerlo come uniforme. Puoi farlo per qualsiasi shader, il che significa che puoi valutare direttamente qualsiasi shader Android senza prima trasformarlo in un Bitmap, inclusi altri oggetti RuntimeShader. Ciò consente un'enorme flessibilità, ma gli shader complessi possono essere costosi da valutare, in particolare in un loop.
uniform shader image;
image.eval(coord).a // The alpha channel from the evaluated image shader
Campionamento del buffer non elaborato
Sebbene la maggior parte delle immagini contenga colori che devono essere gestiti, alcune contengono dati che non sono effettivamente colori, tra cui immagini che memorizzano normali, proprietà dei materiali (ad es. ruvidità), heightmap o altri dati puramente matematici che si trovano a essere memorizzati in un'immagine. Quando utilizzi questo tipo di immagini in AGSL, puoi utilizzare un BitmapShader come buffer non elaborato generico utilizzando RuntimeShader#setInputBuffer. In questo modo eviterai le trasformazioni e i filtri dello spazio colore.