AGSL ist weitgehend kompatibel mit GLSL ES 1.0. Weitere Informationen die entsprechende Funktion in der Dokumentation zur OpenGL ES Shading Language Wenn möglich, wird in dieser Dokumentation versucht, auf Unterschiede zwischen AGSL-Dateien hinzuweisen. und GLSL.
Typen
AGSL unterstützt GLSL ES 1.0-Typen und eine zusätzliche Möglichkeit zur Darstellung von Vektoren
und Matrixtypen. AGSL unterstützt zusätzliche Typen short und half zur Darstellung
mittlere Genauigkeit.
Basistypen
| Typ | Beschreibung |
|---|---|
void
|
Kein Rückgabewert der Funktion oder leerer Parameter Liste. Im Gegensatz zu GLSL werden Funktionen ohne Leerraum muss ein Wert zurückgegeben werden. |
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 Gleitkommazahl mit einfacher Genauigkeit
Skalar/Vektor |
short, short2, short3, short4
|
Entspricht mediump int signiert
Ganzzahl/Vektor |
half, half2, half3, half4 |
Entspricht mediump float Skalar/Vektor |
mat2, mat3, mat4 (float2x2, float3x3, float4x4) |
2 × 2, 3 × 3, 4 × 4 float-Matrix
|
half2x2, half3x3, half4x4 |
Entspricht mediump float Matrixtypen |
Genauigkeit und Mindestwerte
Dies sind die minimale garantierte Precision und der
-Modifikator basierend auf der OpenGL ES 2.0-Spezifikation. Da die meisten Geräte
ES 3.0 unterstützen, haben sie eine garantierte highp Genauigkeit/Reichweite
Bereich int mediump. Genauigkeitsmodifikatoren können auf Skalar-, Vektor- und
Matrixvariablen und -parametern. Nur die unten aufgeführten Mindestbeträge sind garantiert.
lowp ist nicht unbedingt eine geringere Precision als mediump und mediump
ist nicht unbedingt geringer als highp. AGSL wandelt derzeit lowp um
in der Endausgabe auf mediump setzen.
| Modifizierer | 'Gleitkommazahl' Bereich | 'Gleitkommazahl' Größenbereich | 'Gleitkommazahl' Precision | "int" Bereich |
|---|---|---|---|---|
| High | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Relativ: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| Logo: 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 Subskriptsyntax im Array, 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: kann verwendet werden, wenn Sie auf Vektoren zugreifen, die Punkte/Normalen darstellen
vect.rgba: Verwenden Sie diese Option, wenn Sie auf Vektoren zugreifen, die Farben darstellen
vect.LTRB: zu verwenden, wenn der Vektor ein Rechteck darstellt (nicht in GLSL)
In 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 derselben Syntax wie GLSL deklariert, AGSL unterstützt jedoch nur und 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, wobei die Verwendung von Syntax im C- oder GLSL-Stil:
<Basistyp>[<Array-Größe>]-Variablenname – Beispiel: half[10] x;
<Basistyp> Variablenname[<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 Schleifenvariable indexiert werden.
Qualifikation
| Typ | Beschreibung |
|---|---|
const
|
Kompilierungszeitkonstante oder schreibgeschützte Funktion . |
uniform
|
Wert ändert sich nicht über die Primitive hinweg
verarbeitet wird.
Uniformen werden von Android mithilfe von
RuntimeShader
Methoden für setColorUniform, setFloatUniform,
setIntUniform, setInputBuffer und
setInputShader |
in
|
Für übergebene Funktionsparameter. Dies ist die Standardeinstellung. |
out
|
Für übergebene Funktionsparameter. Muss verwendet werden dieselbe Genauigkeit wie die Funktionsdefinition. |
inout
|
Für Parameter, die sowohl an- als auch ausgehend übergeben werden einer Funktion. Muss dieselbe Genauigkeit wie der Funktionsdefinition. |
Variablendeklaration
Deklarationen müssen sich in einem expliziten geschweiften Bereich befinden. Die Deklaration von y in
Das folgende Beispiel ist nicht zulässig:
if (condition)
int y = 0;
Matrix/Struktur/Array-Grundlagen
Beispiele für Matrixkonstruktoren
Wenn eine Matrix mit einem einzigen Wert konstruiert wird, werden alle Werte zusammen
der Diagonalen wird dieser Wert gegeben, die übrigen Nullen. float2x2(1.0) würde
und erstellen daher eine 2 x 2-Identitätsmatrix.
Wenn eine Matrix mit mehreren Werten konstruiert wird, werden zuerst die Spalten ausgefüllt (wichtige Spaltenreihenfolge).
Beachten Sie, dass im Gegensatz zu GLSL-Konstruktoren, die die Anzahl der Komponenten eines
übergebene Vektoren werden nicht unterstützt. Sie können aber
Effekts. Sie erstellen eine vec3 aus einer vec4 in AGSL mit demselben Verhalten wie
GLSL, geben Sie vec3 nv = quadVec.xyz an.
Beispiel für einen Strukturkonstruktor
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 Matrixkomponenten 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-Operator . aus. Zu den Operatoren gehören:
| Operator | Beschreibung |
|---|---|
. |
Feldselektor |
==, != |
Gleichheit |
= |
Zuweisung |
Array-Elemente
Der Zugriff auf Array-Elemente erfolgt mit dem Array-Subskriptoperator [ ]. Beispiel:
diffuseColor += lightIntensity[3] * NdotL;
Netzbetreiber
Die Nummer ist in der Reihenfolge ihrer Priorität nummeriert. Relationale und Gleichheit
Operatoren > < <= >= == != als boolescher Wert auszuwerten. Vektoren vergleichen
Komponentenweise verwenden Sie Funktionen wie lessThan(), equal() usw.
| Operator | Beschreibung | Assoziativität | |
|---|---|---|---|
| 1 | () |
Gruppierung in Klammern | – |
| 2 | [] () . ++ --
|
Tiefgestelltes Array Funktionsaufruf & Konstruktorstruktur Feld oder Methode Selektor, Swizzle Postfix-Inkrement und verringern | Rechtsläufig |
| 3 | ++ -- + - !
|
Präfix-Inkrementierung und Unärer verringern | Linksläufig |
| 4 | * / |
multiplizieren und dividieren | Rechtsläufig |
| 5 | + - |
addieren und subtrahieren | Rechtsläufig |
| 7 | < > <= >= |
relational | Rechtsläufig |
| 8 | == != |
Gleichheit/Ungleichheit | Rechtsläufig |
| 12 | && |
Logisches UND | Rechtsläufig |
| 13 | ^^ |
Logisches XOR | Rechtsläufig |
| 14 | || |
Logisches ODER | Rechtsläufig |
| 15 | ?\:
|
Auswahl (eine ganze Operand) | Rechtsläufig |
| 16 | = += -= *= /=
|
Zuweisungsarithmetik Zuweisungsarithmetik Zuweisung | Rechtsläufig |
| 17 | , |
Sequenz | Rechtsläufig |
Matrix- und Vektoroperationen
Bei Anwendung auf skalare Werte ergeben die arithmetischen Operatoren einen Skalar. Für wenn ein Operand ein Skalar und der andere ein Vektor- oder Matrixstruktur ist, wird die Operation komponentenweise durchgeführt und ergibt die Vektor- oder Matrixtyps. Wenn beide Operationen Vektoren derselben Größe sind, -Vorgang komponentenweise durchgeführt (und gibt denselben Vektortyp zurück).
| 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 |
Matrixkomponentenweise Addition |
m = m - m |
Matrixkomponentenweise Subtraktion |
m = m * m |
Lineare algebraische Multiplikation |
Wenn ein Operand ein Vektor ist, der der Zeilen- oder Spaltengröße unserer Matrix entspricht, gibt die Multiplikationsoperator kann für die algebraische Zeilen- und Spaltenmultiplikation verwendet werden.
| Betrieb | Beschreibung |
|---|---|
m = v * m |
Zeilenvektor × lineare algebraische Multiplikation der Matrix |
m = m * v |
Matrix * Spaltenvektor – lineare algebraische Multiplikation |
Die integrierten Funktionen für Vektor-Punktprodukt, Kreuzprodukt und komponentenweise Multiplikation:
| Funktion | Beschreibung |
|---|---|
f = dot(v, v) |
Vektor-Punktprodukt |
v = cross(v, v) |
Vektorübergreifendes Produkt |
m = matrixCompMult(m, m) |
Komponentenweise Multiplikation |
Programmsteuerung
| Funktionsaufruf | Anruf nach Wert/Rückgabe |
|---|---|
| Iteration | for (<init>;<test>;<next>) { break, continue } |
| Auswahl | if ( ) { } if ( ) { } else { } switch () { break, case }
– Standard-Groß-/Kleinschreibung zuletzt |
| Springen | break, continue, return (Verwerfen ist nicht zulässig) |
| Eintrag | half4 main(float2 fragCoord) |
Für Schleifenbeschränkungen
Ähnlich wie GLSL ES 1.0, "for" Schleifen sind ziemlich begrenzt. muss der Compiler
um die Schleife zu lösen. Das bedeutet, dass der Initialisierer, die Testbedingung und
In der Anweisung next müssen Konstanten verwendet werden, damit alles beim Kompilieren berechnet werden kann
. Die next-Anweisung ist weiter auf die Verwendung von ++, --, +=, or -= beschränkt.
Integrierte Funktionen
GT (allgemeiner Typ) ist float, float2, float3, float4 oder
half, half2, half3 und half4
Die meisten dieser Funktionen werden komponentenbezogen ausgeführt (die Funktion wird pro Komponente). Es wird vermerkt, wenn dies nicht der Fall ist.
Winkel & Trigonometrische Funktionen
Bei Funktionsparametern, die als Winkel angegeben sind, wird davon ausgegangen, dass sie in Radianten angegeben sind. In keinem Fall führt eine dieser Funktionen zu einem "Geteilt durch Null"-Fehler. Wenn die Divisor eines Verhältnisses 0 ist, sind die Ergebnisse nicht definiert.
| Funktion | Beschreibung |
|---|---|
GT radians(GT degrees) |
Wandelt Grad in Radianten um |
GT degrees(GT radians) |
Wandelt Bogenmaß (Radiant) in Grad um. |
GT sin(GT angle) |
Standard-Sinus |
GT cos(GT angle) |
Standardkosinus |
GT tan(GT angle) |
Standardtangente |
GT asin(GT x)
|
Gibt einen Winkel zurück, dessen Sinus x im Bereich ist 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] $ |
GT atan(GT y, GT x)
|
Gibt einen Winkel zurück, dessen Trigonometrischer Arkustangens ist $ \left[{y\over x}\right] $ in der Bereich von $ \left[-\pi,\pi\right] $ |
GT atan(GT y_over_x)
|
Gibt einen Winkel zurück, dessen trigonometrisches
Arkustangens ist y_over_x im Bereich
von $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
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) |
Gibt $ 2^x $ zurück |
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 |
Allgemeine 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 den Wert x zwischen minVal und maxVal zurück. |
GT clamp(GT x, float
minVal, float maxVal) |
Gibt den Wert x zwischen minVal und maxVal zurück. |
GT saturate(GT x) |
Gibt x zurück, der zwischen 0,0 und 1,0 liegt. |
GT mix(GT x, GT y
GT a) |
Gibt die lineare Mischung von x und y zurück |
GT mix(GT x, GT y,
float a) |
Gibt die lineare Mischung 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 Hermite-Interpolation durch zwischen 0 und 1, wenn Edge0 < x < Rand1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
Führt Hermite-Interpolation durch zwischen 0 und 1, wenn Edge0 < x < Rand1 |
Geometrische Funktionen
Diese Funktionen arbeiten mit Vektoren als Vektoren, nicht komponentenweise. GT steht für Gleitkomma-/Halbwertvektoren in den Größen 2–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 das Punktprodukt zurück |
float3/half3
cross(float3/half3 x,
float3/half3 y) |
Produktübergreifende Rückgaben |
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) |
Reflexionsrichtung I: 2 * Punkt(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Gibt einen Brechungsvektor zurück. |
Matrixfunktionen
Der Typ „mat“ ist ein beliebiger quadratischer Matrixtyp.
| Funktion | Beschreibung |
|---|---|
mat matrixCompMult(mat
x, mat y) |
x komponentenweise mit y multiplizieren |
mat inverse(mat m) |
Gibt die Umkehrfunktion von m zurück. |
Vektorrelationale Funktionen
Vergleichen Sie die x- und y-Komponenten. Die Größen der Eingabe- und Rückgabevektoren für einen bestimmten Aufruf müssen übereinstimmen. T ist die Vereinigung von Ganzzahl- und Gleitkommavektortypen. BV ist ein boolescher Vektor, der mit der Größe der Eingabevektoren übereinstimmt.
| Funktion | Beschreibung |
|---|---|
BV lessThan(T x, T y) |
x < J |
BV lessThanEqual(T x,
T y) |
x <= y |
BV greaterThan(T x,
T y) |
x > J |
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 gleich 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 einen nicht vormultiplizierten Wert um Alpha |
half3 toLinearSrgb(half3
color) |
Farbraumtransformation in lineares SRGB |
half3 fromLinearSrgb(half3
color) |
Farbraumtransformation |
Shader-Sampling (Auswertung)
Sampler-Typen werden nicht unterstützt, aber Sie können andere Shader bewerten. Bei Bedarf um eine Textur zu probieren, können Sie BitmapShader-Objekt und fügen es als einheitlich sein. Sie können dies für jeden Shader tun, d. h., Sie können die Daten direkt auswerten einen beliebigen Android Shader verwenden, Zuerst Bitmap, einschließlich anderer RuntimeShader-Objekte. Dadurch können Sie Flexibilität bietet. Komplexe Shader können jedoch teuer werden, insbesondere in einer Schleife.
uniform shader image;
image.eval(coord).a // The alpha channel from the evaluated image shader
Stichprobenerhebung für den Rohpuffer
Obwohl die meisten Bilder Farben enthalten, für die eine Farbverwaltung sinnvoll ist, gibt es einige Bilder. Daten enthalten, die keine Farben sind, wie z. B. Bilder, die Normalen speichern, Materialeigenschaften (z.B. Rauheit), Heightmaps oder andere reine mathematische Daten, die zufällig in einem Bild gespeichert sind. Wenn Sie diese Arten von von Bildern in AGSL können Sie BitmapShader als generischen Rohpuffer verwenden, indem Sie RuntimeShader#setInputBuffer Dadurch werden Farbraumtransformationen und -filter vermieden.