OpenGL Tutorial/fr: what changed

Revision 1 to 2. 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		-	Afin d'utiliser GLUT, vous devez d'abord l'initialiser. C'est fait en utilisant la fonction <b>glutInit</b>. 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++.
	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		-	Après , vous devez créer une fenêtre principale . Fixer le mode d'affichage de la fenêtre principale en utilisant <b>glutInitDisplayMode</b>. Cela nécessite seulement un paramètre qui est une combinaison des drapeaux. Habituellement <b>GLUT_DOUBLE ou GLUT_RGB ou GLUT_DEPTH</b> est tout ce dont vous aurez besoin.
	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		-	La position et la taille de la fenêtre est contrôlée en utilisant <b>glutInitWindowPosition</b> et <b>glutInitWindowSize</b>. 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 <b>glutGet</b> pour trouver la taille de l'écran et centrer la fenêtre.
	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		-	Enfin, la fenêtre devrait être créée en utilisant la fonction <b>glutCreateWindow</b>. 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 .
	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		-	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 <b>glutDisplayFunc</b>, <b>glutReshapeFunc</b> et <b>glutKeyboardFunc</b>.
	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		-	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 <b>Halt</b> à 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 .
	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		-	~~Pour commencer la boucle principale , appellez <b>glutMainLoop</b>. Il écrira une boucle qui ne finit jamais , qui appelle toutes vos procedures de rappel.~~
	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		-	En employant la fonction <b>glMatrixMode</b> vous choisissez quelle matrice vous voulez changer . OpenGL travaille avec 3 matrices : <b>GL_MODELVIEW</b>: celle-ci est employée pour déplacer les sommets vers l'espace modèle . <b>GL_PROJECTION</b>: celle-ci est employée pour convertir les coordonnées 3d en coordonnées 2d pour la position finale des pixels. <b>GL_TEXTURE</b>: celle-ci est employée pour changer des coordonnées de texture .
	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		-	Une fois que vous avez choisi la matrice vous voulez changer , vous pouvez appeler les fonctions qui affectent les valeurs de la matrice. <b>glLoadIdentity</b> 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 .
	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		-	Afin de paramétrer la matrice de perspective, vous pouvez employer la fonction <b>gluPerspective</b>. Quatre paramètres montrent le champ visuel , l'allongement , la surface plane proche et lointaine. C'est aussi simple.
	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		-	<b>glBegin</b> 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.
	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		-	![](/wiki-images/f/f3/SimpleShapePic1.jpg) Vous tracerez un triangle simple et pour cela le drapeau GL_TRIANGLES accomplira cette astuce. La fonction <b>glVertex3f</b> 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.
	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		-	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 <b>glColor3f</b>. glColor peut aussi prendre différents ensemble de paramètres comme glVertex.
	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		-	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. <b>glTranslatef</b> 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.
	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		-	~~À la fin vous appelez les fonctions <b>glEnd</b> qui finissent le dessin. Vous pourriez maintenant commencer d'autres bloc de dessin avec une nouvelle fonction glBegin si vous le souhaitez .~~
	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		-	Parfois vous devrez dessiner quelques objets de multiples fois sur la scène. OpenGL a la capacité de construire <b>des listes d'affichage</b> 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 à <b>glNewList</b> et <b>glEndList</b>.
	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		-	<b>glNewList</b> crée une nouvelle liste d'affichage et toutes les fonctions de dessin seront enregistrées jusqu'à ce que <b>glEndList</b> 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.
	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		-	La fonction <b>glIsList</b> 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 <b>glGenLists</b>. 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
	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		-	<b>glDeleteLists</b> 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
	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		-	![](/wiki-images/a/a5/DisplayListsPic1.jpg) En utilisant <b>glCallList</b> 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 <b>glCallLists</b>. 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 :
	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		-	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 <b>glutEnterGameMode</b> qui crée une fenêtre en mode plein écran. Pour indiquer quel genre de mode plein écran vous voulez, vous appelez la fonction <b>glutGameModeString</b> qui prend un chaine de caractères qui définie le mode que vous aimez . Le format de cette chaine de caractères est :
	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	373		`[largeur "x" hauteur][":" bpp]["@" hertz]`
374	374
375	375		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	376
377		-	Habituellement dans le mode plein écran le curseur n'est pas visible. Pour cacher le curseur vous utilisez la fonction <b>glutSetCursor</b>. Elle utilise seulement un paramètre qui décrit le curseur que vous voudriez voir :
	377	+	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	378
379	379		`GLUT_CURSOR_RIGHT_ARROW`\
380	380		`GLUT_CURSOR_LEFT_ARROW`\
381	381		`GLUT_CURSOR_INFO`\
382	382		`GLUT_CURSOR_DESTROY`\
383	383		`GLUT_CURSOR_HELP`\
384	384		`GLUT_CURSOR_CYCLE`\
385	385		`GLUT_CURSOR_SPRAY`\
386	386		`GLUT_CURSOR_WAIT`\
387	387		`GLUT_CURSOR_TEXT`\
388	388		`GLUT_CURSOR_CROSSHAIR`\
389	389		`GLUT_CURSOR_UP_DOWN`\
390	390		`GLUT_CURSOR_LEFT_RIGHT`\
391	391		`GLUT_CURSOR_TOP_SIDE`\
392	392		`GLUT_CURSOR_BOTTOM_SIDE`\
393	393		`GLUT_CURSOR_LEFT_SIDE`\
394	394		`GLUT_CURSOR_RIGHT_SIDE`\
395	395		`GLUT_CURSOR_TOP_LEFT_CORNER`\
396	396		`GLUT_CURSOR_TOP_RIGHT_CORNER`\
397	397		`GLUT_CURSOR_BOTTOM_RIGHT_CORNER`\
398	398		`GLUT_CURSOR_BOTTOM_LEFT_CORNER`\
399	399		`GLUT_CURSOR_FULL_CROSSHAIR`\
400	400		`GLUT_CURSOR_NONE`\
401	401		`GLUT_CURSOR_INHERIT`
402	402
403		-	<b>glutIdleFunc</b> 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 .
	403	+	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	404
405	405		Maintenant , regardons l'arrêt de programme là où vous devez quitter le mode plein écran :
406	406
407	407		``` pascal
408	408		procedure GLKeyboard(Key: Byte; X, Y: Longint); cdecl;
409	409		begin
410	410		if Key = 27 then
411	411		begin
412	412		glutLeaveGameMode;
413	413		Halt(0);
414	414		end;
415	415		end;
416	416		```
417	417
418		-	~~Comme vous pouvez le voir , tout que vous devez faire est d'appeler <b>glutLeaveGameMode</b>.~~
	418	+	Comme vous pouvez le voir , tout que vous devez faire est d'appeler glutLeaveGameMode.
419	419
420	420		Maintenant , nous allons présenter quelques nouvelles fonctions de matrice. D'abord, changeons la fonction ReSizeGLScene :
421	421
422	422		``` pascal
423	423		procedure ReSizeGLScene(Width, Height: Integer); cdecl;
424	424		begin
425	425		.
426	426		.
427	427		.
428	428
429	429		glMatrixMode(GL_MODELVIEW);
430	430		glLoadIdentity;
431	431		gluLookAt(0, 20, 25, 0, 0, 0, 0, 1, 0);
432	432		end;
433	433		```
434	434
435		-	<b>gluLookAt</b> 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.
	435	+	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	436
437	437		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	438
439	439		``` pascal
440	440		procedure DrawGLScene; cdecl;
441	441		var
442	442		T: Single;
443	443		begin
444	444		T := glutGet(GLUT_ELAPSED_TIME) / 1000;
445	445		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
446	446
447	447		glPushMatrix;
448	448		glRotatef(5 * T, 0, 1, 0);
449	449		glColor3f(1, 1, 0);
450	450		glutWireSphere(2, 20, 20);
451	451		glPopMatrix;
452	452
453	453		glPushMatrix;
454	454		glRotatef(90 * T, 0, 1, 0);
455	455		glTranslatef(5, 0, 0);
456	456		glRotatef(40 * T, 0, 1, 0);
457	457		glColor3f(1, 0, 0);
458	458		glutWireSphere(0.6, 10, 10);
459	459		glPopMatrix;
460	460
461	461		glPushMatrix;
462	462		glRotatef(60 * T, 0, 1, 0);
463	463		glTranslatef(-3, 0, 9);
464	464		glRotatef(50 * T, 0, 1, 0);
465	465		glColor3f(0, 1, 0);
466	466		glutWireSphere(1, 16, 16);
467	467
468	468		glPushMatrix;
469	469		glRotatef(360 * T, 0, 1, 0);
470	470		glTranslatef(-1.7, 0, 0);
471	471		glRotatef(50 * T, 0, 1, 0);
472	472		glColor3f(0, 0, 1);
473	473		glutWireSphere(0.4, 10, 10);
474	474		glPopMatrix;
475	475
476	476		glPopMatrix;
477	477
478	478		glutSwapBuffers;
479	479		end;
480	480		```
481	481
482		-	![](/wiki-images/5/51/FullScreenAnimationPic1.jpg) <b>glPushMatrix</b> et <b>glPopMatrix</b> 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 .
	482	+	![](/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	483
484		-	Vous pouvez vous demander quel est le rôle de la variable <b>T</b> . 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 <b>glutGet</b> avec le paramètre <b>GLUT_ELAPSED_TIME</b> renvoie le temps en milliseconds depuis que glutInit a été appelé. En divisant cette valeur par 1000, nous avons le temps en secondes .
	484	+	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	485
486		-	La fonction <b>glRotatef</b> 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.
	486	+	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	487
488	488		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	489
490	490		# Lumière
491	491
492	492		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	493
494	494		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	495
496	496		``` pascal
497	497		unit utils;
498	498
499	499		{$mode objfpc}{$H+}
500	500
501	501		interface
502	502
503	503		uses
504	504		glut;
505	505
506	506		function GetTotalTime: Single;
507	507		function GetDeltaTime: Single;
508	508		procedure FrameRendered(Count: Integer = 1);
509	509		function GetFPS: Single;
510	510
511	511		implementation
512	512
513	513		var
514	514		OldTime: Integer = 0;
515	515		FPSTime: Integer = 0;
516	516		FPSCount: Integer = 0;
517	517
518	518		function GetTotalTime: Single;
519	519		begin
520	520		Result := glutGet(GLUT_ELAPSED_TIME) / 1000;
521	521		end;
522	522
523	523		function GetDeltaTime: Single;
524	524		var
525	525		NewTime: Integer;
526	526		begin
527	527		NewTime := glutGet(GLUT_ELAPSED_TIME);
528	528		Result := (NewTime - OldTime) / 1000;
529	529		OldTime := NewTime;
530	530		end;
531	531
532	532		procedure FrameRendered(Count: Integer);
533	533		begin
534	534		Inc(FPSCount, Count);
535	535		end;
536	536
537	537		function GetFPS: Single;
538	538		var
539	539		NewTime: Integer;
540	540		begin
541	541		NewTime := glutGet(GLUT_ELAPSED_TIME);
542	542
543	543		Result := FPSCount / ((NewTime - FPSTime) / 1000);
544	544
545	545		FPSTime := NewTime;
546	546		FPSCount := 0;
547	547		end;
548	548
549	549		end.
550	550		```
551	551
552	552		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	553
554	554		Maintenant, amusons nous avec les lumières.
555	555
556	556		OpenGL a plusieurs types de lumières ... ambiante, diffuse, ponctuelle, spot, lumière spéculaire et émissive.
557	557
558	558		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	559
560	560		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	561
562	562		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	563
564	564		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	565
566	566		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	567
568	568		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	569
570	570		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	571
572	572		Voyons comment autoriser la lumière dans la scène :
573	573
574	574		``` pascal
575	575		const
576	576		DiffuseLight: array[0..3] of GLfloat = (0.8, 0.8, 0.8, 1);
577	577
578	578		glEnable(GL_LIGHTING);
579	579		glLightfv(GL_LIGHT0, GL_DIFFUSE, DiffuseLight);
580	580		glEnable(GL_LIGHT0);
581	581		```
582	582
583		-	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 <b>glLightfv</b>. 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 .
	583	+	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	584
585	585		Plus à propos de [glLightfv](http://www.opengl.org//documentation/specs/man_pages/hardcopy/GL/html/gl/light.html)
586	586
587	587		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	588
589	589		`glEnable(GL_COLOR_MATERIAL);`\
590	590		`glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);`
591	591
592		-	![](/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. <b>glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE)</b> dit à OpenGL que glColor change le matériau ambiant et diffus. Nous discuterons des matériaux davantage dans des tutoriels postérieurs .
	592	+	![](/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	593
594	594		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	595
596	596		Après tout ces réglages, la lumière fera briller votre cube :)
597	597
598	598		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	599
600	600		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	601
602	602		# Polices de caractères d'image
603	603
604	604		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	605
606	606		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	607
608	608		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	609
610	610		``` pascal
611	611		function glGetViewportWidth: Integer;
612	612		var
613	613		Rect: array[0..3] of Integer;
614	614		begin
615	615		glGetIntegerv(GL_VIEWPORT, @Rect);
616	616		Result := Rect[2] - Rect[0];
617	617		end;
618	618
619	619		function glGetViewportHeight: Integer;
620	620		var
621	621		Rect: array[0..3] of Integer;
622	622		begin
623	623		glGetIntegerv(GL_VIEWPORT, @Rect);
624	624		Result := Rect[3] - Rect[1];
625	625		end;
626	626		```
627	627
628	628		Nous récupérons juste la gauche /la droite, le haut/le bas et nous calculons la largeur/la hauteur en les soustrayant.
629	629
630	630		Il doit y avoir des fonctions pour entrer et quitter le mode 2D :
631	631
632	632		``` pascal
633	633		procedure glEnter2D;
634	634		begin
635	635		glMatrixMode(GL_PROJECTION);
636	636		glPushMatrix;
637	637		glLoadIdentity;
638	638		gluOrtho2D(0, glGetViewportWidth, 0, glGetViewportHeight);
639	639
640	640		glMatrixMode(GL_MODELVIEW);
641	641		glPushMatrix;
642	642		glLoadIdentity;
643	643
644	644		glDisable(GL_DEPTH_TEST);
645	645		end;
646	646
647	647		procedure glLeave2D;
648	648		begin
649	649		glMatrixMode(GL_PROJECTION);
650	650		glPopMatrix;
651	651		glMatrixMode(GL_MODELVIEW);
652	652		glPopMatrix;
653	653
654	654		glEnable(GL_DEPTH_TEST);
655	655		end;
656	656		```
657	657
658		-	Quand on entre dans le mode 2D, nous enregistrons les matrices en cours et paramétrons les matrices 2D en utilisant la fonction <b>gluOrtho2D</b>. 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.
	658	+	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	659
660	660		Le fait de quitter le mode 2D renvoie juste les anciennes matrices et autorise ZBuffer.
661	661
662	662		Maintenant, nous pouvons créer la fonction pour dessiner du texte:
663	663
664	664		``` pascal
665	665		procedure glWrite(X, Y: GLfloat; Font: Pointer; Text: String);
666	666		var
667	667		I: Integer;
668	668		begin
669	669		glRasterPos2f(X, Y);
670	670		for I := 1 to Length(Text) do
671	671		glutBitmapCharacter(Font, Integer(Text[I]));
672	672		end;
673	673		```
674	674
675		-	<b>glutBitmapCharacter</b> 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.
	675	+	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	676
677		-	Le caractère sera dessiné à la position de trame en cours. Pour placer la position désirée de trame nous appelons la fonction <b>glRasterPos</b>. 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 .
	677	+	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	678
679	679		Ces nouvelles fonctions vont rendre le dessin du texte très facile:
680	680
681	681		``` pascal
682	682		procedure DrawGLScene; cdecl;
683	683		begin
684	684		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
685	685
686	686		glLoadIdentity;
687	687		glTranslatef(0, 0, -5);
688	688		glRotatef(GetTotalTime * 10, 0, 0.5, 0.5);
689	689
690	690		glColor3f(1, 0, 0);
691	691		glutSolidCube(2);
692	692
693	693		glEnter2D;
694	694
695	695		glColor3f(0.2, 0.8 + 0.2 * Sin(GetTotalTime * 5), 0);
696	696		glWrite(20, glGetViewportHeight - 20, GLUT_BITMAP_8_BY_13,
697	697		Format('OpenGL Tutorial :: Bitmap Fonts :: FPS - %.2f FPS', [FPS]));
698	698
699	699		glColor3f(1, 1, 1);
700	700		glWrite(50, glGetViewportHeight - 60, GLUT_BITMAP_9_BY_15, 'GLUT_BITMAP_9_BY_15');
701	701		glWrite(50, glGetViewportHeight - 90, GLUT_BITMAP_8_BY_13, 'GLUT_BITMAP_8_BY_13');
702	702		glWrite(50, glGetViewportHeight - 120, GLUT_BITMAP_TIMES_ROMAN_10, 'GLUT_BITMAP_TIMES_ROMAN_10');
703	703		glWrite(50, glGetViewportHeight - 150, GLUT_BITMAP_TIMES_ROMAN_24, 'GLUT_BITMAP_TIMES_ROMAN_24');
704	704		glWrite(50, glGetViewportHeight - 180, GLUT_BITMAP_HELVETICA_10, 'GLUT_BITMAP_HELVETICA_10');
705	705		glWrite(50, glGetViewportHeight - 210, GLUT_BITMAP_HELVETICA_12, 'GLUT_BITMAP_HELVETICA_12');
706	706		glWrite(50, glGetViewportHeight - 240, GLUT_BITMAP_HELVETICA_18, 'GLUT_BITMAP_HELVETICA_18');
707	707
708	708		glColor3f(0.5, 0.5, 1);
709	709		glWrite(
710	710		glGetViewportWidth - glutBitmapLength(GLUT_BITMAP_9_BY_15, LazText) - 5,
711	711		10, GLUT_BITMAP_9_BY_15, LazText);
712	712
713	713		glLeave2D;
714	714
715	715		glutSwapBuffers;
716	716
717	717		FrameRendered;
718	718		end;
719	719		```
720	720
721		-	![](/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 <b>glutBitmapLength</b> 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 .
	721	+	![](/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	722
723	723		Note: Voir comment les cubes apparaissent sans lumière.
724	724
725	725		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	726
727	727		# Textures
728	728
729	729		Il est temps d'employer des textures :)
730	730
731	731		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	732
733	733		Soyons prêt à démarrer... nous créerons une liste d'affichage pour dessiner un rectangle texturisé :
734	734
735	735		``` pascal
736	736		procedure CreateList;
737	737		begin
738	738		glNewList(LIST_OBJECT, GL_COMPILE);
739	739		glBegin(GL_QUADS);
740	740		glTexCoord2f(1, 0);
741	741		glVertex3f( 2, 2, 0);
742	742		glTexCoord2f(0, 0);
743	743		glVertex3f(-2, 2, 0);
744	744		glTexCoord2f(0, 1);
745	745		glVertex3f(-2,-2, 0);
746	746		glTexCoord2f(1, 1);
747	747		glVertex3f( 2,-2, 0);
748	748		glEnd;
749	749		glEndList;
750	750		end;
751	751		```
752	752
753		-	Notez les fonctions <b>glTexCoord</b>. 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.
	753	+	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	754
755	755		Le téléchargement de texture est extrêmement aisé avec la bibliothèque Imaging de Vampyre:
756	756
757	757		``` pascal
758	758		var
759	759		Tex1, Tex2: GLuint;
760	760
761	761		procedure InitializeGL;
762	762		begin
763	763		glClearColor(0, 0, 0, 0);
764	764		Tex1 := LoadGLTextureFromFile('ashwood.bmp');
765	765		Tex2 := LoadGLTextureFromFile('Flare.bmp');
766	766		glEnable(GL_TEXTURE_2D);
767	767		end;
768	768		```
769	769
770		-	<b>LoadGLTextureFromFile</b> 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.
	770	+	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	771
772	772		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	773
774	774		``` pascal
775	775		...
776	776		glLoadIdentity;
777	777		glTranslatef(-5, 0, -15);
778	778		glBindTexture(GL_TEXTURE_2D, Tex1);
779	779		glCallList(LIST_OBJECT);
780	780		...
781	781		```
782	782
783		-	~~La fonction <b>glBindTexture</b> 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 :)~~
	783	+	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	784
785	785		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	786
787	787		``` pascal
788	788		...
789	789		glLoadIdentity;
790	790		glTranslatef(5, 0, -15);
791	791		glBindTexture(GL_TEXTURE_2D, Tex1);
792	792		glCallList(LIST_OBJECT);
793	793
794	794		glEnable(GL_BLEND);
795	795		glBlendFunc(GL_ZERO, GL_SRC_COLOR);
796	796		glLoadIdentity;
797	797		glTranslatef(5, 0, -15);
798	798		glBindTexture(GL_TEXTURE_2D, Tex2);
799	799		glCallList(LIST_OBJECT);
800	800		glDisable(GL_BLEND);
801	801		...
802	802		```
803	803
804		-	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 <b>glEnable(GL_BLEND)</b>. Mélanger signifie que la couleur finale du Pixel est calculée comme ceci :
	804	+	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	805
806	806		`DrawingColor * SRCBLEND + BackgroundColor * DESTBLEND`
807	807
808		-	SRCBLEND et DESTBLEND sont définis en utilisant la fonction <b>glBlendFunc</b>. Dans ce tutoriel nous paramétrons SRCBLEND à GL_ZERO (zero) et DESTBLENT à GL_SRC_COLOR (DrawingColor) et la couleur finale est alors:
	808	+	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	809
810	810		`DrawingColor * 0 + BackgroundColor * DrawingColor`
811	811
812		-	~~<figure>~~
813		-	~~<img src="TexturesPic1.jpg" title="TexturesPic1.jpg" />~~
814		-	~~<figcaption>TexturesPic1.jpg</figcaption>~~
815		-	~~</figure>~~
	812	+	![](/wiki-images/d/d4/TexturesPic1.jpg)
816	813
817	814		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
818	815
819	816		La fois prochaine , nous utiliserons des extensions pour montrer comment utiliser le multitexturing en une passe.
820	817
821	818		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).
822	819
823	820		# Multitexturing (extensions)
824	821
825	822		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.
826	823
827	824		Voyons à quoi le code ressemble :
828	825
829	826		``` pascal
830	827		procedure InitializeGL;
831	828		begin
832	829		Load_GL_ARB_multitexture;
833	830		glClearColor(0, 0, 0, 0);
834	831		Tex1 := LoadGLTextureFromFile('Lazarus.bmp');
835	832		Tex2 := LoadGLTextureFromFile('Mask.bmp');
836	833		glActiveTextureARB(GL_TEXTURE0_ARB);
837	834		glEnable(GL_TEXTURE_2D);
838	835		glBindTexture(GL_TEXTURE_2D, Tex1);
839	836		glActiveTextureARB(GL_TEXTURE1_ARB);
840	837		glEnable(GL_TEXTURE_2D);
841	838		glBindTexture(GL_TEXTURE_2D, Tex2);
842	839		end;
843	840		```
844	841
845		-	D'abord nous avons besoin de l'extension OpenGL qui nous permettrons d'utiliser les fonctions de multitexture. <b>Load_GL_ARB_multitexture</b> essayera de charger ces extensions et renverra TRUE si l'opération est réussie.
	842	+	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.
846	843
847		-	Pour choisir l'étape de texture sur laquelle vous voulez travailler, utilisez la fonction <b>glActiveTextureARB</b>. 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 .
	844	+	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 .
848	845
849	846		Puisque nous avons paramétrés tout dans la fonction d'initialisation, tout que nous avons à faire est de dessiner l'objet :
850	847
851	848		``` pascal
852	849		procedure DrawGLScene; cdecl;
853	850		begin
854	851		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
855	852
856	853		glLoadIdentity;
857	854		glTranslatef(0, 0, -5);
858	855
859	856		glBegin(GL_QUADS);
860	857		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
861	858		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1, 0);
862	859		glVertex3f(2.516, 2, 0);
863	860		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
864	861		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, 0);
865	862		glVertex3f(-2.516, 2, 0);
866	863		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
867	864		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, 1);
868	865		glVertex3f(-2.516,-2, 0);
869	866		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
870	867		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1, 1);
871	868		glVertex3f(2.516,-2, 0);
872	869		glEnd;
873	870
874	871		glutSwapBuffers;
875	872		end;
876	873		```
877	874
878		-	![](/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 <b>glMultiTexCoord2fARB</b> qui prend l'étape de texture et les coordonnées de texture en paramètre. Tout le reste est inchangé.
	875	+	![](/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é.
879	876
880	877		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.
881	878
882	879		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).
883	880
884	881		# Faire du rendu pour obtenir une texture
885	882
886	883		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.
887	884
888	885		D'abord, nous devons créer une texture vide qui est bien utilisée pour capturer la scène:
889	886
890	887		``` pascal
891	888		procedure SetupRenderTexture;
892	889		var
893	890		Data: Pointer;
894	891		begin
895	892		GetMem(Data, 2562563);
896	893		glGenTextures(1, @RenderTexture);
897	894		glBindTexture(GL_TEXTURE_2D, RenderTexture);
898	895		glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, Data);
899	896		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
900	897		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
901	898		FreeMem(Data);
902	899		end;
903	900		```
904	901
905	902		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.
906	903
907	904		La partie principale est dans la fonction de dessin:
908	905
909	906		``` pascal
910	907		procedure DrawGLScene; cdecl;
911	908		var
912	909		TotalTime: Single;
913	910		begin
914	911		glClearColor(0, 0, 0, 0);
915	912		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
916	913		glEnable(GL_LIGHTING);
917	914		glDisable(GL_TEXTURE_2D);
918	915		glViewport(0, 0, 256, 256);
919	916
920	917		TotalTime := GetTotalTime;
921	918
922	919		glLoadIdentity;
923	920		glTranslatef(0, 0, -5);
924	921		glRotatef(50 * TotalTime, 1, 0, 0);
925	922		glRotatef(100 * TotalTime, 0, 1, 0);
926	923		glRotatef(50 * TotalTime, 0, 0, 1);
927	924
928	925		glColor3f(1, 1, 1);
929	926		glutSolidCube(2);
930	927
931	928		glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 256, 256, 0);
932	929
933	930		glClearColor(0.18, 0.20, 0.66, 0);
934	931		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
935	932		glDisable(GL_LIGHTING);
936	933		glEnable(GL_TEXTURE_2D);
937	934		glViewport(0, 0, AppWidth, AppHeight);
938	935
939	936		glLoadIdentity;
940	937		glTranslatef(0, 0, -7);
941	938		glRotatef(20 * TotalTime, 1, 0, 0);
942	939		glRotatef(50 * TotalTime, 0, 1, 0);
943	940
944	941		glBegin(GL_QUADS);
945	942		glTexCoord2f(1, 0);
946	943		glVertex3f(2, 2, 0);
947	944		glTexCoord2f(0, 0);
948	945		glVertex3f(-2, 2, 0);
949	946		glTexCoord2f(0, 1);
950	947		glVertex3f(-2,-2, 0);
951	948		glTexCoord2f(1, 1);
952	949		glVertex3f(2,-2, 0);
953	950		glEnd;
954	951
955	952		glutSwapBuffers;
956	953		end;
957	954		```
958	955
959		-	![](/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 . <b>glCopyTexImage2D</b> est employé pour capturer la scène à la texture actuellement choisie .
	956	+	![](/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 .
960	957
961	958		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.
962	959
963		-	~~P.S. une texture capturée peut être enregistrée en utilisant la fonction <b>SaveGLTextureToFile</b> de la bibliothèque [Imaging de Vampyre](http://imaginglib.sourceforge.net/).~~
	960	+	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/).
964	961
965	962		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).
966	963
967	964		# Tableau de Sommets
968	965
969	966		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.
970	967
971	968		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.
972	969
973	970		D'abord, définissons quelques types et constantes :
974	971
975	972		``` pascal
976	973		type
977	974		TVertex3f = record
978	975		X, Y, Z: Single;
979	976		end;
980	977
981	978		TColor3f = record
982	979		R, G, B: Single;
983	980		end;
984	981
985	982		VertexBuffer: array [0..5] of TVertex3f = (
986	983		(X : 1; Y : 1; Z : 0),
987	984		(X : -1; Y : 1; Z : 0),
988	985		(X : -1; Y : -1; Z : 0),
989	986		(X : 1; Y : 1; Z : 0),
990	987		(X : -1; Y : -1; Z : 0),
991	988		(X : 1; Y : -1; Z : 0)
992	989		);
993	990		ColorBuffer: array [0..5] of TColor3f = (
994	991		(R : 1; G : 0; B : 1),
995	992		(R : 0; G : 0; B : 1),
996	993		(R : 0; G : 1; B : 0),
997	994		(R : 1; G : 0; B : 1),
998	995		(R : 0; G : 1; B : 0),
999	996		(R : 1; G : 1; B : 0)
1000	997		);
1001	998		```
1002	999
1003	1000		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.
1004	1001
1005	1002		Dessiner des primitives en utilisant les mémoires tampons est facile:
1006	1003
1007	1004		``` pascal
1008	1005		glEnableClientState(GL_VERTEX_ARRAY);
1009	1006		glEnableClientState(GL_COLOR_ARRAY);
1010	1007		glVertexPointer(3, GL_FLOAT, 0, @VertexBuffer[0]);
1011	1008		glColorPointer(3, GL_FLOAT, 0, @ColorBuffer[0]);
1012	1009
1013	1010		glDrawArrays(GL_TRIANGLES, 0, Length(VertexBuffer));
1014	1011
1015	1012		glDisableClientState(GL_VERTEX_ARRAY);
1016	1013		glDisableClientState(GL_COLOR_ARRAY);
1017	1014		```
1018	1015
1019		-	D'abord nous autorisons les mémoires tampon que nous voulons employer en utilisant la fonction <b>glEnableClientState</b>. 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 (<b>glColorPointer</b>, <b>glEdgeFlagPointer</b>, <b>glIndexPointer</b>, <b>glNormalPointer</b>, <b>glTexCoordPointer</b>, <b>glVertexPointer</b>). 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:
	1016	+	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:
1020	1017
1021	1018		``` pascal
1022	1019		type
1023	1020		TBufferData = record
1024	1021		DataBefore: TDataBefore;
1025	1022		Vertex: TVertex;
1026	1023		DataAfter: TDataAfter;
1027	1024		end;
1028	1025
1029	1026		Bytes between elements = SizeOf(TDataBefore) + SizeOf(TDataAfter)
1030	1027		```
1031	1028
1032	1029		Le dernier paramètre est un pointeur vers le début de la mémoire tampon.
1033	1030
1034		-	Quand les mémoires tampons sont sélectionnées, nous pouvons les dessiner employant les fonctions <b>glDrawArrays</b>. 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).
	1031	+	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).
1035	1032
1036	1033		Quand les mémoires tampons ne sont pas nécessaires vous pouvez les neutraliser .
1037	1034
1038	1035		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:
1039	1036
1040	1037		``` pascal
1041	1038		type
1042	1039		TMesh = class
1043	1040		private
1044	1041		FVertices: array of TVertex3f;
1045	1042		FColors: array of TColor3f;
1046	1043		FIndices: array of Integer;
1047	1044		procedure FreeBuffers;
1048	1045		public
1049	1046		constructor Create;
1050	1047		destructor Destroy; override;
1051	1048		procedure LoadMesh(FileName: String);
1052	1049		procedure DrawMesh;
1053	1050		end;
1054	1051		```
1055	1052
1056	1053		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é.
1057	1054
1058	1055		D'abord, nous écrirons du code qui traite la création et la destruction de classe:
1059	1056
1060	1057		``` pascal
1061	1058		procedure TMesh.FreeBuffers;
1062	1059		begin
1063	1060		FVertices := nil;
1064	1061		FColors := nil;
1065	1062		FIndices := nil;
1066	1063		end;
1067	1064
1068	1065		constructor TMesh.Create;
1069	1066		begin
1070	1067		FreeBuffers;
1071	1068		end;
1072	1069
1073	1070		destructor TMesh.Destroy;
1074	1071		begin
1075	1072		FreeBuffers;
1076	1073		inherited Destroy;
1077	1074		end;
1078	1075		```
1079	1076
1080	1077		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:
1081	1078
1082	1079		`3 3`\
1083	1080		`-1 -1 0 1 1 1`\
1084	1081		`1 -1 0 1 1 1`\
1085	1082		`0 1 0 1 1 1`\
1086	1083		`0`\
1087	1084		`1`\
1088	1085		`2`
1089	1086
1090	1087		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 ).
1091	1088
1092	1089		Le code pour charger ces données ressemblera à celui-ci:
1093	1090
1094	1091		``` pascal
1095	1092		procedure TMesh.LoadMesh(FileName: String);
1096	1093		var
1097	1094		MeshFile: TextFile;
1098	1095		VertexCount, IndexCount: Integer;
1099	1096		iV, iI: Integer;
1100	1097		begin
1101	1098		FreeBuffers;
1102	1099
1103	1100		AssignFile(MeshFile, FileName);
1104	1101		Reset(MeshFile);
1105	1102
1106	1103		ReadLn(MeshFile, VertexCount, IndexCount);
1107	1104
1108	1105		SetLength(FVertices, VertexCount);
1109	1106		SetLength(FColors, VertexCount);
1110	1107		SetLength(FIndices, IndexCount);
1111	1108
1112	1109		for iV := 0 to VertexCount - 1 do
1113	1110		ReadLn(MeshFile,
1114	1111		FVertices[iV].X, FVertices[iV].Y, FVertices[iV].Z,
1115	1112		FColors[iV].R, FColors[iV].G, FColors[iV].B);
1116	1113
1117	1114		for iI := 0 to IndexCount - 1 do
1118	1115		ReadLn(MeshFile, FIndices[iI]);
1119	1116
1120	1117		CloseFile(MeshFile);
1121	1118		end;
1122	1119		```
1123	1120
1124	1121		Après le chargement des données, nous avons tout pour faire le dessin :
1125	1122
1126	1123		``` pascal
1127	1124		procedure TMesh.DrawMesh;
1128	1125		begin
1129	1126		glEnableClientState(GL_VERTEX_ARRAY);
1130	1127		glEnableClientState(GL_COLOR_ARRAY);
1131	1128		glVertexPointer(3, GL_FLOAT, 0, @FVertices[0]);
1132	1129		glColorPointer(3, GL_FLOAT, 0, @FColors[0]);
1133	1130
1134	1131		glDrawElements(GL_TRIANGLES, Length(FIndices), GL_UNSIGNED_INT, @FIndices[0]);
1135	1132
1136	1133		glDisableClientState(GL_VERTEX_ARRAY);
1137	1134		glDisableClientState(GL_COLOR_ARRAY);
1138	1135		end;
1139	1136		```
1140	1137
1141		-	![](/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 <b>glDrawElements</b>. 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.
	1138	+	![](/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.
1142	1139
1143	1140		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:
1144	1141
1145	1142		`4 6`\
1146	1143		`1 1 0 1 0 1`\
1147	1144		`-1 1 0 0 0 1`\
1148	1145		`-1 -1 0 0 1 0`\
1149	1146		`1 -1 0 1 1 0`\
1150	1147		`0`\
1151	1148		`1`\
1152	1149		`2`\
1153	1150		`0`\
1154	1151		`2`\
1155	1152		`3`
1156	1153
1157	1154		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.
1158	1155
1159	1156		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).
1160	1157
1161	1158		---
1162	1159		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