[OpenGL/GLSL] Texture - Transparence non voulu

Version imprimable

24/01/2010, 01h00
AuraHxC

[OpenGL/GLSL] Texture - Transparence non voulu

Alors voilà j'ai fait un cube avec application d'une texture mais je vois parfois (voir souvent à travers le cube sans pour autant voir le fond de la scène.
Je joins deux images pour illustrer mes propos.

Vous pensez que cela vient de quoi exactement ? Si besoin je mettrais du code.
24/01/2010, 03h21
oxyde356

Salut à toi, alors enfaite il n'est pas question de transparence, quand tu dessine tes triangles, tu dois donner tes vertex dans un sens précis (celui des aiguilles d'une montre). Sinon ton triangle n'est pas affiché. Ce qu'il se passe dans ton cas c'est que certains points de tes triangles sont données dans le sens inverse des aiguilles d'une montre donc tu vois les faces internes de ton cube. Pour remédier à cela tu dois inverser les vertex quand tu les stockent où quand tu les affichent. De cette façon seuls les faces externes de ton cube seront affichées et tu n'auras pas cet effet bizarre. Si tu ne comprend pas mon explication, donne ton code pour afficher le cube et je te montrerais ;)

Code:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
GLfloat vertices[72] = {
      -1.0f, -1.0f,  1.0f, /* Begin Front Face */
      1.0f, -1.0f,  1.0f,
      1.0f,  1.0f,  1.0f,
      -1.0f,  1.0f,  1.0f, /* End Front Face */
      -1.0f, -1.0f, -1.0f, /* Begin Back Face */
      -1.0f,  1.0f, -1.0f,
      1.0f,  1.0f, -1.0f,
      1.0f, -1.0f, -1.0f,   /* End Back Face */
      -1.0f,  1.0f, -1.0f,  /* Begin Top Face */
      -1.0f,  1.0f,  1.0f,
      1.0f,  1.0f,  1.0f,
      1.0f,  1.0f, -1.0f,   /* End Top Face */
      -1.0f, -1.0f, -1.0f,  /* Begin Bottom Face */
      1.0f, -1.0f, -1.0f,
      1.0f, -1.0f,  1.0f,
      -1.0f, -1.0f, 1.0f,  /* End Bottom Face */
      1.0f, -1.0f, -1.0f,   /* Begin Right Face */
      1.0f,  1.0f, -1.0f,
      1.0f,  1.0f, 1.0f,
      1.0f, -1.0f,  1.0f,   /* End Right Face */
      -1.0f, -1.0f, -1.0f,  /* Begin Left Face */
      -1.0f, -1.0f,  1.0f,
      -1.0f,  1.0f,  1.0f,
      -1.0f,  1.0f, -1.0f   /* End Left Face */
   };
 
   GLuint indices[36] = {
      0, 1, 2,
      2, 3, 0,
      4, 5, 6,
      6, 7, 4,
      8, 9, 10,
      10, 11, 8,
      12, 13, 14,
      14, 15, 12,
      16, 17, 18,
      18, 19, 16,
      20, 21, 22,
      22, 23, 20
   };

Voilà le code des vertices et des indices.

24/01/2010, 17h27
oxyde356

Alors avant de regarder le sens d'affichage de tes faces, je vais te demander de faire une petite optimisation :P
Tu ne dois pas avoir autant de vertices pour dessiner un cube, dans un cube il n'y a que 8 points (un pour chaque coin pas plus, là dans ton cas tu as des doublons), tu dois associer l'indice de ces 8 points pour créer ton cube, une fois que ça c'est fait je trouverais le bon ordre de tes indices. Autre chose, quand tu affiche ton cube tu utilise quoi comme fonction d'affichage, es-tu sûr que celle-ci gère les primitives indexées (utilisant des indices) ?

Mon cube est texturé en fait :

Code:

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
 
GLfloat textures[48] = {
      0.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      0.0f, 1.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      0.0f, 1.0f,
      0.0f, 0.0f,
      0.0f, 1.0f,
      0.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      1.0f, 1.0f,
      0.0f, 1.0f,
      0.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      0.0f, 1.0f,
      0.0f, 0.0f,
      0.0f, 0.0f,
      1.0f, 0.0f,
      1.0f, 1.0f,
      0.0f, 1.0f
   };

Donc est ce bon ou effectivement j'ai trop de vertices ?
Parce que je suis d'accord quand je fais un cube sans texture (je l'ai fait) je n'avais que 8 vertices dans mon VBO.

EDIT : Pour les indices voici comment je fais : juste un bout du code.

Code:

1
2
3
4
5
 
/* On active le buffer des indices */
   glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, buffers[INDICES] );
   /* Rendu de la géométrie */
   glDrawElements( GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0 );

24/01/2010, 18h08
AuraHxC

Tiens j'ai envie de poser une question un peu différente que tu pourras voir après.
Je voudrais faire un peu d'éclairage mais il me faut les normales de mon cube donc faut que je calcul les normales par face (ou par vertex).

1ère question : je fais par face ou par Vertex.
2ème question : Comment je peux faire cela facilement => je regarde sur internet pour les compléments mathématiques mais je voudrais ton/votre avis de comment faire ça bien.
24/01/2010, 19h00
oxyde356
Disons qu'au lieu d'avoir une texture par face, tu peux avoir une texture "patron de cube" qui contient toutes les textures de ton cube et qui s'applique bien. Tu peux le faire via un logiciel de modélisation, mais pour un cube ça se fait bien à la main aussi. Il suffit de faire une texture qui contient les 6 textures de ton cube en forme de croix :
Code:

1 2 3 X XXXX X
Ici chaque X représente la texture d'une face, après les coordonnées de texture c'est pas bien compliqué et tu n'as besoin que de 8 points, tes coordonnées de texture c'est toujours dans l'intervalle 0.0f - 1.0f sauf que là tu as du 1.0f/4.0f et du 1.0f/3.0f fin je pense que tu vois comment ça marche sinon tu peux te renseigner en regardant du coté des "cubemap" tu trouvera vite ;)
Pour les lumières je ne vois pas comment tu veux donner des informations de lumière aux faces, il ne me semble pas que tu puisse passer ces informations à la carte graphique à pars avec un shader mais je ne vois pas l'intérêt tu perdrais des informations en généralisant les propriétés de lumières à tous les pixels d'une face alors qu'en donnant ces informations au pixels, la carte graphique les interpoles. Bon après c'est vrai que pour un cube c'est pas évident, car avec seulement 8 points tu ne peux définir que 8 normales hors il est vrai que pour un cube les normales des faces conviendraient pour l'afficher correctement. Si tu n'as pas peur de t'essayer en shader tu peux essayer de faire du per-pixel-lighting, c'est pas hyper compliqué et l'effet est super et ça te permettrais d'avoir un cube à 8 points ce qui est optimal. Fin moi je te conseil de faire comme ça, je suppose que tu apprends et là ça te permet d'apprendre vite et bien, vu qu'à chaque étape tu aura un rendu.
24/01/2010, 19h11
AuraHxC

Woki je vais regarder ça et sinon je n'utilise que les shaders, je fais du opengl 3.x/GLSL "strict".

EDIT : Sinon pour l'instant je ne vais pas faire le cubemap, je voudrais au moins réussir a avoir un cube texturé qui s'affiche correctement comme je l'ai défini. Le cubemap je verrais ça par après je pense.

Donc tu ferais comment pour définir correctement pour que je n'obtienne pas l'affichage que j'ai pour l'instant (voir photo).
24/01/2010, 20h12
oxyde356
Il faut que tu vérifie les 3 indices par triangle que tu définie de façon à ce que ceux-ci correspondent à des coordonnées "dans le sens des aiguilles d'une montre". Je m'explique :
Code:

1 2 3 4 5 1-------2 | / | | / | | / | 0-------3
Pour dessiner ce quad il faut utiliser cette suite de vertices :
012 023
Dans ce cas le quad s'affiche dans le sens naturel, face à la camera.
Si on fait :
021 032
Alors le triangle va s'afficher derrière, c'est ce qui se passe avec ton cube c'est pour ça que tu vois les faces intérieurs et pas extérieur.

ALors j'ai fait ceci :

Code:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
GLfloat vertices[72] = {
      -1.0f, -1.0f, -1.0f, /* Begin Front Face */
      -1.0f,  1.0f, -1.0f,
      1.0f,  1.0f, -1.0f,
      1.0f, -1.0f, -1.0f,   /* End Front Face */
      -1.0f, -1.0f,  1.0f, /* Begin Back Face */
      1.0f, -1.0f,  1.0f,
      1.0f,  1.0f,  1.0f,
      -1.0f,  1.0f,  1.0f, /* End Back Face */
      -1.0f,  1.0f, -1.0f,  /* Begin Top Face */
      1.0f,  1.0f,  -1.0f,
      1.0f,  1.0f,  1.0f,
      -1.0f,  1.0f, 1.0f,   /* End Top Face */
      -1.0f, -1.0f, -1.0f,  /* Begin Bottom Face */
      1.0f, -1.0f, -1.0f,
      1.0f, -1.0f,  1.0f,
      -1.0f, -1.0f, 1.0f,  /* End Bottom Face */
      1.0f, -1.0f, -1.0f,   /* Begin Right Face */
      1.0f,  -1.0f, 1.0f,
      1.0f,  1.0f, 1.0f,
      1.0f, 1.0f,  -1.0f,   /* End Right Face */
      -1.0f, -1.0f, 1.0f,  /* Begin Left Face */
      -1.0f, -1.0f,  -1.0f,
      -1.0f,  1.0f,  -1.0f,
      -1.0f,  1.0f, 1.0f   /* End Left Face */
   };
 
   GLuint indices[36] = {
      0, 1, 2,
      0, 2, 3,
      4, 5, 6,
      4, 6, 7,
      8, 9, 10,
      8, 10, 11,
      12, 13, 14,
      12, 14, 15,
      16, 17, 18,
      16, 18, 19,
      20, 21, 22,
      20, 22, 23
   };

Je pensais que c'était bon mais cela me donne la même chose, donc je pense que je capte rien...

24/01/2010, 21h08
oxyde356

Bon je les ai pas tous vérifier mais 8,9,10 8,10,11 sont des triangles qui vont être affichés si l'on regarde de l'intérieur du cube et pas de l'extérieur ce qui fait que tu vois dans ton cube. Deux choix s'offrent à toi, ou tu change l'ordre d'affichage de tes indices de façon à ce que tes triangles soient affichés dans le sens des aiguilles d'une montre, dans l'exemple que je t'ai donné change en : 8,11,10 8,10,9 ou sinon tu désactive le backface-culling avec glCull (un truc dans le genre) pour dire à la carte graphique de dessiner les triangles quelques soit l'ordre d'apparition de ses vertices (par contre niveau performance ce n'est pas optimal mais pour débuter c'est tout à fait acceptable).

P.S : dans ta modification tu avais changé l'ordre des indices de 2,3,0 en 0,2,3 ce qui ne change strictement rien dans l'ordre d'apparition de tes points (en plus cette face est correcte pas besoin d'y toucher), dessine toi ton cube sur papier avec les sommets numérotés par tes indices pour t'en convaincre ;)
24/01/2010, 21h20
AuraHxC

Woki je vais dessiner sur papier, faire un essai et je reviens te tenir au courant ;)

Roh je vais finir par pleurer lol
Toujours pas un affichage correct... En fait je me demande si je me trompe pas de sens sur certaines faces du faites que sur mon image j'ai des face où c'est l'intérieur que l'on voit.
Par exemple, la face du fond sur le dessin c'est l'interieur que je vois donc dans ma tête je faisais une rotation de la face pour l'avoir face a moi et faire les indices dans le sens des aiguilles d'une montre, tu vois ce que je veux dire ? est ce bien ?

voilà le code de nouveau modifié... je me demande si je vais y arriver un jour lol

Code:

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
GLfloat vertices[72] = {
      -1.0f, -1.0f, -1.0f, /* Begin Front Face */
      -1.0f,  1.0f, -1.0f,
      1.0f,  1.0f, -1.0f,
      1.0f, -1.0f, -1.0f,   /* End Front Face */
      -1.0f, -1.0f,  1.0f, /* Begin Back Face */
      1.0f, -1.0f,  1.0f,
      1.0f,  1.0f,  1.0f,
      -1.0f,  1.0f,  1.0f, /* End Back Face */
      -1.0f,  1.0f, -1.0f,  /* Begin Top Face */
      1.0f,  1.0f,  -1.0f,
      1.0f,  1.0f,  1.0f,
      -1.0f,  1.0f, 1.0f,   /* End Top Face */
      -1.0f, -1.0f, -1.0f,  /* Begin Bottom Face */
      1.0f, -1.0f, -1.0f,
      1.0f, -1.0f,  1.0f,
      -1.0f, -1.0f, 1.0f,  /* End Bottom Face */
      1.0f, -1.0f, -1.0f,   /* Begin Right Face */
      1.0f,  -1.0f, 1.0f,
      1.0f,  1.0f, 1.0f,
      1.0f, 1.0f,  -1.0f,   /* End Right Face */
      -1.0f, -1.0f, 1.0f,  /* Begin Left Face */
      -1.0f, -1.0f,  -1.0f,
      -1.0f,  1.0f,  -1.0f,
      -1.0f,  1.0f, 1.0f   /* End Left Face */
   };
 
   GLuint indices[36] = {
      0, 1, 2,
      0, 2, 3,
      5, 6, 7,
      5, 7, 4,
      8, 11, 10,
      8, 10, 9,
      13, 14, 15,
      13, 15, 12,
      16, 19, 18,
      16, 18, 17,
      20, 23, 22,
      20, 22, 21
   };

En tout cas merci de prendre du temps alors que je fais vraiment le boulet sur le coup...

24/01/2010, 22h03
oxyde356

Bah t'es trois premiers plans me semblent bon, ce que tu peux faire pour vérifier sans gros risque de te tromper, c'est de limiter ton affichage à ces 3 plans (donc 6 primitives triangles vu que tu utilise des triangle-list je suppose) et tu regarde si sa fait bien un coin extérieur de cube, si oui continue en affichant un triangle de plus, puis un autre et modifie tes indices à chaque fois qu'il y a un problème jusqu'à ce que tu obtiens un cube valide.
24/01/2010, 22h08
AuraHxC

Ok je vais faire par étape ;)

EDIT : Effectivement si j'affiche rien que Front et Back, il y a une face qui cache bien l'autre alors que l'autre on voit à travers. Donc je vais voir par étape, on verra bien.

EDIT2 : Bon je capte pas que je fasse n'importe quoi, ça change rien... toujours le même soucis c'est quand même bizarre cette histoire.

EDIT3 : Ca doit pas venir de mon utilisation des textures parce que si j'enlève la texture pour mettre simplement une couleur cela me fait la même chose donc je dois avoir un soucis niveau du code de dessin, tu veux que je mette mon code entier niveau initialisation + Dessin ?
24/01/2010, 22h43
AuraHxC

Voilà le code de ma fonction init et draw : http://pastebin.com/m15806519
En espérant que tu vois où il peut y avoir une erreur... Je pourrais aussi te donner le code des shaders si besoin est.
25/01/2010, 04h29
oxyde356

Bon déjà pour commencer, tout au début de ta méthode draw() met un

Code:

glDisable(GL_CULL_FACE);

Ton glDrawElements tu lui as laisser 12 comme paramètre count alors que tu n'as que 4 triangles dans ton buffer, donc met ce param a 4 pour éviter des erreurs. Pour moi tes 4 premiers triangles sont correctes. Fais moi deux screenshots avec 4 triangles, un de l'extérieur du cube et un de l'intérieur.
Je te conseille d'enlever le maximum de trucs inutiles, la texture, le shader (pourquoi tu utilise un shader si tu n'arrive pas encore à afficher un cube, et à quoi sert ce shader ?), histoire d'y voir plus clair.
25/01/2010, 12h43
AuraHxC
Citation:

Envoyé par oxyde356

Bon déjà pour commencer, tout au début de ta méthode draw() met un

Code:

glDisable(GL_CULL_FACE);

Ton glDrawElements tu lui as laisser 12 comme paramètre count alors que tu n'as que 4 triangles dans ton buffer, donc met ce param a 4 pour éviter des erreurs. Pour moi tes 4 premiers triangles sont correctes. Fais moi deux screenshots avec 4 triangles, un de l'extérieur du cube et un de l'intérieur.
Je te conseille d'enlever le maximum de trucs inutiles, la texture, le shader (pourquoi tu utilise un shader si tu n'arrive pas encore à afficher un cube, et à quoi sert ce shader ?), histoire d'y voir plus clair.

Je lui passe 12 comme paramètre parce que j'ai 12 indices partout où j'ai regardé pour les VBO sur internet ou dans les livres comme OpenGL 2.0 et le nouveau qui traite de OpenGL 3.0/3.1, il mettait en paramètre le nombre d'indice de leur IBO.
Je essayer ton bout de code.

EDIT : Le fait de rajouter glDisable(GL_CULL_FACE); au début de la fonction draw() ne change strictement rien.

EDIT : Apparemment en rajoutant dans ma fonction init :
Code:

1 2 3 4 /* Initialisation de la couleur d'effacement de l'écran */ glClearColor( 0.0, 0.0, 0.0, 1.0 ); glClearDepth( 1.0 );
et dans la fonction draw :
Code:

1 2 3 4 /* Effacement de l'écran et du tampon de profondeur */ glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glEnable( GL_DEPTH_TEST );
Ca à l'air de fonctionner.
25/01/2010, 16h36
oxyde356

ah lol tu n'avais pas mis le depth_test à l'init d'opengl ok, quand on commence un programme opengl en effet c'est le genre d'init qu'il faut tout le temps mettre, normalement dans tous les didacticiels de base il y est bizarre...
Effectivement ça explique tout, les plans arrières pouvaient être dessiné après les plans les plus proches de ta caméra sans ce test (selon quels indices vont être traités en premiers/derniers), si tu n'as plus de question relative au sujet n'oublie de cliquer sur "Résolu"
25/01/2010, 16h42
AuraHxC

Normalement c'est bon oui.
J'ai un cube texturé correctement et qui s'affiche très bien donc je vais mettre résolu.
En tout cas merci d'avoir passé un peu de temps sur mon problème.

Maintenant j'attaque l'éclairage avec les shaders.