Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

Evasion Membres Publications Images

Menu
Initialiser OpenGL Contenu

avec Windows
1. Crer une fentre Windows

Comme je l'ai dit dans le premier chapitre, il faut obtenir un Device Context (DC), puis un
Rendering Context (RC) afin d'initialiser OpenGL. Et pour cela, nous avons besoin de
matriser quelque peu la gestion de fentres dans Windows. Nous allons donc voir
comment crer une fentre et rcuprer les infos ncessaires l'initialisation.
Il y a en fait deux moyens d'obtenir un DC : soit en se crant sa petite fentre en Win32,
soit en utilisant les MFC. Ici, je ne vais parler que de Win32, car c'est beaucoup plus simple
et pratique que les MFC, qui sont trs lourdes et chiantes utiliser. Mais si vous savez
grer les MFC et compris comment rcuprer un DC et un RC, alors vous ne devriez pas
avoir de problme intgrer OpenGL dans vos programmes utilisant les MFC.
Autre chose : j'utilise Ms Visual C++, que je trouve plus pratique pour ce genre de choses.
Les procdures spcifiques au compilateur, du genre inclure les .lib, seront donc
expliques pour ce logiciel, et pas pour le Borland C++ Builder. Mais le code restera bien
sr le mme quelque soit le compilateur.
Enfin, sachez que la touche F1 est votre amie : chaque fois que je vous prsente une
nouvelle fonction, tudiez-la plus en dtail avec l'aide de votre compliateur, car je ne peux
pas tout vous dire sur tout, ou je n'aurais jamais fini. Servez-vous en donc le plus possible,
et si jamais vous avez encore des doutes, envoyez-moi vos questions.

Pour les newbies de VC++, crez d'abord un nouveau projet par File>New>Project>Win32
Application, puis un nouveau fichier C++ par File>New>File>C/C++ Source File.

Bon, commencont par le commencement, savoir les #include. Il y en a 3 obligatoires,

sans lesquels votre programme ne pourra pas marcher. Les voici :

#include <windows.h>
#include <gl/gl.h>
#include <gl/glu.h>

gl.h et glu.h servent bien videmment utiliser les fonctions OpenGL. Quand windows.h,
il est utilis pour crer les fentres, et vous n'en avez normalement pas besoin si vous
utilisez glut.h. Les header OpenGL sont gnralement dans le rpertoire \include\gl de
votre compilateur.
Mais ce n'est pas tout : les headers se rapportent des fonctions qui sont dfinies dans les
opengl32.dll et glu32.dll : il faut donc les lier votre projet. Pour ce faire, avec VC++,
allez dans Project>Settings>Links, et incluez opengl32.lib et glu32.lib dans la liste
Object/library modules.

Ensuite, il faut savoir que dans un programme Win32, la fonction de dpart n'est plus main
mais WinMain. Crez donc la premire fonction de votre programme :

int WINAPI WinMain( HINSTANCE hInstance,

HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{

La valeur de retour est la mme que pour la fonction main() classique. Voyons maintenant
ce que veulent bien dire ces paramtres bizarres :

1 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

hInstance est une sorte de handle pour votre programme : comme Windows est
multitche, il a besoin de savoir quel programme lui dit quoi. Et c'est travers cette
variable que Windows sait qui il a affaire : c'est en quelque sorte la carte d'identit
du programme. C'est pourquoi il est conseill de la sauvegarder dans une variable
globale, ce que nous allons faire :

HInst = hInstance; //HInst est un variable globale de type HINSTANCE

hPervInstance ne sert plus rien, il est conserv pour des raisons de compaptibilit
avec les programmes 16 bits
lpCmdLine est un pointeur sur la ligne de commande, pour rcuprer les paramtres
ventuels
nCmdShow est le style initial de la fentre : normale, rduite...etc. Il ne nous sert
pas grand chose pour le moment

H bien puisque nous avons notre fonction principale, pourquoi ne pas crer tout de suite
notre fentre ? Allons-y :

HWND OpenGLWindow = CreateWindow

( "BUTTON", //Classe de la fentre
"Fentre OpenGL", //Nom de la fentre
WS_VISIBLE | WS_BORDER, //Caractristiques
0, //Position x
0, //Position y
640, //Largeur
480, //Hauteur
0, //Handle de la fentre mme
0, //Identifiant de la fentre fille
HInst, //HINSTANCE du programme
/*Chaine de caractres envoye
NULL en paramtre lors de la cration
de la fentre*/
);
if (!OpenGLWindow) exit(1);

Je sais que les puristes vont m'incendier, mais je trouve que c'est plus simple de
commencer comme ca. Etudions maintenant cette fonction CreateWindow :

Elle renvoie une valeur de type HWND, c'est--dire un handle pour la fentre (tiens,
on se rapproche du DC). Il s'apparente au HINSTANCE pour le programme, sauf que
l c'est pour une fentre. Vous pouvez aussi le sauvegarder en tant que variable
globale. S'il est nul, il y a eu erreur.
Le premier paramtre correspond la classe de la fentre : c'est elle qui dfinit
presque toutes ses proprits. Ici, nous avons pris une classe prexistante, pour
simplifer l'explication, mais plus tard nous allons devoir en crer une nous-mmes.
Je disais que les puristes allaient m'incendier car en fait on n'utilise jamais ce genre
de classe prdfinie, parce que ca sert rien, puisqu'on ne peut mme pas dfinir la
fonction WinProc. En fait leur seul utilit est d'apprendre utiliser CreateWindow.
Les caractristiques de la fentre peuvent tre multiples. Faites F1 pour obtenir
toutes les options possibles
Les 4 paramtres suivant parlent d'eux-mmes
Les 2 d'aprs ne servent que dans le cas d'applications plusieurs fentres, donc on
s'en fout
Et enfin le dernier paramtre permet de passer des arguments la fonction WinProc
avec le message WM_CREATE. Je sais, vous ne comprenez pas, mais bient vous
saurez.

Ca y est, la fentre est cre. Le programme est fini ? Pas tout fait. Car il faut grer les
interactions avec Windows. Et pour cela il faut savoir comment le programme communique
avec Windows : en fait, ce n'est pas Windows qui transmet au programme les messages le
concernant, mais plutt le programme qui doit demander Windows s'il doit faire quelque
chose, grce la fonction PeekMessage. En quelque sorte, le programme va voir dans son

2 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

casier s'il n'y a pas des messages pour lui via PeekMessage, et s'il y en a, il les rcupre
avec GetMessage, puis les distribue aux membres de son quipe (les fentres), via
DispatchMessage. C'est trs imag mais au moins c'est clair et je suis sr de m'tre fait
comprendre. Voil donc le code crire aprs la cration de la fentre :

MSG msg;
do
{
while (PeekMessage(&msg,OpenGLWindow,0,0,PM_NOREMOVE))
{

if(!GetMessage(&msg,OpenGLWindow,0,0)) exit(0);
DispatchMessage(&msg);

}
}
while(1);

Lorsque le message WM_QUIT est envoy au programme, cela signifie qu'il doit fermer et
que tout est fini. Si c'est ce message que rcupre GetMessage, il renvoie 0 : cela explique
le if(!GetMessage(&msg,OpenGLWindow,0,0)) exit(0); C'est la seule condition pour qu'un
programme quitte. Lorsque le message est rcupr par GetMessage, il est supprim de la
pile des messages (le 'casier' de tout--l'heure), une exception prs : le message
WM_PAINT n'est supprim que lorsqu'il a t trait. Pour l'instant nous n'avons pas besoin
de savoir ce que msg contient, puisque le seul message qui nous importe est WM_QUIT, et
il est gr par GetMessage.
Peut-tre ces histoires de messages vous semblent-elles un peu obscures, mais ne vous
inquitez pas, les rares taches d'ombres vont bientt s'claircir.

Mais finissons d'abord notre programme par les lignes qui suivent :

return 0; //(pour la forme)

}

Et voil ! Le premier programme

d'exemple est termin et vous pouvez le
lancer : vous verrez un zoli bouton avec
"Fentre OpenGL" marqu dessus, et
vous pourrez mme cliquer dessus, et
alors l : RIEN ! H oui ! Il ne se passe
rien quand on clique sur le bouton ! Ben
oui, c'est l le problme : ca sert rien
d'utiliser la classe prdfinie, puisqu'on
peut mme pas lui dire ce qu'on veut
qu'il se passe quand on clique sur le
bouton.

Il va donc falloir qu'on dfinisse notre propre classe de fentre. C'est d'ailleurs toujours
comme ce qu'on fait. Stoppez le programme et recopiez donc le code suivant juste avant
l'appel CreateWindow :

WNDCLASS WindowClass =
{ 0, //Style
WinProc, //Procdure pour la gestion des messages
0, //octets supplmentaires allouer la classe
0, //octets supplmentaires allouer la fentre
HInst, //Handle du programme
0, //Icne
0, //Curseur
0, //Couleur d'arrire-plan
NULL, //Pointeur sur le menu associ la classe

3 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

"La classe!" //Nom de la classe fentre

};
if (!RegisterClass(&WindowClass)) exit(1);

Ca y est : nous avons dfini notre classe de fentre, qui s'appelle "La classe!". On peut
donc remplacer "BUTTON" par "La classe!" dans la procdure CreateWindow. Mais si vous
essayez de lancer le programme tel quel, le compilateur va vous renvoyer une erreur : en
effet, dans la dclaration de la classe, nous lui passons comme fonction de gestion des
messages une fonction que nous avons nomm WinProc (nous aurions aussi bien pu
l'appeler Salutcavaouimoicavaettoicavaouicavaettoiohmoitusaiscava, mais je trouve que
WinProc est plus appropri), mais cette fonction n'existe pas. Il faut donc la crer :

LRESULT CALLBACK WinProc(

HWND hwnd, //Handle de la fentre
UINT uMsg, //Message
WPARAM wParam, //Paramtre word
LPARAM lParam ) //Paramtre long

{
return DefWindowProc(
hwnd,
uMsg,
//Lance la procdure par dfaut
wParam,
lParam
);
}

Voici donc la procdure si mystrieuse : un truc tout con en fait, qui ne fait que passer le
relais une autre procdure dj dfinie. Et puis si vous tes perspicace, vous auriez pu
me dire "Mais alors, on aurait pu tout connement mettre DefWindowProc la place de
WinProc !". H ben en fait...oui. Mais maintenant, on va personnaliser un peu cette
fonction, histoire de s'amuser.

D'abord, vous aurez srement remarqu que le fait d'appuyer sur Alt+F4 ferme la fentre,
mais pas le programme : il faut l'arrter manuellement avec le compilateur ou
Ctrl+Alt+Del. En effet, le fait d'envoyer le message "Ferme la fentre" ne provoque pas
chez DefWindowProc l'envoi du message "Quitte le programme" : nous allons donc
remplacer le contenu de WinProc par :

if (uMsg==WM_CLOSE) {PostQuitMessage(0);return 0;}

else return DefWindowProc(hwnd,uMsg,wParam,lParam);

Ca y est ! nous avons enfin notre propre fonction de gestion de messages nous, qui sait
fermer le programme. Et vous remarquerez que les fameux messages voqus plus haut
(WM_PAINT,WM_QUIT,etc...) sont contenus dans la variable uMsg, transmise WinProc,
et que PostQuitMessage dit au programme de se fermer sans autre forme de procs.

Bon et bien maintenant, si nous intgrions OpenGL notre fentre, pour voir ? C'est vrai,
depuis le dbut du tutorial, on a toujours pas vu de DC ou de RC, juste un HWND, qui ma
foi faisait penser un DC de par sa dfinition. Je ne vous mentirais pas plus longtemps : le
DC est en effet directement tir du HWND. En fait, il suffit de le rcuprer grce la
fonction GetDC. "H bien on n'a qu' le faire alors !" Ok, ok on va le faire...mais o ? aprs
la cration de la fentre, dans le WinMain ? Oui, pourquoi pas, mais ca ferait un petit peu
bidouille, non ? Alors que lorsque l'on appelle CreateWindow, celle-ci excute justement
WinProc une seule fois, avec comme message WM_CREATE... C'est trop beau : tant qu'
faire, on va en profiter pour rcuprer notre DC ! Etoffons donc notre chre WinProc :

switch(uMsg)
{
case WM_CLOSE:

4 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

ReleaseDC(hwnd,DC);
PostQuitMessage(0); //Libre le DC et ferme le programme
break;

case WM_CREATE:

DC=GetDC(hwnd);
//Rcupre le DC
break;

default:

return DefWindowProc(
hwnd,
uMsg,
//Sinon, fait le truc habituel
wParam,
lParam);
break;

}
return 0;

Sans oublier de rajouter

HDC DC;

dans les dclaration de variables globales. Et voil, nous avons notre DC ! Lancez le
programme et vous verrez ce que ca change : ... rien. Car l'initialisation d'OpenGL n'est
mme pas commence. Il nous faut encore rcuprer le Rendering Context, et le dfinir
comme sortie OpenGL courante, en faisant

RC = wglCreateContext(DC); //RC est une variable globale de type HGLRC

if (!RC) SendMessage(hwnd,WM_CLOSE,0,0);
wglMakeCurrent(DC, RC);

aprs le GetDC du WM_CREATE, et en rajoutant

wglMakeCurrent(NULL, NULL);
if (RC) wglDeleteContext(RC);

avant le ReleaseDC du WM_CLOSE.

Voil, normalement ca devrait marcher. Mais ca marche pas. Pourquoi ? Et bien tout
simplement parce qu'on a pas paramtr le Device Context. En effet, il faudrait d'abord lui
dire en quelle rsolution on veut tre, et puis si on utilise le double buffering, et puis qu'on
veut lui associer un RC. Bref, il faut paramtrer ce qu'on appelle le PixelFormat (cad en
gros le format d'affichage). Crons donc une petite fonction qui va nous faire tout ca :

void SetupPixelFormat(HDC hDC)

{
PIXELFORMATDESCRIPTOR pfd =
{
sizeof(PIXELFORMATDESCRIPTOR), //taille du descripteur de format
1, //version
PFD_SUPPORT_OPENGL |
PFD_DRAW_TO_WINDOW | //Proprit
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA, //Mode de couleurs
16, //Bits de couleur
0, 0, 0, 0, 0, 0, //Paramtres des couleurs
0,0, //Paramtres alpha
0,0, 0, 0, 0, //Paramtres du buffer d'accumulation
32, //Bits de profondeur
0, //Bits du buffer stencil
0, //Nombre de buffers auxiliaires

5 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

0, //ignor (obsolte)
0, //rserv/code>
0, //ignor (obsolte)
0, //Couleur de transparence
0 //Ignor (obsolte)
};

int pixelFormat;
pixelFormat = ChoosePixelFormat(hDC, &pfd);
if (!pixelFormat)
{

MessageBox
(
WindowFromDC(hDC),
"Mode graphique non support", /*Vrifie si un PixelFormat du type demand
"Problme", existe*/
MB_ICONERROR | MB_OK
);
exit(1);

}
if (!SetPixelFormat(hDC, pixelFormat, &pfd))
{

MessageBox
(
WindowFromDC(hDC),
"Mode graphique non support",
/*Applique le PixelFormat. Arrte si erreur*/
"Problme",
MB_ICONERROR | MB_OK
);
exit(1);

}
}

Je me fais chier dcrire cette fonction, mais en fait il n'y a pas en dire beaucoup plus.
Les paramtres sont toujours les mmes, sauf peut-tre le nombre de bits de couleur et de
profondeur. A part ca, le reste ne sert pas grand chose, mais c'est ncessaire.
Contentez-vous de recopier la fonction, et interrogez votre compilateur ou moi si quelque
chose vous gne. Mais je vous rassure, vous n'avez pas grand chose savoir sur ces
paramtres.

Tout ce qu'il reste faire, c'est d'inclure un appel cette fonction aprs la rcupration du
DC et avant celle du RC (sans cela wglCreateContext vous renverra une erreur). Et voil !
L c'est rellement fini, et votre fonction WinProc doit ressembler ceci :

LRESULT CALLBACK WinProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam )

{
switch(uMsg)
{
case WM_CLOSE:

wglMakeCurrent(NULL, NULL);
if (RC) wglDeleteContext(RC);
//Libre RC et DC et ferme le
ReleaseDC(hwnd,DC);
programme
PostQuitMessage(0);
break;

case WM_CREATE:

6 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

DC=GetDC(hwnd);
SetupPixelFormat(DC);
RC = wglCreateContext(DC);
if (!RC) //Rcupre le DC et le RC
SendMessage(hwnd,WM_CLOSE,0,0);
wglMakeCurrent(DC, RC);
break;

default:

return DefWindowProc(hwnd,
uMsg,
wParam, //Sinon, fait le truc habituel
lParam);
break;

}
return 0;
}

Si vous lancez le programme maintenant, vous ne verrez cependant pas de changement

par rapport avant, tout simplement parce que le message WM_PAINT est encore gr
par DefWindowProc. Mais sachez qu'OpenGL est bien li cette fentre, et que le pas
entre la fentre vide et un rendu OpenGL est trs mince. Pour le dcouvrir, passez la
deuxime partie de ce tutorial !

2. Attacher OpenGL cette fentre

Dans la premi partie, je vous ai appris crer votre fentre par CreateWindow(),
associer la sortie OpenGL cette fentre par GetDC(), SetupPixelFormat(),
wglCreateContext() et wglMakeCurrent(), et grer les messages envoys cette fentre
par une fonction que nous avons appel WinProc(). Je vais maintenant finir de vous
expliquer comment initialiser OpenGL lui-mme, maintenant que la fentre est bien cre.
Reprenez donc votre programme de la dernire fois, et modifiez votre fonction WinProc()
de faon ce qu'elle ressemble a :

LRESULT CALLBACK WinProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam )

{
switch(uMsg)
{
case WM_CLOSE:

wglMakeCurrent(NULL, NULL);
if (RC) wglDeleteContext(RC);
//Libre RC et DC et ferme le
ReleaseDC(hwnd,DC);
programme
PostQuitMessage(0);
break;

case WM_CREATE:

DC=GetDC(hwnd);
SetupPixelFormat(DC);
RC = wglCreateContext(DC);
if (!RC)
//Rcupre le DC et le RC
SendMessage(hwnd,WM_CLOSE,0,0);
wglMakeCurrent(DC, RC);
InitGL();
break;

case WM_SIZE:

7 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

Reshape(
LOWORD(lParam),
//Met jour les paramtres
HIWORD(lParam)
OGL
);
break;

case WM_PAINT:

Draw();
//Excute le rendu
break;

default:

return DefWindowProc(
hwnd,
uMsg,
wParam, //Sinon, fait le truc habituel
lParam
);
break;

}
return 0;
}

Nous avons rajout un appel 3 fonctions que nous allons crire un peu plus loin : Draw(),
Reshape() et InitGL(). Nous reparlerons beaucoup de Draw() et InitGL() dans les
prochains tutoriaux. Mais parlons d'abord de Reshape() : voici ce qu'il faut crire
l'intrieur :

void Reshape(int width, int height)

{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,float(width)/float(height),0.1,100);
}

glViewport() informe d'abord OpenGL sur la taille de la zone de sortie

Ensuite glMatrixMode() charge la matrice de projection. Une matrice ? qusako ? En
fait, c'est un tableau sur lequel on peut effectuer des oprations mathmatiques
spcifiques. La matrice de projection sert dfinir comment les coordonnes 3D sont
transformes en coordonnes 2D sur l'cran. La matrice modle et vue
(GL_MODELVIEW) dfinit la position du repre de coordonnes dans le monde. C'est sur
cette matrice que l'on effectuent des oprations qui se traduisent par des rotations,
des translations ou des homotties. La matrice texture permet de dfinir l'aspect des
textures plaques sur les faces. On peut aussi lui faire subir des rotations, etc, qui se
rpercutent sur l'affichage. Les matrices sont donc des outils trs puissant de
modlisation.
glLoadIdentity() fait un reset de la matrice (il la rinitialise) pour pouvoir effectuer
des modifications sur celle-ci
Et enfin gluPerspective modifie la matrice courante (c'est--dire ici la matrice de
projection) pour qu'OpenGL transforme les coordonnes 3D au moment du rendu en
coordonnes 2D par rapport l'cran, de faon ce qu'on ait 'impression de
regarder travers un objectif de 45 de focale, de largeur width et de hauteur height,
et dont le clipping va de 0.1 100 (attention la valeur du clipping near - ici 0.1 - doit
tre strictement suprieure 0).

Cette fonction Reshape() est appele chaque fois que la fentre est redimensionne, et
notemment sa cration. Grce cette fonction, OpenGL est totalement initialis et est
parfaitement prs dessiner. Mais alors qu'est-ce que vient faire InitGL() ? Et bien en fait

8 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

on va mettre dans cette fonction toutes les fonctions optionnelles destines paramtrer
le rendu : activation du test de profondeur, dfinition des lumires, textures,
transparence... Donc pour l'instant, comme on n'a rien y mettre, on va quand mme la
crer, mais en la laissant vide :

void InitGL()
{
}

Et maintenant, la fontion Draw() : c'est la fonction qui sera appele chaque fois que la
fentre sera rafrachie, et donc c'est l-dedans qu'on va placer toute la sauce qui va
afficher l'cran de magnifiques images. La fonction Draw() commencera toujours par
glClear() (sauf effet visuel particulier) et finira toujours par SwapBuffers(DC). Mais trve
de bavardages, la voici :

void Draw()
{
glClear
(
GL_COLOR_BUFFER_BIT | //Efface le frame buffer et le Z-buffer
GL_DEPTH_BUFFER_BIT
);
glMatrixMode(GL_MODELVIEW); //Choisit la matrice MODELVIEW
glLoadIdentity(); //Rinitialise la matrice

//Placer ici tout le code de transformation et de dessin

SwapBuffers(DC); //Echange les 2 frame buffers

}

glClear() efface les buffers passs en paramtre. Ici, nous n'utilisons que le frame
buffer (c'est--dire le buffer correspondant l'image affich l'cran) et le z-buffer
(utilis pour les tests de profondeur). Pour l'instant, nous n'utiliseront pas le
z-buffer, mais comme plus tard on l'utilisera toujours, autant vous montrer tout de
suite comment on s'en sert.
Ensuite on charge la matrice modle/vue et on la rinitialise pour pouvoir par la
suite effectuer toutes les transformations 3D ncessaires (rotations, translations...).
Aprs vient tout le code de dessin et de transformation, que l'on remplira au fur et
mesure des tutorials
Et enfin la fonction SwapBuffers(DC) change les deux frame buffers : celui sur
lequel on travaillait est affich l'cran tandis que celui qui tait l'cran est cach
et servira pour le prochain rendu.

Vous pouvez ds maintenant essayer ce programme : vous y verrez un magnifique cran

noir, car pour l'instant rien n'est dessin dans notre cran
Mais pour ne pas vous laisser sur votre fin, voici quelques lignes insrer dans Draw()
entre glLoadIdentity() et SwapBuffers() pour vous montrer que ca marche vraiment :

gluLookAt(0,0,-10,0,0,0,0,1,0);
glBegin(GL_TRIANGLES);

glVertex2i(0,1);
glVertex2i(-1,0);
glVertex2i(1,0);

glEnd();

Je vous laisse dcouvrir ce que ca donne (pour les impatients, allez voir dans le tut glut).

Et voila ! Vous avez rellement dessin en OpenGL, rien qu'avec un petit tutorial de rien
du tout ! C'est-y pas gnial ? Avouez que c'est pas compliqu. Tout ce que vous avez

9 sur 10 05/08/2015 04:23

Initialiser OpenGL avec Windows http://www-evasion.imag.fr/Membres/Antoine.Bouthors/teaching/open...

besoin de savoir pour programmer en OpenGL sous Windows, c'est crer une fentre,
savoir rcuprer et grer les messages qui lui sont transmis, et rcuprer un Device
Context et un Rendering Context pour initialiser le PixelFormat. Et en plus, vous n'avez
mme pas besoin de connatre par coeur comment le faire ! Et si vous trouvez ca dj trop
dur, alors je ne vous laisse mme pas imaginer ce que ce serait si vous vous mettiez
Direct3D.

Antoche

Initialiser OpenGL avec

Introduction Tutoriaux OpenGL
GLUT

Last modified on Tuesday October 18th, 2005 E-mail any comment

10 sur 10 05/08/2015 04:23