Shader-Sprache

Einführung

Godot verwendet eine Shader-Sprache ähnlich GLSL ES 3.0. Die meisten Datentypen und Funktionen werden unterstützt, und die wenigen verbleibenden werden wahrscheinlich im Laufe der Zeit hinzugefügt.

Wenn Sie bereits mit GLSL vertraut sind, ist das Godot Shader-Migrationshandbuch eine Ressource, die Ihnen beim Übergang von regulärem GLSL zu Godots Shader-Sprache hilft.

Datentypen

Die meisten GLSL ES 3.0 Datentypen werden unterstützt:

Art Beschreibung
void Void Datentyp, nur nützlich für Funktionen die nichts zurück übergeben.
bool Boolesche Datentyp, kann nur true oder false enthalten.
bvec2 Zweikomponentenvektor von Booleschen Werten.
bvec3 Drei-Komponenten Vektor mit Booleschen.
bvec4 Vier-Komponenten Vektor mit Booleschen.
int vorzeichenbehaftete skalare Ganzzahl.
ivec2 Zwei-Komponenten Vektor mit vorzeichenbehafteten Ganzzahlen.
ivec3 Drei-Komponenten Vektor mit vorzeichenbehafteten Ganzzahlen.
ivec4 Vier-Komponenten Vektor mit vorzeichenbehafteten Ganzzahlen.
uint Skalare Ganzzahl ohne Vorzeichen, kann keine negativen Zahlen enthalten.
uvec2 Zwei-Komponenten Vektor mit Ganzzahl ohne Vorzeichen.
uvec3 Drei-Komponenten Vektor mit Ganzzahl ohne Vorzeichen.
uvec4 Vier-Komponenten Vektor mit Ganzzahl ohne Vorzeichen.
float Gleitkomma-Skalar.
vec2 Zwei-Komponenten Vektor mit Fließkomma-Werten.
vec3 Drei-Komponenten Vektor mit Fließkomma-Werten.
vec4 Vier-Komponenten Vektor mit Fließkomma-Werten.
mat2 2x2 Matrix, in spaltenweiser Anordnung.
mat3 3x3 Matrix, in spaltenweiser Anordnung.
mat4 4x4 Matrix, in spaltenweiser Anordnung.
sampler2D Sampler Typ um 2D Texturen zu binden, welche als Fließkommazahl gelesen werden.
isampler2D Sampler Typ um 2D Texturen zu binden, welche als vorzeichenbehaftete Ganzzahlen gelesen werden.
usampler2D Sampler Typ um 2D Texturen zu binden, welche als Ganzzahlen ohne Vorzeichen gelesen werden.
sampler2DArray Sampler Typ um 2D Texturfelder zu binden, welche als Fließkommazahl gelesen werden.
isampler2DArray Sampler Typ um 2D Textur-Arrays zu binden, welche als vorzeichenbehaftete Ganzzahlen gelesen werden.
usampler2DArray Sampler Typ um 2D Texturfelder zu binden, welche als Ganzzahlen ohne Vorzeichen gelesen werden.
sampler3D Sampler Typ um 3D Texturen zu binden, welche als Fließkommazahl gelesen werden.
isampler3D Sampler Typ um 3D Texturen zu binden, welche als vorzeichenbehaftete Ganzzahlen gelesen werden.
usampler3D Sampler Typ um 3D Texturen zu binden, welche als Ganzzahlen ohne Vorzeichen gelesen werden.
samplerCube Sampler Typ um Würfelformen zu binden, welche als Fließkommazahl gelesen werden.

Casting (Typumwandlung)

Genau wie bei GLSL ES 3.0 ist implizites Casting zwischen Skalaren und Vektoren gleicher Größe, aber unterschiedlichen Typs nicht zulässig. Casting von Typen unterschiedlicher Größe ist ebenfalls nicht zulässig. Die Konvertierung muss explizit über Konstruktoren erfolgen.

Beispiel:

float a = 2; // invalid
float a = 2.0; // valid
float a = float(2); // valid

Standard-Ganzzahlkonstanten sind vorzeichenbehaftet, daher ist immer eine Umwandlung erforderlich um in vorzeichenlose zu konvertieren:

int a = 2; // valid
uint a = 2; // invalid
uint a = uint(2); // valid

Mitglieder

Individual scalar members of vector types are accessed via the "x", "y", "z" and "w" members. Alternatively, using "r", "g", "b" and "a" also works and is equivalent. Use whatever fits best for your needs.

For matrices, use the m[row][column] indexing syntax to access each scalar, or m[idx] to access a vector by row index. For example, for accessing the y position of an object in a mat4 you use m[3][1].

Konstruieren

Construction of vector types must always pass:

// The required amount of scalars
vec4 a = vec4(0.0, 1.0, 2.0, 3.0);
// Complementary vectors and/or scalars
vec4 a = vec4(vec2(0.0, 1.0), vec2(2.0, 3.0));
vec4 a = vec4(vec3(0.0, 1.0, 2.0), 3.0);
// A single scalar for the whole vector
vec4 a = vec4(0.0);

Construction of matrix types requires vectors of the same dimension as the matrix. You can also build a diagonal matrix using matx(float) syntax. Accordingly, mat4(1.0) is an identity matrix.

mat2 m2 = mat2(vec2(1.0, 0.0), vec2(0.0, 1.0));
mat3 m3 = mat3(vec3(1.0, 0.0, 0.0), vec3(0.0, 1.0, 0.0), vec3(0.0, 0.0, 1.0));
mat4 identity = mat4(1.0);

Matrices can also be built from a matrix of another dimension. There are two rules : If a larger matrix is constructed from a smaller matrix, the additional rows and columns are set to the values they would have in an identity matrix. If a smaller matrix is constructed from a larger matrix, the top, left submatrix of the larger matrix is used.

mat3 basis = mat3(WORLD_MATRIX);
mat4 m4 = mat4(basis);
mat2 m2 = mat2(m4);

Swizzling

It is possible to obtain any combination of components in any order, as long as the result is another vector type (or scalar). This is easier shown than explained:

vec4 a = vec4(0.0, 1.0, 2.0, 3.0);
vec3 b = a.rgb; // Creates a vec3 with vec4 components.
vec3 b = a.ggg; // Also valid; creates a vec3 and fills it with a single vec4 component.
vec3 b = a.bgr; // Order does not matter.
vec3 b = a.xyz; // Also rgba, xyzw are equivalent.
vec3 b = a.stp; // And stpq (for texture coordinates).
float c = b.w; // Invalid, because "w" is not present in vec3 b.
vec3 c = b.xrt; // Invalid, mixing different styles is forbidden.
b.rrr = a.rgb; // Invalid, assignment with duplication.
b.bgr = a.rgb; // Valid assignment.

Präzision

Es ist möglich Datentypen Präzisionsmodifikatoren hinzuzufügen. Verwenden Sie diese für Uniforms, Variablen, Argumente und Variationen:

lowp vec4 a = vec4(0.0, 1.0, 2.0, 3.0); // low precision, usually 8 bits per component mapped to 0-1
mediump vec4 a = vec4(0.0, 1.0, 2.0, 3.0); // medium precision, usually 16 bits or half float
highp vec4 a = vec4(0.0, 1.0, 2.0, 3.0); // high precision, uses full float or integer range (default)

Die Verwendung einer geringeren Genauigkeit für einige Operationen kann den Rechenaufwand beschleunigen (auf Kosten einer geringeren Genauigkeit). Dies wird in der Vertex-Prozessorfunktion selten benötigt (wo die meiste Zeit volle Präzision erforderlich ist), wird jedoch im Fragmentprozessor häufig nützlich.

Some architectures (mainly mobile) can benefit significantly from this, but there are downsides such as the additional overhead of conversion between precisions. Refer to the documentation of the target architecture for further information. In many cases, mobile drivers cause inconsistent or unexpected behavior and it is best to avoid specifying precision unless necessary.

Arrays (Felder)

Arrays are containers for multiple variables of a similar type. Note: As of Godot 3.2, only local and varying arrays have been implemented.

Lokale Arrays

Local arrays are declared in functions. They can use all of the allowed datatypes, except samplers. The array declaration follows a C-style syntax: [const] + [precision] + typename + identifier + [array size].

void fragment() {
    float arr[3];
}

Sie können zu Beginn wie folgt initialisiert werden:

float float_arr[3] = float[3] (1.0, 0.5, 0.0); // first constructor

int int_arr[3] = int[] (2, 1, 0); // second constructor

vec2 vec2_arr[3] = { vec2(1.0, 1.0), vec2(0.5, 0.5), vec2(0.0, 0.0) }; // third constructor

bool bool_arr[] = { true, true, false }; // fourth constructor - size is defined automatically from the element count

Sie können mehrere Arrays (auch mit unterschiedlichen Größen) in einem Ausdruck deklarieren:

float a[3] = float[3] (1.0, 0.5, 0.0),
b[2] = { 1.0, 0.5 },
c[] = { 0.7 },
d = 0.0,
e[5];

Verwenden Sie die Indizierungssyntax, um auf ein Array-Element zuzugreifen:

float arr[3];

arr[0] = 1.0; // setter

COLOR.r = arr[0]; // getter

Arrays also have a built-in function .length() (not to be confused with the built-in length() function). It doesn't accept any parameters and will return the array's size.

float arr[] = { 0.0, 1.0, 0.5, -1.0 };
for (int i = 0; i < arr.length(); i++) {
    // ...
}

Bemerkung

If you use an index below 0 or greater than array size - the shader will crash and break rendering. To prevent this, use length(), if, or clamp() functions to ensure the index is between 0 and the array's length. Always carefully test and check your code. If you pass a constant expression or a simple number, the editor will check its bounds to prevent this crash.

Konstanten

Use the const keyword before the variable declaration to make that variable immutable, which means that it cannot be modified. All basic types, except samplers can be declared as constants. Accessing and using a constant value is slightly faster than using a uniform. Constants must be initialized at their declaration.

const vec2 a = vec2(0.0, 1.0);
vec2 b;

a = b; // invalid
b = a; // valid

Constants cannot be modified and additionally cannot have hints, but multiple of them (if they have the same type) can be declared in a single expression e.g

const vec2 V1 = vec2(1, 1), V2 = vec2(2, 2);

Similar to variables, arrays can also be declared with const.

const float arr[] = { 1.0, 0.5, 0.0 };

arr[0] = 1.0; // invalid

COLOR.r = arr[0]; // valid

Constants can be declared both globally (outside of any function) or locally (inside a function). Global constants are useful when you want to have access to a value throughout your shader that does not need to be modified. Like uniforms, global constants are shared between all shader stages, but they are not accessible outside of the shader.

shader_type spatial;

const float PI = 3.14159265358979323846;

Operatoren

Die Godot Shader-Sprache unterstützt dieselben Operatoren wie GLSL ES 3.0. Unten ist die Liste von ihnen in der Rangfolge:

Priorität Klasse Operator
1 (höchste) Gruppierung in Klammern ()
2 einstellig (unär) +, -, !, ~
3 multiplikativ /, *, %
4 additiv +, -
5 bitweise schieben <<, >>
6 relational <, >, <=, >=
7 Gleichheit ==, !=
8 bitweises UND &
9 bitweises Exklusiv-ODER ^
10 bitweises Inklusiv-ODER |
11 logisches UND &&
12 (niedrigste) logisches inklusiv ODER ||

Flußkontrolle

Godot's Shader-Sprache unterstützt die gebräuchlichsten Typen von Flußkontrollen:

// if and else
if (cond) {

} else {

}

// switch
switch(i) { // signed integer expression
    case -1:
        break;
    case 0:
        return; // break or return
    case 1: // pass-through
    case 2:
        break;
    //...
    default: // optional
        break;
}

// for loops
for (int i = 0; i < 10; i++) {

}

// while
while (true) {

}

// do while
do {

} while(true);

Beachten Sie, dass in modernen GPUs eine Endlosschleife existieren und Ihre Anwendung (einschließlich Editor) einfrieren kann. Godot kann Sie nicht davor schützen, also passen Sie auf, dass Sie diesen Fehler nicht machen!

Warnung

Beim Exportieren eines GLES2-Projekts nach HTML5 wird WebGL 1.0 verwendet. WebGL 1.0 unterstützt keine dynamischen Schleifen, daher funktionieren dort keine Shader, die diese verwenden.

Verwerfen

Fragment- und Beleuchtungsfunktionen können das Schlüsselwort discard verwenden. Bei Verwendung wird das Fragment verworfen und nichts geschrieben.

Funktionen

Es ist möglich, Funktionen in einem Godot-Shader zu definieren. Sie verwenden die folgende Syntax:

ret_type func_name(args) {
    return ret_type; // if returning a value
}

// a more specific example:

int sum2(int a, int b) {
    return a + b;
}

Sie können nur Funktionen verwenden, die oben (höher im Editor) definiert wurden, als die Funktion von der aus Sie sie aufrufen.

Funktionsargumente können spezielle Kennzeichnungsmerkmale haben:

  • in: bedeutet dass Argument kann nur gelesen werden (Standard).
  • out: bedeutet dass Argument kann nur geschrieben werden.
  • inout: bedeutet dass Argument wird komplett als Referenz übergeben.

Hier ein Beispiel:

void sum2(int a, int b, inout int result) {
    result = a + b;
}

Variiert

Um Daten vom Vertex an die Fragment-Prozessorfunktion zu senden, werden Variationen verwendet. Sie werden für jeden einfachen Vertex im Vertex-Prozessor festgelegt und der Wert wird für jedes Pixel im Fragment-Prozessor interpoliert.

shader_type spatial;

varying vec3 some_color;
void vertex() {
    some_color = NORMAL; // Make the normal the color.
}

void fragment() {
    ALBEDO = some_color;
}

Eine Variation kann auch ein Array sein:

shader_type spatial;

varying float var_arr[3];
void vertex() {
    var_arr[0] = 1.0;
    var_arr[1] = 0.0;
}

void fragment() {
    ALBEDO = vec3(var_arr[0], var_arr[1], var_arr[2]); // red color
}

Interpolations-Kennzeichnungsmerkmale

Bestimmte Werte werden während der Shading-Pipeline interpoliert. Sie können die Ausführung dieser Interpolationen mithilfe von Interpolationsqualifizierern ändern.

shader_type spatial;

varying flat vec3 our_color;

void vertex() {
    our_color = COLOR.rgb;
}

void fragment() {
    ALBEDO = our_color;
}

Es gibt zwei mögliche Interpolations-Kennzeichnungsmerkmale:

Merkmal Beschreibung
flat Der Wert ist nicht interpoliert.
smooth Der Wert ist interpoliert in einer perspektivisch korrekten Art. Dies ist der Standard.

Uniforms

Das Übergeben von Werten an Shader ist möglich. Diese sind für den gesamten Shader global und werden als Uniforms bezeichnet. Wenn ein Shader später einem Material zugewiesen wird, werden die Uniforms als bearbeitbare Parameter darin angezeigt. Uniforms können nicht aus dem Shader heraus geschrieben werden.

shader_type spatial;

uniform float some_value;

Sie können Uniforms im Editor im Material festlegen. Oder Sie können sie über GDScript erstellen:

material.set_shader_param("some_value", some_value)

Bemerkung

Das erste Argument für set_shader_param ist der Name des Uniform im Shader. Es muss genau mit dem Namen des Uniform im Shader übereinstimmen, sonst wird es nicht erkannt.

Jeder GLSL-Typ außer void kann ein Uniform sein. Darüber hinaus bietet Godot optionale Shader-Hinweise, damit der Compiler versteht welche Uniform verwendet wird.

shader_type spatial;

uniform vec4 color : hint_color;
uniform float amount : hint_range(0, 1);
uniform vec4 other_color : hint_color = vec4(1.0);

Es ist wichtig zu verstehen, dass Texturen die als Farbe geliefert werden, Hinweise für eine ordnungsgemäße sRGB-> lineare Konvertierung erfordern (z.B. hint_albedo), da die 3D-Engine von Godot im linearen Farbraum gerendert wird.

Hier eine komplette Liste von Hinweisen:

Art Hinweis Beschreibung
vec4 hint_color genutzt als Farbe
int, float hint_range(min, max[, step]) genutzt als Bereich (mit Min/Max/Schritt)
sampler2D hint_albedo genutzt als Albedofarbe, Standard ist weiß
sampler2D hint_black_albedo genutzt als Albedofarbe, Standard ist schwarz
sampler2D hint_normal Als NormalMap verwenden
sampler2D hint_white als Wert, Standard ist weiß
sampler2D hint_black als Wert, Standard ist schwarz
sampler2D hint_aniso Als FlowMap, standardmäßig nach rechts.

GDScript verwendet andere Variablentypen als GLSL. Wenn Sie also Variablen von GDScript an Shader übergeben, konvertiert Godot den Typ automatisch. Unten finden Sie eine Tabelle der entsprechenden Typen:

GDScript-Typ GLSL Typ
bool bool
int int
float float
Vector2 vec2
Vector3 vec3
Color vec4
Transform mat4
Transform2D mat4

Bemerkung

Seien Sie vorsichtig, wenn Sie Shader-Uniforms aus GDScript festlegen. Wenn der Typ nicht übereinstimmt wird kein Fehler ausgegeben. Ihr Shader zeigt nur undefiniertes Verhalten.

Uniforms können auch Standardwerte zugewiesen werden:

shader_type spatial;

uniform vec4 some_vector = vec4(0.0);
uniform vec4 some_color : hint_color = vec4(1.0);

Eingebaute Funktionen

Es wird eine große Anzahl integrierter Funktionen unterstützt, die GLSL ES 3.0 entsprechen. Wenn die Nomenklatur vec_type (float), vec_int_type, vec_uint_type, vec_bool_type verwendet wird, kann sie ein Skalar oder Vektor sein.

Bemerkung

Eine Liste der Funktionen, die im GLES2-Backend nicht verfügbar sind, finden Sie im Unterschiede zwischen GLES2- und GLES3-Dokument.

Funktion Beschreibung
vec_type radians (vec_type degrees) konvertiert Grad nach Radiant
vec_type degrees (vec_type radians) konvertiert Radiant nach Grad
vec_type sin (vec_type x) Sinus
vec_type cos (vec_type x) Kosinus
vec_type tan (vec_type x) Tangens
vec_type asin (vec_type x) Arkussinus
vec_type acos (vec_type x) Arkuskosinus
vec_type atan (vec_type y_over_x) Arkustangens
vec_type atan (vec_type y, vec_type x) Arkustangens um einen Vektor in einem Winkel zu konvertieren
vec_type sinh (vec_type x) Hyperbolischer Sinus
vec_type cosh (vec_type x) Hyperbolischer Kosinus
vec_type tanh (vec_type x) Hyperbolischer Tangens
vec_type asinh (vec_type x) Inverser Hyperbolischer Sinus
vec_type acosh (vec_type x) Inverser Hyperbolischer Kosinus
vec_type atanh (vec_type x) Inverser Hyperbolischer Tangens
vec_type pow (vec_type x, vec_type y) Potenz (undefiniert falls x < 0 oder falls x = 0 und y <= 0)
vec_type exp (vec_type x) Basis-e exponentiell
vec_type exp2 (vec_type x) Basis-2 exponentiell
vec_type log (vec_type x) natürlicher Logarithmus
vec_type log2 (vec_type x) Basis-2 Logarithmus
vec_type sqrt (vec_type x) Quadratwurzel
vec_type inversesqrt (vec_type x) inverse Quadratwurzel
vec_type abs (vec_type x) Absolut
ivec_type abs (ivec_type x) Absolut
vec_type sign (vec_type x) Vorzeichen
ivec_type sign (ivec_type x) Vorzeichen
vec_type floor (vec_type x) Abrundungsfunktion (Gauß-Klammer)
vec_type round (vec_type x) runden
vec_type roundEven (vec_type x) runden auf die nächste gerade Zahl
vec_type trunc (vec_type x) kürzen
vec_type ceil (vec_type x) Aufrundungsfunktion
vec_type fract (vec_type x) Bruchteil
vec_type mod (vec_type x, vec_type y) Rest
vec_type mod (vec_type x , float y) Rest
vec_type modf (vec_type x, out vec_type i) Bruch von x, mit i als Ganzzahl-Teil
vec_type min (vec_type a, vec_type b) Minimum
vec_type max (vec_type a, vec_type b) Maximum
vec_type clamp (vec_type x, vec_type min, vec_type max) Beschränken auf min..max
float mix (float a, float b, float c) Lineare Interpolation
vec_type mix (vec_type a, vec_type b, float c) lineare Interpolation (Skalar Koeffizient)
vec_type mix (vec_type a, vec_type b, vec_type c) Lineare Interpolation (Vector Koeffizient)
vec_type mix (vec_type a, vec_type b, bvec_type c) Lineare Interpolation (Boolesche-Vector Selektion)
vec_type step (vec_type a, vec_type b) b[i] < a[i] ? 0.0 : 1.0
vec_type step (float a, vec_type b) b[i] < a ? 0.0 : 1.0
vec_type smoothstep (vec_type a, vec_type b, vec_type c) Hermiteinterpolation
vec_type smoothstep (float a, float b, vec_type c) Hermiteinterpolation
bvec_type isnan (vec_type x) Liefert true wenn die Skalar oder Vektor-Komponente NaN ist
bvec_type isinf (vec_type x) Liefert true wenn die Skalar oder Vektor-Komponente INF ist
ivec_type floatBitsToInt (vec_type x) Fließkomma->Ganzzahl - Bitweise-Kopieren, keine Konvertierung
uvec_type floatBitsToUint (vec_type x) Fließkomma->vorzeichenlose Ganzzahl - Bitweise-Kopieren, keine Konvertierung
vec_type intBitsToFloat (ivec_type x) Ganzzahl->Fließkomma - Bitweise-Kopieren, keine Konvertierung
vec_type uintBitsToFloat (uvec_type x) vorzeichenlose Ganzzahl->Fließkomma - Bitweise-Kopieren, keine Konvertierung
float length (vec_type x) Vektorlänge
float distance (vec_type a, vec_type b) Abstand zwischen Vektoren, also length(a - b)
float dot (vec_type a, vec_type b) Skalarprodukt (Punktprodukt)
vec3 cross (vec3 a, vec3 b) Kreuzprodukt
vec_type normalize (vec_type x) normalisieren auf die Einheitslänge
vec3 reflect (vec3 I, vec3 N) Reflektieren
vec3 refract (vec3 I, vec3 N, float eta) Ablenken
vec_type faceforward (vec_type N, vec_type I, vec_type Nref) Falls dot(Nref, I) < 0, liefere N zurück, ansonsten –N
mat_type matrixCompMult (mat_type x, mat_type y) Matrizenmultiplikation
mat_type outerProduct (vec_type column, vec_type row) Matrix outer product
mat_type transpose (mat_type m) Transpose matrix
float determinant (mat_type m) Matrix determinant
mat_type inverse (mat_type m) Matrix invertieren
bvec_type lessThan (vec_type x, vec_type y) Boolescher-Vektorvergleich für < int/uint/float-Vektoren
bvec_type greaterThan (vec_type x, vec_type y) Boolescher-Vektorvergleich für > int/uint/float-Vektoren
bvec_type lessThanEqual (vec_type x, vec_type y) Boolescher-Vektorvergleich für <= int/uint/float-Vektoren
bvec_type greaterThanEqual (vec_type x, vec_type y) Boolescher-Vektorvergleich für >= int/uint/float-Vektoren
bvec_type equal (vec_type x, vec_type y) Boolescher-Vektorvergleich für == int/uint/float-Vektoren
bvec_type notEqual (vec_type x, vec_type y) Boolescher-Vektorvergleich für != int/uint/float-Vektoren
bool any (bvec_type x) Irgendeine Komponente ist true
bool all (bvec_type x) Alle Komponenten sind true
bvec_type not (bvec_type x) Booleschen Vektor invertieren
ivec2 textureSize (sampler2D_type s, int lod) Größe einer 2D Textur holen
ivec3 textureSize (sampler2DArray_type s, int lod) Größe eines 2D-Textur-Arrays ermitteln
ivec3 textureSize (sampler3D s, int lod) Größe einer 3D-Textur ermitteln
ivec2 textureSize (samplerCube s, int lod) Größe einer CubeMap-Textur ermitteln
vec4_type texture (sampler2D_type s, vec2 uv [, float bias]) 2D-Texturlesung durchführen
vec4_type texture (sampler2DArray_type s, vec3 uv [, float bias]) 2D-Textur-Arraylesung durchführen
vec4_type texture (sampler3D_type s, vec3 uv [, float bias]) Liest eine 3D Textur ein
vec4 texture (samplerCube s, vec3 uv [, float bias]) CubeMap-Texturlesung durchführen
vec4_type textureProj (sampler2D_type s, vec3 uv [, float bias]) 2D-Texturlesung mit Projektion durchführen
vec4_type textureProj (sampler2D_type s, vec4 uv [, float bias]) 2D-Texturlesung mit Projektion durchführen
vec4_type textureProj (sampler3D_type s, vec4 uv [, float bias]) 3D-Texturlesung mit Projektion durchführen
vec4_type textureLod (sampler2D_type s, vec2 uv, float lod) 2D-Texturlesung in einer benutzerdefinierten MipMap durchführen
vec4_type textureLod (sampler2DArray_type s, vec3 uv, float lod) 2D-Textur-Arraylesung in einer benutzerdefinierten MipMap durchführen
vec4_type textureLod (sampler3D_type s, vec3 uv, float lod) Liest eine 3D Textur aus einer benutzerdefinierten Mipmap
vec4 textureLod (samplerCube s, vec3 uv, float lod) Liest eine 3D Textur aus einer benutzerdefinierten Mipmap
vec4_type textureProjLod (sampler2D_type s, vec3 uv, float lod) Liest eine 2D Textur mit Projektion/LOD
vec4_type textureProjLod (sampler2D_type s, vec4 uv, float lod) Liest eine 2D Textur mit Projektion/LOD
vec4_type textureProjLod (sampler3D_type s, vec4 uv, float lod) Liest eine 3D Textur mit Projektion/LOD
vec4_type texelFetch (sampler2D_type s, ivec2 uv, int lod) Ein einzelnes Texel mit ganzzahligen Koordinaten ermitteln
vec4_type texelFetch (sampler2DArray_type s, ivec3 uv, int lod) Ein einzelnes Texel mit ganzzahligen Koordinaten ermitteln
vec4_type texelFetch (sampler3D_type s, ivec3 uv, int lod) Ein einzelnes Texel mit ganzzahligen Koordinaten ermitteln
vec_type dFdx (vec_type p) Derivative in x using local differencing
vec_type dFdy (vec_type p) Derivative in y using local differencing
vec_type fwidth (vec_type p) Sum of absolute derivative in x and y