Up to date

This page is up to date for Godot 4.2. If you still find outdated information, please open an issue.

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 die Godot-Shader-Migrationsanleitung eine Ressource, die Ihnen beim Übergang von regulärem GLSL zu Godots Shader-Sprache helfen wird.

Datentypen¶

Die meisten GLSL ES 3.0-Datentypen werden unterstützt:

Typ	Beschreibung
void	Void Datentyp, nur nützlich für Funktionen die nichts zurückliefern.
bool	Boolescher Datentyp, kann nur `true` oder `false` enthalten.
bvec2	Zwei-Komponenten-Vektor von Bools.
bvec3	Drei-Komponenten-Vektor mit Bools.
bvec4	Vier-Komponenten-Vektor mit Bools.
int	Signed skalarer Integer.
ivec2	Zwei-Komponenten-Vektor mit Signed Integern.
ivec3	Drei-Komponenten-Vektor mit Signed Integern.
ivec4	Vier-Komponenten-Vektor mit Signed Integern.
uint	Unsigned Skalarer Integer, kann keine negativen Zahlen enthalten.
uvec2	Zwei-Komponenten-Vektor mit Unsigned Integern.
uvec3	Drei-Komponenten-Vektor mit Unsigned Integern.
uvec4	Vier-Komponenten-Vektor mit Unsigned Integern.
float	Float-Skalar.
vec2	Zwei-Komponenten-Vektor mit Float-Werten.
vec3	Drei-Komponenten-Vektor mit Float-Werten.
vec4	Vier-Komponenten-Vektor mit Float-Werten.
mat2	2x2 Matrix, in spaltenweiser Anordnung.
mat3	3x3 Matrix, in spaltenweiser Anordnung.
mat4	4x4 Matrix, in spaltenweiser Anordnung.
sampler2D	Samplertyp, um 2D Texturen zu binden, welche als Float gelesen werden.
isampler2D	Samplertyp, um 2D Texturen zu binden, welche als Signed Integer gelesen werden.
usampler2D	Samplertyp, um 2D Texturen zu binden, welche als Unsigned Integer gelesen werden.
sampler2DArray	Samplertyp, um 2D Texturfelder zu binden, welche als Float gelesen werden.
isampler2DArray	Samplertyp, um 2D Textur-Arrays zu binden, welche als Signed Integer gelesen werden.
usampler2DArray	Samplertyp, um 2D Textur-Arrays zu binden, welche als Unsigned Integer gelesen werden.
sampler3D	Samplertyp, um 3D-Texturen zu binden, welche als Float gelesen werden.
isampler3D	Samplertyp, um 3D-Texturen zu binden, welche als Signed Integer gelesen werden.
usampler3D	Samplertyp, um 3D-Texturen zu binden, welche als Unsigned Integer gelesen werden.
samplerCube	Samplertyp um Cubemaps zu binden, welche als Float gelesen werden.
samplerCubeArray	Samplertyp um Cubemap-Arrays zu binden, welche als Float gelesen werden.

Casting¶

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

Default-Integer-Konstanten sind signed, daher ist immer eine Umwandlung erforderlich, um in unsigned zu konvertieren:

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

Member¶

Auf einzelne skalare Elemente von Vektortypen wird über die Elemente "x", "y", "z" und "w" zugegriffen. Alternativ dazu funktioniert auch die Verwendung von "r", "g", "b" und "a" und ist gleichwertig. Verwenden Sie, was für Ihre Bedürfnisse am besten geeignet ist.

Für Matrizen verwenden Sie die m[Spalte][Zeile] Indizierungssyntax, um auf jeden Skalar zuzugreifen, oder m[idx], um auf einen Vektor nach Zeilenindex zuzugreifen. Um zum Beispiel auf die y-Position eines Objekts in einer mat4 zuzugreifen, verwenden Sie 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);

Die Konstruktion von Matrixtypen erfordert Vektoren der gleichen Dimension wie die Matrix. Sie können auch eine Diagonalmatrix mit der Syntax matx(float) konstruieren. Dementsprechend ist mat4(1.0) eine Einheitsmatrix.

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

Matrizen können auch aus einer Matrix einer anderen Dimension gebildet werden. Es gibt zwei Regeln:

1. 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. 2. If a smaller matrix is constructed from a larger matrix, the top, left submatrix of the larger matrix is used.

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

Swizzling¶

Es ist möglich, eine beliebige Kombination von Komponenten in beliebiger Reihenfolge zu erhalten, solange das Ergebnis ein anderer Vektortyp (oder Skalar) ist. Dies ist einfacher zu zeigen als zu erklären:

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 Varyings:

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 Präzision für einige Operationen kann den Berechnung beschleunigen (auf Kosten einer geringeren Präzision). 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 Präzision. 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¶

Arrays sind Container für mehrere Variablen eines ähnlichen Typs.

Lokale Arrays¶

Lokale Arrays werden in Funktionen deklariert. Sie können alle erlaubten Datentypen verwenden, mit Ausnahme von Samplern. Die Array-Deklaration folgt einer C-ähnlichen Syntax: [const] + [Präzision] + Typname + Bezeichner + [Arraygröße].

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 haben auch eine Built-in-Funktion .length() (nicht zu verwechseln mit der Built-in-Funktion length()). Sie akzeptiert keine Parameter und gibt die Größe des Arrays zurück.

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

Bemerkung

Wenn Sie einen Index verwenden, der entweder kleiner als 0 oder größer als die Array-Größe ist, stürzt der Shader ab und bricht das Rendern ab. Um dies zu verhindern, verwenden Sie die Funktionen length(), if oder clamp(), um sicherzustellen, dass der Index zwischen 0 und der Länge des Arrays liegt. Testen und prüfen Sie Ihren Code immer sorgfältig. Wenn Sie einen konstanten Ausdruck oder eine Zahl übergeben, prüft der Editor deren Grenzen, um diesen Absturz zu verhindern.

Globale Arrays¶

Sie können Arrays auf globaler Ebene wie folgt deklarieren:

shader_type spatial;

const lowp vec3 v[1] = lowp vec3[1] ( vec3(0, 0, 1) );

void fragment() {
  ALBEDO = v[0];
}

Bemerkung

Globale Arrays müssen als globale Konstanten deklariert werden, andernfalls können sie genauso deklariert werden wie lokale Arrays.

Konstanten¶

Verwenden Sie das Schlüsselwort const vor der Variablendeklaration, um diese Variable immutable zu machen, was bedeutet, dass sie nicht verändert werden kann. Alle Grundtypen, außer Sampler, können als Konstanten deklariert werden. Der Zugriff und die Verwendung eines konstanten Wertes ist etwas schneller als die Verwendung einer Uniform. Konstanten müssen bei ihrer Deklaration initialisiert werden.

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

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

Konstanten können nicht verändert werden und können auch keine Hints haben, aber mehrere von ihnen (wenn sie den gleichen Typ haben) können in einem einzigen Ausdruck deklariert werden, z.B

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

Konstanten können sowohl global (außerhalb einer Funktion) als auch lokal (innerhalb einer Funktion) deklariert werden. Globale Konstanten sind nützlich, wenn Sie im gesamten Shader Zugriff auf einen Wert haben möchten, der nicht geändert werden muss. Wie Uniforms werden globale Konstanten von allen Shader-Stufen gemeinsam genutzt, aber sie sind außerhalb des Shaders nicht zugänglich.

shader_type spatial;

const float PI = 3.14159265358979323846;

Konstanten vom Typ float müssen mit der Notation . nach dem Dezimalteil oder mit der wissenschaftlichen Notation initialisiert werden. Das optionale Post-Suffix f wird ebenfalls unterstützt.

float a = 1.0;
float b = 1.0f; // same, using suffix for clarity
float c = 1e-1; // gives 0.1 by using the scientific notation

Konstanten vom Typ uint (unsigned int) müssen mit dem Suffix u versehen werden, um sie von Signed Integern zu unterscheiden. Alternativ kann dies durch die Built-in-Konvertierungsfunktion uint(x) geschehen.

uint a = 1u;
uint b = uint(1);

Structs¶

Structs sind zusammengesetzte Typen, die für eine bessere Abstraktion des Shader-Codes verwendet werden können. Sie können auf globaler Ebene so deklariert werden:

struct PointLight {
    vec3 position;
    vec3 color;
    float intensity;
};

Nach der Deklaration können Sie sie wie folgt instanziieren und initialisieren:

void fragment()
{
    PointLight light;
    light.position = vec3(0.0);
    light.color = vec3(1.0, 0.0, 0.0);
    light.intensity = 0.5;
}

Oder verwenden Sie den Struct-Konstruktor für denselben Zweck:

PointLight light = PointLight(vec3(0.0), vec3(1.0, 0.0, 0.0), 0.5);

Strukturen können andere Strukturen oder Arrays enthalten, Sie können sie auch als globale Konstante instanziieren:

shader_type spatial;

...

struct Scene {
    PointLight lights[2];
};

const Scene scene = Scene(PointLight[2](PointLight(vec3(0.0, 0.0, 0.0), vec3(1.0, 0.0, 0.0), 1.0), PointLight(vec3(0.0, 0.0, 0.0), vec3(1.0, 0.0, 0.0), 1.0)));

void fragment()
{
    ALBEDO = scene.lights[0].color;
}

Sie können sie auch an Funktionen übergeben:

shader_type canvas_item;

...

Scene construct_scene(PointLight light1, PointLight light2) {
    return Scene({light1, light2});
}

void fragment()
{
    COLOR.rgb = construct_scene(PointLight(vec3(0.0, 0.0, 0.0), vec3(1.0, 0.0, 0.0), 1.0), PointLight(vec3(0.0, 0.0, 0.0), vec3(1.0, 0.0, 1.0), 1.0)).lights[0].color;
}

Operatoren¶

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

Rang	Klasse	Operator
1 (höchste)	Gruppierung in Klammern	()
2	unär	+, -, !, ~
3	multiplikativ	*/, , %**
4	additiv	+, -
5	bitweiser Shift	<<, >>
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¶

Die Godot Shadersprache unterstützt die gebräuchlichsten Arten von Flußkontrolle:

// `if` and `else`.
if (cond) {

} else {

}

// Ternary operator.
// This is an expression that behaves like `if`/`else` and returns the value.
// If `cond` evaluates to `true`, `result` will be `9`.
// Otherwise, `result` will be `5`.
int result = cond ? 9 : 5;

// `switch`.
switch (i) { // `i` should be a signed integer expression.
    case -1:
        break;
    case 0:
        return; // `break` or `return` to avoid running the next `case`.
    case 1: // Fallthrough (no `break` or `return`): will run the next `case`.
    case 2:
        break;
    //...
    default: // Only run if no `case` above matches. Optional.
        break;
}

// `for` loop. Best used when the number of elements to iterate on
// is known in advance.
for (int i = 0; i < 10; i++) {

}

// `while` loop. Best used when the number of elements to iterate on
// is not known in advance.
while (cond) {

}

// `do while`. Like `while`, but always runs at least once even if `cond`
// never evaluates to `true`.
do {

} while (cond);

Denken Sie daran, dass bei modernen GPUs eine Endlosschleife existieren kann, die Ihre Anwendung (einschließlich des Editors) einfrieren kann. Godot kann Sie davor nicht schützen. Seien Sie also vorsichtig, um diesen Fehler zu vermeiden!

Wenn Sie Float-Werte mit einer Zahl vergleichen, achten Sie außerdem darauf, dass Sie sie mit einem Bereich und nicht mit einer genauen Zahl vergleichen.

Ein Vergleich wie if (Wert == 0.3) kann nicht zu true ausgewertet werden. Float-Mathematik ist oft annähernd und kann sich den Erwartungen entziehen. Sie kann sich auch je nach Hardware unterschiedlich verhalten.

Tun Sie das nicht.

float value = 0.1 + 0.2;

// May not evaluate to `true`!
if (value == 0.3) {
    // ...
}

Führen Sie stattdessen immer einen Bereichsvergleich mit einem Epsilonwert durch. Je größer die Float-Zahl (und je ungenauer die Float-Zahl), desto größer sollte der Epsilon-Wert sein.

const float EPSILON = 0.0001;
if (value >= 0.3 - EPSILON && value <= 0.3 + EPSILON) {
    // ...
}

Siehe Floating-point-gui.de für weitere Informationen.

Verwerfen¶

Fragment- und Licht-Funktionen können das Schlüsselwort discard verwenden. Wenn es verwendet wird, wird das Fragment verworfen und es wird nichts geschrieben.

Beachten Sie, daß die Verwendung von discard Performance kostet, da sie verhindert, daß der Tiefen-Vordurchlauf auf allen Oberflächen, die den Shader benutzen, wirksam wird. Außerdem muss ein verworfenes Pixel immer noch im Vertex-Shader gerendert werden, was bedeutet, dass ein Shader, der discard auf alle seine Pixel anwendet, immer noch teurer zu rendern ist, als wenn gar kein Objekt gerendert wird.

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 über der Funktion, von der aus Sie sie aufrufen, definiert wurden (höher im Editor). Die Neudefinition einer Funktion, die bereits oben definiert wurde (oder ein Built-in-Funktionsname ist), führt zu einem Fehler.

Funktionsargumente können spezielle Qualifier haben:

in: bedeutet, dass das Argument nur gelesen werden kann (Default).
out: bedeutet, dass das Argument nur geschrieben werden kann.
inout: bedeutet, dass das Argument komplett als Referenz übergeben wird.
const: Bedeutet, dass das Argument eine Konstante ist und nicht geändert werden kann; kann mit dem Qualifizierer in kombiniert werden.

Hier ein Beispiel:

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

Bemerkung

Im Gegensatz zu GLSL unterstützt die Shader-Sprache von Godot keine Funktionsüberladung. Dies bedeutet, dass eine Funktion nicht mehrmals mit unterschiedlichen Argumenttypen oder einer unterschiedlichen Anzahl von Argumenten definiert werden kann. Als Abhilfe können Sie unterschiedliche Namen für Funktionen verwenden, die eine unterschiedliche Anzahl von Argumenten oder Argumente unterschiedlichen Typs akzeptieren.

Varyings¶

Um Daten vom Vertex an die Fragment- (oder Licht-) Prozessorfunktion zu senden, werden Varyings verwendet. Sie werden für jeden primitiven Vertex im Vertex-Prozessor gesetzt, 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;
}

void light() {
    DIFFUSE_LIGHT = some_color * 100; // optionally
}

Ein Varying 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
}

Es ist auch möglich, mit dem Schlüsselwort varying Daten vom Fragment an Licht-Prozessoren zu senden. Dazu können Sie es im Fragment zuweisen und später in der Licht-Funktion verwenden.

shader_type spatial;

varying vec3 some_light;

void fragment() {
    some_light = ALBEDO * 100.0; // Make a shining light.
}

void light() {
    DIFFUSE_LIGHT = some_light;
}

Beachten Sie, dass Varyings nicht in benutzerdefinierten Funktionen oder einer Licht-Prozessor-Funktion zugewiesen werden können, wie:

shader_type spatial;

varying float test;

void foo() {
    test = 0.0; // Error.
}

void vertex() {
    test = 0.0;
}

void light() {
    test = 0.0; // Error too.
}

Diese Einschränkung wurde eingeführt, um eine falsche Verwendung vor der Initialisierung zu verhindern.

Interpolations-Qualifier¶

Bestimmte Werte werden während der Shading-Pipeline interpoliert. Sie können die Ausführung dieser Interpolationen mithilfe von Interpolations-Qualifiern ä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-Qualifier:

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

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;

uniform vec3 colors[3];

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

material.set_shader_parameter("some_value", some_value)

material.set_shader_parameter("colors", [Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1)])

Bemerkung

Das erste Argument von set_shader_parameter ist der Name des Uniforms im Shader. Es muss exakt mit dem Namen des Uniforms im Shader übereinstimmen, sonst wird es nicht erkannt.

Jeder GLSL-Typ mit Ausnahme von void kann ein Uniform sein. Zusätzlich bietet Godot optionale Shader-Hints, damit der Compiler versteht, wofür der Uniform verwendet wird und wie der Editor es dem Benutzer erlauben soll, ihn zu ändern.

shader_type spatial;

uniform vec4 color : source_color;
uniform float amount : hint_range(0, 1);
uniform vec4 other_color : source_color = vec4(1.0); // Default values go after the hint.
uniform sampler2D image : source_color;

Es ist wichtig zu verstehen, dass Texturen, die als Farbe bereitgestellt werden, Hinweise für eine korrekte sRGB -> lineare Konvertierung (d.h. source_color) benötigen, da Godots 3D-Engine im linearen Farbraum rendert. Wenn dies nicht geschieht, erscheint die Textur ausgewaschen.

Bemerkung

Der 2D-Renderer rendert auch im linearen Farbraum, wenn die Projekteinstellung Rendering > Viewport > HDR 2D aktiviert ist, also muss source_color auch in canvas_item-Shadern verwendet werden. Wenn 2D HDR deaktiviert ist, wird source_color weiterhin korrekt in canvas_item-Shadern funktionieren, daher ist es empfehlenswert, es auf jeden Fall zu verwenden.

Hier eine komplette Liste von Hints:

Typ	Hint	Beschreibung
vec3, vec4	source_color	Verwendet als Farbe.
int, float	hint_range(min, max[, step])	Beschränkt auf Werte in einem Bereich (mit Min/Max/Schrittweite).
sampler2D	source_color	Verwendet als Albedofarbe.
sampler2D	hint_normal	Verwendet als Normal Map.
sampler2D	hint_default_white	Verwendet als Albedofarbe, Default ist undurchsichtig weiß.
sampler2D	hint_default_black	Verwendet als Albedofarbe, Default ist undurchsichtig schwarz.
sampler2D	hint_default_transparent	Verwendet als Albedofarbe, Default ist transparent schwarz.
sampler2D	hint_anisotropy	Verwendet als Flow Map, Default nach rechts.
sampler2D	hint_roughness[_r, _g, _b, _a, _normal, _gray]	Verwendet als Rauheitsbegrenzer beim Import (versucht, Specular Aliasing zu reduzieren). `_normal` ist eine Normal Map, die den Rauhigkeitsbegrenzer steuert, wobei die Rauhigkeit in Bereichen mit hochfrequenten Details zunimmt.
sampler2D	filter[_nearest, _linear][_mipmap][_anisotropic]	Aktiviert die angegebene Texturfilterung.
sampler2D	repeat[_enable, _disable]	Aktiviert die Texturwiederholung.
sampler2D	hint_screen_texture	Textur ist die Bildschirms-Textur.
sampler2D	hint_depth_texture	Textur ist die Tiefentextur.
sampler2D	hint_normal_roughness_texture	Textur ist die normale Rauheitstextur (nur in Forward+ unterstützt).

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:

GLSL-Typ	GDScript-Typ	Anmerkungen
bool	bool
bvec2	int	Bitweise gepackter int, wobei Bit 0 (LSB) dem Wert x entspricht. Ein bvec2 von (bx, by) könnte zum Beispiel folgendermaßen erstellt werden: bvec2_input: int = (int(bx)) \| (int(by) << 1)
bvec3	int	Bitweise gepackter int, wobei Bit 0 (LSB) dem Wert x entspricht.
bvec4	int	Bitweise gepackter int, wobei Bit 0 (LSB) dem Wert x entspricht.
int	int
ivec2	Vector2i
ivec3	Vector3i
ivec4	Vector4i
uint	int
uvec2	Vector2i
uvec3	Vector3i
uvec4	Vector4i
float	float
vec2	Vector2
vec3	Vector3, Color	Wenn Farbe verwendet wird, wird sie als (r, g, b) interpretiert.
vec4	Vector4, Color, Rect2, Plane, Quaternion	Wenn Farbe verwendet wird, wird sie als (r, g, b, a) interpretiert. Wenn Rect2 verwendet wird, wird es als (position.x, position.y, size.x, size.y) interpretiert. Wenn Plane verwendet wird, wird es als (normal.x, normal.y, normal.z, d) interpretiert.
mat2	Transform2D
mat3	Basis
mat4 mat4	Projection, Transform3D	Wenn ein Transform3D verwendet wird, wird der w-Vektor auf den Einheitsvektor gesetzt.
sampler2D	Texture2D
isampler2D	Texture2D
usampler2D	Texture2D
sampler2DArray	Texture2DArray
isampler2DArray	Texture2DArray
usampler2DArray	Texture2DArray
sampler3D	Texture3D
isampler3D	Texture3D
usampler3D	Texture3D
samplerCube	Cubemap
samplerCubeArray	CubemapArray

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 Default-Werte zugewiesen werden:

shader_type spatial;

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

Beachten Sie, dass beim Hinzufügen eines Default-Wertes und eines Hints der Defaultwert nach dem Hint kommt.

Wenn Sie mehrere Uniforms in einer bestimmten Kategorie eines Inspektors zusammenfassen möchten, können Sie das Schlüsselwort group_uniform verwenden:

group_uniforms MyGroup;
uniform sampler2D test;

Sie können die Gruppe so schließen:

group_uniforms;

Die Syntax unterstützt auch Untergruppen (es ist nicht zwingend erforderlich, die Basisgruppe vorher zu deklarieren):

group_uniforms MyGroup.MySubgroup;

Globale Uniforms¶

Manchmal möchte man einen Parameter in vielen verschiedenen Shadern auf einmal ändern. Mit einem regulären Uniform erfordert dies eine Menge Arbeit, da all diese Shader getrackt werden müssen und das Uniform für jeden von ihnen eingestellt werden muss. Globale Uniforms erlauben es Ihnen, Uniforms zu erstellen und zu aktualisieren, die in allen Shadern, in jedem Shadertyp (canvas_item, spatial, particles, sky und fog) verfügbar sind.

Globale Uniforms sind besonders nützlich für Umgebungseffekte, die sich auf viele Objekte in einer Szene auswirken, z.B. wenn sich das Laub biegt, wenn der Spieler in der Nähe ist, oder wenn sich Objekte mit dem Wind bewegen.

Um ein globales Uniform zu erstellen, öffnen Sie die Projekteinstellungen und wechseln Sie zum Shader-Globals-Tab. Geben Sie einen Namen für den Uniform (Groß- und Kleinschreibung beachten) und einen Typ an und klicken Sie dann auf Hinzufügen in der oberen rechten Ecke des Dialogs. Sie können dann den dem Uniform zugewiesenen Wert bearbeiten, indem Sie auf den Wert in der Liste der Uniforms klicken:

Hinzufügen eines globalen Uniforms auf dem Shader-Globals-Tab in den Projekteinstellungen¶

Nachdem Sie ein globales Uniform erstellt haben, können Sie es wie folgt in einem Shader verwenden:

shader_type canvas_item;

global uniform vec4 my_color;

void fragment() {
    COLOR = my_color.rgb;
}

Beachten Sie, dass das globale Uniform zum Zeitpunkt des Speicherns des Shaders in den Projekteinstellungen vorhanden sein muss, da sonst die Kompilierung fehlschlägt. Sie können zwar im Shader-Code mit global uniform vec4 my_color = ... einen Default-Wert zuweisen, dieser wird jedoch ignoriert, da das globale Uniform ohnehin immer in den Projekteinstellungen definiert sein muss.

Um den Wert eines globalen Uniforms zur Laufzeit zu ändern, verwenden Sie die Methode RenderingServer.global_shader_parameter_set in einem Skript:

RenderingServer.global_shader_parameter_set("my_color", Color(0.3, 0.6, 1.0))

Die Zuweisung globaler Unform-Werte kann beliebig oft erfolgen, ohne die Performance zu beeinträchtigen, da das Setzen von Daten keine Synchronisierung zwischen CPU und GPU erfordert.

Sie können auch während der Laufzeit globale Uniforms hinzufügen oder entfernen:

RenderingServer.global_shader_parameter_add("my_color", RenderingServer.GLOBAL_VAR_TYPE_COLOR, Color(0.3, 0.6, 1.0))
RenderingServer.global_shader_parameter_remove("my_color")

Das Hinzufügen oder Entfernen von globalen Uniforms zur Laufzeit hat Performance-Einbußen zur Folge, auch wenn diese im Vergleich zum Abrufen globaler Uniformwerte aus einem Skript nicht so ausgeprägt sind (siehe die Warnung unten).

Warnung

Während man den Wert eines globalen Uniforms zur Laufzeit in einem Skript mit RenderingServer.global_shader_parameter_get("uniform_name") abfragen kann, hat dies einen großen Performance-Nachteil, da der Rendering-Thread sich mit dem aufrufenden Thread synchronisieren muss.

Daher ist es nicht empfehlenswert, globale Shader-Uniform-Werte kontinuierlich in einem Skript zu lesen. Wenn Sie Werte in einem Skript lesen müssen, nachdem Sie sie gesetzt haben, sollten Sie ein Autoload erstellen, in dem Sie die Werte, die Sie abfragen müssen, zur gleichen Zeit speichern, in der Sie sie als globale Uniforms setzen.

Pro-Instanz-Uniforms¶

Bemerkung

Pro-Instanz-Uniforms sind nur in spatial (3D) Shadern verfügbar.

Manchmal möchte man einen Parameter an jedem Node mit Hilfe des Materials ändern. Zum Beispiel in einem Wald voller Bäume, wenn Sie wollen, dass jeder Baum eine leicht unterschiedliche Farbe hat, die von Hand bearbeitet werden kann. Ohne instanzspezifische Uniforms muss für jeden Baum ein eigenes Material erstellt werden (jedes mit einem leicht unterschiedlichen Farbton). Dies macht die Materialverwaltung komplexer und hat auch einen Performance-Overhead, da die Szene mehr einzelne Materialinstanzen benötigt. Vertex-Farben könnten auch hier verwendet werden, aber sie würden die Erstellung einzigartiger Kopien des Meshes für jede unterschiedliche Farbe erfordern, was auch einen Performance-Overhead hat.

Pro-Instanz-Uniforms werden für jede GeometryInstance3D statt für jede Materialinstanz festgelegt. Berücksichtigen Sie dies bei der Arbeit mit Meshes, denen mehrere Materialien zugewiesen sind, oder bei MultiMesh-Setups.

shader_type spatial;

// Provide a hint to edit as a color. Optionally, a default value can be provided.
// If no default value is provided, the type's default is used (e.g. opaque black for colors).
instance uniform vec4 my_color : source_color = vec4(1.0, 0.5, 0.0, 1.0);

void fragment() {
    ALBEDO = my_color.rgb;
}

Nachdem Sie den Shader gespeichert haben, können Sie den Wert des Instanzuniforms mit dem Inspektor ändern:

Einstellen des Wertes eines Pro-Instanz-Uniforms im GeometryInstance3D-Abschnitt des Inspektors¶

Per-instance uniform values can also be set at run-time using set_instance_shader_parameter method on a node that inherits from GeometryInstance3D:

$MeshInstance3D.set_instance_shader_parameter("my_color", Color(0.3, 0.6, 1.0))

Bei der Verwendung Pro-Instanz-Uniforms gibt es einige Einschränkungen, die Sie beachten sollten:

Pro-Instanz-Uniforms unterstützen keine Texturen, nur reguläre Skalar- und Vektortypen. Als Workaround können Sie ein Textur-Array als reguläres Uniform übergeben und dann den Index der zu zeichnenden Textur mit einem Pro-Instance-Uniform übergeben.
Es gibt eine praktische Höchstgrenze von 16 Instanz-Uniforms pro Shader.
Wenn Ihr Mesh mehrere Materialien verwendet, haben die Parameter für das erste gefundene Mesh-Material Vorrang vor den nachfolgenden, es sei denn, sie haben denselben Namen, Index und Typ. In diesem Fall werden alle Parameter korrekt berücksichtigt.
Wenn Sie in die oben beschriebene Situation geraten, können Sie Konflikte vermeiden, indem Sie den Index (0-15) des Instanzuniforms mit Hilfe des instance_index-Hints manuell angeben:

instance uniform vec4 my_color : source_color, instance_index(5);

Built-in-Variablen¶

Eine große Anzahl von Built-in-Variablen sind verfügbar, wie UV, COLOR und VERTEX. Welche Variablen verfügbar sind, hängt vom Typ des Shaders (spatial, canvas_item oder particle) und der verwendeten Funktion (vertex, fragment oder light) ab. Eine Liste der Built-in-Variablen, die verfügbar sind, finden Sie auf den entsprechenden Seiten:

Built-in-Funktionen¶

Es wird eine große Anzahl von Built-in-Funktionen wird 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.

Funktion	Beschreibung / Rückgabewert
vec_type radians (vec_type degrees)	Umrechnung von Grad nach Bogenmaß.
vec_type degrees (vec_type radians)	Umrechnung von Bogenmaß in Grad.
vec_type sin (vec_type x)	Sinus.
vec_type cos (vec_type x)	Kosinus.
vec_type tan (vec_type x)	Tangents.
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.
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)	Exponent zur Basis e.
vec_type exp2 (vec_type x)	Exponent zur Basis 2.
vec_type log (vec_type x)	Natürlicher Logarithmus.
vec_type log2 (vec_type x)	Logarithmus zur Basis 2.
vec_type sqrt (vec_type x)	Quadratwurzel.
vec_type inversesqrt (vec_type x)	Inverse Quadratwurzel.
vec_type abs (vec_type x) ivec_type abs (ivec_type x)	Absolutwert (liefert einen positiven Wert zurück, wenn negativ).
vec_type sign (vec_type x) ivec_type sign (ivec_type x)	Vorzeichen (liefert `1.0` wenn positiv, `-1.0` wenn negativ, `0.0` wenn Null).
vec_type floor (vec_type x)	Abrunden auf die nächste ganze Zahl.
vec_type round (vec_type x)	Runden auf die nächste ganze Zahl.
vec_type roundEven (vec_type x)	Runden auf die nächste gerade Zahl.
vec_type trunc (vec_type x)	Abschneiden.
vec_type ceil (vec_type x)	Aufrunden auf die nächste ganze Zahl.
vec_type fract (vec_type x)	Bruchteil (liefert `x - floor(x)` zurück).
vec_type mod (vec_type x, vec_type y) vec_type mod (vec_type x, float y)	Modulo (Rest der Division).
vec_type modf (vec_type x, out vec_type i)	Bruchteil von `x`, mit `i` als ganzzahligem Teil.
vec_type min (vec_type a, vec_type b)	Niedrigster Wert zwischen `a` und `b`.
vec_type max (vec_type a, vec_type b)	Höchster Wert zwischen `a` und `b`.
vec_type clamp (vec_type x, vec_type min, vec_type max)	Clampen von x``zwischen ``min und `max` (einschließlich).
float mix (float a, float b, float c) vec_type mix (vec_type a, vec_type b, float c) vec_type mix (vec_type a, vec_type b, bvec_type c)	Lineare Interpolation zwischen `a` und `b` durch `c`.
vec_type fma (vec_type a, vec_type b, vec_type c)	Führt eine kombinierte Multiplikations-Additions-Operation durch: `(a * b + c)` (schneller als die manuelle Ausführung).
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) vec_type smoothstep (float a, float b, vec_type c)	Hermitische Interpolation zwischen `a` und `b` durch `c`.
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)	Float->Int bitweises Kopieren, keine Konvertierung.
uvec_type floatBitsToUint (vec_type x)	Float->UInt bitweises Kopieren, keine Konvertierung.
vec_type intBitsToFloat (ivec_type x)	Int->Float bitweise Kopieren, keine Konvertierung.
vec_type uintBitsToFloat (uvec_type x)	UInt->Float bitweises 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.
vec3 cross (vec3 a, vec3 b)	Kreuzprodukt.
vec_type normalize (vec_type x)	Normieren auf die Einheitslänge.
vec3 reflect (vec3 I, vec3 N)	Reflektieren.
vec3 refract (vec3 I, vec3 N, float eta)	Brechen.
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)	Multiplikation von Matrixkomponenten.
mat_type outerProduct (vec_type column, vec_type row)	Äußeres Produkt der Matrix.
mat_type transpose (mat_type m)	Transponieren der Matrix.
float determinant (mat_type m)	Matrix-Determinante.
mat_type inverse (mat_type m)	Matrix-Inverse.
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)	`true`, wenn eine Komponente `true` ist, ansonsten `false`.
bool all (bvec_type x)	`true`, wenn alle Komponenten `true` sind, ansonsten `false`.
bvec_type not (bvec_type x)	Booleschen Vektor invertieren.
ivec2 textureSize (gsampler2D s, int lod) ivec3 textureSize (gsampler2DArray s, int lod) ivec3 textureSize (gsampler3D s, int lod) ivec2 textureSize (samplerCube s, int lod) ivec2 textureSize (samplerCubeArray s, int lod)	Ermitteln der Größe einer Textur. Der LOD-Wert bestimmt, welche Mipmap-Ebene verwendet wird. Bei einem LOD-Wert von `0` wird die Textur in voller Auflösung verwendet.
vec2 textureQueryLod (gsampler2D s, vec2 p) vec3 textureQueryLod (gsampler2DArray s, vec2 p) vec2 textureQueryLod (gsampler3D s, vec3 p) vec2 textureQueryLod (samplerCube s, vec3 p)	Berechnet das Level-of-Detail, das zum Abtasten einer Textur verwendet werden würde. Die Komponente `x` des resultierenden Wertes ist das Mipmap-Array, auf das zugegriffen werden würde. Die `y`-Komponente ist das berechnete Level-of-Detail relativ zur Basisebene (unabhängig von den Mipmap-Ebenen der Textur).
int textureQueryLevels (gsampler2D s) int textureQueryLevels (gsampler2DArray s) int textureQueryLevels (gsampler3D s) int textureQueryLevels (samplerCube s)	Ermittelt die Anzahl der zugänglichen Mipmap-Ebenen einer Textur. If the texture is unassigned to a sampler, `1` is returned (Godot always internally assigns a texture even to an empty sampler).
gvec4_type texture (gsampler2D s, vec2 p [, float bias]) gvec4_type texture (gsampler2DArray s, vec3 p [, float bias]) gvec4_type texture (gsampler3D s, vec3 p [, float bias]) vec4 texture (samplerCube s, vec3 p [, float bias]) vec4 texture (samplerCubeArray s, vec4 p [, float bias])	Führt ein Texturlesen durch.
gvec4_type textureProj (gsampler2D s, vec3 p [, float bias]) gvec4_type textureProj (gsampler2D s, vec4 p [, float bias]) gvec4_type textureProj (gsampler3D s, vec4 p [, float bias])	Führt ein Texturlesen mit Projektion durch.
gvec4_type textureLod (gsampler2D s, vec2 p, float lod) gvec4_type textureLod (gsampler2DArray s, vec3 p, float lod) gvec4_type textureLod (gsampler3D s, vec3 p, float lod) vec4 textureLod (samplerCube s, vec3 p, float lod) vec4 textureLod (samplerCubeArray s, vec4 p, float lod)	Führt ein Texturlesen an der benutzerdefinierten Mipmap durch. Der LOD-Wert bestimmt, welche Mipmap-Ebene verwendet wird. Ein LOD-Wert von `0.0` verwendet die volle Auflösung der Textur. Wenn die Textur keine Mipmaps hat, haben alle LOD Werte die gleiche Wirkung wie `0.0`.
gvec4_type textureProjLod (gsampler2D s, vec3 p, float lod) gvec4_type textureProjLod (gsampler2D s, vec4 p, float lod) gvec4_type textureProjLod (gsampler3D s, vec4 p, float lod)	Führt ein Texturlesen mit Projektion/LOD durch. Der LOD-Wert bestimmt, welche Mipmap-Ebene verwendet wird. Ein LOD-Wert von `0.0` verwendet die volle Auflösung der Textur. Wenn die Textur keine Mipmaps hat, haben alle LOD Werte die gleiche Wirkung wie `0.0`.
gvec4_type textureGrad (gsampler2D s, vec2 p, vec2 dPdx, vec2 dPdy) gvec4_type textureGrad (gsampler2DArray s, vec3 p, vec2 dPdx, vec2 dPdy) gvec4_type textureGrad (gsampler3D s, vec3 p, vec2 dPdx, vec2 dPdy) vec4 textureGrad (samplerCube s, vec3 p, vec3 dPdx, vec3 dPdy) vec4 textureGrad (samplerCubeArray s, vec3 p, vec3 dPdx, vec3 dPdy)	Führt ein Texturlesen mit expliziten Farbverläufen durch.
gvec4_type textureProjGrad (gsampler2D s, vec3 p, vec2 dPdx, vec2 dPdy) gvec4_type textureProjGrad (gsampler2D s, vec4 p, vec2 dPdx, vec2 dPdy) gvec4_type textureProjGrad (gsampler3D s, vec4 p, vec3 dPdx, vec3 dPdy)	Führt ein Texturlesen mit Projektion/LOD und mit expliziten Farbverläufen durch.
gvec4_type texelFetch (gsampler2D s, ivec2 p, int lod) gvec4_type texelFetch (gsampler2DArray s, ivec3 p, int lod) gvec4_type texelFetch (gsampler3D s, ivec3 p, int lod)	Holt ein einzelnes Texel mit Integer-Koordinaten. Der LOD-Wert bestimmt, welche Mipmap-Ebene verwendet wird. Bei einem LOD-Wert von `0` wird die Textur in voller Auflösung verwendet.
gvec4_type textureGather (gsampler2D s, vec2 p [, int comps]) gvec4_type textureGather (gsampler2DArray s, vec3 p [, int comps]) vec4 textureGather (samplerCube s, vec3 p [, int comps])	Holt vier Texel aus einer Textur. Benutzen Sie `comps` im Bereich von 0..3 um zu definieren, welche Komponente (x, y, z, w) zurückgegeben wird. Wird `comps` nicht angegeben, wird 0 (oder die x-Komponente) verwendet.
vec_type dFdx (vec_type p)	Ableitung in `x` unter Verwendung von lokaler Differenzierung. Intern kann entweder `dFdxCoarse` oder `dFdxFine` verwendet werden, aber die Entscheidung, welche Ableitung verwendet wird, trifft der GPU-Treiber.
vec_type dFdxCoarse (vec_type p)	Berechnet die Ableitung nach der `x`-Fensterkoordinate unter Verwendung der lokalen Differenzierung, basierend auf dem Wert von `p` für den/die aktuellen Fragment-Nachbarn, und schließt möglicherweise, aber nicht notwendigerweise, den Wert für das aktuelle Fragment ein. Diese Funktion ist im Profil `gl_compatibility` nicht verfügbar.
vec_type dFdxFine (vec_type p)	Berechnet die Ableitung nach der `x`-Fensterkoordinate unter Verwendung der lokalen Differenzierung auf der Grundlage des Wertes von `p` für das aktuelle Fragment und seine unmittelbaren Nachbarn. Diese Funktion ist im Profil `gl_compatibility` nicht verfügbar.
vec_type dFdy (vec_type p)	Ableitung in `y` unter Verwendung der lokalen Differenzierung. Intern kann entweder `dFdyCoarse` oder `dFdyFine` verwendet werden, aber die Entscheidung, welche Ableitung verwendet wird, trifft der GPU-Treiber.
vec_type dFdyCoarse (vec_type p)	Berechnet die Ableitung nach der `y`-Fensterkoordinate unter Verwendung der lokalen Differenzierung, basierend auf dem Wert von `p` für die aktuellen Fragmentnachbarn, und schließt möglicherweise, aber nicht notwendigerweise, den Wert für das aktuelle Fragment ein. Diese Funktion ist im Profil `gl_compatibility` nicht verfügbar.
vec_type dFdyFine (vec_type p)	Berechnet die Ableitung nach der `y`-Fensterkoordinate unter Verwendung der lokalen Differenzierung auf der Grundlage des Wertes von `p` für das aktuelle Fragment und seine unmittelbaren Nachbarn. Diese Funktion ist im Profil `gl_compatibility` nicht verfügbar.
vec_type fwidth (vec_type p)	Summe der absoluten Ableitungen in `x` und `y`. Dies ist gleichbedeutend mit der Verwendung von `abs(dFdx(p)) + abs(dFdy(p))`.
vec_type fwidthCoarse (vec_type p)	Summe der absoluten Ableitung in `x` und `y`. Dies ist das Äquivalent zur Verwendung von `abs(dFdxCoarse(p)) + abs(dFdyGrob(p))`. Diese Funktion ist im Profil `gl_compatibility` nicht verfügbar.
vec_type fwidthFine (vec_type p)	Summe der absoluten Ableitung in `x` und `y`. Dies ist das Äquivalent zur Verwendung von `abs(dFdxFine(p)) + abs(dFdyFine(p))`. Diese Funktion ist im Profil `gl_compatibility` nicht verfügbar.
uint packHalf2x16 (vec2 v) vec2 unpackHalf2x16 (uint v)	Konvertiert zwei 32-Bit-Float-Zahlen in 16-Bit und packt sie in eine 32-Bit-Unsigned Integer und umgekehrt.
uint packUnorm2x16 (vec2 v) vec2 unpackUnorm2x16 (uint v)	Konvertiert zwei 32-Bit-Float-Zahlen (im Bereich 0..1) in 16-Bit und packt sie in eine 32-Bit-Unsigned Integer und umgekehrt.
uint packSnorm2x16 (vec2 v) vec2 unpackSnorm2x16 (uint v)	Konvertiert zwei 32-Bit-Float-Zahlen (geclamped im Bereich -1..1) in 16-Bit und packt sie in eine 32-Bit-Unsigned Integer-Zahl und umgekehrt.
uint packUnorm4x8 (vec4 v) vec4 unpackUnorm4x8 (uint v)	Konvertiert vier 32-Bit-Float-Zahlen (geclamped im Bereich 0..1) in 8-Bit und packt sie in eine 32-Bit-Unsigned Integer-Zahl und umgekehrt.
uint packSnorm4x8 (vec4 v) vec4 unpackSnorm4x8 (uint v)	Konvertiert vier 32-Bit-Float-Zahlen (geclampt im Bereich -1..1) in 8-Bit und packt sie in eine 32-Bit-Unsigned Integer-Zahl und umgekehrt.
ivec_type bitfieldExtract (ivec_type value, int offset, int bits) uvec_type bitfieldExtract (uvec_type value, int offset, int bits)	Extrahiert einen Bereich von Bits aus einer Integer.
ivec_type bitfieldInsert (ivec_type base, ivec_type insert, int offset, int bits) uvec_type bitfieldInsert (uvec_type base, uvec_type insert, int offset, int bits)	Fügt einen Bereich von Bits in eine Integer ein.
ivec_type bitfieldReverse (ivec_type value) uvec_type bitfieldReverse (uvec_type value)	Kehrt die Reihenfolge der Bits in einer Integer um.
ivec_type bitCount (ivec_type value) uvec_type bitCount (uvec_type value)	Zählt die Anzahl der 1-Bits in einer Integer.
ivec_type findLSB (ivec_type value) uvec_type findLSB (uvec_type value)	Ermittelt den Index des niederwertigsten Bits, das in einer Integer-Zahl auf 1 gesetzt ist.
ivec_type findMSB (ivec_type value) uvec_type findMSB (uvec_type value)	Ermittelt den Index des höchstwertigen Bits, das in einer Integer-Zahl auf 1 gesetzt ist.
void imulExtended (ivec_type x, ivec_type y, out ivec_type msb, out ivec_type lsb) void umulExtended (uvec_type x, uvec_type y, out uvec_type msb, out uvec_type lsb)	Multipliziert zwei 32-Bit-Zahlen und erzeugt ein 64-Bit-Ergebnis. `x` - die erste Zahl. `y` - die zweite Zahl. `msb` - enthält die höchstwertigen Bits. `lsb` - enthält die niederwertigsten Bits.
uvec_type uaddCarry (uvec_type x, uvec_type y, out uvec_type carry)	Addiert zwei Unsigned Integer-Zahlen und erzeugt einen Übertrag.
uvec_type usubBorrow (uvec_type x, uvec_type y, out uvec_type borrow)	Subtrahiert zwei Unsigned Integer-Zahlen und erzeugt ein Borrow.
vec_type ldexp (vec_type x, out ivec_type exp)	Setzt eine Float-Zahl aus einem Wert und einem Exponenten zusammen. Wenn dieses Produkt zu groß ist, um im Float-Typ dargestellt zu werden, ist das Ergebnis undefiniert.
vec_type frexp (vec_type x, out ivec_type exp)	Zerlegt eine Float-Zahl (`x`) in eine Mantisse (im Bereich von [0.5, 1.0]) und einen Integer-Exponenten. Für `x` gleich Null sind sowohl die Mantisse als auch der Exponent gleich Null. Für `x` von unendlich oder NaN sind die Ergebnisse undefiniert.