AGSL è progettato per essere ampiamente compatibile con GLSL ES 1.0. Per ulteriori informazioni, consulta la funzione equivalente nella documentazione di OpenID ES Shading Language. Ove possibile, questa documentazione tenta di evidenziare le differenze tra AGSL e GLSL.
Tipi
AGSL supporta i tipi GLSL ES 1.0 insieme a un modo aggiuntivo per rappresentare i tipi di vettore e matrici. AGSL supporta altri tipi di short e half per rappresentare
una precisione media.
Tipi di base
| Tipo | Descrizione |
|---|---|
void
|
Nessuna funzione restituisce valore o elenco parametri vuoto. A differenza di GLSL, le funzioni senza un tipo restituito void devono restituire un valore. |
bool, bvec2, bvec3, bvec4 (bool2, bool3, bool4). |
Scalare booleano/vettore |
int, ivec2, ivec3, ivec4 (int2, int3, int4) |
Numero intero/vettore firmato highp
|
float, vec2, vec3, vec4 (float2, float3, float4)
|
highp (precisione singola)
scalare/vettore con rappresentazione in virgola mobile |
short, short2, short3, short4
|
equivalente a mediump int con intero/vettore |
half, half2, half3, half4 |
equivalente a mediump float scalare/vettore |
mat2, mat3, mat4 (float2x2, float3x3, float4x4) |
Matrice float 2x2, 3x3, 4x4
|
half2x2, half3x3, half4x4 |
Equivalente a mediump float tipi di matrici |
Precisione e valori minimi dell'intervallo
Precisione e intervallo minimi garantiti associati a ciascun modificatore in base alla specifica OpenGL ES 2.0. Poiché la maggior parte dei dispositivi
supporta ES 3.0, avrà highp precisione/intervallo e portata int mediump più garantiti. I modificatori di precisione possono essere applicati a variabili e parametri scalari, vettoriali e matriciali. Sono garantiti solo i valori minimi elencati di seguito;
lowp non è necessariamente una precisione inferiore a mediump e mediump
non è necessariamente una precisione inferiore a highp. AGSL attualmente converte lowp
in mediump nell'output finale.
| Modificatore | intervallo "in virgola mobile" | intervallo di magnitudo "float" | precisione "float" | intervallo "int" |
|---|---|---|---|---|
| massimo | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Parente: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| mediop | \(\left\{-2^{14},2^{14}\right\}\) | \(\left\{2^{-14},2^{14}\right\}\) | Parente: \(2^{-10}\) | \(\left\{-2^{10},2^{10}\right\}\) |
| bassa | \(\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 per accedere a vettori che rappresentano punti/normali.
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 usati per produrre una costante 0 o 1 in quel canale.
Esempio: vect.rgb1 == vec4(vect.rgb,1)
Strutture e array
Le strutture sono dichiarate con la stessa sintassi di GLSL, ma AGSL supporta solo strutture nell'ambito globale.
struct type-name {
members
} struct-name; // optional variable declaration.
Solo gli array unidimensionali sono supportati con una dimensione esplicita, utilizzando una sintassi di stile C o GLSL:
Nome variabile <tipo di base>[<array size>], ad esempio half[10] x;
<tipo di base> nome variabile[<dimensione array>], ad esempio half x[10];
Gli array non possono essere restituiti da una funzione, copiati, assegnati o confrontati. Le restrizioni degli array si propagano alle strutture contenenti array. Gli array possono essere indicizzati solo utilizzando una costante o una variabile di loop.
Qualificazioni
| Tipo | Descrizione |
|---|---|
const
|
Costante di tempo di compilazione o parametro della funzione di sola lettura. |
uniform
|
Il valore non cambia nella primitiva
in fase di elaborazione.
Le uniformi vengono trasmesse da Android utilizzando i metodi
RuntimeShader
per setColorUniform, setFloatUniform,
setIntUniform, setInputBuffer e
setInputShader. |
in
|
Per i parametri di funzione trasmessi. Questa è l'impostazione predefinita. |
out
|
Per i parametri di funzione passati. Deve utilizzare la stessa precisione della definizione della funzione. |
inout
|
Per i parametri trasmessi sia in entrata che all'esterno di una funzione. Deve utilizzare la stessa precisione della definizione della funzione. |
Dichiarazione della variabile
Le dichiarazioni devono essere in un ambito forzato esplicito. La dichiarazione di y nel seguente esempio non è consentita:
if (condition)
int y = 0;
Nozioni di base su matrice/struttura/array
Esempi di costruttori di matrici
Quando una matrice è costruita con un singolo valore, a tutti i valori lungo la diagonale viene assegnato quel valore, mentre agli altri vengono assegnati zeri. float2x2(1.0) creerebbe quindi una matrice identità 2 x 2.
Quando una matrice è costruita con più valori, le colonne vengono riempite per prime (ordine 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 la rotazione 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 della struttura
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 sintassi di indicizzazione degli 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 della struttura
Seleziona i campi della struttura utilizzando l'operatore del periodo .. Gli operatori includono:
| Operatore | Descrizione |
|---|---|
. |
selettore campi |
==, != |
uguaglianza |
= |
compito |
Elementi array
Gli elementi array sono accessibili utilizzando l'operatore pedice dell'array [ ]. Ecco alcuni esempi:
diffuseColor += lightIntensity[3] * NdotL;
Operatori
Numerati in ordine di precedenza. Gli operatori relazionali e di uguaglianza > < <= >= == != restituiscono un valore booleano. Per confrontare i vettori a livello di componente, utilizza funzioni quali lessThan(), equal() e così via.
| Operatore | Descrizione | Associatività | |
|---|---|---|---|
| 1 | () |
raggruppamento parentetico | N/A |
| 2 | [] () . ++ --
|
pedice dell'array chiamata di funzione e struttura costruttore campo o selettore metodo selettore di metodo swizzle incremento e decremento postfix | Da sinistra verso destra |
| 3 | ++ -- + - !
|
incremento e decremento unario | Da destra verso sinistra |
| 4 | * / |
moltiplicare e dividere | Da sinistra verso destra |
| 5 | + - |
aggiungere e sottrarre | Da sinistra verso destra |
| 7 | < > <= >= |
relazionale | Da sinistra verso destra |
| 8 | == != |
uguaglianza/disparità | Da sinistra verso destra |
| 12 | && |
AND logico | Da sinistra verso destra |
| 13 | ^^ |
XOR logico | Da sinistra verso destra |
| 14 | || |
OR logico | Da sinistra verso destra |
| 15 | ?\:
|
selezione (un intero operando) | Da sinistra verso destra |
| 16 | = += -= *= /=
|
assegnazione aritmetica compito aritmetica compito | Da sinistra verso destra |
| 17 | , |
sequence | Da sinistra verso destra |
Operazioni matriciali e vettoriali
Quando applicati a valori scalari, gli operatori aritmetici generano uno scalare. Per operatori diversi da modulo, se un operando è uno scalare e l'altro è un vettore o una matrice, l'operazione viene eseguita a livello di componente e genera lo stesso vettore o tipo di matrice. Se entrambe le operazioni sono vettori della stessa dimensione, l'operazione viene eseguita a livello di componente (e restituisce lo stesso tipo di vettore).
| Funzionamento | Descrizione |
|---|---|
m = f * m |
Moltiplicazione della matrice per i componenti per un valore scalare |
v = f * v |
Moltiplicazione dei vettori per i componenti per un valore scalare |
v = v * v |
Moltiplicazione dei vettori per i componenti per un valore vettoriale |
m = m + m |
Addizione a livello dei componenti della matrice |
m = m - m |
Sottrazione per componente della matrice |
m = m * m |
Moltiplicazione algebrica lineare |
Se un operando è un vettore che corrisponde alla dimensione di riga o colonna della nostra matrice, l'operatore di moltiplicazione può essere utilizzato per eseguire la moltiplicazione algebrica di righe e colonne.
| Funzionamento | Descrizione |
|---|---|
m = v * m |
Moltiplicazione algebrica lineare per vettore di riga * matrice |
m = m * v |
Moltiplicazione algebrica lineare per vettore di matrice * colonna |
Utilizza le funzioni integrate per prodotti a punti vettoriali, prodotti incrociati e moltiplicazione per componenti:
| Funzione | Descrizione |
|---|---|
f = dot(v, v) |
Prodotto scalare vettoriale |
v = cross(v, v) |
Prodotto trasversale vettoriale |
m = matrixCompMult(m, m) |
Moltiplicazione per componenti |
Controllo programma
| Chiamata funzione | Chiamata per valore-ritorno |
|---|---|
| Iterazione | for (<init>;<test>;<next>) { break, continue } |
| Selezione | if ( ) { } if ( ) { } else { } switch () { break, case }
- ultima richiesta predefinita |
| Saltare | break, continue, return (non è consentito l'annullamento) |
| Voce | half4 main(float2 fragCoord) |
Limitazioni for loop
Analogamente a GLSL ES 1.0, i loop "for" sono piuttosto limitati; il compilatore deve essere in grado di eseguire il loop. Ciò significa che l'inizializzazione, la condizione di test e l'istruzione next 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). se ciò non accade.
Funzioni angolari e trigonometriche
Si presume che i parametri delle funzioni specificati come angolo siano espressi in unità di radianti. In nessun caso nessuna di queste funzioni genererà un errore di divisione per zero. Se il divisore di un rapporto è 0, i risultati saranno indefiniti.
| Funzione | Descrizione |
|---|---|
GT radians(GT degrees) |
Converte 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 compreso nell'intervallo $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
GT acos(GT x)
|
Restituisce un angolo il cui coseno è x compreso nell'intervallo di $ \left[0,\pi\right] $ |
GT atan(GT y, GT x)
|
Restituisce un angolo il cui arcotangente trigonometrico è $ \left[{y\over x}\right] $ nell'intervallo di $ \left[-\pi,\pi\right] $ |
GT atan(GT y_over_x)
|
Restituisce un angolo il cui arcotangente trigonometrico è y_over_x nell'intervallo $ \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 frazionata di x |
GT mod(GT x, GT y) |
Restituisce il valore di x modulo y |
GT mod(GT x, float y) |
Restituisce il valore di x modulo 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 tra minVal e maxVal. |
GT clamp(GT x, float
minVal, float maxVal) |
Restituisce x clampata tra minVal e maxVal |
GT saturate(GT x) |
Restituisce x fissato 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 < bordo, altrimenti 1.0 |
GT step(float edge,
GT x) |
Restituisce 0.0 se x < bordo, 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 a livello di componente. GT è un vettore float/mezzo 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 punti |
float/half dot(GT x,
GT y) |
Restituisce il prodotto scalare |
float3/half3
cross(float3/half3 x,
float3/half3 y) |
Restituisce prodotti incrociati |
GT normalize(GT x) |
Normalizza il vettore alla lunghezza 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 riflesso I - 2 * punto(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Restituisce un vettore di rifrazione |
Funzioni matriciali
Il tipo di tappetino è qualsiasi tipo di matrice quadrata.
| Funzione | Descrizione |
|---|---|
mat matrixCompMult(mat
x, mat y) |
Moltiplicare x per y per i componenti |
mat inverse(mat m) |
Restituisce l'inversa di m |
Funzioni relazionali vettoriali
Confrontare x e y per i componenti. Le dimensioni dei vettori di input e di ritorno per una determinata chiamata devono corrispondere. T è l'unione dei tipi di vettori con numeri interi e in virgola mobile. VL è un vettore booleano che corrisponde alla dimensione 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 uno o più componenti 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 colore
| Funzione | Descrizione |
|---|---|
vec4 unpremul(vec4
color) |
Converte il valore del colore in alfa non premoltiplicato |
half3 toLinearSrgb(half3
color) |
Trasformazione dello spazio colore in SRGB lineare |
half3 fromLinearSrgb(half3
color) |
Trasformazione dello spazio colore |
Campionamento Shader (valutazione)
I tipi di Sampler non sono supportati, ma puoi valutare altri Shader. Se hai bisogno di campionare 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 una Bitmap, inclusi altri oggetti RuntimeShader. Ciò consente una grande flessibilità, ma glishadowr complessi possono essere costosi da valutare, soprattutto in un loop.
uniform shader image;
image.eval(coord).a // The alpha channel from the evaluated image shader
Campionamento buffer non elaborato
Sebbene la maggior parte delle immagini contenga colori che devono essere gestiti dai colori, alcune contengono dati che in realtà non sono colori, tra cui immagini che memorizzano valori normali, proprietà materiali (ad es. rugosità), mappe di altezza o qualsiasi altro dato puramente matematico che viene memorizzato in un'immagine. Quando utilizzi questi tipi di immagini in AGSL, puoi utilizzare BitmapShader come buffer non elaborato generico utilizzando RuntimeShader#setInputBuffer. In questo modo eviterai trasformazioni e filtri dello spazio colore.