AGSL-Kurzübersicht

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.