debutant opengl : d'ou viennent ces problemes ?

Bonjour,

Je developpe depuis environ deux semaines avec OpenGL. Je m'arrache les cheveux depuis 3 jours. J'obtiens des effets "bizarres", lorque j'utilise le blending (+/- le fog). J'ai lu et relu mon code, des tutorials sur le net, mais rien faire.

Voici les captures des differents effets que j'obtiens (les "lignes" sont detaillees dans le code source) :

Cas 1 :
ligne I : commenté
ligne II : non commenté
ligne III : commenté
http://www.freazer.com/perso/nemohck/opengl/cas1.png

Cas 2 :
ligne I : non commenté
ligne II : non commenté
ligne III : commenté
http://www.freazer.com/perso/nemohck/opengl/cas2.png

Cas 3 :
ligne I : commenté
ligne II : non commenté
ligne III : non commenté
http://www.freazer.com/perso/nemohck/opengl/cas3.png

Cas 4 :
ligne I : non commenté
ligne II : non commenté
ligne III : non commenté
http://www.freazer.com/perso/nemohck/opengl/cas4.png

Le code source :

Citation:

---

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>


GLsizei w, h;
GLfloat fogColor [4] = {1.0, 1.0, 0.5, 1.0};


void init (void) {
glClearColor (1.0, 1.0, 0.5, 1.0);
glShadeModel (GL_SMOOTH);

glEnable (GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);

glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective (30, 1.0, .1, 15);

glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();

// Initialisation du blending + lissage
glHint (GL_LINE_SMOOTH_HINT, GL_FASTEST);
glHint (GL_POLYGON_SMOOTH_HINT, GL_FASTEST);
glLineWidth (1.5);
glEnable (GL_LINE_SMOOTH);
// glEnable (GL_POLYGON_SMOOTH); // <<<======================= Ligne I
glEnable (GL_BLEND); // <<<===================================== Ligne II
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

// Initialisation du fog
glFogi (GL_FOG_MODE, GL_EXP);
glFogf (GL_FOG_DENSITY, .5);
glFogfv (GL_FOG_COLOR, fogColor);
glHint (GL_FOG_HINT, GL_FASTEST);
glFogf (GL_FOG_START, 1.0);
glFogf (GL_FOG_END, 5.0);
glEnable (GL_FOG); // <<<======================================= Ligne III
}


void display (void) {
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

// Transformation de visualisation
glPushMatrix ();
glRotatef (0, 0, 1, 0);
glTranslatef (0, 0, -9);

glDepthMask (GL_FALSE);

// Dessine 2 lignes croisees
glColor4f (1.0, .0, 1.0, 1.0);
glBegin (GL_LINES);
glVertex3f (-.5, -.5, 0);
glVertex3f (1.5, .5, 0);
glVertex3f (.5, -.5, 0);
glVertex3f (-1.5, .5, 0);
glEnd ();

glPushMatrix ();
glColor4f (1.0, .0, .5, .4);
glTranslatef (1.75, 0, -1.0);

// Dessine le triangle
glPushMatrix ();
glTranslatef (-1.5, 0.0, 0);
glBegin (GL_TRIANGLES);
glVertex3f (-.5, -.5, 0);
glVertex3f (.5, -.5, 0);
glVertex3f (0, .5, 0);
glEnd ();
glPopMatrix ();


// Dessine 3 spheres
glutSolidSphere (1.0, 20, 16);
glTranslatef (-1.5, 0, -1.5);
glTranslatef (-1.5, 0, -1.5);
glutSolidSphere (1.0, 20, 16);
glTranslatef (-1.5, 0, -1.5);
glutSolidSphere (1.0, 20, 16);

glPopMatrix ();
glPopMatrix ();

glDepthMask (GL_TRUE);
glutSwapBuffers ();
}


int main (int argc, char ** argv) {
w = 400;
h = 400;

glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize (w, h);
glutInitWindowPosition (0, 0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMainLoop();
return 0;
}

---

Je ne comprends pas les différents effets que j'obtiens et les moyens de les contourner.

Pour le cas 1, seul le blending est activé, çà fonctionne normalement.

Pour le cas 2, j'ai activé le blending et le lissage des polygones. Les traits qui correspondent au chevauchement des polygones peuvent etre supprimé (je crois) par le multi-echantillonage. Cela, signifie-t-il qu'on ne peut pas utiliser le lissage des polygones dans la majorité des situations ?

Pour le cas3, j'ai activé le blending et le fog, cependant on obtient le meme resultat que dans le cas 1 (avec les couleur un peu plus claires). Les spheres ne se trouvant pas à la meme profondeur ont devrait constater une difference de couleur.

Pour le cas 4, j'ai activé le blending avec lissage des polygones et le fog. Là, je comprends strictement rien.


Ma carte video est une ATI rage mobility P/M. Je sais que c'est de la dob. Le problème pourrait-il venir de là.

Je sais que çà fait beaucoup de questions pour un seul post.

Merci pour vos réponses.

ouaip en fait le blending (qui veut dire mélange) mélange donc la couleur obtenue avec l'ancienne couleur se trouvant dans le backbuffer... c'est à dire que si tu n'affiche pas tes sphères dans un certain ordre : (du plus loin au plus pret) eh bas tu auras ce résultat final ;)

en fin c'est ce que je pense j'a pas lu le code :roll:

bob.killer,

en koi le fait d'afficher mes objet dans un certain ordre va-t-il resoudre les effets que j'obtiens sur mes spheres dans le cas 2, et supprimer les effets "louches" que j'obtiens dans le cas 4 ?

De plus, si tu regardes mon code :wink:, tu verras que j'ai desactivé le mode ecriture dans le Z-buffer ==> glDepthMask(GL_FALSE);

Losque tu veux afficher des objets opaques et translucides, il est vrai que tu dois commencer par afficher les objets opaques, puis desactiver l'ecriture du Z-buffer, puis de dessiner les objets transparents. Or, ma scene est composée d'objets translucides sauf les deux droites.

Merci pour ta reponse.

Petite precision, dans le cas 2, les effets indesirables ne sont pas le chevauchement des spheres, mais mais celui des QUADS sur chage spheres.

Si, vous voulez des precisions, demandez moi.

Tiré de la doc de glBlendFunc :

Transparency is best implemented using glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) with primitives sorted from farthest to nearest.

la fonction de blending que tu utilises est dépendante de l'ordre d'affichage de tes objets

assures toi d'afficher tes polygones du plus lointain au plus proche et regardes le résultat

par contre je ne comprend pas ton histoire de quads dans le cas 2, tu n'affiches aucun quad :?:

Citation:

---

Envoyé par shenron666

par contre je ne comprend pas ton histoire de quads dans le cas 2, tu n'affiches aucun quad :?:

---

Je pense qu'il parle du fait qu'on voit la triangulation des sphères...

Jc

Oui, en effet, la primitive geometrique de la sphere n'existe pas, donc les spheres sont composées de GL_QUADS.
Dans le cas 2, on le voit nettement avec le probleme que j'ai : les lignes sur les spheres sont un effet provoqué par le lissage des polygones entre les GL_QUADS.

Par contre, afficher les polygones dans un certain ordre (profondeur) suppose que l'on connaisse les coordonnées des polygones apres transformation de MODEL_VIEW et de PROJECTION. Existe-t-il une fonction permettant de recuperer ces coordonnees ? Ou faut-il le faire "à la main" en multipliant les coordonnees du sommet par la matrice de modelisation et de projection ce qui serait une perte de temps ?

Je sais ! Il faudrait que j'essaie de faire des phrases plus courte. :roll:

tu dois connaitre les coordonnées de tes objets et de ton point de vue
tu fais des calculs de distance d'un point à un autre, c'est approximatif mais suffisant