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

Die Konstruktion von Vektortypen muss immer bestehen aus:

// 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 (Elemente eines Vektors neu anordnen)

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; // "b" will be vec3(2.0, 1.0, 0.0).
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. "b"'s "blue" component will be "a"'s "red" and vice versa.

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.

Einige Architekturen (hauptsächlich mobile) können stark davon profitieren, aber es gibt auch Nachteile, beispielsweise den Mehraufwand zur Konvertierung zwischen Werten unterschiedlicher Genauigkeit. Bitte lesen Sie die entsprechende Dokumentation zur Zielarchitektur, um mehr zu erfahren. In vielen Fällen verursachen mobile Treiber inkonsistentes oder unerwartetes Verhalten. Es ist deshalb am besten, keine Präzision anzugeben, wenn es nicht unbedingt erforderlich ist.

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);

Ähnlich wie Variablen können Arrays auch mit const deklariert werden.

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);

Built-in variables

A large number of built-in variables are available, like UV, COLOR and VERTEX. What variables are available depends on the type of shader (spatial, canvas_item or particle) and the function used (vertex, fragment or light). For a list of the build-in variables that are available, please see the corresponding pages:

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-Außenprodukt

mat_type transpose (mat_type m)

Matrix transponieren

float determinant (mat_type m)

Matrix-Determinante

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)

Ableitung in x unter Verwendung lokaler Differenzierung

vec_type dFdy (vec_type p)

Ableitung in y unter Verwendung lokaler Differenzierung

vec_type fwidth (vec_type p)

Summe der absoluten Ableitung in x und y