Discussion :

[Lung]

J'essais de me remettre à OpenGL.
Actuellement, j'arrive à afficher des objets sans problème, utiliser des translations et des rotations pour placer mes objets, et me déplacer autour.
Le problème, c'est la lumière : pas moyen de la faire fonctionner.

Voici ce que j'utilise comme valeur pour la matière et la lumière :

Code :

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

1
2
3
4
5
6
7
8
9
   Matiere_Ambiente: array[0..3] of GLfloat = (0.4, 0.4, 0.0, 1.0);
   Matiere_Diffuse: array[0..3] of GLfloat = (0.4, 0.4, 0.0, 1.0);
   Matiere_Speculaire: array[0..3] of GLfloat = (1.0, 1.0, 1.0, 1.0);
 
   Lumiere_Ambiente: array[0..3] of GLfloat = (0.4, 0.4, 0.0, 1.0);
   Lumiere_Diffuse: array[0..3] of GLfloat = (0.5, 0.3, 0.0, 1.0);
   Lumiere_Speculaire: array[0..3] of GLfloat = (0.7, 0.7, 0.0, 1.0);
   Lumiere_Position: array[0..3] of GLfloat = (0.0, 0.0, 1.0, 0.0);
   Lumiere_Direction: array[0..2] of GLfloat = (0.0, 0.0, -1.0);

Voila comment j'initialise :

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
   glMaterialfv(GL_FRONT, GL_AMBIENT, @Matiere_Ambiente);
   glMaterialfv(GL_FRONT, GL_DIFFUSE, @Matiere_Diffuse);
   glMaterialfv(GL_FRONT, GL_SPECULAR, @Matiere_Speculaire);
   glMaterialf(GL_FRONT, GL_SHININESS, 20);
 
   glLightfv(GL_LIGHT0, GL_AMBIENT, @Lumiere_Ambiente);
   glLightfv(GL_LIGHT0, GL_DIFFUSE, @Lumiere_Diffuse);
   glLightfv(GL_LIGHT0, GL_SPECULAR, @Lumiere_Speculaire);
   glLightfv(GL_LIGHT0, GL_POSITION, @Lumiere_Position);
   glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, @Lumiere_Direction);
 
   //.Activation de l'éclairage.
   glEnable(GL_LIGHTING);
 
   //.Activation de la première lumière.
   glEnable(GL_LIGHT0);
 
   //.Activation du buffer de profondeur.
   glEnable(GL_DEPTH_TEST);

Un exemple de définition d'un objet :

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
   glPushMatrix;
      glEnable(GL_LINE_SMOOTH);
 
      glBegin(GL_QUADS);
         //.Haut.
         glNormal3f(0, 1, 0);
         glVertex3d((dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));   glVertex3d(-(dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));
         glVertex3d(-(dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));   glVertex3d((dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));
 
...
 
      glEnd;
 
      glEnable(GL_NORMALIZE);
   glPopMatrix;      //.Reprend la matrice de la pile.

Résultat, je vois bien mes objets, mais comme ils sont de même couleur, je n'ai aucun effet de 3D, vu qu'il n'y a pas de lumière (donc pas d'ombre).
J'ai raté quelque chose ?
J'ai mal défini quelque chose ?

Merci de votre aide ...

[shenron666]

Normalement tu dois passer des normales à ton objet pour qu'OpenGL saches comment la lumière doit réagir

je vois que tu utilises glEnable(GL_NORMALIZE) mais je ne sais pas si cela se substitue aux normales et je nepense pas

par contre, ton glEnable(GL_NORMALIZE) n'est pas au bon endroit, tu dois le mettre avant ta boucle (avant le dessin donc), voire à l'initialisation

[Lung]

Normalement tu dois passer des normales à ton objet pour qu'OpenGL saches comment la lumière doit réagir

je vois que tu utilises glEnable(GL_NORMALIZE) mais je ne sais pas si cela se substitue aux normales et je nepense pas

C'est pas à ca que sert glNormal3f(0, 1, 0); ?

par contre, ton glEnable(GL_NORMALIZE) n'est pas au bon endroit, tu dois le mettre avant ta boucle (avant le dessin donc), voire à l'initialisation

Je vais essayer ?
Je teste ...

[shenron666]

Normalement tu dois passer des normales à ton objet pour qu'OpenGL saches comment la lumière doit réagir

C'est pas à ca que sert glNormal3f(0, 1, 0); ?

Si mais il faut 1 normale par vertex, je ne me suis pas bien expliqué désolé, en fait lorsque tu envoies une vertex, OpenGL utilise la dernière normale transmise

[bafman]

heu... si tu envoi la même normal à tout tes vertex forcement ca va etre eclairé de la même maniere...

[Lung]

Bon, ca ne fonctionne toujours pas. J'ai déplacé glEnable(GL_NORMALIZE) au début :

Code :

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

1
2
3
4
5
6
   //.Activation de l'éclairage.
   glEnable(GL_LIGHTING);
 
   //.Activation de la première lumière.
   glEnable(GL_LIGHT0);
   glEnable(GL_NORMALIZE);

Voici un exemple d'un élément :

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
28
   glPushMatrix;
      glBegin(GL_QUADS);
         //.Haut.
         glNormal3f(0, 1, 0);
         glVertex3d((dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));   glVertex3d(-(dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));
         glVertex3d(-(dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));   glVertex3d((dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));
         //.Bas.
         glNormal3f(0, -1, 0);
         glVertex3d((dLargeur / 2), -(dHauteur / 2), (dEpaisseur / 2));   glVertex3d(-(dLargeur / 2), -(dHauteur / 2), (dEpaisseur / 2));
         glVertex3d(-(dLargeur / 2), -(dHauteur / 2), -(dEpaisseur / 2));   glVertex3d((dLargeur / 2), -(dHauteur / 2), -(dEpaisseur / 2));
         //.Devant.
         glNormal3f(0, 0, -1);
         glVertex3d((dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));   glVertex3d(-(dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));
         glVertex3d(-(dLargeur / 2), -(dHauteur / 2), (dEpaisseur / 2));   glVertex3d((dLargeur / 2), -(dHauteur / 2), (dEpaisseur / 2));
         //.Derrière.
         glNormal3f(0, 0, 1);
         glVertex3d((dLargeur / 2), -(dHauteur / 2), -(dEpaisseur / 2));   glVertex3d(-(dLargeur / 2), -(dHauteur / 2), -(dEpaisseur / 2));
         glVertex3d(-(dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));   glVertex3d((dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));
         //.Droite.
         glNormal3f(1, 0, 0);
         glVertex3d((dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));   glVertex3d((dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));
         glVertex3d((dLargeur / 2), -(dHauteur / 2), (dEpaisseur / 2));   glVertex3d((dLargeur / 2), -(dHauteur / 2), -(dEpaisseur / 2));
         //.Gauche.
         glNormal3f(-1, 0, 0);
         glVertex3d(-(dLargeur / 2), (dHauteur / 2), (dEpaisseur / 2));   glVertex3d(-(dLargeur / 2), (dHauteur / 2), -(dEpaisseur / 2));
         glVertex3d(-(dLargeur / 2), -(dHauteur / 2), -(dEpaisseur / 2));   glVertex3d(-(dLargeur / 2), -(dHauteur / 2), (dEpaisseur / 2));
      glEnd;
   glPopMatrix;

Je créer une normale par face en faisant ça, non ?
Je m'y prend mal ?

:

[Laurent Gomila]

Comme on te l'a dit, si tu envoies la même normale pour chaque sommet tu ne vas pas éclairer grand chose. Il faut la calculer correctement pour tous tes vertices.

Question à trois sous : est-ce que tu sais au moins ce qu'est une normale, et à quoi ça sert dans les calculs d'éclairage ? (autant commencer par le début...)

[Lung]

Comme on te l'a dit, si tu envoies la même normale pour chaque sommet tu ne vas pas éclairer grand chose. Il faut la calculer correctement pour tous tes vertices.

Ca fonctionne par sommet ? Pas par face ?
Bon, alors effectivement, j'ai rien compris à ce que j'ai lu ...

Question à trois sous : est-ce que tu sais au moins ce qu'est une normale, et à quoi ça sert dans les calculs d'éclairage ? (autant commencer par le début...)

Je pensais que c'était une ligne perpendiculaire à une face d'un objet.

Finnalement, je ne serais pas contre une petite explication claire ...

[bafman]

tu peut aussi les utiliser par faces mais tu n'aura pas un eclairage lissé...
ha et un autre truc : toujours envoyer les normales deja normalisée, comme ca tu n'a pas à activer la normalisation qui est inutilement consommatrice de ressources...

[Lung]

tu peut aussi les utiliser par faces mais tu n'aura pas un eclairage lissé...

Comment faire autrement que par face ?
J'ai pas trouvé d'exemple (ou alors j'ai pas compris).

ha et un autre truc : toujours envoyer les normales deja normalisée, comme ca tu n'a pas à activer la normalisation qui est inutilement consommatrice de ressources...

Comment normaliser avant ?

:

[bafman]

en fait tu a 2 solution pour gerer les normales par vertex :
- tu utiliser un format de model qui gere les normales par vertex : c'est au createur du model de gerer ses normales. cette methode a le gros aventage de pouvoir gerer les normales de facon complexes (par exemples avec des smooth group et autre)
- tu charge le model et tu calcule tes normales par vertex toi même. un algorithme basique mais qui merche bien est :

Code :

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

1
2
3
4
5
6
7
8
 
on met a 0 la normale de chaque vertex
pour chaque face :
    on calcule la normal de la face
    pour chaque vertex de la face
        on additione la normale la la face à la normale du vertex
pour chaque vertex
    on normalise la normale

sinon pour noraliser une normale, rien de plus simple :
il suffit de diviser chaque composante de la normale par la longeur du vecteur
ce qui donne (en C)

Code :

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

1
2
3
4
5
6
 
float vect[] = {x,y,z};
float length = sqrt(x*x + y*y + z*z); // racine carré de x*x + y*y + z*z
vect[0] = vect[0]/length;
vect[1] = vect[1]/length;
vect[2] = vect[2]/length;

et voila un vecteur normlisé

[shenron666]

A propos des normales normalisées, tu transmet des normales de longueur (norme) 1 et donc normalisées donc il n'est pas nécessaire d'utiliser glEnable(GL_NORMALIZE)
une normale normalisée a une norme égale à 1

[Lung]

en fait tu a 2 solution pour gerer les normales par vertex :
- tu utiliser un format de model qui gere les normales par vertex : c'est au createur du model de gerer ses normales. cette methode a le gros aventage de pouvoir gerer les normales de facon complexes (par exemples avec des smooth group et autre)
- tu charge le model et tu calcule tes normales par vertex toi même. un algorithme basique mais qui merche bien est :

Code :

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

1
2
3
4
5
6
7
8
 
on met a 0 la normale de chaque vertex
pour chaque face :
    on calcule la normal de la face
    pour chaque vertex de la face
        on additione la normale la la face à la normale du vertex
pour chaque vertex
    on normalise la normale

Quels sont les avantages de chacunes des 2 solutions ?
Pourais-tu détailler quelles fonctions à utiliser dans chacunes des 2 solutions ?

[bigquick]

A propos des normales normalisées, tu transmet des normales de longueur (norme) 1 et donc normalisées donc il n'est pas nécessaire d'utiliser glEnable(GL_NORMALIZE)
une normale normalisée a une norme égale à 1

Attention quand même à utiliser GL_RESCALE_NORMAL
( cf. http://www.developpez.net/forums/viewtopic.php?t=429481 )
A moins d'être sur de ce qu'on fait

18.090
Why is the lighting incorrect after I scale my scene to change its size?

The OpenGL specification needs normals to be unit length to achieve typical lighting results. The current ModelView matrix transforms normals. If that matrix contains a scale transformation, transformed normals might not be unit length, resulting in undesirable lighting problems.

OpenGL 1.1 lets you call glEnable(GL_NORMALIZE), which will make all normals unit length after they're transformed. This is often implemented with a square root and can be expensive for geometry limited applications.

Another solution, available in OpenGL 1.2 (and as an extension to many 1.1 implementations), is glEnable(GL_RESCALE_NORMAL). Rather than making normals unit length by computing a square root, GL_RESCALE_NORMAL multiplies the transformed normal by a scale factor. If the original normals are unit length, and the ModelView matrix contains uniform scaling, this multiplication will restore the normals to unit length.

If the ModelView matrix contains nonuniform scaling, GL_NORMALIZE is the preferred solution.

[bafman]

en fait le probleme de l'algo que j'ai donné c'est qu'il ne prend pas en compte l'angle entre les faces. ca merche tres bien pour des surfaces courbes, mais par contre pour un cube, ca donne n'importe quoi... c'est pour ca qu'il est preferable d'utiliser les normales fouris par le logiciel de modelisation, qui lui generalement prend en compte l'angle entre les faces...

[shenron666]

Attention quand même à utiliser GL_RESCALE_NORMAL
( cf. http://www.developpez.net/forums/viewtopic.php?t=429481 )
A moins d'être sur de ce qu'on fait

Donc en fait cela pose un problème lorsqu'on utilise glScale
Merci pour cette précision bigquick