AGSL è progettato per essere ampiamente compatibile con GLSL ES 1.0. Per ulteriori informazioni, vedi la funzione equivalente nella Documentazione di OpenGL ES Shading Language. Laddove possibile, questa documentazione cerca di evidenziare le differenze tra AGSL e GLSL.
Tipi
AGSL supporta i tipi GLSL ES 1.0 insieme a un ulteriore modo per rappresentare i vettori
e tipi di matrici. AGSL supporta i tipi aggiuntivi short e half per rappresentare
precisione media.
Tipi di base
| Tipo | Descrizione |
|---|---|
void
|
Nessun valore restituito dalla funzione o parametro vuoto dall'elenco di lettura. A differenza di GLSL, le funzioni senza vuoto deve restituire un valore. |
bool, bvec2, bvec3, bvec4 (bool2, bool3, bool4) |
Vettore/scalare booleano |
int, ivec2, ivec3, ivec4 (int2, int3, int4) |
highp intero/vettore firmato
|
float, vec2, vec3, vec4 (float2, float3, float4)
|
Virgola mobile highp (precisione singola)
scalare/vettore |
short, short2, short3, short4
|
equivalente a mediump int firmato
numero 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 ai tipi di matrice mediump float |
Minimi di precisione e intervallo
Si tratta della precisione e dell'intervallo minimi garantiti associati a ogni
basato sulla specifica OpenGL ES 2.0. Poiché la maggior parte dei dispositivi
supportano ES 3.0, avranno una precisione/intervallo più garantito di highp
Intervallo int mediump. I modificatori di precisione possono essere applicati a scalari, vettoriali e
variabili e parametri della matrice. Sono garantiti solo i minimi elencati di seguito.
lowp non è necessariamente una precisione inferiore a mediump e mediump
non è necessariamente inferiore a highp. AGSL al momento converte lowp
a mediump nell'output finale.
| Modificatore | "float" intervallo | "float" intervallo di magnitudo | "float" precisione | "int" intervallo |
|---|---|---|---|---|
| massimo | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Parente: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| medio | \(\left\{-2^{14},2^{14}\right\}\) | \(\left\{2^{-14},2^{14}\right\}\) | Parente: \(2^{-10}\) | \(\left\{-2^{10},2^{10}\right\}\) |
| basso | \(\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 es. 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 per accedere 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 vengono dichiarate con la stessa sintassi di GLSL, ma AGSL supporta solo di archiviazione a livello globale.
struct type-name {
members
} struct-name; // optional variable declaration.
Solo gli array monodimensionali sono supportati con una dimensione array esplicita, utilizzando sintassi di stile C o GLSL:
<tipo di base>[<dimensione array>], nome variabile, 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 relative agli array si propagano alle strutture che contengono array. Gli array possono l'indicizzazione può essere eseguita solo utilizzando una variabile costante o loop.
Qualificazioni
| Tipo | Descrizione |
|---|---|
const
|
Costante di tempo di compilazione o funzione di sola lettura . |
uniform
|
Il valore non cambia nella primitiva
in fase di elaborazione.
Le uniformi vengono trasmesse da Android tramite
Shader di runtime
metodi per setColorUniform, setFloatUniform,
setIntUniform, setInputBuffer e
setInputShader. |
in
|
Per i parametri delle funzioni trasmesse. Questo è il predefinito. |
out
|
Per i parametri delle funzioni ignorate. Da utilizzare la stessa precisione della definizione della funzione. |
inout
|
Per i parametri trasmessi in entrata e in uscita di una funzione. Deve utilizzare la stessa precisione di la definizione della funzione. |
Dichiarazione delle variabili
Le dichiarazioni devono avere un ambito di protezione esplicito. La dichiarazione di y in
il seguente esempio non è consentito:
if (condition)
int y = 0;
Nozioni di base su matrice/struttura/array
Esempi di costruttori di matrici
Quando una matrice viene creata con un singolo valore, tutti i valori insieme
alla diagonale quel valore, mentre al resto vengono dati zeri. float2x2(1.0) lo farebbe
pertanto si crea una matrice identità 2x2.
Quando una matrice è creata con più valori, le colonne vengono riempite per prime (ordine colonna-maggiore).
Tieni presente che, a differenza di GLSL, i costruttori che riducono il numero di componenti di un
il vettore passato non è supportato, ma puoi usare 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 la sintassi di obbligo di sottoscrizione a un 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 punto .. Gli operatori includono:
| Operatore | Descrizione |
|---|---|
. |
selettore di campi |
==, != |
uguaglianza |
= |
compito |
Elementi array
Per accedere agli elementi array, utilizza l'operatore [ ] di pedice dell'array. Ad esempio:
diffuseColor += lightIntensity[3] * NdotL;
Operatori
Sono numerati in ordine di precedenza. Lo scenario relazionale e l'uguaglianza
operatori > < <= >= == != restituisce un valore booleano. Per confrontare i vettori
a livello di componente, usa funzioni quali lessThan(), equal() e così via.
| Operatore | Descrizione | Associatività | |
|---|---|---|---|
| 1 | () |
raggruppamento tra parentesi | N/D |
| 2 | [] () . ++ --
|
pedice array funzione chiamata & struttura costruttore campo o metodo selettore, swizzle l'incremento automatico diminuisci | Da sinistra verso destra |
| 3 | ++ -- + - !
|
l'incremento del prefisso diminuisci unario | Da destra verso sinistra |
| 4 | * / |
moltiplicare e dividere | Da sinistra verso destra |
| 5 | + - |
add e sottrai | Da sinistra verso destra |
| 7 | < > <= >= |
relazionale | Da sinistra verso destra |
| 8 | == != |
uguaglianza/disuguaglianza | 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 | ?\:
|
una selezione (un'intera operando) | Da sinistra verso destra |
| 16 | = += -= *= /=
|
aritmetica di assegnazione aritmetica di assegnazione compito | Da sinistra verso destra |
| 17 | , |
sequence | Da sinistra verso destra |
Operazioni su matrici e vettori
Quando vengono applicati a valori scalari, gli operatori aritmetici generano uno scalare. Per operatori diversi da modulo, se un operando è scalare e l'altro è un un vettore o una matrice, l'operazione viene eseguita per componenti e ha come risultato lo stesso vettore o tipo di matrice. Se entrambe le operazioni sono vettori della stessa dimensione, viene eseguita a livello di componenti (e restituisce lo stesso tipo di vettore).
| Funzionamento | Descrizione |
|---|---|
m = f * m |
Moltiplicazione della matrice a livello di componenti per un valore scalare |
v = f * v |
Moltiplicazione del vettore a livello di componenti per un valore scalare |
v = v * v |
Moltiplicazione del vettore a livello di componenti per un valore vettoriale |
m = m + m |
Addizione a livello di componenti della matrice |
m = m - m |
Sottrazione dal punto di vista dei componenti della matrice |
m = m * m |
Moltiplicazione algebrica lineare |
Se un operando è un vettore che corrisponde alla dimensione di riga o colonna della nostra matrice, il l'operatore di moltiplicazione può essere utilizzato per eseguire le moltiplicazioni algebriche di righe e colonne.
| Funzionamento | Descrizione |
|---|---|
m = v * m |
Moltiplicazione algebrica lineare del vettore di riga * della matrice |
m = m * v |
Matrice * colonna algebrica lineare vettoriale per colonna |
Utilizza le funzioni integrate per il prodotto Vector., il prodotto incrociato e moltiplicazione per componenti:
| Funzione | Descrizione |
|---|---|
f = dot(v, v) |
Prodotto con punti vettoriali |
v = cross(v, v) |
Prodotto incrociato vettoriale |
m = matrixCompMult(m, m) |
Moltiplicazione a livello di componenti |
Controllo programma
| Chiamata funzione | Chiamata in base al valore-ritorno |
|---|---|
| Iterazione | for (<init>;<test>;<next>) { break, continue } |
| Selezione | if ( ) { } if ( ) { } else { } switch () { break, case }
- ultima richiesta predefinita |
| Salta | break, continue, return (non consentito) |
| Da principiante | half4 main(float2 fragCoord) |
For loop limitazioni
Simile a GLSL ES 1.0, "for" che sono abbastanza limitati; il compilatore deve essere in grado
per svolgere il ciclo. Ciò significa che l'inizializzatore, la condizione di test
L'istruzione next deve utilizzare costanti affinché sia possibile calcolare tutto in fase di compilazione
nel tempo. 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). Si rileva quando non è così.
Angolo e funzioni trigonometriche
I parametri della funzione specificati come angolo si presume siano espressi in radianti. In nessun caso nessuna di queste funzioni genererà un errore di divisione per zero. Se divisore di un rapporto è 0, i risultati saranno indefiniti.
| Funzione | Descrizione |
|---|---|
GT radians(GT degrees) |
Converte da 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 nella intervallo di $ \left[0,\pi\right] $ |
GT atan(GT y, GT x)
|
Restituisce un angolo il cui arcotangente trigonometrico è $ \left[{y\over x}\right] $ in intervallo di $ \left[-\pi,\pi\right] $ |
GT atan(GT y_over_x)
|
Restituisce un angolo la cui trigonometria
l'arcotangente è 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 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 bloccato tra minVal e maxVal. |
GT clamp(GT x, float
minVal, float maxVal) |
Restituisce x bloccato tra minVal e maxVal |
GT saturate(GT x) |
Restituisce x bloccato tra 0,0 e 1,0 |
GT mix(GT x, GT y
GT a) |
Restituisce una combinazione lineare di x e y |
GT mix(GT x, GT y,
float a) |
Restituisce una 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 edge0 < x < bordo1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
Esegue l'interpolazione Hermite tra 0 e 1 quando edge0 < x < bordo1 |
Funzioni geometriche
Queste funzioni operano sui vettori come vettori, non a livello di componenti. GT è un vettore mobile/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 punto(Nref, I) < 0, altrimenti -N. |
GT reflect(GT I, GT N) |
Direzione della riflessione I - 2 * punto(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Restituisce un vettore di rifrazione |
Funzioni matriciali
Il tappetino è di qualsiasi tipo a matrice quadrata.
| Funzione | Descrizione |
|---|---|
mat matrixCompMult(mat
x, mat y) |
Moltiplicare x per y per il componente |
mat inverse(mat m) |
Restituisce l'inverso di m |
Funzioni relazionali vettoriali
Confrontare i componenti x e y. Le dimensioni dei vettori di input e di ritorno per una particolare chiamata devono corrispondere. "T" indica l'unione dei tipi di vettori interi e con virgola mobile. BV è un vettore booleano che corrisponde alla dimensione dei vettori di input.
| Funzione | Descrizione |
|---|---|
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 se uno qualsiasi dei 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 non premoltiplicato alfa |
half3 toLinearSrgb(half3
color) |
Trasformazione dello spazio colore in SRGB lineare |
half3 fromLinearSrgb(half3
color) |
Trasformazione dello spazio colore |
Campionamento ombreggiamento (valutazione)
I tipi di Sampler non sono supportati, ma puoi valutare altri Shader. Se hai bisogno per campionare una texture, puoi creare BitmapShader e aggiungilo come oggetto uniforme. Puoi fare questo per qualsiasi Shar, il che significa che puoi valutare direttamente qualsiasi Shader Android senza trasformarlo in un Bitmap, incluse altre RuntimeShader. Ciò consente per avere una grande flessibilità, ma gli ombreggiatori complessi possono essere costosi e valuta, 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
Anche se la maggior parte delle immagini contiene colori che devono essere gestiti, alcune contengono dati che non sono effettivamente colori, tra cui immagini che contengono valori normali, proprietà dei materiali (ad es. rugosità), mappe di altezza o qualsiasi altro dati matematici che vengono archiviati in un'immagine. Quando si utilizzano questi tipi di immagini in AGSL, puoi usare un BitmapShader come buffer non elaborato generico utilizzando RuntimeShader#setInputBuffer. In questo modo eviterai trasformazioni e filtri dello spazio colore.