Opengl - Problème avec les arrêtes

Version imprimable

1 pièce(s) jointe(s)

Bonjour,

Alors voila c'est très simple,
Je programme une petite appli avec OPENGL, juste pour le fun. Et je suis passé à l'utilisation des lumières. J'arrive à m'en servir, vecteur normal et tout. Mais lorsque j'éclaire une surface plane, pour laquelle j'ai maximiser le nombre de sommet, afin que la lumière puisse être effective au maximum, j'obtiens des strilles qui fausse l'image un peu comme l'aliasing.

Mieux vaut une bonne image qu'un long discours :p : (voir image en bas du post. AuraHxC)

C'est bizar.
Voici un petit bout de code qui montre ma configuration OPENGL :

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
//Type de projection, perspective
		gl.glMatrixMode(GL.GL_PROJECTION);
		gl.glLoadIdentity();
 
		glu.gluPerspective(40, FLUX.mainWindowWidth/FLUX.mainWindowHeight, 1.0, 1000.0);
		gl.glScalef(0.2f, 0.4f, 1);
 
 
 
		//Taille d'une ligen par default
		gl.glLineWidth(1.5f);
 
		//Buffer qOptions
		gl.glEnable(GL.GL_DEPTH_TEST);
		gl.glEnable(GL.GL_TEXTURE_2D);
		gl.glEnable (GL.GL_NORMALIZE);
		gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
 
 
		gl.glEnable( GL.GL_POLYGON_SMOOTH );
		gl.glBlendFunc( GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA );
		gl.glEnable( GL.GL_BLEND );
 
                        //TEXTURE SOL
			sol.setTexParameteri(GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT);
			sol.setTexParameteri(GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT);
			sol.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
			sol.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
 
        float[] mambient = {0.11f, 0.06f, 0.11f, 1.0f};
	float[] mdiffuse = {0.43f, 0.47f, 0.54f, 1.0f};
	float[] mspecular = {0.33f, 0.33f, 0.52f, 1.0f};
	float[] memission = {0f, 0f, 0f, 0.0f};
	float mshininess = 10.0f;
 
	float[] position = {0.0f, 0.0f, 1f, 1.0f};
	float[] ambient = {0.0f, 0.0f, 0.0f, 1.0f};
	float[] diffuse = {1.0f, 1.0f, 1.0f, 1.0f};
	float[] specular = {1.0f, 1.0f, 1.0f, 1.0f};
 
 
 
		gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, position, 0);
		gl.glLightfv(GL.GL_LIGHT0, GL.GL_AMBIENT, ambient, 0);
		gl.glLightfv(GL.GL_LIGHT0, GL.GL_DIFFUSE, diffuse, 0);
		gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPECULAR, specular, 0);
 
		gl.glLightf(GL.GL_LIGHT0, GL.GL_SPOT_CUTOFF, 30);
 
		gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT, mambient, 0);
		gl.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, mdiffuse, 0);
		gl.glMaterialfv(GL.GL_FRONT, GL.GL_SPECULAR, mspecular, 0);
		gl.glMaterialfv(GL.GL_FRONT, GL.GL_EMISSION, memission, 0);
		gl.glMaterialf(GL.GL_FRONT, GL.GL_SHININESS, mshininess);
 
 
		gl.glEnable(GL.GL_LIGHT0);
 
		gl.glEnable(GL.GL_COLOR_MATERIAL); 
		gl.glEnable(GL.GL_LIGHTING);

ma boucle :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
//On met à jour le tampon
		gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
 
		//Affichage et positionnement de la caméra
		gl.glMatrixMode(GL.GL_MODELVIEW);
		gl.glLoadIdentity();
				//gluLookAt( camX, camY, camZ, cibleX, cibleY, cibleZ, vertX, vertY, vertZ );
				glu.gluLookAt(CameraX, CameraY, CameraZ, CameraCibleX, CameraCibleY, CameraCibleZ, 0, 1, 0);
 
               //PUIS JE DESSINE...

Est-ce que quelqu'un saurait d'où cela pourrait-il venir ? :euh:
Merci à vous,

18/08/2010, 22h02
coda_blank

on dirait que la texture est plaquée sur toute l'image :?

un problème de coordonnées de textures peut-être ?

Bonjour,

Merci d'avoir répondu mais non, la texture est bien affichée. En faite, la texture est très bien affichée quand il s'agit de la lumière "normale" par default.

Voici la fonction que j'utilise pour afficher mon rectangle. En Faite j'utilise GL_QUAD_STRIP qui m'évite de devoir faire plusieurs GL_QUAD et donc d'appel à GL_BEGIN. De plus, cela me permet de gérer le nombre de subdivision de ma surface avec le parametre "int nb_div" de ma fonction. Car j'ai crû comprendre qu'OpenGL calculait la lumière selon les sommets, et donc, plus il y a de sommet plus la lumière est précise.

Cette fonction est toute fraiche, il n'y a pas eu d'optimisation. Tant que tout ce que je veux faire ne s'affiche pas, je laisse ça en "brouillon".

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
//MultiTexRectangle(GL gl, float x, float y, float z, float width, float height, int nb_div, int TexEchelle)
	//nb_div, est le nombre de division en carré de la surface, avec de garantir un nombre important de sommet, s'il faut éclairer la surface
	private void MultiTexRectangle(GL gl, float x, float y, float z, float width, float height, int nb_div, int TexEchelle){
		vector normale;
		//On déssine le rectangle
		gl.glColor3f( 1.0f, 1.0f, 1.0f );
 
		gl.glBegin(GL.GL_QUAD_STRIP);
 
		float nb_div_width = nb_div;
		float nb_div_height = nb_div;
 
		float sizew = (width / nb_div_width); //Rect_Division_Size
		float sizeh = (height / nb_div_height); //Rect_Division_Size
 
 
		float TexX = 1/nb_div_width;
		float TexY = 1/nb_div_height;
 
		TexX *= TexEchelle;
		TexY *= TexEchelle;
 
 
		//System.out.println("x:"+normale[0]+" y:"+normale[1]+" z:"+normale[2]);
 
		//gl.glNormal3f(normale[0], normale[1], normale[2]);
		//gl.glNormal3f(normale[0], normale[1], normale[2]);
 
 
 
 
 
 
		gl.glColor3f( 1.0f, 1.0f, 1.0f );
		for(int i=0;i<nb_div_width;i++){
 
 
			//VERTEX 1
			normale = CalculateSurfaceNormal(new float[] {
					x,  y + i * sizeh + sizeh, z,
					x, y + i * sizeh, z,
					x + sizew, y + i * sizeh, z 
					}, true);
 
			gl.glNormal3f(normale.x, normale.y, normale.z);
		gl.glTexCoord2f(0.0f, 1-(i*TexY));  gl.glVertex3f(x, y + i * sizeh, z);    //1 ... Y
 
			//VERTEX 2
		normale = CalculateSurfaceNormal(new float[] {
				x + sizew,  y + i * sizeh + sizeh, z,
				x,  y + i * sizeh + sizeh, z,
				x, y + i * sizeh, z 
				}, true);
			gl.glNormal3f(normale.x, normale.y, normale.z);
		gl.glTexCoord2f(0.0f, 1-((i+1)*TexY));  gl.glVertex3f(x,  y + i * sizeh + sizeh, z);   //2 ... Y
 
			//VERTEX 3
		normale = CalculateSurfaceNormal(new float[] {
				x, y + i * sizeh, z,
				x + sizew, y + i * sizeh, z,
				x + sizew,  y + i * sizeh + sizeh, z 
				}, true);
			gl.glNormal3f(normale.x, normale.y, normale.z);
		gl.glTexCoord2f(TexX, 1-(i*TexY));  gl.glVertex3f(x + sizew, y + i * sizeh, z);   //3 .. Y
 
			//VERTEX 4
		normale = CalculateSurfaceNormal(new float[] {
				x + sizew, y + i * sizeh, z,
				x + sizew,  y + i * sizeh + sizeh, z,
				x,  y + i * sizeh + sizeh, z 
				}, true);
			gl.glNormal3f(normale.x, normale.y, normale.z);
		gl.glTexCoord2f(TexX, 1-((i+1)*TexY));  gl.glVertex3f(x + sizew,  y + i * sizeh + sizeh, z);//4 ... Y
 
 
		for(int j=1;j<nb_div_height;j++){
			//VERTEX 5
			normale = CalculateSurfaceNormal(new float[] {
					x + sizew*j, y + i * sizeh, z,
					x + sizew + j * sizew, y + i * sizeh, z,
					x + sizew + j * sizew, y + i * sizeh + sizeh, z 
					}, true);
				gl.glNormal3f(normale.x, normale.y, normale.z);
			gl.glTexCoord2f((j+1)*TexX,  1-(i*TexY)); gl.glVertex3f(x + sizew + j * sizew, y + i * sizeh, z);//5 ... X
 
			//VERTEX 6
			normale = CalculateSurfaceNormal(new float[] {
					x + sizew + j * sizew, y + i * sizeh, z,
					x + sizew + j * sizew, y + i * sizeh + sizeh, z,
					x + sizew*j,  y + i * sizeh + sizeh, z 
					}, true);
				gl.glNormal3f(normale.x, normale.y, normale.z);
			gl.glTexCoord2f((j+1)*TexX,  1-((i+1)*TexY)); gl.glVertex3f(x + sizew + j * sizew, y + i * sizeh + sizeh, z);//6 ... X
		}
 
		}
 
 
 
		gl.glEnd();
 
	}

Elle est un peu compliquée à visualiser. Personnellement j'ai beaucoup galéré à la faire, étant donné que je suis un gros débutant d'opengl.

Voici l'appel à cette fonction dans DISPLAY :

Code:

1
2
3
4
5
6
7
8
9
10
11
	gl.glMatrixMode(GL.GL_MODELVIEW);
		gl.glLoadIdentity();
				glu.gluLookAt(CameraX, CameraY, CameraZ, CameraCibleX, CameraCibleY, CameraCibleZ, 0, 1, 0);
 
 
				gl.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, new float[]{SpotX, SpotY, 500f, 1.0f}, 0);
				gl.glLightfv(GL.GL_LIGHT0, GL.GL_SPOT_DIRECTION, new float[]{SpotCibleX, SpotCibleY, -1f}, 0);
 
				//Texture a afficher
				sol.bind();
				MultiTexRectangle(gl, 0, 0, 0, 800, 600, 100, 5);

J'espère que quelqu'un y verra une erreur qui résoudra tout.

Merci à vous,
Cordialement,

20/08/2010, 15h58
darkman19320

Bonjour,
Je ne vois pas la fonction de test de profondeur.
Essaye de rajouter au niveau de l'initialisation: glDephtFunc(GL_LEQUAL);
20/08/2010, 16h28
Sawyer4

Merci d'avoir répondu,
Non cela ne change rien,

Bon après minte recherche, j'ai finit pas remarquer que le fait d'avoir des sommets qui se confondent peut poser problème. Donc j'ai décidé d'utiliser les Vertex Arrays qui me semblent plus performant que les DisplayLists dans beaucoup de contextes et qui me "simplifieront la vie".

Il semble intérressant de s'en servir, car ces tableaux intègrent un système d'indices qui me permet de choisir un sommet plusieurs fois, ainsi éviter la "superposition" de sommets.

De plus, cela me permet d'utiliser GL_QUAD plusieurs fois plutôt que GL_TRIANGLE_STRIP ou autre qui sont bien compliqués.
En effet, si j'utilisais QUAD_STRIP c'était pour éviter les gl_begin() gl_end() à répétition.
Car ils s'ouvrent un accès au pilote à chaque fois. Ce qui detruit les performances :p
Donc avec les Vertex Arrays je pourrais utiliser GL_QUADS car il n'ouvre un accès pilote qu'au debut du tableau de sommets, puis à la fin de la lecture du tableau.
Pratique non !
Et enfin le dernier avantage des Vertex Array c'est qu'ils sont utilisable dans un VertexBuffer. Buffer veut dire tampon. Donc memoire tampon. Donc memoire Vidéo ici. Donc cela permet d'utilsier des "VBO" pour écrire directement mes tableaux dans la memoire de la Carte Graphique.
Pratique !!

Je vais mettre ce topic en résolu. Si ce que je dis s'avère fonctionner je viendrais donner des nouvelles. Pas tout de suite vu que c'est secondaire pour moi en ce moment.

Merci à vous en tout cas.
Cordialement,