Discussion :

[deeal]

Bonjour
je voulais dessiner une surface utilisant une equation 3D
voici le code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
GL.glPolygonMode(GL.GL_FRONT_AND_BACK,GL.GL_LINE);
					GL.glBegin(GL.GL_POLYGON);
					for (int i=1;i<=10;i++)
					{
				    	for (int j=1;j<=10;j++)
						{
							y =(float)System.Math.Cos(j) + (float) System.Math.Cos(j);
							GL.glVertex3f(i,y,j);
 
						}
					}
					GL.glEnd();

mais ce que j'obtient cest des point relies n'importe comment
quel est le probleme?
Merci

[vdumont]

Hum si je ne me trompe pas tu dessines seulement des points individuels dans cette fonction à cause du glPolygonMode.

[deeal]

oui en effet, j'ai essaie avec GL_LINE et ca me donnait des resultat bizzard c'est pour cela que j'ai change en point

[ToTo13]

Bonjour,

OpenGl ne sait pas trianguler ta surface. Il relie en général les points par ordre d'apparition.

En fait, il te faut générer les points et calculer toi même ta triangulation, puis faire afficher les triangles résultats.

[shenron666]

ton polygone doit être convexe :
http://fr.wikipedia.org/wiki/Concavit%C3%A9

sinon, OpenGL ne saura pas l'afficher correctement
auquel cas, il te faut le découper autant que possible en polygones convexes
le triangle est un polygone ne pouvant être que convexe, c'est pourquoi il est si répandu et les cartes sont optimisées pour l'afficher
un GL_QUAD ou GL_POLYGON sera transformé en triangles sans vérifier si celui-ci est convexe ou concave et donnera des résultats inattendus dans le cas concave

[deeal]

merci hier en attendant quelques eclaircissements, j'ai bosse un peu, j'ai fait un truc, mais pour des petits Box ca donne de bons resultats, mais des que j'augmente la taille ca rame

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
 
private void DrawBackground()
		{
			if (this.BackGround)
			{	
 
 
 
				GL.glPolygonMode(GL.GL_FRONT_AND_BACK,GL.GL_LINE);
 
				for (int i=-this.BackXSize/2;i<=this.BackXSize/2;i++)
				{
					for (int j=-this.BackYSize/2;j<=this.BackYSize/2;j++)
					{
						for (int k=-this.BackZSize;k<=0;k++)
						{
							this.DrawVoxel(i,j,k,BColor);
						}
					}
				}
 
 
			}	
		}

et la function DrawVoxel c'est juste de dessiner un Cube de 6 faces

mais je crois que ce n'4est pas la meilleur solution, deja avec l'appel de fonction DrawVoxel() a chaque fois ca ne donne pas de tres bon results

vous n'auriez pas une idee, pour ameliorer cela

Merci
deeal

[ToTo13]

Bonjour,

il y a déjà glutsolidcube qui fait afficher des cubes.
Sinon tu peux déssiner un cube à l'aide de six faces (normal pour un cube) avec GL_POLYGON.

sinon , le plus rapide au niveau affichage est quand même de désiner des triangles.

Penses également à dessiner dans une GlList.

Voici un petit exemple pour un cube :

Code :

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

1
2
3
4
5
6
7
 
glNewList(....., GL_COMPILE) ;
glPushMatrix() ;
glTranslatef() ;
glutSolidCube(1.0) ;
glPopMatrix() ;
glEndList() ;

[deeal]

Merci Toto13
tu sais j'essaie d'utiliser GLUT avec C#, mais ca bugue a chaque fois, je ne sais pas pourquoi, mais juste pour savoir
est-ce que il suffit de faire cela pour dessiner un cube

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
for (int i=1;i<=10;i++)
					{
				    	for (int j=1;j<=10;j++)
						{
							y =(float)System.Math.Pow(i,4) - (float) System.Math.Pow(j,4);
							GL.glLoadIdentity();
							GL.glTranslated(i,y,j);
							GLUT.glutSolidCube(1);
						}
					}
					GLUT.glEnd();

et j'ai essaie avec une sphere et ca bugue aussi

Code :

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

1
2
3
 
 GLUquadric Quadric1 =new GLUquadric();
 GLU.gluSphere(Quadric1, 3, 10, 10);

[ToTo13]

Bonjour,

non, tu t'y prend mal, mais rien de méchant :

GL.glLoadIdentity();

sert à réinitialiser la matrice de vue. Donc toutes les opérations et autre rotation sont perdues. Il ne doit être appellé qu'une seule fois au tout début de ta fonction d'affichage.

si tu mets :

GLUT.glEnd();

il te faut un GLUT.glBegin(...) ; Mais avec nun glutsolidcube, pas besoin de glBegin.

De plus, si tu faut pour chaque des étapes de la boucle :

GL.glTranslated(i,y,j);

tu vas à chaque fois décaler de y, plus tous les décalage de y précédent. C'est pour cela que je fais un glpushmatrix qui duplique la matrice de vue courante, je travaille alors avec cette matrice dupliquée, puis je fais un glpopmatrix qui va écraser la matrice dupliqué une fois que j'ai fini mon travail.

Utilises les gllists, c'est super pratique et très simple d'utilisation. Mais résoud ton problème, on les mettra ensuite, c'est uniquement trois lignes à changer.

Bonne continuation

[deeal]

en fait j'ai utilise LoadIdentity a chaque fois pour supprimer la translation que j'ai faite pour le premier cube, donc je reviens vers (0,0,0), et avant de dessiner le prochaine cubem je fais une translation, pour avoir (i,y,j)

je vais essayer ce que tu m'as propose mais je n'ai pas compris le truc de
glpopMatrix[/img]

Edit :
tu as raison pour LoadIdentity, mais il la faut quand meme
car quand je la load je perd la vue que j'ai effectue, donc il faut que je cree une liste ( je n'ai pas encore essaie pour mettre resolu )
avec mes parametres d'affichage et je l'appelle apres mon load identity car j'en ai beoisn pour faire une translation apartir de 0,0,0

sinon qu'est-ce que tu me disais pour GlpopMatrix?

Merci

Edit : j'ai cree une liste d'affichage et je l'appelle et ca donne d'assez bonne resultats, donc la je ne sais pas si c'est optimal ou pas, mais bon ca marche pour l'instant

[ToTo13]

Bonsoir,

lorsque tu fais un gltranslate, glrotate, glscale, .... tu agit directement sur la matrice de vue. Ceci est à la fois pratique est enuyeux dans certains cas :
- Pratique parce que toute la scène et donc le rendu dépend de cette matrice, donc si on la modifie, c'est bien que tout les objets soient modifié en conséquence.
- Non pratique parce que l'on souhaiterai à un moment donné, déplacer un objet à partir de la matrice, mais sans la modifier définitivement. C'est là qu'intervient glpushmatrix. Cela va permettre de dupliquer la matrice de vue (d'en faire un copie) afin de pouvoir modifier la matrice pour le temps de opérations ponctuelles que l'on souhaite réaliser. Puis on détruit cette matrice à l'aide de glpopmatrix.

un petit exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
glLoadIdentity() ; // Pour initialiser la matrice à 0 partout
glutSolidCube(1.0) ; // place un cube en 0 0 0
 
for (i=1 ; i < 5 ; i++)
     {
     glPushMatrix() ; // Duplique la matrice courante (fait un copie)
     glTranslatef((float)i, 0.0, 0.0) ; // translation de i
     glutSolidCube(1.0) ; // On met le cube en i 0 0
     glPopMatrix() ; // On détruit la copie de la matrice
     }
 
glTranslatef(10.0, 0.0, 0.0) ; // Désormais tout sera déplacé de 10 0 0
glutSolidCube(1.0) ; // place un cube en 10 0 0

Dans cet exemple, j'ai pu placer mes cube de la boucle sans altérer la matrice pour la suite des opérations.
Si je n'avais pas mis le Push et Pop, à la fin de la boucle, la translation en X aurait été de 1+2+3+4=10, donc le dernier cube posé en dehors de la boucle aurait été placé en 20 0 0

En espérant que cela te convienne...

PS: je n'ai pas exécuté ce morceau de code à la main, il se peut qu'il y ait des erreurs de frappe.

[deeal]

Ah super Toto13 Merci beaucoup
j'ai compris le truc du Push

Merci et a bientot

[shenron666]

je me permet juste d'ajouter une petite note : un push = un pop

push stocke une information, pop la reprend
si tu engranges des infos et ne les reprends pas, tu finiras par planter sur un dépassement de pile (la pile OpenGL bien sûr)

donc ton code doit contenir autant d'appels à pop que d'appels à push