OpenGL Tutorial/fr: what changed

Revision 2 to 3. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		OpenGL est l'environnement idéal pour développer des applications graphiques portables , interactives en 2D et 3D. Depuis son introduction en 1992 , OpenGL est devenu l'interface de programmation d'applications (API) soutenant les graphiques 2D et 3D la plus largement utilisée de l'industrie, amenant plusieurs milliers d'applications à une grande variété de plateformes d'ordinateur. OpenGL stimule l'innovation et accélère le développement d'applications en incorporant un large ensemble de rendus, mappage de texture, effets spéciaux , et d'autres fonctions puissantes de visualisation . Les développeurs peuvent accroître la puissance de OpenGL à travers toutes les plate-formes de bureau communes et les plate-formes de poste de travail, assurant un large déploiement d'applications.
2	2
3	3		Vous pouvez trouver plus d'information à propos d'OpenGL [ici](http://www.opengl.org/about/overview/).
4	4
5	5		GLUT (prononcé comme the glut in gluttony) est une trousse à outils pour OpenGL, une trousse à outil indépendante du système window pour écrire des programmes OpenGL. Il implémente une simple interface de programmation d'application avec fenêtrage (API) pour OpenGL. GLUT rend considérablement plus facile l'apprentissage et l'exploration de la programmation OpenGL. GLUT fournit une API portable ainsi vous pouvez écrire un programme simple avec OpenGL qui travaille sur les plate-formes avec système d'exploitation à base de PC et de station de travail.
6	6
7	7		Vous pouvez trouver plus d'information à propos de GLUT [ici](http://www.opengl.org/resources/libraries/glut/).
8	8
9	9		Beaucoup d'OS viennent avec GLUT préinstallé, mais si le votre n'en a pas un, vous pouvez facilement le trouver en utilisant [Google](http://www.google.com/).
10	10
11	11		Les fichiers binaires Windows peut être téléchargé depuis [www.xmission.com](http://www.xmission.com/~nate/glut.html).
12	12
13	13		# Créer votre premier programme GLUT
14	14
15	15		Afin d'utiliser GLUT, vous devez d'abord l'initialiser. C'est fait en utilisant la fonction glutInit. Cette fonction peut analyser la ligne de commande et fixer les paramètres de la fenêtre principale, mais il s'attend à une entrée dans le style C/C++ . Vous devrez écrire votre propre fonction pour faire la conversion à partir de ParamCount et ParamStr vers des paramètres en ligne de commande similaire à C/C++.
16	16
17	17		``` pascal
18	18		procedure glutInitPascal(ParseCmdLine: Boolean);
19	19		var
20	20		Cmd: array of PChar;
21	21		CmdCount, I: Integer;
22	22		begin
23	23		if ParseCmdLine then
24	24		CmdCount := ParamCount + 1
25	25		else
26	26		CmdCount := 1;
27	27		SetLength(Cmd, CmdCount);
28	28		for I := 0 to CmdCount - 1 do
29	29		Cmd[I] := PChar(ParamStr(I));
30	30		glutInit(@CmdCount, @Cmd);
31	31		end;
32	32		```
33	33
34	34		Essentiellement , vous créez un tableau et le remplissez avec les chaînes de caractères de ParamStr. Cette fonction prend également un paramètre qui peut contrôler ce qui est passé à glutInit -- ou bien la ligne de commande en entier ou juste le nom du fichier exécutable .
35	35
36	36		Plus à propos de glutInit: [ici](http://www.opengl.org/resources/libraries/glut/spec3/node10.html)
37	37
38	38		Après , vous devez créer une fenêtre principale . Fixer le mode d'affichage de la fenêtre principale en utilisant glutInitDisplayMode. Cela nécessite seulement un paramètre qui est une combinaison des drapeaux. Habituellement GLUT_DOUBLE ou GLUT_RGB ou GLUT_DEPTH est tout ce dont vous aurez besoin.
39	39
40	40		Plus à propos de glutInitDisplayMode: [ici](http://www.opengl.org/resources/libraries/glut/spec3/node12.html)
41	41
42	42		La position et la taille de la fenêtre est contrôlée en utilisant glutInitWindowPosition et glutInitWindowSize. Elles ont 2 paramètres . Les coordonnées X et Y dans le premier, et la largeur et la hauteur dans le dernier. Vous pouvez employer glutGet pour trouver la taille de l'écran et centrer la fenêtre.
43	43
44	44		Plus à propos de glutInitWindowPosition, glutInitWindowSize et glutGet: [ici](http://www.opengl.org/resources/libraries/glut/spec3/node11.html) et [là](http://www.opengl.org/documentation/specs/glut/spec3/node70.html)
45	45
46	46		Enfin, la fenêtre devrait être créée en utilisant la fonction glutCreateWindow. Il créera la fenêtre et fixera son caption au moyen d'un paramètre. Comme résultat il renverra l'handle de la fenêtre . Ceci peut être employé avec d'autres fonctions qui l'exigent .
47	47
48	48		Plus à propos de glutCreateWindow: [ici](http://www.opengl.org/resources/libraries/glut/spec3/node16.html)
49	49
50	50		Avant que votre programme puisse entrer dans la boucle principale, vous devez paramétrer quelques procedures de rappel(callbacks). Vous aurez besoin de procédures de rappel pour dessiner la fenêtre , pour redimensionner et pour obtenir les entrées au clavier. Ces procédures de rappel sont paramétrées en utilisant glutDisplayFunc, glutReshapeFunc et glutKeyboardFunc.
51	51
52	52		Plus à propos du paramétrage des fonctions de rappel: [ici](http://www.opengl.org/resources/libraries/glut/spec3/node45.html#SECTION00080000000000000000)
53	53
54	54		Votre fonction de dessin pourrait ressembler à ceci :
55	55
56	56		``` pascal
57	57		procedure DrawGLScene; cdecl;
58	58		begin
59	59		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
60	60		glutSwapBuffers;
61	61		end;
62	62		```
63	63
64	64		Cela va seulement effacer la fenêtre à la couleur du fond et remettre à zéro le zbuffer (ne pas s'inquiéter pour zbuffer... vous en saurez plus à ce propos plus tard).
65	65
66	66		Votre fonction de redimension pourrait ressembler à ceci :
67	67
68	68		``` pascal
69	69		procedure ReSizeGLScene(Width, Height: Integer); cdecl;
70	70		begin
71	71		if Height = 0 then
72	72		Height := 1;
73	73
74	74		glViewport(0, 0, Width, Height);
75	75		glMatrixMode(GL_PROJECTION);
76	76		glLoadIdentity;
77	77		gluPerspective(45, Width / Height, 0.1, 1000);
78	78
79	79		glMatrixMode(GL_MODELVIEW);
80	80		glLoadIdentity;
81	81		end;
82	82		```
83	83
84	84		Avec ce code, vous dites à OpenGL où dans la fenêtre il devrait dessiner et fixer les matrices aux valeurs désirées (les fonctions de matrice seront expliquées plus tard ).
85	85
86	86		L'entrée au clavier est évaluée avec la procedure de rappel suivante:
87	87
88	88		``` pascal
89	89		procedure GLKeyboard(Key: Byte; X, Y: Longint); cdecl;
90	90		begin
91	91		if Key = 27 then
92	92		Halt(0);
93	93		end;
94	94		```
95	95
96	96		Cette fonction demandera à votre programme de quitter si vous appuyez sur la touche ESC. GLUT est conduit par des évènement et la seule manière de terminer votre programme est d'appeler Halt à l'intérieur d'une de vos fonctions de rappel. Si vous fermez la fenêtre d'une autre manière, elle disparaîtra , mais le programme continuera à faire une boucle au travers de la routine principale indéfiniment .
97	97
98	98		Pour commencer la boucle principale , appellez glutMainLoop. Il écrira une boucle qui ne finit jamais , qui appelle toutes vos procedures de rappel.
99	99
100	100		La partie principale de votre programme pourrait ressembler à ceci :
101	101
102	102		``` pascal
103	103		const
104	104		AppWidth = 640;
105	105		AppHeight = 480;
106	106
107	107		procedure InitializeGL;
108	108		begin
109	109		glClearColor(0.18, 0.20, 0.66, 0);
110	110		end;
111	111
112	112		var
113	113		ScreenWidth, ScreenHeight: Integer;
114	114		begin
115	115		glutInitPascal(True);
116	116		glutInitDisplayMode(GLUT_DOUBLE or GLUT_RGB or GLUT_DEPTH);
117	117		glutInitWindowSize(AppWidth, AppHeight);
118	118		ScreenWidth := glutGet(GLUT_SCREEN_WIDTH);
119	119		ScreenHeight := glutGet(GLUT_SCREEN_HEIGHT);
120	120		glutInitWindowPosition((ScreenWidth - AppWidth) div 2,
121	121		(ScreenHeight - AppHeight) div 2);
122	122		glutCreateWindow('OpenGL Tutorial 1');
123	123
124	124		InitializeGL;
125	125
126	126		glutDisplayFunc(@DrawGLScene);
127	127		glutReshapeFunc(@ReSizeGLScene);
128	128		glutKeyboardFunc(@GLKeyboard);
129	129
130	130		glutMainLoop;
131	131		end.
132	132		```
133	133
134	134		Le tutoriel suivant ajoutera un certain code qui dessinera une forme simple .
135	135
136	136		Télécharger le code source ou un executable linux/windows depuis le site [SourceForge CCR de Lazarus](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
137	137
138	138		# Dessiner une forme simple
139	139
140	140		Cette fois nous ajouterons juste quelques lignes de code et nous nous focaliserons sur l'explication de certaines des fonctions OpenGL .
141	141
142	142		Expliquons le code que vous avez déjà.
143	143
144	144		``` pascal
145	145
146	146		.
147	147		.
148	148		.
149	149		glMatrixMode(GL_PROJECTION);
150	150		glLoadIdentity;
151	151		gluPerspective(45, Width / Height, 0.1, 1000);
152	152
153	153		glMatrixMode(GL_MODELVIEW);
154	154		glLoadIdentity;
155	155		end;
156	156		```
157	157
158	158		En employant la fonction glMatrixMode vous choisissez quelle matrice vous voulez changer . OpenGL travaille avec 3 matrices : GL_MODELVIEW: celle-ci est employée pour déplacer les sommets vers l'espace modèle . GL_PROJECTION: celle-ci est employée pour convertir les coordonnées 3d en coordonnées 2d pour la position finale des pixels. GL_TEXTURE: celle-ci est employée pour changer des coordonnées de texture .
159	159
160	160		Une fois que vous avez choisi la matrice vous voulez changer , vous pouvez appeler les fonctions qui affectent les valeurs de la matrice. glLoadIdentity remettra à zéro la matrice ainsi il n'affecte pas la position des sommets. Puisque la plupart des fonctions de matrice multiplient la matrice courante par celle générée , vous devez parfois effacer la matrice avec cette fonction .
161	161
162	162		Afin de paramétrer la matrice de perspective, vous pouvez employer la fonction gluPerspective. Quatre paramètres montrent le champ visuel , l'allongement , la surface plane proche et lointaine. C'est aussi simple.
163	163
164	164		Maintenant , vous changerez la matrice modèle ... pendant ce temps , vous l'avez juste paramétré à la matrice identité .
165	165
166	166		OK ... et maintenant , le code pour dessiner la première forme :
167	167
168	168		``` pascal
169	169		procedure DrawGLScene; cdecl;
170	170		begin
171	171		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
172	172
173	173		glLoadIdentity;
174	174		glTranslatef(0, 0, -5);
175	175
176	176		glBegin(GL_TRIANGLES);
177	177		glColor3f(1, 0, 0);
178	178		glVertex3f(-1, -1, 0);
179	179
180	180		glColor3f(0, 1, 0);
181	181		glVertex3f(1, -1, 0);
182	182
183	183		glColor3f(0, 0, 1);
184	184		glVertex3f(0, 1, 0);
185	185		glEnd;
186	186
187	187		glutSwapBuffers;
188	188		end;
189	189		```
190	190
191	191		Nous avons déjà employé la fonction glClear. Elle remettra juste à zéro les mémoires tampons(buffers). Nous passerons les deux fonctions suivantes et nous nous dirigerons vers celles de dessin.
192	192
193	193		glBegin marque le commencement du bloc de dessin . Après cette fonction vous pouvez commencer à entrer les sommets. Le paramètre(entre parenthèse) décrit comment sont utilisés les sommets en dessinant : GL_POINTS: Traite chaque sommet comme simple point. Le sommet n définit le point n . N points sont dessinés.
194	194
195	195		GL_LINES: Traite chaque paire de sommets comme segment de ligne indépendant. Les sommets 2n-1 et 2n définissent la ligne n . n/2 lignes sont tracées .
196	196
197	197		GL_LINE_STRIP: Dessine un groupe relié de segments de ligne du premier sommet au dernier. n-1 lignes sont tracées.
198	198
199	199		GL_LINE_LOOP: Dessine un groupe relié de segments de ligne du premier sommet au dernier, en revenant vers le premier. Les sommets n et n+1 définissent la ligne n . La dernière ligne , cependant , est défini par les sommets n et 1.n lignes sont tracées .
200	200
201	201		GL_TRIANGLES: Traite chaque triplet des sommets comme un triangle indépendant . Les sommets 3n-2, 3n-1 et 3n définissent le triangle n. n/3 triangles sont tracées .
202	202
203	203		GL_TRIANGLE_STRIP: Dessine un groupe relié de triangles . Un triangle est défini pour chaque sommet présenté après les deux premiers sommets. Pour n impair, les sommets n, n+1 et n+2 définissent le triangle n. Pour n pair, les sommets n+1, n et n+2 définissent le triangle n . n-2 triangles sont tracées .
204	204
205	205		GL_TRIANGLE_FAN: Dessine un groupe relié de triangles . Une triangle est définie pour chaque sommet présenté après les deux premiers sommets . Les sommets 1, n+1 et n+2 définissent le triangle n. n-2 triangles sont dessinés .
206	206
207	207		GL_QUADS: Traite chaque groupe de quatre sommets comme un quadrilatère indépendant. Les sommets 4n-3, 4n-2, 4n-1 et 4n définissent le quadrilatère n. n/4 quadrilatères sont dessinés.
208	208
209	209		GL_QUAD_STRIP: Dessine un groupe relié de quadrilatères. Un quadrilatère est défini pour chaque paire de sommets présentés après la première paire.Les sommets 2n-1, 2n, 2n+2 et 2n+1 définissent le quadrilatère n. n/2-1 quadrilatères sont dessinés. Notez que l'ordre dans lequel des sommets sont employés pour construire un quadrilatère à partir des données reliées est différent de celui utilisé avec des données indépendantes.
210	210
211	211		GL_POLYGON: Dessine un polygone simple et convexe . Les sommets 1 jusqu'à n définissent ce polygone .
212	212
213	213		![](/wiki-images/f/f3/SimpleShapePic1.jpg) Vous tracerez un triangle simple et pour cela le drapeau GL_TRIANGLES accomplira cette astuce. La fonction glVertex3f définit la position d'un sommet que vous voulez dessiner. Il y a plus de fonctions glVertex* . La seule différence est le nombre et le type de paramètres que ces fonctions prennent. Par exemple ... glVertex2i prend deux paramètres (x et y) du type nombre entier. glVertex3f sera presque toujours juste ce que vous avez besoin.
214	214
215	215		Avant glVertex vous pouvez fixer la couleur, le matériel , les textures... Pour la simplicité vous indiquerez juste la couleur pour chaque sommet dans tutoriel . La couleur est paramétrée en utilisant la fonction glColor3f. glColor peut aussi prendre différents ensemble de paramètres comme glVertex.
216	216
217	217		Si on jette un coup d'oeil sur le code, nous pouvons voir que Z est paramétré à 0 pour tous les sommets. Puisque vous avez fixé la plan proche à 0.1, le triangle ne sera pas visible. C'est là que nous avons passé les deux fonctions au commencement. Nous savons déjà que glLoadIdentity remet à zéro la matrice. glTranslatef déplace les triangles selon les valeurs X, Y et Z que vous fournissez. Puisque vous avez fixé Z à -5 (z négatif est plus loin de la caméra) tous les sommets seront dessinés avec un éloignement de 5 unités du point de vue et seront visibles.
218	218
219	219		À la fin vous appelez les fonctions glEnd qui finissent le dessin. Vous pourriez maintenant commencer d'autres bloc de dessin avec une nouvelle fonction glBegin si vous le souhaitez .
220	220
221	221		Téléchargez le code source , l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
222	222
223	223		# Employer des listes d'affichage
224	224
225	225		Parfois vous devrez dessiner quelques objets de multiples fois sur la scène. OpenGL a la capacité de construire des listes d'affichage ce qui rend le dessin un peu plus rapide.Créer une liste d'affichage est très facile ... dessinez juste les sommets comme vous l'avez fait dans le précédent tutoriel et enfermez-les avec les appels à glNewList et glEndList.
226	226
227	227		``` pascal
228	228		const
229	229		LIST_OBJECT = 1;
230	230
231	231		procedure CreateList;
232	232		begin
233	233		glNewList(LIST_OBJECT, GL_COMPILE);
234	234		glBegin(GL_TRIANGLE_FAN);
235	235		glColor3f(1, 0, 0);
236	236		glVertex3f(0, 0.5, 0);
237	237
238	238		glColor3f(1, 1, 0);
239	239		glVertex3f(-0.5, -0.5, 0.5);
240	240
241	241		glColor3f(1, 1, 1);
242	242		glVertex3f(0.5, -0.5, 0.5);
243	243
244	244		glColor3f(0, 1, 1);
245	245		glVertex3f(0.5, -0.5, -0.5);
246	246
247	247		glColor3f(0, 0, 1);
248	248		glVertex3f(-0.5, -0.5, -0.5);
249	249
250	250		glColor3f(0, 1, 0);
251	251		glVertex3f(-0.5, -0.5, 0.5);
252	252		glEnd;
253	253
254	254		glBegin(GL_QUADS);
255	255		glColor3f(1, 1, 0);
256	256		glVertex3f(-0.5, -0.5, 0.5);
257	257
258	258		glColor3f(1, 1, 1);
259	259		glVertex3f(0.5, -0.5, 0.5);
260	260
261	261		glColor3f(0, 1, 1);
262	262		glVertex3f(0.5, -0.5, -0.5);
263	263
264	264		glColor3f(0, 0, 1);
265	265		glVertex3f(-0.5, -0.5, -0.5);
266	266
267	267		glColor3f(0, 1, 0);
268	268		glVertex3f(-0.5, -0.5, 0.5);
269	269		glEnd;
270	270		glEndList;
271	271		end;
272	272		```
273	273
274	274		glNewList crée une nouvelle liste d'affichage et toutes les fonctions de dessin seront enregistrées jusqu'à ce que glEndList soit appelé. Le premier paramètre pour la fonction glNewList est l'identification de la liste(ID).Chaque liste est définie par son ID. Si une liste avec une identification donnée est déjà créée son contenu est effacé avant l'enregistrement. Si le deuxième paramètre est GL_COMPILE alors toutes les fonctions de dessin sont juste enregistrées , mais si c'est GL_COMPILE_AND_EXECUTE alors elles sont enregistrées et exécutées automatiquement.
275	275
276	276		La fonction glIsList peut vous aider avec des listes d'affichage. Il peut indiquer si une certaine identification de liste est déjà remplie de données. Une autre fonction utile est glGenLists. Il créera de multiple listes d'affichage vides. Vous passez le nombre de listes d'affichage dont vous avez besoin et vous obtenez l'identification de la première. Si vous exigez n listes, et obtenez r identifications,les listes d'affichage produites sont : r, r+1, r+2,..., r+n-1
277	277
278	278		Toutes les listes créées devraient être supprimées. Vous ferez cela avant de quitter le programme :
279	279
280	280		``` pascal
281	281		procedure GLKeyboard(Key: Byte; X, Y: Longint); cdecl;
282	282		begin
283	283		if Key = 27 then
284	284		begin
285	285		glDeleteLists(LIST_OBJECT, 1);
286	286		Halt(0);
287	287		end;
288	288		end;
289	289		```
290	290
291	291		glDeleteLists prend 2 paramètres, l'identification de la liste d'affichage et le nombre de listes à supprimer. Si l'identification est r, et le nombre de listes à supprimer est n, les listes supprimées sont : r, r+1, r+2,..., r+n-1
292	292
293	293		Maintenant vous savez créer et supprimer des listes d'affichage ... voyons comment les dessiner :
294	294
295	295		``` pascal
296	296		procedure DrawGLScene; cdecl;
297	297		begin
298	298		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
299	299
300	300		glLoadIdentity;
301	301		glTranslatef(-2, 0, -5);
302	302		glRotatef(40, 1, 0, 1);
303	303		glCallList(LIST_OBJECT);
304	304
305	305		glLoadIdentity;
306	306		glTranslatef(1, -2, -10);
307	307		glRotatef(62, 0, 1, 0);
308	308		glCallList(LIST_OBJECT);
309	309
310	310		glLoadIdentity;
311	311		glTranslatef(-4, 0.5, -15);
312	312		glRotatef(200, 1, 0, 0);
313	313		glCallList(LIST_OBJECT);
314	314
315	315		glutSwapBuffers;
316	316		end;
317	317		```
318	318
319	319		![](/wiki-images/a/a5/DisplayListsPic1.jpg) En utilisant glCallList vous pouvez dessiner seulement une liste d'affichage . Dans ce tutoriel, avant de dessiner une liste d'affichage, vous changez la matrice modèle et dessinez l'objet en différents endroits . Quelques fois vous voudriez dessiner des listes multiples d'un coup. C'est possible en utilisant la fonction glCallLists. Il prend le nombre de listes que vous voulez dessiner, le type de tableau qui contient les identifications de liste d'affichage et le tableau avec les identifications de liste d'affichage. Le type de liste peut être l'un des suivant :
320	320
321	321		GL_BYTE: la liste est traitée comme un tableau d'octets signés, chacun dans l'intervalle de -128 à 127 .
322	322
323	323		GL_UNSIGNED_BYTE: la liste est traitée comme un tableau d'octets non signés, chacun dans l'intervalle de 0 à 255.
324	324
325	325		GL_SHORT: la liste est traitée comme un tableau d'entiers sur 2 octets signés, chacun dans l'intervalle de -32768 à 32767.
326	326
327	327		GL_UNSIGNED_SHORT: la liste est traitée comme un tableau d'entiers sur 2 octets non signés, chacun dans l'intervalle de 0 à 65535.
328	328
329	329		GL_INT: la liste est traitée comme un tableau d'entiers sur 4 octets signés.
330	330
331	331		GL_UNSIGNED_INT: la liste est traitée comme un tableau d'entiers sur 4 octets non signés.
332	332
333	333		GL_FLOAT: la liste est traitée comme un tableau de valeurs à virgule flottante sur 4 octets.
334	334
335	335		GL_2_BYTES: la liste est traitée comme un tableau d'octets non signés. Chaque paire d'octet spécifie une identification simple de la liste d'affichage. La valeur de la paire est calculée comme étant 256 fois la valeur du premier octet non signée plus la valeur du deuxième octet non signée .
336	336
337	337		GL_3_BYTES: la liste est traitée comme un tableau d'octets non signés. Chaque triplet d'octet spécifie une identification simple de la liste d'affichage. La valeur du triplet est calculée comme étant 65536 fois la valeur du premier octet non signée, plus 256 fois la valeur du deuxième octet non signée, plus la valeur du troisième octet non signée.
338	338
339	339		GL_4_BYTES: la liste est traitée comme un tableau d'octets non signés. Chaque quadruplet d'octet spécifie une identification simple de la liste d'affichage. La valeur du quadruplet est calculée comme étant 16777216 fois la valeur du premier octet non signée, plus 65536 fois la valeur du deuxième octet non signée, plus 256 la valeur du troisième octet non signée, plus la valeur du quatrième octet non signée.
340	340
341	341		C'est tout pour le moment. Le prochain tutoriel montrera comment créer petit système planétaire. Nous parlerons des matrices et comment faire une scène animée qui ne dépend pas du nombre d'images par seconde .
342	342
343	343		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
344	344
345	345		# Animation en plein écran
346	346
347	347		Entrer dans le mode plein écran est facile avec GLUT. Changeons la partie principale du programme :
348	348
349	349		``` pascal
350	350		const
351	351		FSMode = '800x600:32@75';
352	352
353	353		begin
354	354		glutInitPascal(False);
355	355		glutInitDisplayMode(GLUT_DOUBLE or GLUT_RGB or GLUT_DEPTH);
356	356		glutGameModeString(FSMode);
357	357		glutEnterGameMode;
358	358		glutSetCursor(GLUT_CURSOR_NONE);
359	359
360	360		InitializeGL;
361	361
362	362		glutDisplayFunc(@DrawGLScene);
363	363		glutReshapeFunc(@ReSizeGLScene);
364	364		glutKeyboardFunc(@GLKeyboard);
365	365		glutIdleFunc(@DrawGLScene);
366	366
367	367		glutMainLoop;
368	368		end.
369	369		```
370	370
371	371		Puisque nous ne voulons pas que GLUT analyse la ligne de commande cette fois nous appelons glutInitPascal avec le paramètre false. Comme vous pouvez le voir, il n'y a aucun code pour la création de fenêtre. GLUT a glutEnterGameMode qui crée une fenêtre en mode plein écran. Pour indiquer quel genre de mode plein écran vous voulez, vous appelez la fonction glutGameModeString qui prend un chaine de caractères qui définie le mode que vous aimez . Le format de cette chaine de caractères est :
372	372
373		-	~~`[largeur "x" hauteur][":" bpp]["@" hertz]`~~
	373	+	```text
	374	+	[largeur "x" hauteur][":" bpp]["@" hertz]
	375	+	```
374	376
375	377		Dans la chaine de caractères FSMode nous avons déclaré que le mode plein écran devrait être 800x600, avec une pallete de 32bit et un rafraîchissements de 75Hz. Il est possible de sauter un des groupes . Si vous omettez la taille , GLUT essayera d'employer la taille courante ou la première des plus petites qui peut fonctionner. Cette politique est employée et pour d'autres paramètres .
376	378
377	379		Habituellement dans le mode plein écran le curseur n'est pas visible. Pour cacher le curseur vous utilisez la fonction glutSetCursor. Elle utilise seulement un paramètre qui décrit le curseur que vous voudriez voir :
378	380
379		-	~~`GLUT_CURSOR_RIGHT_ARROW`\~~
380		-	~~`GLUT_CURSOR_LEFT_ARROW`\~~
381		-	~~`GLUT_CURSOR_INFO`\~~
382		-	~~`GLUT_CURSOR_DESTROY`\~~
383		-	~~`GLUT_CURSOR_HELP`\~~
384		-	~~`GLUT_CURSOR_CYCLE`\~~
385		-	~~`GLUT_CURSOR_SPRAY`\~~
386		-	~~`GLUT_CURSOR_WAIT`\~~
387		-	~~`GLUT_CURSOR_TEXT`\~~
388		-	~~`GLUT_CURSOR_CROSSHAIR`\~~
389		-	~~`GLUT_CURSOR_UP_DOWN`\~~
390		-	~~`GLUT_CURSOR_LEFT_RIGHT`\~~
391		-	~~`GLUT_CURSOR_TOP_SIDE`\~~
392		-	~~`GLUT_CURSOR_BOTTOM_SIDE`\~~
393		-	~~`GLUT_CURSOR_LEFT_SIDE`\~~
394		-	~~`GLUT_CURSOR_RIGHT_SIDE`\~~
395		-	~~`GLUT_CURSOR_TOP_LEFT_CORNER`\~~
396		-	~~`GLUT_CURSOR_TOP_RIGHT_CORNER`\~~
397		-	~~`GLUT_CURSOR_BOTTOM_RIGHT_CORNER`\~~
398		-	~~`GLUT_CURSOR_BOTTOM_LEFT_CORNER`\~~
399		-	~~`GLUT_CURSOR_FULL_CROSSHAIR`\~~
400		-	~~`GLUT_CURSOR_NONE`\~~
401		-	~~`GLUT_CURSOR_INHERIT`~~
	381	+	```text
	382	+	GLUT_CURSOR_RIGHT_ARROW
	383	+	GLUT_CURSOR_LEFT_ARROW
	384	+	GLUT_CURSOR_INFO
	385	+	GLUT_CURSOR_DESTROY
	386	+	GLUT_CURSOR_HELP
	387	+	GLUT_CURSOR_CYCLE
	388	+	GLUT_CURSOR_SPRAY
	389	+	GLUT_CURSOR_WAIT
	390	+	GLUT_CURSOR_TEXT
	391	+	GLUT_CURSOR_CROSSHAIR
	392	+	GLUT_CURSOR_UP_DOWN
	393	+	GLUT_CURSOR_LEFT_RIGHT
	394	+	GLUT_CURSOR_TOP_SIDE
	395	+	GLUT_CURSOR_BOTTOM_SIDE
	396	+	GLUT_CURSOR_LEFT_SIDE
	397	+	GLUT_CURSOR_RIGHT_SIDE
	398	+	GLUT_CURSOR_TOP_LEFT_CORNER
	399	+	GLUT_CURSOR_TOP_RIGHT_CORNER
	400	+	GLUT_CURSOR_BOTTOM_RIGHT_CORNER
	401	+	GLUT_CURSOR_BOTTOM_LEFT_CORNER
	402	+	GLUT_CURSOR_FULL_CROSSHAIR
	403	+	GLUT_CURSOR_NONE
	404	+	GLUT_CURSOR_INHERIT
	405	+	```
402	406
403	407		glutIdleFunc définit une fonction de rappel que vous voulez appeler chaque fois que votre programme n'a aucun message à traiter. Puisque nous voulons juste faire le rendu de la nouvelle image s'il n'y a rien à faire, juste faire tourner en idle DrawGLScene. Certains autres tutoriels montrent que la fonction idle devrait envoyer un message de refresh plutôt que de dessin, mais ainsi j'ai 50-100 images de moins qu'en utilisant la méthode que j'ai décrit .
404	408
405	409		Maintenant , regardons l'arrêt de programme là où vous devez quitter le mode plein écran :
406	410
407	411		``` pascal
408	412		procedure GLKeyboard(Key: Byte; X, Y: Longint); cdecl;
409	413		begin
410	414		if Key = 27 then
411	415		begin
412	416		glutLeaveGameMode;
413	417		Halt(0);
414	418		end;
415	419		end;
416	420		```
417	421
418	422		Comme vous pouvez le voir , tout que vous devez faire est d'appeler glutLeaveGameMode.
419	423
420	424		Maintenant , nous allons présenter quelques nouvelles fonctions de matrice. D'abord, changeons la fonction ReSizeGLScene :
421	425
422	426		``` pascal
423	427		procedure ReSizeGLScene(Width, Height: Integer); cdecl;
424	428		begin
425	429		.
426	430		.
427	431		.
428	432
429	433		glMatrixMode(GL_MODELVIEW);
430	434		glLoadIdentity;
431	435		gluLookAt(0, 20, 25, 0, 0, 0, 0, 1, 0);
432	436		end;
433	437		```
434	438
435	439		gluLookAt créer la matrice qui définira d'où êtes vous pour regarder les objets. Les 3 premiers paramètres sont les coordonnées X, Y et Z de la position de la caméra. les 3 paramètres suivants sont les coordonnées X, Y et Z du point vers où la caméra regarde, et les 3 derniers paramètres définissent un vecteur « vers le haut » (C'est « vers le haut » pour la caméra). Habituellement , « vers le haut » est l'axe y positif.
436	440
437	441		OK, dessinons maintenant. Puisque vous avez défini la matrice avec gluLookAt laquelle devrait être employé avec tous les objets, vous ne pouvez pas simplement employer glLoadIdentity pour remettre à zéro la matrice pour le prochain objet ... vous sauverez l'état précédent de la matrice et le restaurerez après que l'objet soit dessiné :
438	442
439	443		``` pascal
440	444		procedure DrawGLScene; cdecl;
441	445		var
442	446		T: Single;
443	447		begin
444	448		T := glutGet(GLUT_ELAPSED_TIME) / 1000;
445	449		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
446	450
447	451		glPushMatrix;
448	452		glRotatef(5 * T, 0, 1, 0);
449	453		glColor3f(1, 1, 0);
450	454		glutWireSphere(2, 20, 20);
451	455		glPopMatrix;
452	456
453	457		glPushMatrix;
454	458		glRotatef(90 * T, 0, 1, 0);
455	459		glTranslatef(5, 0, 0);
456	460		glRotatef(40 * T, 0, 1, 0);
457	461		glColor3f(1, 0, 0);
458	462		glutWireSphere(0.6, 10, 10);
459	463		glPopMatrix;
460	464
461	465		glPushMatrix;
462	466		glRotatef(60 * T, 0, 1, 0);
463	467		glTranslatef(-3, 0, 9);
464	468		glRotatef(50 * T, 0, 1, 0);
465	469		glColor3f(0, 1, 0);
466	470		glutWireSphere(1, 16, 16);
467	471
468	472		glPushMatrix;
469	473		glRotatef(360 * T, 0, 1, 0);
470	474		glTranslatef(-1.7, 0, 0);
471	475		glRotatef(50 * T, 0, 1, 0);
472	476		glColor3f(0, 0, 1);
473	477		glutWireSphere(0.4, 10, 10);
474	478		glPopMatrix;
475	479
476	480		glPopMatrix;
477	481
478	482		glutSwapBuffers;
479	483		end;
480	484		```
481	485
482	486		![](/wiki-images/5/51/FullScreenAnimationPic1.jpg) glPushMatrix et glPopMatrix sont employés pour enregistrer et restaurer l'état de la matrice. Comme vous pouvez le voir, nous enregistrons l'état de la matrice, ensuite changeons la matrice afin de dessiner l'objet à la bonne place, et restaurons ensuite l'ancien état de la matrice .
483	487
484	488		Vous pouvez vous demander quel est le rôle de la variable T . Bien, elle est employée pour déterminer la vitesse d'animation. Chaque changement qui dépend du temps est multiplié par T. De cette manière, la vitesse d'animation est constante pour chaque rapidité d'affichage . La fonction glutGet avec le paramètre GLUT_ELAPSED_TIME renvoie le temps en milliseconds depuis que glutInit a été appelé. En divisant cette valeur par 1000, nous avons le temps en secondes .
485	489
486	490		La fonction glRotatef créer une matrice de rotation. Le premier paramètre est l'angle en degrés,et les 3 derniers paramètres définissent l'axe autour duquel la rotation sera faite . Puisque vous avez multiplié l'angle par T, l'objet sera tourné de cet angle en exactement 1 seconde.
487	491
488	492		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
489	493
490	494		# Lumière
491	495
492	496		Ce tutoriel présentera une certaine lumière à la scène. Vous ferez tourner un cube et une lumière ajoutera du réalisme à la scène, mais d'abord faisons une unité d'outils .
493	497
494	498		Dans l'immédiat, il y aura seulement des fonctions fondamentales pour nous aider à obtenir le temps courant et la variation de temps(temps qui s'est écoulé depuis un appel à un rendu à l'autre) afin de calculer le nombre d'images par secondes.
495	499
496	500		``` pascal
497	501		unit utils;
498	502
499	503		{$mode objfpc}{$H+}
500	504
501	505		interface
502	506
503	507		uses
504	508		glut;
505	509
506	510		function GetTotalTime: Single;
507	511		function GetDeltaTime: Single;
508	512		procedure FrameRendered(Count: Integer = 1);
509	513		function GetFPS: Single;
510	514
511	515		implementation
512	516
513	517		var
514	518		OldTime: Integer = 0;
515	519		FPSTime: Integer = 0;
516	520		FPSCount: Integer = 0;
517	521
518	522		function GetTotalTime: Single;
519	523		begin
520	524		Result := glutGet(GLUT_ELAPSED_TIME) / 1000;
521	525		end;
522	526
523	527		function GetDeltaTime: Single;
524	528		var
525	529		NewTime: Integer;
526	530		begin
527	531		NewTime := glutGet(GLUT_ELAPSED_TIME);
528	532		Result := (NewTime - OldTime) / 1000;
529	533		OldTime := NewTime;
530	534		end;
531	535
532	536		procedure FrameRendered(Count: Integer);
533	537		begin
534	538		Inc(FPSCount, Count);
535	539		end;
536	540
537	541		function GetFPS: Single;
538	542		var
539	543		NewTime: Integer;
540	544		begin
541	545		NewTime := glutGet(GLUT_ELAPSED_TIME);
542	546
543	547		Result := FPSCount / ((NewTime - FPSTime) / 1000);
544	548
545	549		FPSTime := NewTime;
546	550		FPSCount := 0;
547	551		end;
548	552
549	553		end.
550	554		```
551	555
552	556		Comme vous pouvez le voir, il n'y a rien de compliqué dans cette unité. Le temps est simplement enregistré entre chaque appel et la différence est retournée. FrameRendered devrait être appelé chaque fois que vous dessinez la scène ainsi la fonction peut calculer les FPS.
553	557
554	558		Maintenant, amusons nous avec les lumières.
555	559
556	560		OpenGL a plusieurs types de lumières ... ambiante, diffuse, ponctuelle, spot, lumière spéculaire et émissive.
557	561
558	562		La lumière ambiante est quelque chose comme le Soleil. Quand les rayons du soleil traversent la fenêtre d'une salle, ils frappent les murs et sont réfléchis et dispersés dans toutes les différentes directions ce qui illumine en moyenne toute la salle. Tous les sommets sont éclairés avec la lumière ambiante .
559	563
560	564		La lumière diffuse peut être représentée par des rayons de lumière parallèles venant de loin. Ils vont seulement éclairer les sommets qui sont orientés vers la source lumineuse.
561	565
562	566		La lumière ponctuelle éclaire tout autour d'elle. C'est comme une boule de feu, elle envoie des rayons lumineux tout autour d'elle et éclaire les sommets qui sont orientés vers la source lumineuse et qui sont assez proche.
563	567
564	568		La lumière spot est comme la lumière d'une lampe-torche. C'est simplement une source ponctuelle lumineuse avec un petit faisceau de lumière en forme de cône. Tous les sommets qui tombent à l'intérieur du cône et sont assez proche sont éclairés.
565	569
566	570		Juste comme la lumière diffuse, la lumière spéculaire est un type directionnel de lumière. Elle vient d'une direction particulière. La différence entre les deux est que la lumière spéculaire se reflète sur la surface d'une manière directionnelle et uniforme. Le rendu de la lumière spéculaire repose sur l'observateur et la source lumineuse. Du point de vue de l'observateur, la lumière spéculaire crée un secteur accentué sur la surface de l'objet vu, connu en tant que "specular highlight" ou réflexion spéculaire.
567	571
568	572		La lumière émissive est peu une différente que tout autre composants lumineux précédemment expliqué. Cette lumière sort de l'objet que vous dessinez but pas n'éclaire pas d'autres objets dans son environnement .
569	573
570	574		Pour plus de simplicité, nous emploierons seulement la lumière diffuse dans ce tutoriel. Plus tard, d'autres lumières peuvent apparaître dans les tutoriels :)
571	575
572	576		Voyons comment autoriser la lumière dans la scène :
573	577
574	578		``` pascal
575	579		const
576	580		DiffuseLight: array[0..3] of GLfloat = (0.8, 0.8, 0.8, 1);
577	581
578	582		glEnable(GL_LIGHTING);
579	583		glLightfv(GL_LIGHT0, GL_DIFFUSE, DiffuseLight);
580	584		glEnable(GL_LIGHT0);
581	585		```
582	586
583	587		Comme vous le voyez, nous permettons l'éclairage dans OpenGL ainsi les lumières affectent la scène dont vous faites le rendu. Des paramètres lumineux sont fixés avec la fonction glLightfv. Elle prend 3 paramètres... un pour le numéro de la lumière que vous voulez changer (OpenGL supporte jusqu'à 8 lumières), ensuite dit à OpenGL quel paramètre lumineux changer, et le dernier est un nouveau paramètre pour la lumière . Vous fixerez juste la couleur diffuse pour la lumière dans ce tutoriel. Après cela, vous pouvez permettre la lumière et il y aura la lumière dans la scène ... mais ... ce n'est pas tout .
584	588
585	589		Plus à propos de [glLightfv](http://www.opengl.org//documentation/specs/man_pages/hardcopy/GL/html/gl/light.html)
586	590
587	591		Si vous voulez employer des lumières, vous ne pouvez pas simplement fixer la couleur des sommets ... vous devez choisir le matériau pour les sommets . Installons le matériau pour le dessin :
588	592
589		-	~~`glEnable(GL_COLOR_MATERIAL);`\~~
590		-	~~`glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);`~~
	593	+	```text
	594	+	glEnable(GL_COLOR_MATERIAL);
	595	+	glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
	596	+	```
591	597
592	598		![](/wiki-images/e/ed/LightPic1.jpg) Vous vous êtes attendus à quelque chose plus compliquée, n'est ce pas? :) Bien, ce code nous permet d'employer la fonction glColor pour fixer le matériau aux sommets. En employant la fonction glEnable et le drapeau GL_COLOR_MATERIAL, vous pouvez définir quelles propriétés matérielles vont changer glColor. glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE) dit à OpenGL que glColor change le matériau ambiant et diffus. Nous discuterons des matériaux davantage dans des tutoriels postérieurs .
593	599
594	600		Une chose de plus qui est importante en utilisant des lumières... chaque sommet doit avoir une normale qui lui est associée. La normale est employée pour trouver la direction du sommet ainsi la lumière peut être calculée correctement . Vous emploierez un fonction GLUT pour dessiner le cube et elle fournit les normales pour nous, ainsi cette fois nous marcherons juste par les normales (???).
595	601
596	602		Après tout ces réglages, la lumière fera briller votre cube :)
597	603
598	604		Une partie du texte est copiée depuis [La bible de la lumière avec OpenGL](http://www.falloutsoftware.com/tutorials/gl/gl8.htm)
599	605
600	606		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
601	607
602	608		# Polices de caractères d'image
603	609
604	610		Les jeux et les programmes doivent habituellement écrire un certain texte sur l'écran. GLUT fournit plusieurs fonctions pour dessiner des caractères qui sont indépendantes de la plate-forme .
605	611
606	612		D'abord, nous montrerons comment employer les polices de caractères d'image par défaut. Presque toutes les additions de code seront faites à l'unité utils.pas .
607	613
608	614		Puisque le texte sera dessiné en 2D, nous devrons savoir la largeur et la hauteur de la clôture(viewport) ... ainsi, nous écrirons deux fonctions pour cela :
609	615
610	616		``` pascal
611	617		function glGetViewportWidth: Integer;
612	618		var
613	619		Rect: array[0..3] of Integer;
614	620		begin
615	621		glGetIntegerv(GL_VIEWPORT, @Rect);
616	622		Result := Rect[2] - Rect[0];
617	623		end;
618	624
619	625		function glGetViewportHeight: Integer;
620	626		var
621	627		Rect: array[0..3] of Integer;
622	628		begin
623	629		glGetIntegerv(GL_VIEWPORT, @Rect);
624	630		Result := Rect[3] - Rect[1];
625	631		end;
626	632		```
627	633
628	634		Nous récupérons juste la gauche /la droite, le haut/le bas et nous calculons la largeur/la hauteur en les soustrayant.
629	635
630	636		Il doit y avoir des fonctions pour entrer et quitter le mode 2D :
631	637
632	638		``` pascal
633	639		procedure glEnter2D;
634	640		begin
635	641		glMatrixMode(GL_PROJECTION);
636	642		glPushMatrix;
637	643		glLoadIdentity;
638	644		gluOrtho2D(0, glGetViewportWidth, 0, glGetViewportHeight);
639	645
640	646		glMatrixMode(GL_MODELVIEW);
641	647		glPushMatrix;
642	648		glLoadIdentity;
643	649
644	650		glDisable(GL_DEPTH_TEST);
645	651		end;
646	652
647	653		procedure glLeave2D;
648	654		begin
649	655		glMatrixMode(GL_PROJECTION);
650	656		glPopMatrix;
651	657		glMatrixMode(GL_MODELVIEW);
652	658		glPopMatrix;
653	659
654	660		glEnable(GL_DEPTH_TEST);
655	661		end;
656	662		```
657	663
658	664		Quand on entre dans le mode 2D, nous enregistrons les matrices en cours et paramétrons les matrices 2D en utilisant la fonction gluOrtho2D. De cette façon si nous dessinons quelque chose sur (un viewport de) 100, 100 cette chose sera dessinée sur exactement 100 Pixels à partir du bord gauche de la fenêtre, et 100 Pixels depuis le bord inférieur (le y positif est vers le haut). En outre , nous interdisons ZBuffer. De cette façon, le texte n'altèrera pas ZBuffer.
659	665
660	666		Le fait de quitter le mode 2D renvoie juste les anciennes matrices et autorise ZBuffer.
661	667
662	668		Maintenant, nous pouvons créer la fonction pour dessiner du texte:
663	669
664	670		``` pascal
665	671		procedure glWrite(X, Y: GLfloat; Font: Pointer; Text: String);
666	672		var
667	673		I: Integer;
668	674		begin
669	675		glRasterPos2f(X, Y);
670	676		for I := 1 to Length(Text) do
671	677		glutBitmapCharacter(Font, Integer(Text[I]));
672	678		end;
673	679		```
674	680
675	681		glutBitmapCharacter peut dessiner seulement un caractère de la police de caractères choisie. Le premier paramètre est la police de caractères désirée (GLUT_BITMAP_9_BY_15, GLUT_BITMAP_8_BY_13, GLUT_BITMAP_TIMES_ROMAN_10, GLUT_BITMAP_TIMES_ROMAN_24, GLUT_BITMAP_HELVETICA_10, GLUT_BITMAP_HELVETICA_12 ou GLUT_BITMAP_HELVETICA_18) et l'autre paramètre est le caractère.
676	682
677	683		Le caractère sera dessiné à la position de trame en cours. Pour placer la position désirée de trame nous appelons la fonction glRasterPos. glRasterPos peut traiter des nombres et des types de paramètres différents juste comme la fonction glVertex. La coordonnée indiquée est transformée par les matrices modèle et de projection pour obtenir la coordonnée 2D là où sera la nouvelle position de trame. Depuis que nous sommes entrés dans le mode 2D , Les coordonnées X et Y sont les coordonnées 2D réelles où le dessin se produira .
678	684
679	685		Ces nouvelles fonctions vont rendre le dessin du texte très facile:
680	686
681	687		``` pascal
682	688		procedure DrawGLScene; cdecl;
683	689		begin
684	690		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
685	691
686	692		glLoadIdentity;
687	693		glTranslatef(0, 0, -5);
688	694		glRotatef(GetTotalTime * 10, 0, 0.5, 0.5);
689	695
690	696		glColor3f(1, 0, 0);
691	697		glutSolidCube(2);
692	698
693	699		glEnter2D;
694	700
695	701		glColor3f(0.2, 0.8 + 0.2 * Sin(GetTotalTime * 5), 0);
696	702		glWrite(20, glGetViewportHeight - 20, GLUT_BITMAP_8_BY_13,
697	703		Format('OpenGL Tutorial :: Bitmap Fonts :: FPS - %.2f FPS', [FPS]));
698	704
699	705		glColor3f(1, 1, 1);
700	706		glWrite(50, glGetViewportHeight - 60, GLUT_BITMAP_9_BY_15, 'GLUT_BITMAP_9_BY_15');
701	707		glWrite(50, glGetViewportHeight - 90, GLUT_BITMAP_8_BY_13, 'GLUT_BITMAP_8_BY_13');
702	708		glWrite(50, glGetViewportHeight - 120, GLUT_BITMAP_TIMES_ROMAN_10, 'GLUT_BITMAP_TIMES_ROMAN_10');
703	709		glWrite(50, glGetViewportHeight - 150, GLUT_BITMAP_TIMES_ROMAN_24, 'GLUT_BITMAP_TIMES_ROMAN_24');
704	710		glWrite(50, glGetViewportHeight - 180, GLUT_BITMAP_HELVETICA_10, 'GLUT_BITMAP_HELVETICA_10');
705	711		glWrite(50, glGetViewportHeight - 210, GLUT_BITMAP_HELVETICA_12, 'GLUT_BITMAP_HELVETICA_12');
706	712		glWrite(50, glGetViewportHeight - 240, GLUT_BITMAP_HELVETICA_18, 'GLUT_BITMAP_HELVETICA_18');
707	713
708	714		glColor3f(0.5, 0.5, 1);
709	715		glWrite(
710	716		glGetViewportWidth - glutBitmapLength(GLUT_BITMAP_9_BY_15, LazText) - 5,
711	717		10, GLUT_BITMAP_9_BY_15, LazText);
712	718
713	719		glLeave2D;
714	720
715	721		glutSwapBuffers;
716	722
717	723		FrameRendered;
718	724		end;
719	725		```
720	726
721	727		![](/wiki-images/b/ba/BitmapFontsPic1.jpg) Nous dessinons un cube rouge et le faisons tourner, et un peu de texte pour montrer à quel point les diverses polices de caractères d'image ressemblent. La fonction glutBitmapLength est employée pour trouver la largeur des chaînes de caractères ainsi elles pourraient être alignées vers la droite. Le code peut facilement être changé pour centrer le texte .
722	728
723	729		Note: Voir comment les cubes apparaissent sans lumière.
724	730
725	731		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
726	732
727	733		# Textures
728	734
729	735		Il est temps d'employer des textures :)
730	736
731	737		Ce tutoriel montrera comment dessiner les polygones texturisés et comment mélanger des textures en utilisant une technique à plusieurs passages. Puisque OpenGL n'a aucun mécanisme interne pour télécharger des textures, nous emploierons une bibliothèque externe : [la bibliothèque Imaging de Vampyre](http://imaginglib.sourceforge.net/). Nous emploierons juste des fonctions d'aide d'OpenGL, mais vous pouvez trouver cette bibliothèque maniable pour aussi d'autres choses.
732	738
733	739		Soyons prêt à démarrer... nous créerons une liste d'affichage pour dessiner un rectangle texturisé :
734	740
735	741		``` pascal
736	742		procedure CreateList;
737	743		begin
738	744		glNewList(LIST_OBJECT, GL_COMPILE);
739	745		glBegin(GL_QUADS);
740	746		glTexCoord2f(1, 0);
741	747		glVertex3f( 2, 2, 0);
742	748		glTexCoord2f(0, 0);
743	749		glVertex3f(-2, 2, 0);
744	750		glTexCoord2f(0, 1);
745	751		glVertex3f(-2,-2, 0);
746	752		glTexCoord2f(1, 1);
747	753		glVertex3f( 2,-2, 0);
748	754		glEnd;
749	755		glEndList;
750	756		end;
751	757		```
752	758
753	759		Notez les fonctions glTexCoord. Elles sont utilisées pour indiquer quelle partie de la texture est assignée au sommet. Les coordonnées définies dans ces fonctions vont de 0 à 1 (Les valeurs supérieures à 1 sont permises mais peuvent produire des résultats différents). 0 est le premier Pixel et 1 est le dernier Pixel . Ainsi, 0.5 sera exactement au milieu de la texture.
754	760
755	761		Le téléchargement de texture est extrêmement aisé avec la bibliothèque Imaging de Vampyre:
756	762
757	763		``` pascal
758	764		var
759	765		Tex1, Tex2: GLuint;
760	766
761	767		procedure InitializeGL;
762	768		begin
763	769		glClearColor(0, 0, 0, 0);
764	770		Tex1 := LoadGLTextureFromFile('ashwood.bmp');
765	771		Tex2 := LoadGLTextureFromFile('Flare.bmp');
766	772		glEnable(GL_TEXTURE_2D);
767	773		end;
768	774		```
769	775
770	776		LoadGLTextureFromFile charge une texture depuis un fichier et renvoie son ID. Quand la texture est chargée elle est déjà paramétrée pour le rendu. La dernière ligne autorise juste les textures 2D.
771	777
772	778		Pour dessiner un polygone texturisé vous devez lier la texture et paramétrer les coordonnées de texture(les coordonnées de texture sont fixées dans la liste d'affichage dans ce tutoriel):
773	779
774	780		``` pascal
775	781		...
776	782		glLoadIdentity;
777	783		glTranslatef(-5, 0, -15);
778	784		glBindTexture(GL_TEXTURE_2D, Tex1);
779	785		glCallList(LIST_OBJECT);
780	786		...
781	787		```
782	788
783	789		La fonction glBindTexture est employée pour choisir la texture. Quand vous dessinez des polygones ils auront la texture sélectionnée sur eux. C'est aussi simple :)
784	790
785	791		Ainsi , employer une texture est facile ... mais comment mélanger deux textures . Fondamentalement vous dessinez le polygone une fois avec une texture, paramétrez les paramètres du mélange, et dessinez le polygone une fois de plus avec une autre texture. Vous pouvez mélanger des centaines de texture de cette façon. Voyons à quoi le code pour faire ceci ressemble :
786	792
787	793		``` pascal
788	794		...
789	795		glLoadIdentity;
790	796		glTranslatef(5, 0, -15);
791	797		glBindTexture(GL_TEXTURE_2D, Tex1);
792	798		glCallList(LIST_OBJECT);
793	799
794	800		glEnable(GL_BLEND);
795	801		glBlendFunc(GL_ZERO, GL_SRC_COLOR);
796	802		glLoadIdentity;
797	803		glTranslatef(5, 0, -15);
798	804		glBindTexture(GL_TEXTURE_2D, Tex2);
799	805		glCallList(LIST_OBJECT);
800	806		glDisable(GL_BLEND);
801	807		...
802	808		```
803	809
804	810		Comme vous pouvez le voir , le polygone est dessiné la première fois comme nous le savons déjà. Avant le deuxième dessin nous permettons le mélange de textures en appelant la procédure glEnable(GL_BLEND). Mélanger signifie que la couleur finale du Pixel est calculée comme ceci :
805	811
806		-	~~`DrawingColor * SRCBLEND + BackgroundColor * DESTBLEND`~~
	812	+	```text
	813	+	DrawingColor * SRCBLEND + BackgroundColor * DESTBLEND
	814	+	```
807	815
808	816		SRCBLEND et DESTBLEND sont définis en utilisant la fonction glBlendFunc. Dans ce tutoriel nous paramétrons SRCBLEND à GL_ZERO (zero) et DESTBLENT à GL_SRC_COLOR (DrawingColor) et la couleur finale est alors:
809	817
810		-	~~`DrawingColor * 0 + BackgroundColor * DrawingColor`~~
	818	+	```text
	819	+	DrawingColor * 0 + BackgroundColor * DrawingColor
	820	+	```
811	821
812	822		![](/wiki-images/d/d4/TexturesPic1.jpg)
813	823
814	824		Ceci signifie que l'arrière plan deviendra plus foncé quand vous dessinez avec des couleurs foncées ... quand vous dessinez avec de la couleur blanche , la couleur de l'arrière plan ne sera pas changée. Le résultat ressemblera à ceci
815	825
816	826		La fois prochaine , nous utiliserons des extensions pour montrer comment utiliser le multitexturing en une passe.
817	827
818	828		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
819	829
820	830		# Multitexturing (extensions)
821	831
822	832		Quand vous connaissez le multitexturing en plusieurs passes, celui en une passe est très simple. Appliquer une texture est séparé en étapes. La première étape permet de paramétrer et de dessiner la première texture, la seconde étape en dessine une autre et ainsi de suite. Tous que vous devez faire est de paramétrer les étapes avec les textures et de faire le rendu de l'objet.
823	833
824	834		Voyons à quoi le code ressemble :
825	835
826	836		``` pascal
827	837		procedure InitializeGL;
828	838		begin
829	839		Load_GL_ARB_multitexture;
830	840		glClearColor(0, 0, 0, 0);
831	841		Tex1 := LoadGLTextureFromFile('Lazarus.bmp');
832	842		Tex2 := LoadGLTextureFromFile('Mask.bmp');
833	843		glActiveTextureARB(GL_TEXTURE0_ARB);
834	844		glEnable(GL_TEXTURE_2D);
835	845		glBindTexture(GL_TEXTURE_2D, Tex1);
836	846		glActiveTextureARB(GL_TEXTURE1_ARB);
837	847		glEnable(GL_TEXTURE_2D);
838	848		glBindTexture(GL_TEXTURE_2D, Tex2);
839	849		end;
840	850		```
841	851
842	852		D'abord nous avons besoin de l'extension OpenGL qui nous permettrons d'utiliser les fonctions de multitexture. Load_GL_ARB_multitexture essayera de charger ces extensions et renverra TRUE si l'opération est réussie.
843	853
844	854		Pour choisir l'étape de texture sur laquelle vous voulez travailler, utilisez la fonction glActiveTextureARB. Elle demande seulement un paramètre qui défini l'étape que vous voulez. Après ça toutes les fonctions de texture (enabling, disabling, binding, creating...) affecteront cette étape .
845	855
846	856		Puisque nous avons paramétrés tout dans la fonction d'initialisation, tout que nous avons à faire est de dessiner l'objet :
847	857
848	858		``` pascal
849	859		procedure DrawGLScene; cdecl;
850	860		begin
851	861		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
852	862
853	863		glLoadIdentity;
854	864		glTranslatef(0, 0, -5);
855	865
856	866		glBegin(GL_QUADS);
857	867		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
858	868		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1, 0);
859	869		glVertex3f(2.516, 2, 0);
860	870		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
861	871		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, 0);
862	872		glVertex3f(-2.516, 2, 0);
863	873		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
864	874		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, 1);
865	875		glVertex3f(-2.516,-2, 0);
866	876		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
867	877		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1, 1);
868	878		glVertex3f(2.516,-2, 0);
869	879		glEnd;
870	880
871	881		glutSwapBuffers;
872	882		end;
873	883		```
874	884
875	885		![](/wiki-images/5/52/MultitexturePic1.jpg) Comme vous pouvez le voir, la différence est seulement dans la définitions des coordonnées de texture. Nous utilisons maintenant la fonction glMultiTexCoord2fARB qui prend l'étape de texture et les coordonnées de texture en paramètre. Tout le reste est inchangé.
876	886
877	887		Aujourd'hui presque toutes les cartes graphiques supportent au moins 2 étapes de texture . L'utilisation du multitexturing en une passe est plus rapide que la version multipasse puisque vous dessinez les objets une seule fois. Si le matériel supporte le multitexturing en une passe (Load_GL_ARB_multitexture renvoie TRUE) utilisez le.
878	888
879	889		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
880	890
881	891		# Faire du rendu pour obtenir une texture
882	892
883	893		Ce paragraphe sera court. OpenGL peut capturer la scène courante pour en faire une texture ainsi vous pouvez l'employer pour appliquer une texture sur d'autres objets (écran TV , miroir ou quelque chose d'autre). Bien faisons immédiatement un rendu de scène vers une texture et appliquons la à un plan rotatif.
884	894
885	895		D'abord, nous devons créer une texture vide qui est bien utilisée pour capturer la scène:
886	896
887	897		``` pascal
888	898		procedure SetupRenderTexture;
889	899		var
890	900		Data: Pointer;
891	901		begin
892	902		GetMem(Data, 2562563);
893	903		glGenTextures(1, @RenderTexture);
894	904		glBindTexture(GL_TEXTURE_2D, RenderTexture);
895	905		glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, Data);
896	906		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
897	907		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
898	908		FreeMem(Data);
899	909		end;
900	910		```
901	911
902	912		La mémoire tampon de l'image RGB 256*256 pixels est crée et elle est utilisée pour paramétrer la texture 2D.
903	913
904	914		La partie principale est dans la fonction de dessin:
905	915
906	916		``` pascal
907	917		procedure DrawGLScene; cdecl;
908	918		var
909	919		TotalTime: Single;
910	920		begin
911	921		glClearColor(0, 0, 0, 0);
912	922		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
913	923		glEnable(GL_LIGHTING);
914	924		glDisable(GL_TEXTURE_2D);
915	925		glViewport(0, 0, 256, 256);
916	926
917	927		TotalTime := GetTotalTime;
918	928
919	929		glLoadIdentity;
920	930		glTranslatef(0, 0, -5);
921	931		glRotatef(50 * TotalTime, 1, 0, 0);
922	932		glRotatef(100 * TotalTime, 0, 1, 0);
923	933		glRotatef(50 * TotalTime, 0, 0, 1);
924	934
925	935		glColor3f(1, 1, 1);
926	936		glutSolidCube(2);
927	937
928	938		glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 256, 256, 0);
929	939
930	940		glClearColor(0.18, 0.20, 0.66, 0);
931	941		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
932	942		glDisable(GL_LIGHTING);
933	943		glEnable(GL_TEXTURE_2D);
934	944		glViewport(0, 0, AppWidth, AppHeight);
935	945
936	946		glLoadIdentity;
937	947		glTranslatef(0, 0, -7);
938	948		glRotatef(20 * TotalTime, 1, 0, 0);
939	949		glRotatef(50 * TotalTime, 0, 1, 0);
940	950
941	951		glBegin(GL_QUADS);
942	952		glTexCoord2f(1, 0);
943	953		glVertex3f(2, 2, 0);
944	954		glTexCoord2f(0, 0);
945	955		glVertex3f(-2, 2, 0);
946	956		glTexCoord2f(0, 1);
947	957		glVertex3f(-2,-2, 0);
948	958		glTexCoord2f(1, 1);
949	959		glVertex3f(2,-2, 0);
950	960		glEnd;
951	961
952	962		glutSwapBuffers;
953	963		end;
954	964		```
955	965
956	966		![](/wiki-images/6/6e/RenderToTexturePic1.jpg) D'abord, tout est paramétré pour la scène qui sera capturée. La fenêtre de clôture(Viewport)est réduite à 256*256 de telle façon qu'elle s'adapte à la texture et la scène est dessinée . glCopyTexImage2D est employé pour capturer la scène à la texture actuellement choisie .
957	967
958	968		Quand nous avons capturé la scène vers la texture, tout peut être effacé à nouveau, La fenêtre de clôture(viewport) peut se remettre à sa taille d'origine et la scène finale est dessinée en utilisant la scène précédente comme texture.
959	969
960	970		P.S. une texture capturée peut être enregistrée en utilisant la fonction SaveGLTextureToFile de la bibliothèque [Imaging de Vampyre](http://imaginglib.sourceforge.net/).
961	971
962	972		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
963	973
964	974		# Tableau de Sommets
965	975
966	976		OpenGL est capable de faire le rendu de primitives en utilisant les données qui sont stockées dans les mémoires tampons au lieu d'appeler glVertex. Les mémoires tampons peuvent être appelées pour définir les coordonnées des sommets et celles des textures, et les couleurs (index et RGBA), les drapeaux normaux et de bord.
967	977
968	978		Dans ce tutoriel nous utiliserons seulement les mémoires tampon de sommet et de couleur, et nous montrerons du dessin non-indexé et indexé. le mode non-indexé dessine des mémoires tampon en tant que flux. Le mode indexé dessinera des éléments de la mémoire tampon dans l'ordre dans lequel cela a été défini dans l'index de la mémoire tampon. Mais assez parlé... Commençons à coder.
969	979
970	980		D'abord, définissons quelques types et constantes :
971	981
972	982		``` pascal
973	983		type
974	984		TVertex3f = record
975	985		X, Y, Z: Single;
976	986		end;
977	987
978	988		TColor3f = record
979	989		R, G, B: Single;
980	990		end;
981	991
982	992		VertexBuffer: array [0..5] of TVertex3f = (
983	993		(X : 1; Y : 1; Z : 0),
984	994		(X : -1; Y : 1; Z : 0),
985	995		(X : -1; Y : -1; Z : 0),
986	996		(X : 1; Y : 1; Z : 0),
987	997		(X : -1; Y : -1; Z : 0),
988	998		(X : 1; Y : -1; Z : 0)
989	999		);
990	1000		ColorBuffer: array [0..5] of TColor3f = (
991	1001		(R : 1; G : 0; B : 1),
992	1002		(R : 0; G : 0; B : 1),
993	1003		(R : 0; G : 1; B : 0),
994	1004		(R : 1; G : 0; B : 1),
995	1005		(R : 0; G : 1; B : 0),
996	1006		(R : 1; G : 1; B : 0)
997	1007		);
998	1008		```
999	1009
1000	1010		Nous avons deux mémoires tampon. Une pour les coordonnées des sommets et une pour les couleurs des sommets. Ces 6 sommets définissent 2 triangles qui forment un rectangle.
1001	1011
1002	1012		Dessiner des primitives en utilisant les mémoires tampons est facile:
1003	1013
1004	1014		``` pascal
1005	1015		glEnableClientState(GL_VERTEX_ARRAY);
1006	1016		glEnableClientState(GL_COLOR_ARRAY);
1007	1017		glVertexPointer(3, GL_FLOAT, 0, @VertexBuffer[0]);
1008	1018		glColorPointer(3, GL_FLOAT, 0, @ColorBuffer[0]);
1009	1019
1010	1020		glDrawArrays(GL_TRIANGLES, 0, Length(VertexBuffer));
1011	1021
1012	1022		glDisableClientState(GL_VERTEX_ARRAY);
1013	1023		glDisableClientState(GL_COLOR_ARRAY);
1014	1024		```
1015	1025
1016	1026		D'abord nous autorisons les mémoires tampon que nous voulons employer en utilisant la fonction glEnableClientState. Ensuite nous pouvons sélectionner les mémoires tampons que nous voulons utiliser. Chaque type de mémoire tampon a une fonction propre pour cette sélection (glColorPointer, glEdgeFlagPointer, glIndexPointer, glNormalPointer, glTexCoordPointer, glVertexPointer). Le premier paramètre de ces fonctions défini combien de nombres chaque élément contient. Par exemple , prenons la mémoire tampon des sommets. Si ce paramètre est 2 alors OpenGL compte que chaque élément de la mémoire tampon contienne les coordonnées x et y. Si ce paramètre est , par exemple , 4, alors chaque élément devrait contenir les coordonnées x, y, z et w. Le paramètre suivant défini quel type d'élément de donnée la mémoire tampon contient (GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT ou GL_DOUBLE). Le suivant défini combien il y a d'octets entre chaque élément. De cette façon, vous pouvez avoir une mémoire tampon qui contient des coordonnées de sommets et quelques données faites sur commande. Pour des types de données arbitraire, ce paramètre peut être calculé ainsi:
1017	1027
1018	1028		``` pascal
1019	1029		type
1020	1030		TBufferData = record
1021	1031		DataBefore: TDataBefore;
1022	1032		Vertex: TVertex;
1023	1033		DataAfter: TDataAfter;
1024	1034		end;
1025	1035
1026	1036		Bytes between elements = SizeOf(TDataBefore) + SizeOf(TDataAfter)
1027	1037		```
1028	1038
1029	1039		Le dernier paramètre est un pointeur vers le début de la mémoire tampon.
1030	1040
1031	1041		Quand les mémoires tampons sont sélectionnées, nous pouvons les dessiner employant les fonctions glDrawArrays. Toutes les mémoires tampons autorisées sont utilisées pour dessiner les primitives. Le genre de polygones qui sont générés est défini dans le premier paramètre (pareil que avec la fonction glBegin). Les deux paramètres suivant définissent le sous-ensemble de mémoire tampon qui est utilisé pour dessiner (début et compte).
1032	1042
1033	1043		Quand les mémoires tampons ne sont pas nécessaires vous pouvez les neutraliser .
1034	1044
1035	1045		Pour démontrer le mode indexé, j'ai réalisé un classe de maillage simple qui peut charger des sommet, des couleurs et indexer les données depuis des fichiers externes:
1036	1046
1037	1047		``` pascal
1038	1048		type
1039	1049		TMesh = class
1040	1050		private
1041	1051		FVertices: array of TVertex3f;
1042	1052		FColors: array of TColor3f;
1043	1053		FIndices: array of Integer;
1044	1054		procedure FreeBuffers;
1045	1055		public
1046	1056		constructor Create;
1047	1057		destructor Destroy; override;
1048	1058		procedure LoadMesh(FileName: String);
1049	1059		procedure DrawMesh;
1050	1060		end;
1051	1061		```
1052	1062
1053	1063		FVertices contiendra les données sur les sommets , FColors les données sur les couleurs et FIndices les données sur les index quand le fichier externe est chargé.
1054	1064
1055	1065		D'abord, nous écrirons du code qui traite la création et la destruction de classe:
1056	1066
1057	1067		``` pascal
1058	1068		procedure TMesh.FreeBuffers;
1059	1069		begin
1060	1070		FVertices := nil;
1061	1071		FColors := nil;
1062	1072		FIndices := nil;
1063	1073		end;
1064	1074
1065	1075		constructor TMesh.Create;
1066	1076		begin
1067	1077		FreeBuffers;
1068	1078		end;
1069	1079
1070	1080		destructor TMesh.Destroy;
1071	1081		begin
1072	1082		FreeBuffers;
1073	1083		inherited Destroy;
1074	1084		end;
1075	1085		```
1076	1086
1077	1087		Le fichier qui contiendra les données de maillage est un simple fichier texte. La première ligne contiendra le nombre de sommets et les index séparés par un espace. Après cette ligne viendra les lignes pour chaque sommet et couleur. X, Y, Z, R, G et B toutes séparées par un espace. A la fin, il y aura les lignes des index... chaque nombre représentant un index est écrit dans sa propre ligne... ainsi , pour un triangle, le fichier de données ressemblera à ceci:
1078	1088
1079		-	~~`3 3`\~~
1080		-	~~`-1 -1 0 1 1 1`\~~
1081		-	~~`1 -1 0 1 1 1`\~~
1082		-	~~`0 1 0 1 1 1`\~~
1083		-	~~`0`\~~
1084		-	~~`1`\~~
1085		-	~~`2`~~
	1089	+	```text
	1090	+	3 3
	1091	+	-1 -1 0 1 1 1
	1092	+	1 -1 0 1 1 1
	1093	+	0 1 0 1 1 1
	1094	+	0
	1095	+	1
	1096	+	2
	1097	+	```
1086	1098
1087	1099		Cela signifie qu'il y a 3 sommets et 3 index défini dans le fichier. Le premier sommer est à la position -1, -1, 0 et a comme couleur RGB 1, 1, 1 et ainsi de suite . Les index définissent cet ordre dans lequel les sommets sont dessinés (dans ce cas-ci les sommets sont dessinés dans le même ordre qu'ils sont défini ).
1088	1100
1089	1101		Le code pour charger ces données ressemblera à celui-ci:
1090	1102
1091	1103		``` pascal
1092	1104		procedure TMesh.LoadMesh(FileName: String);
1093	1105		var
1094	1106		MeshFile: TextFile;
1095	1107		VertexCount, IndexCount: Integer;
1096	1108		iV, iI: Integer;
1097	1109		begin
1098	1110		FreeBuffers;
1099	1111
1100	1112		AssignFile(MeshFile, FileName);
1101	1113		Reset(MeshFile);
1102	1114
1103	1115		ReadLn(MeshFile, VertexCount, IndexCount);
1104	1116
1105	1117		SetLength(FVertices, VertexCount);
1106	1118		SetLength(FColors, VertexCount);
1107	1119		SetLength(FIndices, IndexCount);
1108	1120
1109	1121		for iV := 0 to VertexCount - 1 do
1110	1122		ReadLn(MeshFile,
1111	1123		FVertices[iV].X, FVertices[iV].Y, FVertices[iV].Z,
1112	1124		FColors[iV].R, FColors[iV].G, FColors[iV].B);
1113	1125
1114	1126		for iI := 0 to IndexCount - 1 do
1115	1127		ReadLn(MeshFile, FIndices[iI]);
1116	1128
1117	1129		CloseFile(MeshFile);
1118	1130		end;
1119	1131		```
1120	1132
1121	1133		Après le chargement des données, nous avons tout pour faire le dessin :
1122	1134
1123	1135		``` pascal
1124	1136		procedure TMesh.DrawMesh;
1125	1137		begin
1126	1138		glEnableClientState(GL_VERTEX_ARRAY);
1127	1139		glEnableClientState(GL_COLOR_ARRAY);
1128	1140		glVertexPointer(3, GL_FLOAT, 0, @FVertices[0]);
1129	1141		glColorPointer(3, GL_FLOAT, 0, @FColors[0]);
1130	1142
1131	1143		glDrawElements(GL_TRIANGLES, Length(FIndices), GL_UNSIGNED_INT, @FIndices[0]);
1132	1144
1133	1145		glDisableClientState(GL_VERTEX_ARRAY);
1134	1146		glDisableClientState(GL_COLOR_ARRAY);
1135	1147		end;
1136	1148		```
1137	1149
1138	1150		![](/wiki-images/7/77/VertexArrayPic1.jpg)Comme vous pouvez le voir, presque tout est identique que faire un dessin non indexé, excepté la fonction qui dessine actuellement les polygones. Dans ce cas nous employons la fonction glDrawElements. Pour celle-ci, nous indiquons quel genre de polygones nous voulons, combien d'index sont dans la mémoire tampon, le type de données dans l'index de la mémoire tampon et un pointeur vers le début de l'index de la mémoire tampon.
1139	1151
1140	1152		Le code source complet vient avec le fichier de données de maillage que cette classe peut employer pour générer un rectangle qui est identique à celui qui est dessiné en utilisant le mode non-indexé. Le fichier de données de maillage ressemble à ceci:
1141	1153
1142		-	~~`4 6`\~~
1143		-	~~`1 1 0 1 0 1`\~~
1144		-	~~`-1 1 0 0 0 1`\~~
1145		-	~~`-1 -1 0 0 1 0`\~~
1146		-	~~`1 -1 0 1 1 0`\~~
1147		-	~~`0`\~~
1148		-	~~`1`\~~
1149		-	~~`2`\~~
1150		-	~~`0`\~~
1151		-	~~`2`\~~
1152		-	~~`3`~~
	1154	+	```text
	1155	+	4 6
	1156	+	1 1 0 1 0 1
	1157	+	-1 1 0 0 0 1
	1158	+	-1 -1 0 0 1 0
	1159	+	1 -1 0 1 1 0
	1160	+	0
	1161	+	1
	1162	+	2
	1163	+	0
	1164	+	2
	1165	+	3
	1166	+	```
1153	1167
1154	1168		Comme vous pouvez le voir, il y a des données pour seulement 4 sommets et 6 index. Ainsi, le premier triangle est défini par les sommets 0, 1 et 2, et le second par les sommets 0, 2 et 3. En utilisant le mode indexé, nous n'avons pas à dupliquer les sommets.
1155	1169
1156	1170		Téléchargez le code source, l'exécutable linux ou l'exécutable windows depuis [le dépôt Lazarus CCR de SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
1157	1171
1158	1172		---
1159	1173		From the Free Pascal wiki, page "OpenGL Tutorial/fr", as it stood on 2020-02-23 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history