Langue de shading¶
Introduction¶
Godot utilise un langage de shading semblable à celui de GLSL ES 3.0. La plupart des types de données et des fonctions sont pris en charge, et les quelques autres seront probablement ajoutés au fil du temps.
Si vous êtes déjà familier avec GLSL, le Godot Shader Migration Guide est une ressource qui vous aidera à faire la transition entre GLSL normal et le langage de shading de Godot.
types¶
La plupart des types de GLSL ES 3.0 sont supportés :
Type |
Description |
---|---|
void |
Type void, seulement utile pour les fonctions ne retournant rien. |
bool |
Type de données booléen, ne peut contenir que |
bvec2 |
vecteur à deux composants de booléens. |
bvec3 |
Vecteur de booléens à trois composants. |
bvec4 |
Vecteur de booléens à quatre composants. |
int |
Entier scalaire signé. |
ivec2 |
Vecteur d'entier signé (int) à deux composants. |
ivec3 |
Vecteur d'entier signé (int) à trois composants. |
ivec4 |
Vecteur d'entier signé (int) à quatre composants. |
uint |
Entier scalaire non-signé ; ne peut contenir de nombre négatif. |
uvec2 |
Vecteur d'entier non-signé (unsigned int) à deux composants. |
uvec3 |
Vecteur d'entier non-signé (unsigned int) à trois composants. |
uvec4 |
Vecteur d'entier non-signé (unsigned int) à quatre composants. |
float |
Scalaire à virgule flottante. |
vec2 |
Vecteur à deux composantes de valeurs à virgule flottante. |
vec3 |
Vecteur à trois composantes de valeurs à virgule flottante. |
vec4 |
Vecteur à quatre composantes de valeurs à virgule flottante. |
mat2 |
Matrice 2x2, dans l'ordre principal des colonnes. |
mat3 |
Matrice 3x3, dans l'ordre principal des colonnes. |
mat4 |
Matrice 4x4, dans l'ordre principal des colonnes. |
sampler2D |
Type d'échantillonneur pour lier des textures 2D, qui sont lues comme des flottants. |
isampler2D |
Type d'échantillonneur pour lier des textures 2D, qui sont lues comme des entiers signés. |
usampler2D |
Type d'échantillonneur pour lier des textures 2D, qui sont lues comme des entiers non signés. |
Sampler2DArray |
Type d'échantillonneur pour lier des tableaux de textures 2D, qui sont lues comme des flottants. |
isampler2DArray |
Type d'échantillonneur pour lier des tableaux de textures 2D, qui sont lues comme des entiers signés. |
usampler2DArray |
Type d'échantillonneur pour lier des tableaux de textures 2D, qui sont lues comme des entiers non signés. |
sampler3D |
Type d'échantillonneur pour lier des textures 3D, qui sont lues comme des flottants. |
isampler3D |
Type d'échantillonneur pour lier des textures 3D, qui sont lues comme des entiers signés. |
usampler3D |
Type d'échantillonneur pour lier des textures 3D, qui sont lues comme des entiers non signés. |
samplerCube |
Type d'échantillonneur pour lier des Cubemaps, qui sont lus comme des flottants. |
Conversion de type¶
Comme dans GLSL ES 3.0, les conversions (casts) implicites entre sclaires et vecteurs de la même taille mais de type différent sont interdites. La conversion de type de différentes tailles est aussi interdite. Les conversions doivent être faites explicitement via les constructeurs.
Exemple :
float a = 2; // invalid
float a = 2.0; // valid
float a = float(2); // valid
Les entiers de base sont signés, ce qui oblige l'utilisation des casts pour convertir en non-signé :
int a = 2; // valid
uint a = 2; // invalid
uint a = uint(2); // valid
Membres¶
Les membre scalaires des types vecteurs sont accessible par les membres "x", "y", "z" et "w". Cependant, utiliser "r", "g", "b" et "a" fonctionne aussi et est équivalent. Utilisez ce qui correspond le mieux à vos besoins.
Pour les matrices utilisez la syntaxe d'indexation m[ligne][colonne]
pour accéder à chaque scalaire, ou m[idx]
pour accéder à un vecteur par. Par exemple, pour accéder à la position y d'un objet de type mat4 utilisez m[3][1]
.
Construction¶
La construction de vecteurs doit toujours passer :
// 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);
La construction des types matrice nécessite des vecteurs de même dimension que la matrice. Vous pouvez également construire une matrice diagonale en utilisant la syntaxe matx (float)
. Par conséquent, mat4 (1.0)
est une matrice identité.
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);
Les matrices peuvent également être construites à partir d'une matrice d'une autre dimension. Deux règles s'appliquent : si une matrice plus grande est construite à partir d'une matrice plus petite, les lignes et colonnes supplémentaires prennent les valeurs qu'elles auraient dans une matrice identité. Si une matrice plus petite est construite à partir d'une matrice plus grande, la sous-matrice supérieure gauche de la matrice plus grande est utilisée.
mat3 basis = mat3(WORLD_MATRIX);
mat4 m4 = mat4(basis);
mat2 m2 = mat2(m4);
Mélange¶
Il est possible d'obtenir n'importe quelle combinaison de composants dans n'importe quel ordre, tant que le résultat est un autre type vecteur (ou scalaire). C'est plus facile à montrer qu'à expliquer :
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écision¶
Il est possible d'ajouter des modificateurs de précision aux types de données. Utilisez-les pour les uniformes, les variables, les arguments et les 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)
L'utilisation d'une précision inférieure pour certaines opérations peut accélérer les calculs (au prix d'une moindre précision). Ceci est rarement nécessaire dans la fonction de processeur de vertex (où la précision maximum est nécessaire la plupart du temps), mais c'est souvent utile dans le processeur de fragment.
Certaines architectures (principalement mobiles) peuvent en bénéficier de manière significative, mais il y a des inconvénients tels que le surcoût de la conversion entre les précisions. Pour plus d'informations, veuillez vous reporter à la documentation de l'architecture cible. Dans de nombreux cas, les pilotes mobiles provoquent un comportement incohérent ou inattendu et il est préférable d'éviter de spécifier la précision, sauf si cela s'avère nécessaire.
Les tableaux¶
Les tableaux sont des conteneurs pour plusieurs variables d'un type similaire. Remarque : Depuis Godot 3.2, seuls les tableaux locaux ont été implémentés.
Tableaux locaux¶
Les tableaux locaux sont déclarés dans les fonctions. Ils peuvent utiliser tous les types de données autorisés, sauf les samplers. La déclaration du tableau suit une syntaxe de type C : [const] + [precision] + typename + identifier + [array size]
.
void fragment() {
float arr[3];
}
Ils peuvent être initialisés au début comme cela :
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
Vous pouvez déclarer plusieurs tableaux (même avec des tailles différentes) dans une expression :
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];
Pour accéder à un élément de tableau, utilisez la syntaxe d'indexation :
float arr[3];
arr[0] = 1.0; // setter
COLOR.r = arr[0]; // getter
Les tableaux ont aussi une fonction intégrée .length()
(à ne pas confondre avec la fonction intégrée length()
). Il n'accepte aucun paramètre et retourne la taille du tableau.
float arr[] = { 0.0, 1.0, 0.5, -1.0 };
for (int i = 0; i < arr.length(); i++) {
// ...
}
Note
Si vous utilisez un indice inférieur à 0 ou supérieur à la taille du tableau - le shader va planter et casser le rendu. Pour éviter cela, utilisez les fonctions length()
, if
, ou clamp()
pour vous assurer que l'index est compris entre 0 et la longueur du tableau. Testez et vérifiez toujours soigneusement votre code. Si vous passez une expression constante ou un simple nombre, l'éditeur vérifiera ses limites pour éviter ce plantage.
Constantes¶
Utilisez le mot-clé const
avant la déclaration de la variable pour rendre cette variable immuable, ce qui signifie qu'elle ne peut pas être modifiée. Tous les types de base, sauf les samplers, peuvent être déclarés comme des constantes. L'accès et l'utilisation d'une valeur constante est légèrement plus rapide que l'utilisation d'un uniforme. Les constantes doivent être initialisées lors de leur déclaration.
const vec2 a = vec2(0.0, 1.0);
vec2 b;
a = b; // invalid
b = a; // valid
Les constantes ne peuvent pas être modifiées et ne peuvent pas non plus avoir d'indices, mais plusieurs d'entre elles (si elles ont le même type) peuvent être déclarées dans une seule expression, par exemple
const vec2 V1 = vec2(1, 1), V2 = vec2(2, 2);
Comme les variables, les tableaux peuvent aussi être déclarés avec const
.
const float arr[] = { 1.0, 0.5, 0.0 };
arr[0] = 1.0; // invalid
COLOR.r = arr[0]; // valid
Les constantes peuvent être déclarées à la fois globalement (en dehors de toute fonction) ou localement (à l'intérieur d'une fonction). Les constantes globales sont utiles lorsque vous voulez avoir accès à une valeur dans tout votre shader qui n'a pas besoin d'être modifiée. Comme les uniformes, les constantes globales sont partagées entre tous les étages de shaders, mais elles ne sont pas accessibles en dehors du shader.
shader_type spatial;
const float PI = 3.14159265358979323846;
Opérateurs¶
Le langage de shading de Godot prend en charge le même ensemble d'opérateurs que GLSL ES 3.0. Vous trouverez ci-dessous la liste de ces derniers par ordre de priorité :
Priorité |
Classe |
Opérateur |
1 (le plus élevé) |
groupement entre parenthèses |
() |
2 |
unaire |
+, -, !, ~ |
3 |
multiplicatif |
/, *, % |
4 |
additif |
+, - |
5 |
décalage par bits |
<<, >> |
6 |
relationnel |
<, >, <=, >= |
7 |
égalité |
==, != |
8 |
bit-wise ET |
& |
9 |
bit-wise OU exclusif |
^ |
10 |
bit-wise OU inclusif |
| |
11 |
ET logique |
&& |
12 (le plus bas) |
OU inclusif logique |
|| |
Contrôle de flux¶
Le langage de Shading de Godot prend en charge les types de contrôle de flux les plus courants :
// 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);
Gardez à l'esprit que, dans les GPU modernes, une boucle infinie peut exister et peut geler votre application (y compris l'éditeur). Godot ne peut pas vous protéger de ça, alors faites attention à ne pas faire cette erreur !
Avertissement
Lors de l'exportation d'un projet GLES2 vers HTML5, WebGL 1.0 sera utilisé. WebGL 1.0 ne prend pas en charge les boucles dynamiques, donc les shaders qui les utilisent ne fonctionneront pas.
Jeter¶
Les fonctions fragment et lumière peuvent utiliser le mot-clé discard. S'il est utilisé, le fragment est jeté et rien n'est écrit.
Fonctions¶
Il est possible de définir des fonctions dans un shader Godot. Elles utilisent la syntaxe suivante :
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;
}
Vous pouvez uniquement utiliser les fonctions qui ont été définies au-dessus (plus haut dans l'éditeur) la fonction à partir de laquelle vous les appelez.
Les arguments de fonction peuvent avoir des qualificateurs spéciaux :
in : Signifie que l'argument est seulement en lecture seule (par défaut).
out : Cela signifie que l'argument est en écriture seule.
inout : Signifie que l'argument est entièrement passé par la référence.
Exemple ci-dessous :
void sum2(int a, int b, inout int result) {
result = a + b;
}
Varyings¶
Pour envoyer des données de la fonction de traitement de sommets à la fonction de traitement de fragments, des varyings sont utilisées. Ils sont définis pour chaque sommet primitif dans le traitement de sommets, et la valeur est interpolée pour chaque pixel dans le traitement de fragments.
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
}
Il est possible d'utiliser un tableau comme Varying :
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
}
Il est également possible d'envoyer des données depuis fragment vers les processeurs light en utilisant le mot clé varying. Pour ce faire, vous pouvez l'affecter dans fragment et l'utiliser plus tard dans la fonction light.
shader_type spatial;
varying vec3 some_light;
void fragment() {
some_light = ALBEDO * 100.0; // Make a shining light.
}
void light() {
DIFFUSE_LIGHT = some_light;
}
Notez qu'un varying ne peut pas être attribué dans les fonctions personnalisées ou dans un processeur de lumière comme :
shader_type spatial;
varying float test;
void foo() {
test = 0.0; // Error.
}
void vertex() {
test = 0.0;
}
void light() {
test = 0.0; // Error too.
}
Cette limite a été introduite pour empêcher un usage incorrect avec l'initialisation.
Qualificateurs d'interpolation¶
Certaines valeurs sont interpolées pendant le pipeline de shading. Vous pouvez modifier la façon dont ces interpolations sont effectuées en utilisant les qualificateurs d'interpolation.
shader_type spatial;
varying flat vec3 our_color;
void vertex() {
our_color = COLOR.rgb;
}
void fragment() {
ALBEDO = our_color;
}
Il y a deux qualificateur d'interpolation possibles :
Qualificateur |
Description |
---|---|
flat |
La valeur n'est pas interpolée. |
smooth |
La valeur est interpolée de façon à corriger la perspective. C'est la valeur par défaut. |
Uniforms¶
La transmission de valeurs aux shaders est possible. Ces dernieres sont globales à l'ensemble des shaders et sont appelés uniforms. Lorsqu'un shader est ultérieurement affecté à un matériau, les uniforms y apparaissent comme des paramètres modifiables. Les uniforms ne peuvent pas être écrites de l'intérieur du shader.
shader_type spatial;
uniform float some_value;
Vous pouvez définir des uniforms dans l'éditeur du matériau. Ou vous pouvez les définir via GDScript :
material.set_shader_param("some_value", some_value)
Note
Le premier argument de set_shader_param
est le nom de l'uniform dans le shader. Il doit correspondre exactement au nom de l'uniform du shader, sinon il ne sera pas reconnu.
Any GLSL type except for void can be a uniform. Additionally, Godot provides optional shader hints to make the compiler understand for what the uniform is used, and how the editor should allow users to modify it.
shader_type spatial;
uniform vec4 color : hint_color;
uniform float amount : hint_range(0, 1);
uniform vec4 other_color : hint_color = vec4(1.0);
Il est important de comprendre que les textures qui sont fournies sous forme de couleur nécessitent des indices pour une conversion sRGB->linear (i.e. hint_albedo
), car le moteur 3D de Godot effectue le rendu dans un espace de couleur linéaire.
Liste complète des indices ci-dessous :
Type |
Suggestion |
Description |
---|---|---|
vec4 |
hint_color |
Utilisé comme couleur. |
int, float |
hint_range(min, max[, step]) |
Limité aux valeurs d'un intervalle (avec min/max/étape). |
sampler2D |
hint_albedo |
Utilisé comme couleur d'albédo, blanc par défaut. |
sampler2D |
hint_black_albedo |
Utilisé comme couleur d'albédo, noir par défaut. |
sampler2D |
hint_normal |
Utilisé comme une NormalMap. |
sampler2D |
hint_white |
Comme valeur, par défaut blanc. |
sampler2D |
hint_black |
Comme valeur, par défaut noir |
sampler2D |
hint_aniso |
Comme flowmap, par défaut à droite. |
GDScript utilise des types de variables différents de ceux de GLSL, donc lors du passage des variables de GDScript aux shaders, Godot convertit le type automatiquement. Vous trouverez ci-dessous un tableau des types correspondants :
Type GDScript |
type GLSL |
---|---|
bool |
bool |
int |
int |
float |
float |
Vector2 |
vec2 |
Vector3 |
vec3 |
Color |
vec4 |
Transform |
mat4 |
Transform2D |
mat4 |
Note
Faites attention lorsque vous définissez des uniforms de shader à partir de GDScript, aucune erreur ne sera lancée si le type ne correspond pas. Votre shader ne fera que présenter un comportement indéfini.
Des valeurs par défaut peuvent également être attribuées aux uniforms :
shader_type spatial;
uniform vec4 some_vector = vec4(0.0);
uniform vec4 some_color : hint_color = vec4(1.0);
Variables intégrées¶
Un grand nombre de variables intégrées sont disponibles, comme UV
, COLOR
et VERTEX
. Les variables disponibles dépendent du type de shader (spatial
, canvas_item
ou particule
) et de la fonction utilisée (vertex
, fragment
ou light
). Pour une liste des variables intégrées qui sont disponibles, veuillez consulter les pages correspondantes :
Fonctions intégrées¶
Un grand nombre de fonctions intégrées sont prises en charge, conformément à GLSL ES 3.0. Lorsque la nomenclature vec_type (float), vec_int_type, vec_uint_type, vec_bool_type est utilisée, elle peut être scalaire ou vectorielle.
Note
Pour une liste des fonctions qui ne sont pas disponibles dans le backend GLES2, veuillez consulter le document Différences entre GLES2 et GLES3 doc.
Fonction |
Description |
---|---|
vec_type radians (vec_type degrees) |
Convertir les degrés en radians |
vec_type degrees (vec_type radians) |
Convertir les radians en degrés |
vec_type sin (vec_type x) |
Sinus |
vec_type cos (vec_type x) |
Cosinus |
vec_type tan (vec_type x) |
Tangente |
vec_type asin (vec_type x) |
Arc sinus |
vec_type acos (vec_type x) |
Arc cosinus |
vec_type atan (vec_type y_over_x) |
Arc Tangente |
vec_type atan (vec_type y, vec_type x) |
Arc Tangente pour convertir un vecteur en angle |
vec_type sinh (vec_type x) |
Sinus hyperbolique |
vec_type cosh (vec_type x) |
Cosinus hyperbolique |
vec_type tanh (vec_type x) |
Tangente hyperbolique |
vec_type asinh (vec_type x) |
Sinus hyperbolique inverse |
vec_type acosh (vec_type x) |
Cosinus hyperbolique inverse |
vec_type atanh (vec_type x) |
Tangente hyperbolique inverse |
vec_type pow (vec_type x, vec_type y) |
Puissance (indéfinie si |
vec_type exp (vec_type x) |
Exponentielle de base e |
vec_type exp2 (vec_type x) |
Exponentielle de base 2 |
vec_type log (vec_type x) |
Logarithme naturel |
vec_type log2 (vec_type x) |
Logarithme de base 2 |
vec_type sqrt (vec_type x) |
Racine carrée |
vec_type inversesqrt (vec_type x) |
Racine carrée inverse |
vec_type abs (vec_type x) |
Absolue |
ivec_type abs (ivec_type x) |
Absolue |
vec_type sign (vec_type x) |
Signe |
ivec_type sign (ivec_type x) |
Signe |
vec_type floor (vec_type x) |
Plancher |
vec_type round (vec_type x) |
Arrondi |
vec_type roundEven (vec_type x) |
Arrondir au nombre pair le plus proche |
vec_type trunc (vec_type x) |
Troncature |
vec_type ceil (vec_type x) |
Partie entière |
vec_type fract (vec_type x) |
Partie fractionnaire |
vec_type mod (vec_type x, vec_type y) |
Reste |
vec_type mod (vec_type x , float y) |
Reste |
vec_type modf (vec_type x, out vec_type i) |
Partie fractionnaire de |
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) |
Fixation(clamp) à |
float mix (float a, float b, float c) |
Interpolation linéaire |
vec_type mix (vec_type a, vec_type b, float c) |
Interpolation linéaire (coefficient scalaire) |
vec_type mix (vec_type a, vec_type b, vec_type c) |
Interpolation linéaire (coefficient vecteur) |
vec_type mix (vec_type a, vec_type b, bvec_type c) |
Interpolation linéaire (sélection par vecteur de booléens) |
vec_type step (vec_type a, vec_type b) |
|
vec_type step (float a, vec_type b) |
|
vec_type smoothstep (vec_type a, vec_type b, vec_type c) |
Interpolation Hermite |
vec_type smoothstep (float a, float b, vec_type c) |
Interpolation Hermite |
bvec_type isnan (vec_type x) |
Renvoie |
bvec_type isinf (vec_type x) |
Renvoie |
ivec_type floatBitsToInt (vec_type x) |
Copie de bits Float->Int, pas de conversion |
uvec_type floatBitsToUint (vec_type x) |
Copie de bits Float->UInt, pas de conversion |
vec_type intBitsToFloat (ivec_type x) |
Copie de bits Int->Float, pas de conversion |
vec_type uintBitsToFloat (uvec_type x) |
Copie de bits UInt->Float, pas de conversion |
float length (vec_type x) |
Longueur du vecteur |
float distance (vec_type a, vec_type b) |
Distance entre les vecteurs, c'est à dire |
float dot (vec_type a, vec_type b) |
Produit scalaire |
vec3 cross (vec3 a, vec3 b) |
Produit Vectoriel |
vec_type normalize (vec_type x) |
Normaliser à la longueur unitaire |
vec3 reflect (vec3 I, vec3 N) |
Réflexion |
vec3 refract (vec3 I, vec3 N, float eta) |
Réfraction |
vec_type faceforward (vec_type N, vec_type I, vec_type Nref) |
Si |
mat_type matrixCompMult (mat_type x, mat_type y) |
Multiplication de composants matriciels |
mat_type outerProduct (vec_type column, vec_type row) |
Produit Dyadique Matrice |
mat_type transpose (mat_type m) |
Matrice transposée |
float determinant (mat_type m) |
Déterminant de la matrice |
mat_type inverse (mat_type m) |
Matrice inverse |
bvec_type lessThan (vec_type x, vec_type y) |
Comparaison de bool vector < sur des vectors int/uint/float |
bvec_type greaterThan (vec_type x, vec_type y) |
Comparaison de bool vector > sur des vectors int/uint/float |
bvec_type lessThanEqual (vec_type x, vec_type y) |
Comparaison de bool vector <= sur des vectors int/uint/float |
bvec_type greaterThanEqual (vec_type x, vec_type y) |
Comparaison de bool vector >= sur des vectors int/uint/float |
bvec_type equal (vec_type x, vec_type y) |
Comparaison de bool vector == sur des vectors int/uint/float |
bvec_type nonEgaux (vec_type x, vec_type y) |
Comparaison de bool vector != sur des vectors int/uint/float |
bool n'importe (bvec_type x) |
N'importe quel composante est |
bool all (bvec_type x) |
Toutes les composantes sont |
bvec_type not (bvec_type x) |
Inverser le vecteur booléen |
ivec2 textureSize (sampler2D_type s, int lod) |
Obtenir la taille d'une texture 2D |
ivec3 textureSize (sampler2DArray_type s, int lod) |
Obtenir la taille d'une table de textures 2D |
ivec3 textureSize (sampler3D s, int lod) |
Obtenir la taille d'une texture 3D |
ivec2 textureSize (samplerCube s, int lod) |
Obtenez la taille d'une texture cubemap |
vec4_type texture (sampler2D_type s, vec2 uv [, float bias]) |
Effectuer une lecture de texture 2D |
vec4_type texture (sampler2DArray_type s, vec3 uv [, float bias]) |
Effectuer une lecture de table de textures 2D |
vec4_type texture (sampler3D_type s, vec3 uv [, float bias]) |
Effectuer une lecture de texture 3D |
ec4 texture (samplerCube s, vec3 uv [, float bias]) |
Effectuer une lecture de texture cubemap |
vec4_type textureProj (sampler2D_type s, vec3 uv [, float bias]) |
Effectuer une lecture de texture 2D avec projection |
vec4_type textureProj (sampler2D_type s, vec4 uv [, float bias]) |
Effectuer une lecture de texture 2D avec projection |
vec4_type textureProj (sampler3D_type s, vec4 uv [, float bias]) |
Effectuer une lecture de texture 3D avec projection |
vec4_type textureLod (sampler2D_type s, vec2 uv, float lod) |
Effectuer une lecture de texture 2D avec mipmap personnalisé |
vec4_type textureLod (sampler2DArray_type s, vec3 uv, float lod) |
Effectuer une lecture de table de textures 2D avec mipmap personnalisé |
vec4_type textureLod (sampler3D_type s, vec3 uv, float lod) |
Effectuer une lecture de texture 3D avec mipmap personnalisé |
vec4 textureLod (samplerCube s, vec3 uv, float lod) |
Effectuer une lecture de texture 3D avec mipmap personnalisé |
vec4_type textureProjLod (sampler2D_type s, vec3 uv, float lod) |
Effectuer une lecture de texture 2D avec projection/LOD |
vec4_type textureProjLod (sampler2D_type s, vec4 uv, float lod) |
Effectuer une lecture de texture 2D avec projection/LOD |
vec4_type textureProjLod (sampler3D_type s, vec4 uv, float lod) |
Effectuer une lecture de texture 3D avec projection/LOD |
vec4_type texelFetch (sampler2D_type s, ivec2 uv, int lod) |
Récupérer un seul texel à l'aide de coordonnées entières |
vec4_type texelFetch (sampler2DArray_type s, ivec3 uv, int lod) |
Récupérer un seul texel à l'aide de coordonnées entières |
vec4_type texelFetch (sampler3D_type s, ivec3 uv, int lod) |
Récupérer un seul texel à l'aide de coordonnées entières |
vec_type dFdx (vec_type p) |
Dérivée en |
vec_type dFdy (vec_type p) |
Dérivée en |
vec_type fwidth (vec_type p) |
Somme de la dérivée absolue en |