Discussion :

[Bakura]

Bonsoir à tous,

Voilà, de nouveau avec un problème, c'est nouveau ça

Je commence tout juste le chapitre sur l'éclairage, et je bloque un peu sur le calcul de la normale. D'abord, si je comprends bien, la normale est tout simplement le vecteur qui est perpendiculaire à la surface et qui va indiquer comment la lumière doit "rebondir", c'est bien ça ? Par exemple si l'objet est plat, allongé, et que la normale est penché à 45°, les lumières se refleterait sur la droite (ok c'est pas très logique,...) ?

Bon ensuite pour le calcul de la normale, j'ai un peu plus de mal . Mon livre écrit :

A x B = (AyBz - AzBy, AzBx - AxBz, AxBy - AyBx)
La formule ne paraît pas compliquer, mais je ne suis pas sûr de la manière à comment je calcule mes vecteurs. Imaginons donc qu'on ait un triangle, comme ceci :

P1 = glVertex3f (0.0f, 0.0f, 0.0f);
P2 = glVertex3f (1.0f, 0.0f, 0.0f);
P3 = glVertex3f (0.0f, 1.0f, 0.0f);

Bref un triangle rectangle tout simple. Donc les deux vecteurs V1 et V2 sont,... V1 = P2 - P1 et V2 = P3 - P1. Toutefois le livre indique : "Remember that when taking the cross product, the order of the vectors matters". C'est à dire que des fois, il peut s'agir de V1 = P3 - P1 et V2 = P2 - P1. Dans quelle condition ce serait comme ça ?

Continuons les petits calculs ^^. Si je suis bien, il faut que je trouve les coordonnées des 2 vecteurs, soit :

P2 - P1 = (1.0 - 0.0, 0.0 - 0.0, 0.0 - 0.0) = (1.0, 0.0, 0.0)
P3 - P1 = (0.0 - 0.0, 1.0 - 0.0, 0.0 - 0.0) = (0.0, 1.0, 0.0)

Puis si on applique la formule du livre pour calculer la normale :

V1 x V2 = (0.0*0.0 - 0.0*1.0, 0.0*0.0 - 1.0*0.0, 1.0*1.0 - 0.0*0.0)
V1 x V2 = (-1.0, -1.0, 1.0)

Donc la normale pour ce triangle serait (-1.0, -1.0, 1.0) ? Ou je me trompe complètement ?

glBegin (GL_TRIANGLES);
glNormal3f (-1.0f, -1.0f, 1.0f);
glVertex3f (0.0f, 0.0f, 0.0f);
glVertex3f (1.0f, 0.0f, 0.0f);
glVertex3f (0.0f, 1.0f, 0.0f);
glEnd ();

Ici la normale est donc unique ? Il ne peut pas y avoir d'autres possibilités pour CE triangle là ? D'autre part, si on applique une rotation au triangle, il faudra également modifier la normale ?

Merci

PS : désolé pour tous ces topics ^^.

[plegat]

Salut,

Par exemple si l'objet est plat, allongé, et que la normale est penché à 45°, les lumières se refleterait sur la droite (ok c'est pas très logique,...) ?

Sais pas... pas compris quel tête a ton objet...

A x B = (AyBz - AzBy, AzBx - AxBz, AxBy - AyBx)
La formule ne paraît pas compliquer, mais je ne suis pas sûr de la manière à comment je calcule mes vecteurs.

Formule du produit vectoriel.
Tu devrais trouver ça dans un cours de math de.... je ne sais plus quelle classe!

Bref un triangle rectangle tout simple. Donc les deux vecteurs V1 et V2 sont,... V1 = P2 - P1 et V2 = P3 - P1. Toutefois le livre indique : "Remember that when taking the cross product, the order of the vectors matters". C'est à dire que des fois, il peut s'agir de V1 = P3 - P1 et V2 = P2 - P1.

Non. Ca veut "n'oubliez pas que quand vous calculez le produit vectoriel, l'ordre des vecteurs à une importance". Sous-entendu, sur le résultat.
En gros, si tu inverses les vecteurs, tu obtiens l'inverse. Si V1xV2=V3, tu auras V2xV1=-V3

V1 x V2 = (0.0*0.0 - 0.0*1.0, 0.0*0.0 - 1.0*0.0, 1.0*1.0 - 0.0*0.0)
V1 x V2 = (-1.0, -1.0, 1.0)

0.0*1.0 ça fait 0.0 chez moi. Mais c'est peut-être l'athlon qui déconne...
(remarque que de tête, le vecteur normal c'est le z, donc un truc du genre (0,0,1), ou (0,0,-1) en fonction de l'ordre dans lequel tu prends tes vecteurs pour faire le produit)

Ici la normale est donc unique ? Il ne peut pas y avoir d'autres possibilités pour CE triangle là ?

Au vu de ce qui a été dit précédemment, si je te dis qu'il y en a deux, tu sauras dire pourquoi?

D'autre part, si on applique une rotation au triangle, il faudra également modifier la normale ?

yes.
Sauf si c'est une rotation qui a pour axe le vecteur normal.

[Bakura]

Sais pas... pas compris quel tête a ton objet...

Euh, un triangle à plat, comme une feuille de papier sur une table.

Formule du produit vectoriel.
Tu devrais trouver ça dans un cours de math de.... je ne sais plus quelle classe!

Hum j'ai pas le souvenir d'avoir fait ça... Je sais qu'en vector l'année dernière en seconde on calculait surtout la distance d'un vecteur, les coordonnées d'un vecteur... déjà on utilisait pas de troisième dimension.

0.0*1.0 ça fait 0.0 chez moi. Mais c'est peut-être l'athlon qui déconne...
(remarque que de tête, le vecteur normal c'est le z, donc un truc du genre (0,0,1), ou (0,0,-1) en fonction de l'ordre dans lequel tu prends tes vecteurs pour faire le produit)

Oula, j'avais complètement oublié... attend je refait les calculs.

V1 x V2 = (0.0*0.0 - 0.0*1.0, 0.0*0.0 - 1.0*0.0, 1.0*1.0 - 0.0*0.0)
V1 x V2 = (0.0, 0.0, 1.0)

Voilà je crois que c'est ça ^^

Au vu de ce qui a été dit précédemment, si je te dis qu'il y en a deux, tu sauras dire pourquoi?

Euh, pas sur, mais je dirais que V3 (0.0, 0.0, 1.0) et -V3 (0.0, 0.0, -1.0) ?

Sauf si c'est une rotation qui a pour axe le vecteur normal.

Ok, mais lors de translation et de scaling, ça n'influence pas non ?

Mais sinon au niveau du calcul c'est bien ce que je fais (calcul des coordonnées des vecteurs et le calcul plus haut ?) ?

[plegat]

Euh, un triangle à plat, comme une feuille de papier sur une table.

Ok ok... et elle est où la droite?
Non, je taquine, si tu dis que c'est le vecteur perpendiculaire à la surface, c'est bon, t'as compris ce que c'est.

Hum j'ai pas le souvenir d'avoir fait ça... Je sais qu'en vector l'année dernière en seconde on calculait surtout la distance d'un vecteur, les coordonnées d'un vecteur... déjà on utilisait pas de troisième dimension.

Là, il te faut utiliser les trois dimensions de l'espace.
Ca doit se voir en première ou en terminale alors...

Euh, pas sur, mais je dirais que V3 (0.0, 0.0, 1.0) et -V3 (0.0, 0.0, -1.0) ?

Ouaip.
Une surface a deux faces (les puristes diront sauf certaines, telles le ruban de Moebius, mais bon, c'est des théoriciens...), tu as donc deux normales, une pour chaque face de ton triangle.

Ok, mais lors de translation et de scaling, ça n'influence pas non ?

La translation non.
Le scaling, oui (vu que tes vecteurs V1 et V2 vont subir un scaling, le résultat du produit vectoriel subira le même scaling... enfin, au carré). Pour t'affranchir de cela, tu peux utiliser des normales normées (dont la longueur est égale à 1)

Mais sinon au niveau du calcul c'est bien ce que je fais (calcul des coordonnées des vecteurs et le calcul plus haut ?) ?

A ma connaissance, oui.

[Edit] P'tite correction sur le scaling de la normale...

[Bakura]

Ok je te remercie pour tout ça, je vais pouvoir avancer ... Bonne nuit.

[Bakura]

Hum en fait j'ai pas trop compris les normales ^^... Je me permet de reposter si je pourrai avoir des explications supplémentaires. Bon la normale en elle même j'ai compris en grso ce que c'est, c'est un vecteur perpendicularie à la surface... En gros 1 normale par surface. Mais j'ai lu que la normale était calculé par vertex... A quoi cela sert ? . sur une surface plane, ca ne sert à rien non ? Vu que de toute façon une surface est forcément plane sauf si c'est une sphère, donc qu'une normale ?

D'autre part, j'ai découvert ce truc de système normalisée ... Oulalala c'est plus dur ça. En gros glNormal3f (1.0f, 0.0f, 0.0f) est une normale normalisée, et glNormal3f (0.9f, 0.0f, 0.0f) n'en est pas une ? Mais si les calculs donnent 0.9 quoi faire ? On arrondit à l'entier supérieur pour faire une normale ? Dans mon livre et dans les exemples que j'ai vues, ils règlent quasi à chaque fois à un truc du genre glNormal3f (1.0f, 0.0f, 0.0f), alors à quoi sert cette formule : A x B = (AyBz - AzBy, AzBx - AxBz, AxBy - AyBx) si c'est pour toujours mettre à 1.0 ?

Concernant la fonction GL_NORMALIZE, visiblement il a été dit de ne pas l'utiliser, mais si je comprends son usage, c'est justement de faire passer en normal normalisé des trucs du genre glNormal3f (0.6f, 0.5f, 0.0f) ?

Enfin bref j'ai pas trop compris ce coup des normales, si je pourrais avoir quelques infos sur ça, je vous serai reconnaissant ^^.

[plegat]

Mais j'ai lu que la normale était calculé par vertex... A quoi cela sert ? . sur une surface plane, ca ne sert à rien non ? Vu que de toute façon une surface est forcément plane sauf si c'est une sphère, donc qu'une normale ?

En modélisation 3D, on utilise souvent des surfaces non planes autres que la sphère, genre surface de Bézier. Là, tu ne pourras pas avoir une normale unique pour toute la surface.

Oulalala c'est plus dur ça.

Détrompe-toi, c'est hyper simple!

En gros glNormal3f (1.0f, 0.0f, 0.0f) est une normale normalisée, et glNormal3f (0.9f, 0.0f, 0.0f) n'en est pas une ? Mais si les calculs donnent 0.9 quoi faire ? On arrondit à l'entier supérieur pour faire une normale ?

Un vecteur normalisé à une norme égale à 1.
La norme du vecteur V(x,y,z) se calcul avec la formule racine(x^2+y^2+z^2)
Et tu normalises ton vecteur en divisant ses trois composante par la norme du vecteur.
Donc ton vecteur (0.9,0,0), de norme 0.9, tu divises les composantes par la norme, tu as donc (0.9/0.9,0/0.9,0/0.9)=(1,0,0)

alors à quoi sert cette formule : A x B = (AyBz - AzBy, AzBx - AxBz, AxBy - AyBx) si c'est pour toujours mettre à 1.0 ?

A t'éviter de sortir les trois composantes du vecteur de manière totalement arbitraire.
Il faut quand même faire un minimum de calcul, non, pour avoir au moins la direction du vecteur....


A mon avis, il te faudrait un bon tutoriel sur les vecteurs... Ca ira de suite mieux ensuite! Il y a quelques notions à assimiler, après tu verras que ce sont des outils très puissants.

[Sixissor]

Bon la normale en elle même j'ai compris en grso ce que c'est, c'est un vecteur perpendicularie à la surface... En gros 1 normale par surface. Mais j'ai lu que la normale était calculé par vertex... A quoi cela sert ? . sur une surface plane, ca ne sert à rien non ? Vu que de toute façon une surface est forcément plane sauf si c'est une sphère, donc qu'une normale ?

Il y a 2 types d'ombrages disponibles avec OpenGL de base: l'ombrage plat (flat shading) et ombrage Gouraud (Gouraud shading).

Pour l'ombrage plat, il suffit d'avoir une seule normale par face car la lumière diffuse associée sera seulement calculé en fonction du vecteur direction de la vue et de la normale de la face: valeur du produit scalaire (s'il est négatif) X une constante propre au matériel = lumière diffuse de la face. Cette technique est assez grossière...

Ensuite, il y a l'ombrage Gouraud, plus efficace: au lieu d'avoir une normale par face, on en a une par vertex. Pourquoi ? Tout simplement pour adoucir la luminosité car on calcule une normale moyenne par vertex ! Il y a donc une interpolation de la luminosité entre les 3 sommets d'un polygone, d'où une coloration des pixels plus nuancée.

Exemple en image:
équivaut à cette représentation des normales:
équivaut à cette représentation des normales:

Commentaire: normale bleue = moyenne des normales rouges (par sommet).

Comme tu le vois dans ce cas, l'ombrage Gouraud permet clairement d'arrondir les angles, en donnant un rendu plus lisse.

D'autre part, j'ai découvert ce truc de système normalisée ... Oulalala c'est plus dur ça. En gros glNormal3f (1.0f, 0.0f, 0.0f) est une normale normalisée, et glNormal3f (0.9f, 0.0f, 0.0f) n'en est pas une ? Mais si les calculs donnent 0.9 quoi faire ? On arrondit à l'entier supérieur pour faire une normale ? Dans mon livre et dans les exemples que j'ai vues, ils règlent quasi à chaque fois à un truc du genre glNormal3f (1.0f, 0.0f, 0.0f), alors à quoi sert cette formule : A x B = (AyBz - AzBy, AzBx - AxBz, AxBy - AyBx) si c'est pour toujours mettre à 1.0 ?

Concernant la fonction GL_NORMALIZE, visiblement il a été dit de ne pas l'utiliser, mais si je comprends son usage, c'est justement de faire passer en normal normalisé des trucs du genre glNormal3f (0.6f, 0.5f, 0.0f) ?

Il est important de normaliser ses vecteurs normaux pour avoir une lumière correctement calculée. Si tu ne les normalises pas, ils peuvent être faussés par certaines transformations, et donc tu obtiens un faux éclairage.
Concernant GL_NORMALIZE, il s'agit d'un état qui permet, grâce à son activation par glEnable() , de recalculer les vecteurs normaux normalisés. Il s'agit en effet d'une opération qui influe pas mal sur les performances, donc à n'utiliser qu'en cas de nécessité

++

[Ti-R]

Ce thread ci-dessous peut aussi t'éclairer sur une bonne utilisation des normales


http://www.developpez.net/forums/sho...d.php?t=194564

[Bakura]

Merci pour vos réponses... J'ai essayé de faire un petit programme avec un cube qui tourne, une lumière rouge statique très atténué et une lumière verte non attenué qui tourne autour du cube.

Voici le zip avec l'exe et le code source : Pièce jointe 4225

Voici mon cube, avec les normals :

glBegin (GL_QUADS);
glColor3ub (192, 192, 192);
glNormal3f (0.0f, 0.0f, 1.0f);
glVertex3f (-1.0f, 1.0f, 1.0f); // Devant
glVertex3f (1.0f, 1.0f, 1.0f);
glVertex3f (1.0f, -1.0f, 1.0f);
glVertex3f (-1.0f, -1.0f, 1.0f);
glNormal3f (0.0f, 0.0f, -1.0f);
glVertex3f (-1.0f, 1.0f, -1.0f); // Derrière
glVertex3f (1.0f, 1.0f, -1.0f);
glVertex3f (1.0f, -1.0f, -1.0f);
glVertex3f (-1.0f, -1.0f, -1.0f);
glNormal3f (0.0f, 1.0f, 0.0f);
glVertex3f (-1.0f, 1.0f, 1.0f); // Haut
glVertex3f (1.0f, 1.0f, 1.0f);
glVertex3f (1.0f, 1.0f, -1.0f);
glVertex3f (-1.0f, 1.0f, -1.0f);
glNormal3f (0.0f, -1.0f, 0.0f);
glVertex3f (-1.0f, -1.0f, 1.0f); // Bas
glVertex3f (1.0f, -1.0f, 1.0f);
glVertex3f (1.0f, -1.0f, -1.0f);
glVertex3f (-1.0f, -1.0f, -1.0f);
glNormal3f (-1.0f, 0.0f, 0.0f);
glVertex3f (-1.0f, 1.0f, 1.0f); // Gauche
glVertex3f (-1.0f, 1.0f, -1.0f);
glVertex3f (-1.0f, -1.0f, -1.0f);
glVertex3f (-1.0f, -1.0f, 1.0f);
glNormal3f (1.0f, 0.0f, 0.0f);
glVertex3f (1.0f, 1.0f, 1.0f); // Droite
glVertex3f (1.0f, 1.0f, -1.0f);
glVertex3f (1.0f, -1.0f, -1.0f);
glVertex3f (1.0f, -1.0f, 1.0f);
glEnd ();

Donc là j'ai bien ce que vous appeliez du flat shading avec une seule normale par face ? Mais j'avoue que j'ai du mal à trouvé les normales par vertices... Normalement pour que le résultat soit optimale il faudrait donc qu'il y ait une normale par vertice. Donc par exemple que la normale du point haut gauche de la face de devant soit la moyenne de la normale de la face de devant soit : glNormal3f (0.0f, 0.0f, 1.0f) et de celle de gauche : glNormal3f (-1.0f, 0.0f, 0.0f), c'est bien ça ? Ce qui nous donne pour la vertice haut gauche et haut bas de la face de devant ainsi que les vertices haut droit et bas droit de la face de gauche, la normal... glNormal3f (-0.5f, 0.0f, 0.5f) ? Par contre la problème :

Donc ton vecteur (0.9,0,0), de norme 0.9, tu divises les composantes par la norme, tu as donc (0.9/0.9,0/0.9,0/0.9)=(1,0,0)

La il est de norme 0.5 ou -0.5 ?

Ca peut donc donner glNormal3f (-0.5/-0.5, 0.0f, 0.5 / 0.5) = (-1.0, 0, 1.0f)... Est-ce correct ?

Dans tous les cas, si il s'avère que c'est ça... Il n'y a pas de technique plus rapide ? Parceque la c'est un cube donc en deux minutes c'est fait, mais j'imagine pas sur des formes complexes, rien qu'à l'idée de se représenter tout ça...

[Ti-R]

Bakura, sur un cube ce que tu as fait est bien !
1 seule normale par face.

Ensuite tout dépend de ce que tu veux faire, cela va faire bizarre d'interpoler les normales aux sommets de ton cube...

Les normales sont plus définies par le graphiste, ce n’est pas à toi de les recalculer !!

Regarde le lien que j'ai donné si dessus, car je vais me répéter (il y a 2 pages), tu peux t'amuser à coder un loader de fichier ASE basique pour t'entraîner et voir l'effet des normales lors d'exportation d'objets 3D vers ton application.

[Bakura]

Juste une dernière petite question,... Je commence à me faire une petite démo avec des cubes, des sphères, avec plusieurs lampes de différents types et pouvoir bouger dans tout ça, histoire de m'y retrouver un peu mieux (même si j'ai toujours du mal à cerner les différences entre les specular, emissive,... D'ailleurs j'ai trouvé un truc sur un site américain qui pourrait un peu me simplifier tout ceci, est-ce que quelqu'un peut me confirmer que c'est pas du pipot ?

Lumières :

A good set of settings for a light source would be to set the Diffuse and Specular components to the colour of the light source, and the Ambient to the same colour - but at MUCH reduced intensity, 10% to 40% seems reasonable in most cases.

Matériels :

For the glMaterial, it's usual to set the Ambient and Diffuse colours to the natural colour of the object and to put the Specular colour to white. The emission colour is generally black for objects that do not shine by their own light.

Concernant la normalisation d'un vecteur, j'ai pris des coordonnés un peu différente et j'ai refait les calculs pour trouver la normale et la normaliser :

v0 : glVertex3f (-1.0f, 2.0f, 1.0f)
v1 : glVertex3f (-1.0, -2.0f, 0.0f)
v2 : glVertex3f (2.0f, 0.0f, 0.0f);

a.x = 0.0
a.y = 4.0
a.z = 1.0

b.x = -3.0
b.y = -2.0
b.z = 0.0

normal.x = (0) - (-2.0) = 2.0f
normal.y = (-3.0) - (0.0) = -3.0f
normal.z = 0.0 - (-12.0) = -12.0f

(2.0, -3.0, -12.0)

longueur = 12.53

v.x = 2.0 / 12.53 = 0.15
v.y = -3.0 / 12.53 = -0.23
v.z = -12.0 / 12.53 = -0.95

Donc ce qu'il faudra écrire dans la glNormal3f ce sont ces trois coordonnées... Pourtant personne n'a écrit plus haut q'un vecteur normalisé c'était un vecteur qui avait une longueur de 1 ? C'est pas le cas ici ?

Promis je vous embête plus, je viendrais juste poster ma petite démo ^^.

[plegat]

Pourtant personne n'a écrit plus haut q'un vecteur normalisé c'était un vecteur qui avait une longueur de 1 ?

Si, c'est moi qui ai dit ça!

C'est pas le cas ici ?

Ben si.
Enfin, avec trois chiffres après la virgule pour tes composantes, ça marche mieux!

[Bakura]

Ben si.
Enfin, avec trois chiffres après la virgule pour tes composantes, ça marche mieux!

J'ai rien dit , je viens de m'apercevoir de mon erreur ^^...

Bon allez je retourne sur mes spots (qui marchent pas, évidemment ^^).

[Bakura]

Désolé d'upper ce vieux topic ^^...

Voila en fait j'ai besoin de trouver la normale mais par vertex. Pour trouver la normale de la face :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      CVector a (m_vVertices [m_vFaces [i].indexVertices [0]].x, m_vVertices [m_vFaces [i].indexVertices [0]].y,
                 m_vVertices [m_vFaces [i].indexVertices [0]].z);
      CVector b (m_vVertices [m_vFaces [i].indexVertices [1]].x, m_vVertices [m_vFaces [i].indexVertices [1]].y,
                 m_vVertices [m_vFaces [i].indexVertices [1]].z);
      CVector c (m_vVertices [m_vFaces [i].indexVertices [2]].x, m_vVertices [m_vFaces [i].indexVertices [2]].y,
                 m_vVertices [m_vFaces [i].indexVertices [2]].z);
 
      CVector normale;
      normale.Normal (a, b, c);
 
      normale.x = normale.x;
      normale.y = normale.y;
      normale.z = normale.z;
 
      normaletmp.Normalize ();
 
      aseVertex tmp;
      tmp.x = normale.x;
      tmp.y = normale.y;
      tmp.z = normale.z;
 
      m_vNormales.push_back (tmp);
      m_vNormales.push_back (tmp);
      m_vNormales.push_back (tmp);
   }

Mais évidemment, j'obtiens un flat shading tout moche :



Bref, je voudrais savoir comment calculer une normale mais par vertice, à partir de ma normale de la face ?

[fearyourself]

Bref, je voudrais savoir comment calculer une normale mais par vertice, à partir de ma normale de la face ?

La solution la plus répandue est de faire la moyenne des normales des faces dont le vertice fait partie.

On fait ce calcul une fois et après on réutilise le résultat directement.

Jc

[Bakura]

La solution la plus répandue est de faire la moyenne des normales des faces dont le vertice fait partie.

On fait ce calcul une fois et après on réutilise le résultat directement.

Jc

Euh j'ai pas compris ? Je n'ai qu'une normale par face, comment veux-tu que je fasse une moyenne d'un seul élément ?

[Bakura]

Hop hop !

Je reviens de nouveau, mais cette fois-ci pas pour un problème, juste pour quelques questions ^^

Voilà j'ai continué à jouer un peu avec les lumières, et j'ai réussi à faire fonctionner les spots. J'ai fait un petit programme avec trois spheres éparpillés, une à droite, une à gauche, et une au fond... Et deux lampes-spot, une rouge, et une bleu, pour faire des gyrophares, qui tournent chacun en sens inverse. Je suis plutôt content du rendu que ça donne : SDLOGL.zip (désolé fearyourself, toujours pas de makefile, mais c'est en zip maintenant et plus en rar, ya déjà du progrès )

Bon première petite question (à savoir que j'ai réglé tous les matériaux pour chaque sphère via la fonction glColorMaterial, j'ia donc réglé Specular, Ambient, Diffuse et Emission, et pour les lampes j'ai tout réglé aussi). La sphère de gauche est donc bleu... Quand le spot bleu passe sur elle est bien éclairé par le bas (normal le spot se trouve en bas)... Alors que le spot rouge éclaire bien par le haut mais juste un petit point (je crois que c'est ça le specular, l'impact juste de la lumière). Mais la la lumière ne "s'étend" aps sur la sphère comme le fait la lumière blanche... J'ai pas de lumière rouge pour tester, mais c'est juste parceque le bleu absorbe tout le rouge donc on ne voit pas trop de rouge c'est bien ça ?

A contrario, sur la sphère grise, la lumière rouge est très visible.

Pour continuer sur mes questions, j'ai donc à l'intérieur de mes deux sphères qui tourne un "spot"... Quand le spot est en direction opposé à l'écran, je concoie que la sphère ne soit pas éclairé. Toutefois lorsque la sphère est vers nous, elle n'est pas élcairé (alors que l'intérieur de la sphère devrait normalement être éclairé). Lancez le programme vous comprendrez ^^.

D'autres part j'ai un truc un peu bizarre. Pourquoi lorsque je baisse l'attribut GL_SPOT_CUTOFF le rendu est tout cracra (on voit les pixels), alors qu'à une certaine valuer, le rendu est très joli...

Voilà c'est tout ^^