Le fonctionnement de opengl ?

**AsmCode** · 21/10/2005, 00h50

Salut :d

D'après mes recherches, il y aurait donc plusieurs matrices ? mais j'ai de la misère à saisir le pourquoi de "sauvegarder" la matrice courante (quand on la met sur la pile). Selon les exemples que j'ai lu, quand par exemple on fait un cube, si on désire y ajouter un autre cube différent dans une position différente il faut dabord mettre la matrice courante dans la pile, donc on "sauvegarde" notre cube actuel ?

Et concernant son fonctionnement général..opengl n'est en fait que de la manipulation graphique par des fonctions, mais comment accède-t-il à l'écran ? je veux dire pour dessiner une ligne, il utilise les api du OS ? ou s'il s'adresse directement à la mémoire vidéo par un standard comme vesa par exemple ?

Merci de m'éclairer sur ce point

**bafman** · 21/10/2005, 08h55

sauvegarde la matrice sert tout simplement a sauvegarder la "position" courante du monde, par exemple si tu a le monde dans une configuration et que tu veut afficher un cube translaté sans changer le reste du monde (ce qui sera envoyé apres l'affichage du cube), tu a 2 solution :
- tu effectue un glTranslate(x,y,z), tu affiche ton cube puis tu effectue un deuxieme glTranslate(-x,-y,-z) pour remettre le monde dans son etat precedent

- tu fait un glPushMatrix(),glTranslate(x,y,z),tu affiche le cube puis tu fait un glPopMatrix().

l'aventage de la deuxieme methode est qu'elle effectue nettement moins de calcule matriciel tres couteux...

sinon openGL accede à la carte graphique via un device context, qui lui donne par derriere acces au driver de la carte graphique, sui lui sait comment se debrouiller. c'est ce passage par le device context qui permet a openGL d'etre multi platforme

**AsmCode** · 21/10/2005, 19h36

Ok, mais admettons que j'ai un cube dans ma scène, si je veux le voir d'un autre angle je vais bouger la caméra, mais si je veux seulement le bouger lui, je vais devoir jouer avec la rotation, la translation, etc.

Mais supposons que je dessine un deuxième cube, sans changer mon angle de vue, je ne peux pas dessiner mon cube directement dans une position précise ? je dois donc le dessiner et ensuite le transformer ? Et si je comprends bien, si j'utilises une rotation il va bouger mes 2 cubes en même temps ? il me semble que c'est mal fait, je devrais pouvoir spécifier de bouger le cube1 ou le cube2

Sinon comment faire si j'ai 5 cubes et que je veux les bouger séparément dans des directions différentes ? toujours sans changer l'angle de vue bien sûr.

**shenron666** · 21/10/2005, 20h30

Je vais essayer de te faire comprendre le processus en décrivant le rendu d'une scène composée de 3 cubes:

Contexte : la projection est initalisée comme d'habitude à l'aide de gluPerspective puis on passe en glMatrixMode(GL_MODELVIEW) pour le reste du programme.

Début de la boucle qui est appelée pour chaque image
- appel de glLoadIdentity -> on reset la vue
- appel de glPushMatrix -> on sauvegarde la matrice
- appel de glTranslate(CUBE1) -> on place le CUBE1
- appel de glRotate(CUBE1) -> on tourne le CUBE1
- dessin du CUBE1
- appel de glPopMatrix -> on rappelle la dernière matrice sauvegardée
- appel de glPushMatrix -> on sauvegarde la matrice
- appel de glTranslate(CUBE2) -> on place le CUBE2
- appel de glRotate(CUBE2) -> on tourne le CUBE2
- dessin du CUBE2
- appel de glPopMatrix -> récupération de la dernière matrice sauvegardée
- modification de l'angle de rotaion de CUBE1
- modification de l'angle de rotaion de CUBE2
- affichage de l'image
Fin de la boucle

Dans cet aexemple tu vas me dire que les sauvegardes des matrices sont inutiles, c'est juste pour te montrer à quoi ça sert

je peux te donner un autre exemple assez simple à réaliser toi même, je viens de faire un test avec le tutorial 5 de nehe, j'ai mis dans une fonction à part le dessin du cube et le dessin de la pyramide et j'ai remplacé la fonction DrawGLScene par la suivante :

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
int DrawGLScene(GLvoid)									// Here's Where We Do All The Drawing
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	// Clear Screen And Depth Buffer
	glLoadIdentity();									// Reset The Current Modelview Matrix
	glTranslatef(-1.5f,0.0f,-6.0f);						// Move Left 1.5 Units And Into The Screen 6.0
	glRotatef(rtri,0.0f,1.0f,0.0f);						// Rotate The Triangle On The Y axis ( NEW )
	DrawTri();
 
	glLoadIdentity();									// Reset The Current Modelview Matrix
	glTranslatef(1.5f,0.0f,-7.0f);						// Move Right 1.5 Units And Into The Screen 7.0
	glRotatef(rquad,1.0f,1.0f,1.0f);					// Rotate The Quad On The X axis ( NEW )
	DrawCube();
	for(float p=0.f; p < 360.f; p+=30.f)
	{
		glPushMatrix();
		glRotatef(p,0.0f,1.0f,0.0f);						// Rotate The Triangle On The Y axis ( NEW )
		glTranslatef( 0.f, 0.5f, -6.0f);						// Move Left 1.5 Units And Into The Screen 6.0
		DrawTri();
		glPopMatrix();
	}
 
	rtri+=0.2f;											// Increase The Rotation Variable For The Triangle ( NEW )
	rquad-=0.15f;										// Decrease The Rotation Variable For The Quad ( NEW )
	return TRUE;										// Keep Going
}

Si tu met glPushMatrix et glPopMatrix en commentaire que se passe t-il ?
si tu arrives à comprendre c'est bon, sinon je te conseille de reprendre les docs sur OpenGL et sur les maths (vecteurs et matrices)

si tu cherches un exemple de l'utilité de glPushMatrix (et de glPopMatrix qui va de pair) je te répondrai simplement : l'animation à base de hirarchie (comme un corps humain ou d'animal ou un bras de robot...)
si tu comprends leur utilité tu trouveras pleins d'autres endroits où les utiliser

une dernière chose, glPushMatrix et glPopMatrix vont de pair, tu dois toujours avoir un glPushMatrix suivi d'un glPopMatrix car ils se servent d'une pile. glPushMatrix copie la matrice courante dans la pile, glPopMatrix la retire (ça fonctionne comme une pile d'assiettes, et elle doit toujours être vide à la fin de la création de ta scène donc entre 2 affichages d'une image tu dois avoir AUTANT de glPushMatrix que de glPopMatrix)

**AsmCode** · 21/10/2005, 21h07

Donc... quand on fait une rotation, ce n'est pas le cube qui tourne mais plutôt la scène ?

Car la matrice, contient quoi au juste ? l'ensemble de ce qui est sur la scène ?

appel de glLoadIdentity -> on reset la vue
reset la vue veut dire de remettre la caméra dans la position originale ? car pour moi, la "vue" veut dire la position de la caméra, par OU est-ce que on regarde et dans quelle DIRECTION qu'on regarde

Donc...quand on fait une rotation, c'est plutôt la caméra qui tourne ? et quand on fait une homotétie on regarde de plus au moins loin ? mais si on déforme l'objet, il me semble que c'est l'objet qui change et non la caméra ...

**AsmCode** · 21/10/2005, 23h49

J'ai essayé ceci:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
  	int x;
	float z = 0.0f;
	bool direction = true;
 
	for (x=0;x<100;x++) {
 
		z--;
 
		//glPushMatrix();
		glTranslatef(0.0f, 0.0f, z);
		DrawTheCube();
		//glPopMatrix();
 
	}

Pourtant mon cube ne bouge pas.

Pourquoi

:

j'ai essayé aussi avec glPush et glPop et ça ne fonctionne pas plus

**shenron666** · 22/10/2005, 00h15

Lorsque tu fais une rotation ou une translation, tu modifies la matrice de transformation, par conséquent tout ce que tu envoies (glVertex) à opengl sera transformé (tourné, déplacé) avant d'être projeté

oui lorsque tu fais une rotation tu fais tout tourner, lorsque tu crée un point en (5,2,7) tu le crée par rapport à 0 qui est l'origine après les transformation que tu as effectué

ton code n'est pas incorrect mais le fait que ut ne vois pas de différence c'est aussi parceque tu dessine plusieurs cubes les uns derrière les autres, donc le premier cache ceux qui sont derrière
sans push et pop tu translate de 0 en z puis dessine un cube, puis tu translate de -1 en z et dessine puis tu translate de -2 en z (et comme tu avais déjà translaté de -1 il sera en -3) et dessine puis translation en z de 3 (tu etais en -3 tu passes en -6) etc, donc tu as des cubes les uns derrière les autres aux Z : 0, -1, -3, -6, -10, -15, -21, -28, ...

la différence avec le cas où tu actives push et pop : tu reviens à ta position à chaque boucle et translate de ta valeur en Z et donc tes cubes seront en Z : 0, -1, -2, -3, -4, -5, -6, -7, ...

essaies plutot sur l'axe des X afin de voir tes cubes à l'écran

sinon est-ce que tu as essayé mon exemple ?

**bafman** · 22/10/2005, 10h19

bon on va reprendre les bases...

en openGL tu a une matrice : MODELVIEW qui contient l'ensemble des informations de positionnement dans l'espace (pour info : openGL utilise une seule matrice alors que direct3D en utilise 2 : la matrice MODEL qui contient les info du modele n cours de dessin et la matrice VIEW qui contient les info de la camera, et lors du rendu, les 2 matrice sont multipliée pour donner l'equivalent de la matrice MODELVIEW d'openGL)

mais qu'est cu que ces matrice contiennent ? simplement la position et l'orientation du monde sous cette forme
[X1,Y1,Z1,0]
[X2,Y2,Z2,0]
[X3,Y3,Z3,0]
[pX,pY,pZ,1]

ou {X1,X2,X3} representent le vecteur X de la base dans l'espace, par defaut il vaut {1,0,0}
{Y1,Y2,Y3} represente le vecteur Y de la base dans l'espace, par defaut il vaut {0,1,0}
{Z1,Z2,Z3} represente le vecteur Z de la base dans l'espace, par defaut il vaut {0,0,1}
et {pX,pY,Pz} represente la position de la camera dans l'espace.
on peut remarquer la 4eme colonne qui ne sert a rien (en tout cas pour un debutant

par la suite on peut l'utiliser pour faire des truc amusant) mais qui est necessaire pour avoir une matrice homogene (avec le même nombre de colonne et de matrice) afin de faciliter les calcules.

une fois qu'on a cette matrice MODELVIEW, chaque vertex envoyé a la carte est multiplié par la matrice pour obtenire sa position relativement à la camera, donc en fait quand tu pense deplacer un vertex avec un glTranslate() tu ne fait que modifier la matrice, et donc tout vertex envoyé par la suit passera par la matrice modifiée... d'ou l'utilitée de pouvoir sauvegarder et restaurer les matrices, car les calcules de matrices sont couteux et sans glPush/pop, on serait obligé d'effectuer les translation à l'inverse pour restaurer la matrice dans sont etat precedent (sans parler de certains calcules complexes a base de quaternions et autre qui ne sont pas trivialement inversables

)

**djo.mos** · 22/10/2005, 11h29

Pour répondre à la deuxième partie de ta question, je dirais que le constructeur de la carte graphique qui fournit un pilote openGL, qui utilise directement les fonction d'acceleration de la carte graphique, sans passer par le sys d'exploitation ou un autre API, mais en piochant directement dans le materiel pour pouvoir offrir un niveau de performance honorable.

**bafman** · 22/10/2005, 11h44

en effet toutes les fonction mathematiques sont gravée directement dans le GPU, et même de nombreuses informations sont stockée directement dans la memoire graphique , voir même dans des registres du GPU (la pile de matrice en est un tres bon exemple, c'est comme ca qu'on se retrouve avec des carte intel qui ont une pile limitée a matrices

)

**AsmCode** · 22/10/2005, 21h22

Envoyé par bafman

bon on va reprendre les bases...

en openGL tu a une matrice : MODELVIEW qui contient l'ensemble des informations de positionnement dans l'espace (pour info : openGL utilise une seule matrice alors que direct3D en utilise 2 : la matrice MODEL qui contient les info du modele n cours de dessin et la matrice VIEW qui contient les info de la camera, et lors du rendu, les 2 matrice sont multipliée pour donner l'equivalent de la matrice MODELVIEW d'openGL)

mais qu'est cu que ces matrice contiennent ? simplement la position et l'orientation du monde sous cette forme
[X1,Y1,Z1,0]
[X2,Y2,Z2,0]
[X3,Y3,Z3,0]
[pX,pY,pZ,1]

ou {X1,X2,X3} representent le vecteur X de la base dans l'espace, par defaut il vaut {1,0,0}
{Y1,Y2,Y3} represente le vecteur Y de la base dans l'espace, par defaut il vaut {0,1,0}
{Z1,Z2,Z3} represente le vecteur Z de la base dans l'espace, par defaut il vaut {0,0,1}
et {pX,pY,Pz} represente la position de la camera dans l'espace.
on peut remarquer la 4eme colonne qui ne sert a rien (en tout cas pour un debutant

par la suite on peut l'utiliser pour faire des truc amusant) mais qui est necessaire pour avoir une matrice homogene (avec le même nombre de colonne et de matrice) afin de faciliter les calcules.

une fois qu'on a cette matrice MODELVIEW, chaque vertex envoyé a la carte est multiplié par la matrice pour obtenire sa position relativement à la camera, donc en fait quand tu pense deplacer un vertex avec un glTranslate() tu ne fait que modifier la matrice, et donc tout vertex envoyé par la suit passera par la matrice modifiée... d'ou l'utilitée de pouvoir sauvegarder et restaurer les matrices, car les calcules de matrices sont couteux et sans glPush/pop, on serait obligé d'effectuer les translation à l'inverse pour restaurer la matrice dans sont etat precedent (sans parler de certains calcules complexes a base de quaternions et autre qui ne sont pas trivialement inversables

)

Daccord

Donc..si je comprends bien, la position du monde virtuel et la position de la caméra pour voir ce monde se trouve dans une seule matrice. Mais pourquoi avoir besoin de glLoadIdentity() ?

Ensuite, si je veux accéder individuellement à mes objets sur ma scène, comment je dois faire ? admettons un truc simple: 2 cubes, et je veux les bouger indépendamment.

Jusqu'ici j'ai essayé d'animer qu'un seul cube, mais sans succès, je voulais faire en sorte avec le code ci-haut, d'avoir un cube et qu'il bouge sur l'axe des z avant et arrière, mais je crois que mon code ne fait que refaire plein de cube finalement ..

Je que la matrice MODELVIEW est le monde virtuel et la position de la caméra, mais dans quel matrice se trouve tout mes cubes ?

Le fonctionnement de opengl ?

OpenGL

Vue hybride

Discussions similaires

Partager

Partager