AGSL ist weitgehend kompatibel mit GLSL ES 1.0. Weitere Informationen finden Sie in der entsprechenden Funktion in der Dokumentation zu OpenGL ES Shading Language. Wenn möglich, wird in dieser Dokumentation versucht, Unterschiede zwischen AGSL und GLSL aufzuzeigen.
Typen
AGSL unterstützt GLSL ES 1.0-Typen und eine zusätzliche Möglichkeit zur Darstellung von Vektor- und Matrixtypen. AGSL unterstützt zusätzliche Typen short
und half
für mittlere Präzision.
Basistypen
Typ | Beschreibung |
---|---|
void
|
Kein Funktionsrückgabewert oder leere Parameterliste. Im Gegensatz zu GLSL müssen Funktionen ohne „void“-Rückgabetyp einen Wert zurückgeben. |
bool, bvec2, bvec3, bvec4 (bool2, bool3, bool4) |
Boolescher Skalar/Vektor |
int, ivec2, ivec3, ivec4 (int2, int3, int4) |
highp vorzeichenbehaftete Ganzzahl/Vektor
|
float, vec2, vec3, vec4 (float2, float3, float4)
|
highp (einfache Genauigkeit) Gleitkommaskalar/Vektor |
short, short2, short3, short4
|
Entspricht mediump int vorzeichenbehafteter
Ganzzahl/-Vektor |
half, half2, half3, half4 |
entspricht mediump float Skalar/Vektor |
mat2, mat3, mat4 (float2x2, float3x3, float4x4) |
float -Matrix (2 x 2, 3 x 3, 4 x 4)
|
half2x2, half3x3, half4x4 |
Entspricht mediump float -Matrixtypen |
Mindestwerte für Genauigkeit und Bereich
Dies sind die garantierten Mindestwert für die Genauigkeit und den Mindestbereich für jeden Modifizierer, die auf der OpenGL ES 2.0-Spezifikation basieren. Da die meisten Geräte ES 3.0 unterstützen, bieten sie eine garantiertere highp
-Genauigkeit/Reichweite und einen int mediump
-Bereich. Präzisionsmodifikatoren können auf Skalar-, Vektor- und Matrixvariablen und -parameter angewendet werden. Nur die unten aufgeführten Mindestwerte sind garantiert. lowp
hat nicht unbedingt eine geringere Genauigkeit als mediump
und mediump
hat nicht unbedingt eine geringere Genauigkeit als highp
. AGSL wandelt lowp
in der Endausgabe derzeit in mediump
um.
Modifikator | „Gleitkommazahl“-Bereich | Größenbereich „Gleitkommazahl“ | Präzision 'Fließkommastellen' | Bereich „int“ |
---|---|---|---|---|
Highp | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Relativ: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
Mediump | \(\left\{-2^{14},2^{14}\right\}\) | \(\left\{2^{-14},2^{14}\right\}\) | Relativ: \(2^{-10}\) | \(\left\{-2^{10},2^{10}\right\}\) |
Lowp | \(\left\{-2,2\right\}\) | \(\left\{2^{-8},2\right\}\) | Absolut: \(2^{-8}\) | \(\left\{-2^{8},2^{8}\right\}\) |
Zusätzlich zur numerischen Subskript-Syntax des Arrays, z. B.: 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
: Für den Zugriff auf Vektoren verwenden, die Punkte/Normale darstellen
vect.rgba
: wird beim Zugriff auf Vektoren verwendet, die Farben darstellen
vect.LTRB
: Verwenden Sie diese Option, wenn der Vektor ein Rechteck darstellt (nicht in GLSL).
Im AGSL können 0 und 1 verwendet werden, um eine konstante 0 oder 1 in diesem Kanal zu erzeugen.
Beispiel: vect.rgb1 == vec4(vect.rgb,1)
Strukturen und Arrays
Strukturen werden mit der gleichen Syntax wie GLSL deklariert, aber AGSL unterstützt nur Strukturen auf globaler Ebene.
struct type-name {
members
} struct-name; // optional variable declaration.
Es werden nur eindimensionale Arrays mit einer expliziten Arraygröße unterstützt. Dabei kann entweder die C- oder GLSL-Stilsyntax verwendet werden:
<Basistyp>[<Arraygröße>]: Variablenname – Beispiel: half[10] x;
<Basistyp>-Variablename[<Arraygröße>] – Beispiel: half x[10];
Arrays können nicht von einer Funktion zurückgegeben, kopiert, zugewiesen oder verglichen werden. Array-Einschränkungen werden auf Strukturen angewendet, die Arrays enthalten. Arrays können nur mit einer Konstanten oder einer Schleifenvariablen indexiert werden.
Qualifikation
Typ | Beschreibung |
---|---|
const
|
Kompilieren Sie eine Zeitkonstante oder einen schreibgeschützten Funktionsparameter. |
uniform
|
Der Wert ändert sich in der verarbeiteten Primitive nicht.
Uniformen werden von Android mit RuntimeShader-Methoden für setColorUniform , setFloatUniform , setIntUniform , setInputBuffer und setInputShader übergeben. |
in
|
Für übergebene Funktionsparameter. Das ist die Standardeinstellung. |
out
|
Für übergebene Funktionsparameter. Sie müssen dieselbe Genauigkeit wie in der Funktionsdefinition verwenden. |
inout
|
Für Parameter, die sowohl in als auch aus einer Funktion übergeben werden. Sie muss dieselbe Genauigkeit wie in der Funktionsdefinition verwenden. |
Variablendeklaration
Deklarationen müssen in einem expliziten, geschweiften Bereich angegeben werden. Im folgenden Beispiel darf y
nicht deklariert werden:
if (condition)
int y = 0;
Grundlagen zu Matrix/Struktur/Array
Beispiele für Matrixkonstruktoren
Wenn eine Matrix mit einem einzelnen Wert konstruiert wird, erhalten alle Werte entlang der Diagonale diesen Wert, während der Rest Nullen erhält. float2x2(1.0)
würde daher eine 2x2-Identitätsmatrix erstellen.
Wenn eine Matrix mit mehreren Werten erstellt wird, werden die Spalten zuerst gefüllt (Spalten-Hauptreihenfolge).
Im Gegensatz zu GLSL werden Konstruktoren, die die Anzahl der Komponenten eines übergebenen Vektors reduzieren, nicht unterstützt. Sie können jedoch Swizzling verwenden, um denselben Effekt zu erzielen. Wenn Sie eine vec3
aus einer vec4
in AGSL mit dem gleichen Verhalten wie in GLSL erstellen möchten, geben Sie vec3 nv = quadVec.xyz
an.
Beispiel für einen Gebäudekonstruktor
struct light { float intensity; float3 pos; };
// literal integer constants auto-converted to floating point
light lightVar = light(3, float3(1, 2, 3.0));
Matrixkomponenten
Auf Komponenten einer Matrix mit Array-Subskriptionssyntax zugreifen.
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
Strukturfelder
Wählen Sie Strukturfelder mit dem Punkt .
aus. Zu den Operatoren gehören:
Operator | Beschreibung |
---|---|
. |
Feldauswahl |
==, != |
Gleichheit |
= |
Abtretung |
Array-Elemente
Auf Array-Elemente kann mit dem tiefgestellten Array-Operator [ ]
zugegriffen werden. Beispiele:
diffuseColor += lightIntensity[3] * NdotL;
Netzbetreiber
Nummeriert in der Reihenfolge ihrer Priorität. Die Relationen- und Gleichheitsoperatoren > < <= >= == != ergeben einen booleschen Wert. Um Vektoren auf Komponentenebene zu vergleichen, können Sie Funktionen wie lessThan()
, equal()
usw. verwenden.
Operator | Beschreibung | Assoziation | |
---|---|---|---|
1 | () |
Gruppierung in Klammern | – |
2 | [] () . ++ --
|
Array subscript Funktionsaufruf und Konstruktorstruktur Feld- oder Methodenauswahl, Swizzle Postfix-Inkrementierung und Dekrementierung | Rechtsläufig |
3 | ++ -- + - !
|
Unäres Präfix-Inkrement und Dekrementierung unär | Linksläufig |
4 | * / |
multiplizieren und dividieren | Rechtsläufig |
5 | + - |
addieren und subtrahieren | Rechtsläufig |
7 | < > <= >= |
Relationale Operatoren | Rechtsläufig |
8 | == != |
Gleichheit/Ungleichheit | Rechtsläufig |
12 | && |
logisches UND | Rechtsläufig |
13 | ^^ |
logisches XOR | Rechtsläufig |
14 | || |
logisches ODER | Rechtsläufig |
15 | ?\:
|
Auswahl (ein ganzer Operand) | Rechtsläufig |
16 | = += -= *= /=
|
Zuweisungsarithmetik Aufgabe arithmetische Zuweisung | Rechtsläufig |
17 | , |
Sequenz | Rechtsläufig |
Matrix- und Vektoroperationen
Bei Anwendung auf Skalarwerte führen die arithmetischen Operatoren zu einem Skalar. Wenn bei anderen Operatoren als Modulo ein skalarer Operand und der andere ein Vektor oder eine Matrix ist, wird die Operation komponentenweise ausgeführt und führt zum selben Vektor oder Matrixtyp. Wenn beide Operationen Vektoren derselben Größe sind, wird der Vorgang komponentenweise ausgeführt und der gleiche Vektortyp zurückgegeben.
Betrieb | Beschreibung |
---|---|
m = f * m |
Komponentenweise Matrixmultiplikation mit einem Skalarwert |
v = f * v |
Komponentenweise Vektormultiplikation mit einem Skalarwert |
v = v * v |
Komponentenweise Vektormultiplikation mit einem Vektorwert |
m = m + m |
Matrixkomponentenbasiertes Addieren |
m = m - m |
Matrixkomponentenbasierte Subtraktion |
m = m * m |
Lineare algebraische Multiplikation |
Wenn ein Operand ein Vektor ist, der mit der Zeilen- oder Spaltengröße unserer Matrix übereinstimmt, kann der Multiplikationsoperator zur algebraischen Zeilen- und Spaltenmultiplikation verwendet werden.
Betrieb | Beschreibung |
---|---|
m = v * m |
Zeilenvektor * lineare algebraische Matrixmultiplikation |
m = m * v |
Matrix * Spaltenvektor – lineare algebraische Multiplikation |
Verwenden Sie die integrierten Funktionen für das Vektorpunktprodukt, das Kreuzprodukt und die komponentenweise Multiplikation:
Funktion | Beschreibung |
---|---|
f = dot(v, v) |
Vektorpunktprodukt |
v = cross(v, v) |
Vektorübergreifendes Produkt |
m = matrixCompMult(m, m) |
Komponentenweises Multiplizieren |
Programmsteuerung
Funktionsaufruf | Anruf nach Wertschöpfung |
---|---|
Iteration | for (<init>;<test>;<next>) { break, continue } |
Auswahl | if ( ) { } if ( ) { } else { } switch () { break, case }
– Standardfall zuletzt |
Springen | break, continue, return (Verwerfen ist nicht zulässig) |
Eintrag | half4 main(float2 fragCoord) |
Für Einschränkungen von Schleifen
Ähnlich wie bei GLSL ES 1.0 sind „for“-Schleifen recht begrenzt. Der Compiler muss die Schleife entrollen können. Das bedeutet, dass der Initialisierer, die Testbedingung und die next
-Anweisung Konstanten verwenden müssen, damit alles zur Kompilierungszeit berechnet werden kann. Die Anweisung next
ist weiter auf die Verwendung von ++, --, +=, or -=
beschränkt.
Integrierte Funktionen
GT
(generischer Typ) ist float
, float2
, float3
, float4
oder half
, half2
, half3
, half4
.
Die meisten dieser Funktionen arbeiten auf Komponentenebene (die Funktion wird pro Komponente angewendet). Es wird vermerkt, wenn dies nicht der Fall ist.
Winkel- und trigonometrische Funktionen
Bei Funktionsparametern, die als Winkel angegeben werden, wird angenommen, dass sie in Radianteneinheiten angegeben werden. In keinem Fall wird keine dieser Funktionen zu einem „Division durch Null“-Fehler führen. Wenn der Divisor eines Verhältnisses 0 ist, sind die Ergebnisse nicht definiert.
Funktion | Beschreibung |
---|---|
GT radians(GT degrees) |
Wandelt Grad in Bogenmaß um |
GT degrees(GT radians) |
Wandelt Bogenmaß (Radiant) in Grad um |
GT sin(GT angle) |
Standardsinus |
GT cos(GT angle) |
Standardkosinus |
GT tan(GT angle) |
Standardtangens |
GT asin(GT x)
|
Gibt einen Winkel zurück, dessen Sinus x im Bereich von $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
GT acos(GT x)
|
Gibt einen Winkel zurück, dessen Kosinus x im Bereich von $ \left[0,\pi\right] $ ist. |
GT atan(GT y, GT x)
|
Gibt einen Winkel zurück, dessen trigonometrischer Arkustangens $ \left[{y\over x}\right] $ im Bereich von $ \left[-\pi,\pi\right] $ ist. |
GT atan(GT y_over_x)
|
Gibt einen Winkel zurück, dessen trigonometrischer Arkustangens y_over_x im Bereich von $ \left[-{\pi\over 2},{\pi\over 2}\right] $ ist |
Exponentialfunktionen
Funktion | Beschreibung |
---|---|
GT pow(GT x, GT y) |
Gibt $ x^y $ zurück |
GT exp(GT x) |
Gibt $ e^x $ zurück |
GT log(GT x) |
Gibt $ ln(x) $ zurück |
GT exp2(GT x) |
Retouren: 2^x $ |
GT log2(GT x) |
Gibt $ log_2(x) $ zurück |
GT sqrt(GT x) |
Gibt $ \sqrt{x} $ zurück |
GT inversesqrt(GT x) |
Gibt $ 1\over{\sqrt{x}} $ zurück |
Gängige Funktionen
Funktion | Beschreibung |
---|---|
GT abs(GT x) |
Absoluter Wert |
GT sign(GT x) |
Gibt -1.0, 0.0 oder 1.0 basierend auf dem Vorzeichen von x zurück. |
GT floor(GT x) |
Nächste Ganzzahl <= x |
GT ceil(GT x) |
Nächste Ganzzahl >= x |
GT fract(GT x) |
Gibt den Bruchteil von x zurück |
GT mod(GT x, GT y) |
Gibt den Wert von x Modulo y zurück |
GT mod(GT x, float y) |
Gibt den Wert von x Modulo y zurück |
GT min(GT x, GT y) |
Gibt den Minimalwert von x oder y zurück |
GT min(GT x, float y) |
Gibt den Minimalwert von x oder y zurück |
GT max(GT x, GT y) |
Gibt den Maximalwert von x oder y zurück |
GT max(GT x, float y) |
Gibt den Maximalwert von x oder y zurück |
GT clamp(GT x, GT
minVal, GT maxVal) |
Gibt x zurück, das zwischen minVal und maxVal liegt. |
GT clamp(GT x, float
minVal, float maxVal) |
Gibt x zurück, das zwischen minVal und maxVal liegt. |
GT saturate(GT x) |
Gibt x zurück, muss zwischen 0,0 und 1,0 liegen |
GT mix(GT x, GT y
GT a) |
Gibt die lineare Zusammenführung von x und y zurück |
GT mix(GT x, GT y,
float a) |
Gibt die lineare Zusammenführung von x und y zurück |
GT step(GT edge, GT x) |
Gibt 0,0 zurück, wenn x < Edge, sonst 1,0 |
GT step(float edge,
GT x) |
Gibt 0,0 zurück, wenn x < Edge, sonst 1,0 |
GT smoothstep(GT edge0,
GT edge1, GT x) |
Führt eine Hermite-Interpolation zwischen 0 und 1 durch, wenn Edge0 < x < Edge1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
Führt eine Hermite-Interpolation zwischen 0 und 1 durch, wenn Edge0 < x < Edge1 |
Geometrische Funktionen
Diese Funktionen arbeiten mit Vektoren als Vektoren, nicht in Bezug auf Komponenten. GT ist ein Gleitkomma-/Halbvektor in den Größen 2 bis 4.
Funktion | Beschreibung |
---|---|
float/half length
(GT x) |
Gibt die Länge des Vektors zurück |
float/half distance(GT
p0, GT p1) |
Gibt die Entfernung zwischen Punkten zurück |
float/half dot(GT x,
GT y) |
Gibt Punktprodukt zurück |
float3/half3
cross(float3/half3 x,
float3/half3 y) |
Produktübergreifende Rückgabe |
GT normalize(GT x) |
Vektor auf Länge 1 normalisieren |
GT faceforward(GT N,
GT I, GT Nref) |
Gibt N zurück, wenn Punkt(Nref; I) < 0, sonst -N. |
GT reflect(GT I, GT N) |
Richtung der Reflexion I – 2 * Punkt(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Gibt den Brechungsvektor zurück |
Matrixfunktionen
Typ „mat“ ist ein beliebiger quadratischer Matrixtyp.
Funktion | Beschreibung |
---|---|
mat matrixCompMult(mat
x, mat y) |
Komponentenweise x mit y multiplizieren |
mat inverse(mat m) |
Gibt den Kehrwert von m zurück |
Relationale Vektorfunktionen
Vergleichen Sie die Komponenten x und y. Die Größen der Eingabe- und Rückgabevektoren für einen bestimmten Aufruf müssen übereinstimmen. T ist die Zusammenführung von Ganzzahl- und Gleitkomma-Vektortypen. BV ist ein boolescher Vektor, der der Größe der Eingabevektoren entspricht.
Funktion | Beschreibung |
---|---|
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 , wenn eine Komponente von x true ist |
bool all(BV x) |
true , wenn alle Komponenten von x true sind. |
BV not(BV x) |
logisches Komplement von x |
Farbfunktionen
Funktion | Beschreibung |
---|---|
vec4 unpremul(vec4
color) |
Wandelt den Farbwert in eine nicht vorab multiplizierte Alpha um. |
half3 toLinearSrgb(half3
color) |
Farbraum in lineares SRGB umwandeln |
half3 fromLinearSrgb(half3
color) |
Farbraumtransformation |
Shader-Sampling (Bewertung)
Sampler-Typen werden nicht unterstützt. Sie können jedoch andere Shader bewerten. Wenn Sie eine Textur testen möchten, können Sie ein BitmapShader-Objekt erstellen und als Einheit hinzufügen. Das ist mit jedem Shader möglich. Sie können also jeden Android-Shader direkt bewerten, ohne ihn vorher in eine Bitmap umzuwandeln, einschließlich anderer RuntimeShader-Objekte. Das bietet ein hohes Maß an Flexibilität, aber die Auswertung komplexer Shader kann teuer sein, insbesondere in einer Schleife.
uniform shader image;
image.eval(coord).a // The alpha channel from the evaluated image shader
Rohdaten zu Puffern
Die meisten Bilder enthalten Farben, die farblich verwaltet werden sollten. Einige Bilder enthalten jedoch auch Daten, die keine Farben sind. Dazu gehören Bilder, in denen Normalen, Materialeigenschaften (z. B. Rauheit), Höhenkarten oder andere rein mathematische Daten gespeichert sind, die in einem Bild gespeichert sind. Wenn Sie diese Art von Bildern in AGSL nutzen, können Sie einen BitmapShader mit RuntimeShader#setInputBuffer als generischen Rohpuffer verwenden. Dadurch werden Umwandlungen und Filterungen von Farbräumen vermieden.