Partager via

Opérateurs

  • Article

Les expressions sont des séquences de variables et de littéraux ponctués par des opérateurs. Les opérateurs déterminent la façon dont les variables et les littéraux sont combinés, comparés, sélectionnés, etc. Les opérateurs sont notamment :

Nom de l'opérateur Opérateurs
Opérateurs additifs et multiplicatifs +, -, *, /, %
Opérateur de tableau [i]
Opérateurs d’assignation =, +=, -=, *=, /=, %=
Casts binaires Règles C pour les float et int, règles C ou intrinsèques HLSL pour bool
Opérateurs au niveau du bit ~, <<, >>, &, |, ^, <<=, >>=, &=, |=, ^=
Opérateurs mathématiques booléens &&, ||, ?:
Opérateur de cast (type)
Opérateur de virgule ,
Opérateurs de comparaison <, >, ==, !=, <=, >=
Opérateurs de préfixe ou postfix ++, --
Opérateur de structure .
Opérateurs unaires !, -, +

 

De nombreux opérateurs sont appliqués par composant, ce qui signifie que l’opération est effectuée indépendamment pour chaque composant de chaque variable. Par exemple, une variable à un seul composant a une seule opération effectuée. En revanche, une variable à quatre composants a quatre opérations effectuées, une pour chaque composant.

Tous les opérateurs qui agissent sur la valeur, comme + et *, fonctionnent par composant.

Les opérateurs de comparaison nécessitent un seul composant pour fonctionner, sauf si vous utilisez la fonction intrinsèque all ou any avec une variable à plusieurs composants. L’opération suivante échoue, car l’instruction if nécessite une seule valeur booléenne, mais reçoit un bool4 :

if (A4 < B4)

Les opérations suivantes réussissent :

if ( any(A4 < B4) )
if ( all(A4 < B4) )

Les opérateurs de cast binaire asfloat, asint, etc. fonctionnent par composant, sauf asdouble dont les règles spéciales sont documentées.

Les opérateurs de sélection comme le point, la virgule et les crochets de tableau ne fonctionnent pas par composant.

Les opérateurs de cast changent le nombre de composants. Les opérations de cast suivantes montrent leur équivalence :

(float) i4 ->   float(i4.x)
(float4)i ->   float4(i, i, i, i)

Opérateurs additifs et multiplicatifs

Les opérateurs additifs et multiplicatifs sont : +, -, *, /, %

int i1 = 1;
int i2 = 2;
int i3 = i1 + i2;  // i3 = 3
i3 = i1 * i2;        // i3 = 1 * 2 = 2

i3 = i1/i2;       // i3 = 1/3 = 0.333. Truncated to 0 because i3 is an integer.
i3 = i2/i1;       // i3 = 2/1 = 2

float f1 = 1.0;
float f2 = 2.0f;
float f3 = f1 - f2; // f3 = 1.0 - 2.0 = -1.0
f3 = f1 * f2;         // f3 = 1.0 * 2.0 = 2.0

f3 = f1/f2;        // f3 = 1.0/2.0 = 0.5
f3 = f2/f1;        // f3 = 2.0/1.0 = 2.0

L’opérateur modulus renvoie le reste d’une division. Cela produit des résultats différents en cas d’utilisation d’entiers et de nombres à virgule flottante. Les restes entiers qui sont fractionnaires sont tronqués.

int i1 = 1;
int i2 = 2;
i3 = i1 % i2;      // i3 = remainder of 1/2, which is 1
i3 = i2 % i1;      // i3 = remainder of 2/1, which is 0
i3 = 5 % 2;        // i3 = remainder of 5/2, which is 1
i3 = 9 % 2;        // i3 = remainder of 9/2, which is 1

L’opérateur modulus tronque un reste fractionnaire en cas d’utilisation d’entiers.

f3 = f1 % f2;      // f3 = remainder of 1.0/2.0, which is 0.5
f3 = f2 % f1;      // f3 = remainder of 2.0/1.0, which is 0.0

L’opérateur % est défini uniquement quand les deux côtés sont positifs ou négatifs. Contrairement à C, il fonctionne également sur des types de données à virgule flottante, ainsi que sur des entiers.

Opérateur de tableau

L’opérateur de sélection de membre de tableau « [i] » sélectionne un ou plusieurs composants dans un tableau. Il s’agit d’un jeu de crochets contenant un index de base zéro.

int arrayOfInts[4] = { 0,1,2,3 };
arrayOfInts[0] = 2;
arrayOfInts[1] = arrayOfInts[0];

L’opérateur de tableau peut également être utilisé pour accéder à un vecteur.

float4 4D_Vector = { 0.0f, 1.0f, 2.0f, 3.0f  };         
float 1DFloat = 4D_Vector[1];          // 1.0f

En ajoutant un index supplémentaire, l’opérateur de tableau peut également accéder à une matrice.

float4x4 mat4x4 = {{0,0,0,0}, {1,1,1,1}, {2,2,2,2}, {3,3,3,3} };
mat4x4[0][1] = 1.1f;
float 1DFloat = mat4x4[0][1];      // 0.0f

Le premier index est l’index de ligne de base zéro. Le deuxième index est l’index de colonne de base zéro.

Opérateurs d’assignation

Les opérateurs d’assignation sont : =, +=, -=, *=, /=

Les variables peuvent recevoir des valeurs littérales :

int i = 1;            
float f2 = 3.1f; 
bool b = false;
string str = "string";

Les variables peuvent également recevoir le résultat d’une opération mathématique :

int i1 = 1;
i1 += 2;           // i1 = 1 + 2 = 3

Une variable peut être utilisée d’un côté ou de l’autre du signe égal :

float f3 = 0.5f;
f3 *= f3;          // f3 = 0.5 * 0.5 = 0.25

La division des variables à virgule flottante se fait comme prévu, car les restes décimaux ne sont pas un problème.

float f1 = 1.0;
f1 /= 3.0f;        // f1 = 1.0/3.0 = 0.333

Soyez attentifs quand vous utilisez des entiers qui peuvent être divisés, en particulier quand la troncation affecte le résultat. Cet exemple est identique à l’exemple précédent, à l’exception du type de données. La troncation provoque un résultat très différent.

int i1 = 1;
i1 /= 3;           // i1 = 1/3 = 0.333, which gets truncated to 0

Casts binaires

L’opération de cast entre int et float convertit la valeur numérique en représentations appropriées en suivant les règles C pour tronquer un type int. Le cast d’une valeur float en int, puis à nouveau en float entraîne une conversion avec perte selon la précision de la cible.

Les casts binaires peuvent également être effectués avec des Fonctions intrinsèques (DirectX HLSL) qui réinterprètent la représentation binaire d’un nombre dans le type de données cible.

asfloat() // Cast to float
asint()   // Cast to int 
asuint()  // Cast to uint

Opérateurs au niveau du bit

HLSL prend en charge les opérateurs suivants au niveau du bit, qui suivent la même priorité que C en ce qui concerne les autres opérateurs. Le tableau suivant décrit les opérateurs.

Remarque

Les opérateurs au niveau du bit nécessitent Shader Model 4_0 avec un matériel Direct3D 10 et version supérieure.

 

Opérateur Fonction
~ NOT logique
<< Maj gauche
>> Décalage vers la droite
& And logique
| Or logique
^ Xor logique
<<= Décalage à gauche égal
>>= Décalage à droite égal
&= And égal
|= Or égal
^= Xor égal

 

Les opérateurs au niveau du bit sont définis pour fonctionner uniquement sur les types de données int et uint. Si vous tentez d’utiliser des opérateurs au niveau du bit sur les types de données float ou struct, une erreur se produit.

Opérateurs mathématiques booléens

Les opérateurs mathématiques booléens sont : &&, ||, ?:

bool b1 = true;
bool b2 = false;
bool b3 = b1 && b2 // b3 = true AND false = false
b3 = b1 || b2                // b3 = true OR false = true

Contrairement à l’évaluation de court-circuit de &&, || et ?: en C, les expressions HLSL ne court-circuitent jamais une évaluation, car ce sont des opérations vectorielles. Tous les côtés de l’expression sont toujours évalués.

Les opérateurs booléens fonctionnent par composant. Cela signifie que si vous comparez deux vecteurs, le résultat est un vecteur contenant le résultat booléen de la comparaison pour chaque composant.

Pour les expressions qui utilisent des opérateurs booléens, la taille et le type de composant de chaque variable sont promus pour être identiques avant que l’opération ne se produise. Le type promu détermine la résolution à laquelle l’opération a lieu, ainsi que le type de résultat de l’expression. Par exemple, une expression int3 + float est promue en float3 + float3 pour l’évaluation, et son résultat est de type float3.

Opérateur de conversion

Une expression précédée d’un nom de type entre parenthèses est un cast de type explicite. Un cast de type convertit l’expression d’origine en type de données du cast. En général, les types de données simples peuvent être castés en types de données plus complexes (avec un cast de promotion), mais seuls certains types de données complexes peuvent être castés en types de données simples (avec un cast de rétrogradation).

Seul le cast de type du côté droit est légal. Par exemple, des expressions comme (int)myFloat = myInt; sont illégales. Utilisez myFloat = (float)myInt; à la place.

Le compilateur effectue également un cast de type implicite. Par exemple, les deux expressions suivantes sont équivalentes :

int2 b = int2(1,2) + 2;
int2 b = int2(1,2) + int2(2,2);

Opérateur de virgule

L’opérateur de virgule (,) sépare une ou plusieurs expressions à évaluer dans l’ordre. La valeur de la dernière expression de la séquence est utilisée comme valeur de la séquence.

Voici un cas qui mérite une attention particulière. Si le type de constructeur est accidentellement supprimé du côté droit du signe égal, le côté droit contient maintenant quatre expressions, séparées par trois virgules.

// Instead of using a constructor
float4 x = float4(0,0,0,1); 

// The type on the right side is accidentally left off
float4 x = (0,0,0,1);

L’opérateur de virgule évalue une expression de gauche à droite. Cela réduit le côté droit à :

float4 x = 1;

HLSL utilisant la promotion scalaire dans ce cas, le résultat est le même que si l’équation avait été écrite de la façon suivante :

float4 x = float4(1,1,1,1);

Dans ce cas, la suppression du type float4 du côté droit est probablement une erreur que le compilateur ne peut pas détecter, car il s’agit d’une instruction valide.

Opérateurs de comparaison

Les opérateurs de comparaison sont : <, >, ==, !=, <=, >=.

Ils comparent des valeurs qui sont supérieures (ou inférieures) à une valeur scalaire :

if( dot(lightDirection, normalVector) > 0 )
   // Do something; the face is lit

if( dot(lightDirection, normalVector) < 0 )
   // Do nothing; the face is backwards

Ou, ils comparent des valeurs égales à (ou non égales à) une valeur scalaire :

if(color.a == 0)
   // Skip processing because the face is invisible

if(color.a != 0)
   // Blend two colors together using the alpha value

Ou ils combinent les deux et comparent les valeurs qui sont supérieures ou égales à (ou inférieures ou égales à) une valeur scalaire :

if( position.z >= oldPosition.z )
   // Skip the new face because it is behind the existing face

if( currentValue <= someInitialCondition )
   // Reset the current value to its initial condition

Chacune de ces comparaisons peut être effectuée avec n’importe quel type de données scalaire.

Pour utiliser des opérateurs de comparaison avec des types de vecteur et de matrice, utilisez la fonction intrinsèque all ou any.

Cette opération échoue, car l’instruction if nécessite une seule valeur booléenne, mais reçoit un bool4 :

if (A4 < B4)

Ces opérations réussissent :

if ( any(A4 < B4) )
if ( all(A4 < B4) )

Opérateurs de préfixe ou postfix

Les opérateurs de préfixe et postfix sont : ++, --. Les opérateurs de préfixe changent le contenu de la variable avant l’évaluation de l’expression. Les opérateurs de postfix changent le contenu de la variable après l’évaluation de l’expression.

Dans ce cas, une boucle utilise le contenu de i pour suivre le nombre de boucles.

float4 arrayOfFloats[4] = { 1.0f, 2.0f, 3.0f, 4.4f };

for (int i = 0; i<4; )
{
    arrayOfFloats[i++] *= 2; 
}

Comme l’opérateur d’incrément de postfix (++) est utilisé, arrayOfFloats[i] est multiplié par 2 avant que i soit incrémenté. Cela peut être légèrement réorganisé pour utiliser l’opérateur d’incrément de préfixe. Celui-ci est plus difficile à lire, bien que les deux exemples soient équivalents.

float4 arrayOfFloats[4] = { 1.0f, 2.0f, 3.0f, 4.4f };

for (int i = 0; i<4; )
{
    arrayOfFloats[++i - 1] *= 2; 
}

Comme l’opérateur de préfixe (++) est utilisé, arrayOfFloats[i+1 - 1] est multiplié par 2 après l’incrément de i.

L’opérateur de décrément de préfixe et de décrément de postfix (--) sont appliqués dans le même ordre que l’opérateur d’incrément. La différence est que le décrément soustrait 1 au lieu d’ajouter 1.

Opérateur de structure

L’opérateur de sélection de membre de structure (.) est un point. Étant donné cette structure :

struct position
{
float4 x;
float4 y;
float4 z;
};

Il peut être lu de la façon suivante :

struct position pos = { 1,2,3 };

float 1D_Float = pos.x
1D_Float = pos.y

Chaque membre peut être lu ou écrit avec l’opérateur de structure :

struct position pos = { 1,2,3 };
pos.x = 2.0f;
pos.z = 1.0f;       // z = 1.0f
pos.z = pos.x      // z = 2.0f

Opérateurs unaires

Les opérateurs unaires sont : !, -, +

Les opérateurs unaires opèrent sur un seul opérande.

bool b = false;
bool b2 = !b;      // b2 = true
int i = 2;
int i2 = -i;       // i2 = -2
int j = +i2;       // j = +2

Priorité des opérateurs

Quand une expression contient plusieurs opérateurs, la priorité des opérateurs détermine l’ordre d’évaluation. La priorité des opérateurs pour HLSL suit la même priorité que C.

Notes

Les accolades ({,}) ouvrent et ferment un bloc d’instructions. Quand un bloc d’instructions utilise une seule instruction, les accolades sont facultatives.

Instructions (DirectX HLSL)