Discussion :

[Charlie111]

Bonjour,

en regardant le code exemple des NxController du moteur PhysX j'ai bloqué sur un problème de syntaxe :
Il y a cette ligne dans le programme d'exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
enum CollisionGroup
{
	GROUP_NON_COLLIDABLE,
	GROUP_COLLIDABLE_NON_PUSHABLE,
	GROUP_COLLIDABLE_PUSHABLE,
};
 
#define COLLIDABLE_MASK	(1<< GROUP_COLLIDABLE_NON_PUSHABLE)

Qu'y a-t'il dans COLLIDE_MASK ?? à quoi sert << ??

Merci d'avance !

++

Charlie

[JulienDuSud]

Collide Mask contiendra le mask binaire 10.

<< appliqué sur des entiers est un opérateur qui agit directement sur les bits, en les déplacant.

Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1 << 2

Veut dire: tu prend la représentation binaire de 1 (00000001) et tu le déplace 2 fois à gauche.

Donc le nombre devient:
00000100

ce qui représente 4.

Dans l'autre sens, c'est pareil:

00100000 >> 2
devient donc
00001000

attention à la perte de donnée

(00000001 >> 1) << 1 ça donne 0 car 0 << X donne toujours 0.

[koala01]

Salut,

On peut ajouter une précision sur le fonctionnement des énumérations:

Par défaut (comprend: en dehors de toute indication de valeur contraire), la première valeur énumérée d'une énumération vaut... 0 et toute valeur énumérée vaut... la valeur énumérée précédente +1.

Cela signifie que, dans l'exemple que tu donne:

• GROUP_NON_COLLIDABLE vaut 0
• GROUP_COLLIDABLE_NON_PUSHABLE vaut 1
• GROUP_COLLIDABLE_PUSHABLE vaut 2

Maintenant, comme l'a si bien indiqué JulienDuSud, l'opérateur << provoque le décalage des bits vers la gauche du nombre de bit correspondant à ce qui se trouve après l'opérateur.

De ce fait, le défine remplacera

• COLLIDABLE_MASK (1<< GROUP_NON_COLLIDABLE) par la valeur binaire 00000001 (soit... 1 en décimal)
• COLLIDABLE_MASK (1<< GROUP_COLLIDABLE_NON_PUSHABLE) par la valeur binaire 00000010 (soit 2 en décimal)
• COLLIDABLE_MASK (1<< GROUP_COLLIDABLE_PUSHABLE) par la valeur binaire 00000100 (soit 4 en décimal)

Comme il s'agit d'une directive de définition destinée au préprocesseur, tu peux estimer que, chaque fois que tu rencontre COLLIDABLE_MASK(1<< un des termes énumérés), cela revient à écrire dans le code respectivement 1, 2 ou 4, mais avec des valeurs plus "parlantes"