OpenGL Tutorial/ru: what changed

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

Old	New		Line
1	1		# Введение
2	2
3	3		OpenGL является средой для разработки интерактивных 2D и 3D графических приложений. OpenGL позволяет быстро разрабатывать приложения, включающие в себя рендеринг, текстурирование, спецэффекты и другие мощные функции визуализации. Разработчики могут использовать OpenGL на всех популярных платформах и операционных системах.
4	4
5	5		Более подробную информацию о OpenGL можно узнать [здесь](http://www.opengl.org/about/overview/).
6	6
7	7		## GLUT
8	8
9	9		GLUT - библиотека для использования OpenGL, реализующий простой оконный интерфейс API. GLUT делает изучение OpenGL более легким. Это кроссплатформенный API, так что вы можете написать программу OpenGL, которая будет работать на большинстве операционных систем.
10	10
11	11		Подробнее о GLUT вы можете почитать [здесь](http://www.opengl.org/resources/libraries/glut/).
12	12
13	13		Многие ОС поставляются с GLUT, но если у вас её не оказалось, можно поискать её в Интернете с помощью [Google](http://www.google.com/).
14	14
15	15		Версию для Windows можно скачать на [www.xmission.com](http://www.xmission.com/~nate/glut.html).
16	16
17	17		Про GLUT unit можно почитать в статье [[OpenGL]].
18	18
19	19		## GLFW
20	20
21	21		См. <http://www.glfw.org/>
22	22
23	23		## LCL
24	24
25	25		The Lazarus Component Library также может быть использована при работе с OpenGL. Lazarus включает в себя TOpenGLControl. Пакет LazOpenGLContext можно найти в lazarus/components/opengl/lazopenglcontext.lpk, примеры использования - в lazarus/examples/openglcontrol/openglcontrol_demo.lpi.
26	26
27	27		## LCL / GLFW / GLUT
28	28
29	29		Когда нужно использовать GLUT, а когда LCL?
30	30
31	31		- GLUT лучше применим, если вы хотите сделать все сами.
32	32		- LCL лучше использовать для обычных приложений. Например, 3D-редактор должен иметь несколько окон OpenGL и прочие обыкновенные элементы: кнопки, выпадающие списки, окна, модальные окна и т. д.
33	33
34	34		Часть OpenGL почти такая же. Для GLUT нужны dll под windows, а LCL обычно работает "из коробки", но и исполняемый файл имеет больший размер.
35	35
36	36		# Примеры
37	37
38	38		## Ваша первая LCL-программа
39	39
40	40		Использование LCL, как правило, является самым простым способом доступа к OpenGL с помощью Lazarus. Поскольку GLUT устарела, использование LCL - это хорошая идея для нового проекта OpenGL Lazarus. Большинство примеров кода, описанных ниже для GLUT, легко перевести в код LCL, хотя вам нужно будет найти эквиваленты для функций с префиксом 'glut', например, вместо "glutSwapBuffers" мы будем использовать LCL-свойство "SwapBuffers" для отображения нашего рендеринга. Единственная замечательная функция, которую обеспечивает GLUT и которую трудно сделать с LCL - это отображение текста на экране (см. Раздел «Растровые шрифты» GLUT ниже). Однако, поскольку это ваша первая LCL-программа, мы немного упростим ее, не отображая текст.
41	41
42	42		Lazarus поставляется с примером программы OpenGL, вы можете найти ее в папке Lazarus/Examples/openglcontrol. Этот пример демонстрирует множество мощных функций для создания анимированного изображения OpenGL. Тем не менее, это также относительно сложная программа. Ниже приведен минимальный проект Lazarus, который имитирует некоторые функции, описанные в примерах GLUT, описанных ниже. Чтобы создать его, запустите Lazarus и выберите Project/NewProject, чтобы создать новое приложение. Выберите пункт меню Project/ProjectInspector, нажмите кнопку 'Add..' (Добавить ...), перейдите к 'New Requirement' (Новое требование) и пакету «LazOpenGLContext». Затем вставьте приведенный ниже код в ваш 'unit1.pas'. Затем щелкните форму и на вкладке событий инспектора объектов свяжите событие «OnCreate» с функцией «FormCreate». Теперь вы сможете запустить новое приложение, выбрав пункт меню Run/Run (Выполнить/запустить).
43	43
44	44		Код создает новую панель OpenGL, которая заполняет форму. OpenGL рисует простой треугольник на форме. Обратите внимание, что при запуске приложения вы можете изменить размер формы, и треугольник, чтобы заполнить форму, масштабируется пропорционально.
45	45
46	46		``` pascal
47	47		unit Unit1;
48	48
49	49		{$mode objfpc}{$H+}
50	50
51	51		interface
52	52
53	53		uses
54	54		Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, OpenGLContext, gl;
55	55
56	56		type
57	57		TForm1 = class(TForm)
58	58		procedure FormCreate(Sender: TObject);
59	59		procedure GLboxPaint(Sender: TObject);
60	60		private
61	61		GLBox: TOpenGLControl;
62	62		public
63	63		end;
64	64
65	65		var
66	66		Form1: TForm1;
67	67
68	68		implementation
69	69
70	70		{$R *.lfm}
71	71
72	72		procedure TForm1.GLboxPaint(Sender: TObject);
73	73		begin
74	74		glClearColor(0.27, 0.53, 0.71, 1.0); // Задаем синий фон
75	75		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
76	76		glLoadIdentity;
77	77		glBegin(GL_TRIANGLES);
78	78		glColor3f(1, 0, 0);
79	79		glVertex3f( 0.0, 1.0, 0.0);
80	80		glColor3f(0, 1, 0);
81	81		glVertex3f(-1.0,-1.0, 0.0);
82	82		glColor3f(0, 0, 1);
83	83		glVertex3f( 1.0,-1.0, 0.0);
84	84		glEnd;
85	85		GLbox.SwapBuffers;
86	86		end;
87	87
88	88		procedure TForm1.FormCreate(Sender: TObject);
89	89		begin
90	90		GLbox := TOpenGLControl.Create(Self);
91	91		GLbox.AutoResizeViewport := true;
92	92		GLBox.Parent := Self;
93	93		GLBox.MultiSampling := 4;
94	94		GLBox.Align := alClient;
95	95		GLBox.OnPaint := @GLboxPaint; // для "mode delphi" должно быть "GLBox.OnPaint := GLboxPaint"
96	96		GLBox.invalidate;
97	97		end;
98	98
99	99		end.
100	100		```
101	101
102	102		## Ваша первая GLUT-программа
103	103
104		-	Для того чтобы использовать GLUT, сначала необходимо инициализировать его. Это делается с помощью функции <b>glutInit</b>. Эта функция может разобрать командную строку и установить параметры для главного окна, но она ожидает, что ввод будет в стиле C/C++. Вы можете написать собственную функцию, которая будет преобразовывать ParamCount и ParamStr в стиль C/C++.
	104	+	Для того чтобы использовать GLUT, сначала необходимо инициализировать его. Это делается с помощью функции glutInit. Эта функция может разобрать командную строку и установить параметры для главного окна, но она ожидает, что ввод будет в стиле C/C++. Вы можете написать собственную функцию, которая будет преобразовывать ParamCount и ParamStr в стиль C/C++.
105	105
106	106		``` pascal
107	107		procedure glutInitPascal(ParseCmdLine: Boolean);
108	108		var
109	109		Cmd: array of PChar;
110	110		CmdCount, I: Integer;
111	111		begin
112	112		if ParseCmdLine then
113	113		CmdCount := ParamCount + 1
114	114		else
115	115		CmdCount := 1;
116	116		SetLength(Cmd, CmdCount);
117	117		for I := 0 to CmdCount - 1 do
118	118		Cmd[I] := PChar(ParamStr(I));
119	119		glutInit(@CmdCount, @Cmd);
120	120		end;
121	121		```
122	122
123	123		По сути, вы создаете массив и заполняете его строками из ParamStr. Эта функция также имеет параметр, который указывает то, что передается glutInit -- вся команда или просто имя исполняемого файла.
124	124
125	125		ToDo: вероятно достаточно glutInit(@argc, @argv);.
126	126
127	127		Подробнее о glutInit: <http://www.opengl.org/resources/libraries/glut/spec3/node10.html>
128	128
129	129		Дальше нужно создать главное окно. Установите режим отображения для главного окна использованием `glutInitDisplayMode`. Она принимает только один параметр, который является комбинацией флагов. Обычно `GLUT_DOUBLE or GLUT_RGB or GLUT_DEPTH` - это всё, что необходимо.
130	130
131	131		Подробнее о glutInitDisplayMode: <http://www.opengl.org/resources/libraries/glut/spec3/node12.html>
132	132
133	133		Положение и размер окна изменяются с помощью `glutInitWindowPosition` и `glutInitWindowSize`. Они принимают 2 параметра: X и Y координаты в первой функции, ширина и высота в последней. Вы можете использовать `glutGet`, чтобы найти размер экрана и поместить центр окна.
134	134
135	135		ToDo: неверный перевод
136	136
137	137		Подробнее о `glutInitWindowPosition`, `glutInitWindowSize` и `glutGet`: <http://www.opengl.org/resources/libraries/glut/spec3/node11.html> <http://www.opengl.org/documentation/specs/glut/spec3/node70.html>
138	138
139		-	Наконец, окна должны быть созданы с использованием функции <b>glutCreateWindow</b>. Это создаст его с названием, переданным в параметре. Функция возвращает handle окна. Это можно использовать в других функциях, которые требуют handle.
	139	+	Наконец, окна должны быть созданы с использованием функции glutCreateWindow. Это создаст его с названием, переданным в параметре. Функция возвращает handle окна. Это можно использовать в других функциях, которые требуют handle.
140	140
141	141		Подробнее о glutCreateWindow: <http://www.opengl.org/resources/libraries/glut/spec3/node16.html>
142	142
143	143		Прежде чем программа войдёт в главный цикл, нужно установить некоторые функции для обратной связи. Это нужно для рисования окна, для изменения размеров и для получения нажатий клавиш на клавиатуре. Она устаналивается с помощью `glutDisplayFunc`, `glutReshapeFunc` и `glutKeyboardFunc`.
144	144
145	145		Подробнее: <http://www.opengl.org/resources/libraries/glut/spec3/node45.html#SECTION00080000000000000000>
146	146
147	147		Функция рисования может выглядеть следующим образом:
148	148
149	149		``` pascal
150	150		procedure DrawGLScene; cdecl;
151	151		begin
152	152		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
153	153		glutSwapBuffers;
154	154		end;
155	155		```
156	156
157	157		Она только очистит окно, зальёт его цветом фона и сбросит ZBuffer (не волнуйтесь о zbuffer... об этом позже).
158	158
159	159		Функция изменения размера может выглядеть так:
160	160
161	161		``` pascal
162	162		procedure ReSizeGLScene(Width, Height: Integer); cdecl;
163	163		begin
164	164		if Height = 0 then
165	165		Height := 1;
166	166
167	167		glViewport(0, 0, Width, Height);
168	168		glMatrixMode(GL_PROJECTION);
169	169		glLoadIdentity;
170	170		gluPerspective(45, Width / Height, 0.1, 1000);
171	171
172	172		glMatrixMode(GL_MODELVIEW);
173	173		glLoadIdentity;
174	174		end;
175	175		```
176	176
177	177		С помощью этого кода вы говорите OpenGL, где в окне будет происходить отрисовка и задаете матрицу (матричные функции будут описаны позже).
178	178
179	179		Ввод с клавиатуры:
180	180
181	181		``` pascal
182	182		procedure GLKeyboard(Key: Byte; X, Y: Longint); cdecl;
183	183		begin
184	184		if Key = 27 then
185	185		Halt(0);
186	186		end;
187	187		```
188	188
189	189		Эта функция завершит работу программы при нажатии клавиши ESC. Это единственный способ остановить программу. Если вы закроете окно по-другому, оно исчезнет, но сама программа продолжит работать бесконечно долго.
190	190
191	191		Для запуска основного цикла вызовите `glutMainLoop`. Это запустит бесконечный цикл, в котором содержатся все ваши функции для обратной связи.
192	192
193	193		Основная часть программы может выглядеть так:
194	194
195	195		``` pascal
196	196		const
197	197		AppWidth = 640;
198	198		AppHeight = 480;
199	199
200	200		procedure InitializeGL;
201	201		begin
202	202		glClearColor(0.18, 0.20, 0.66, 0);
203	203		end;
204	204
205	205		var
206	206		ScreenWidth, ScreenHeight: Integer;
207	207		begin
208	208		glutInitPascal(True);
209	209		glutInitDisplayMode(GLUT_DOUBLE or GLUT_RGB or GLUT_DEPTH);
210	210		glutInitWindowSize(AppWidth, AppHeight);
211	211		ScreenWidth := glutGet(GLUT_SCREEN_WIDTH);
212	212		ScreenHeight := glutGet(GLUT_SCREEN_HEIGHT);
213	213		glutInitWindowPosition((ScreenWidth - AppWidth) div 2,
214	214		(ScreenHeight - AppHeight) div 2);
215	215		glutCreateWindow('OpenGL Tutorial 1');
216	216
217	217		InitializeGL;
218	218
219	219		glutDisplayFunc(@DrawGLScene);
220	220		glutReshapeFunc(@ReSizeGLScene);
221	221		glutKeyboardFunc(@GLKeyboard);
222	222
223	223		glutMainLoop;
224	224		end.
225	225		```
226	226
227	227		Следующий урок добавит некоторый код, который будет рисовать простую фигуру.
228	228
229	229		Скачать исходный код или исполняемые файлы linux/windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
230	230
231	231		## Рисование простой фигуры
232	232
233	233		> Note: Следующие детали описывают в основном только код OpenGL, поэтому они будут работать как с GLUT, так и с LCL. Вы можете узнать функции GLUT по префиксу 'glu'.
234	234
235	235		Мы добавим только несколько строк кода и сосредоточим внимание на объяснение некоторых функций OpenGL.
236	236
237	237		Поясним следующий код.
238	238
239	239		``` pascal
240	240		begin
241	241		glMatrixMode(GL_PROJECTION);
242	242		glLoadIdentity;
243	243		gluPerspective(45, Width / Height, 0.1, 1000);
244	244
245	245		glMatrixMode(GL_MODELVIEW);
246	246		glLoadIdentity;
247	247		end;
248	248		```
249	249
250	250		Использование функции `glMatrixMode` указывает, какую матрицу вы хотите установить. OpenGL работает с 3 матрицами: `GL_MODELVIEW`: это используется при перемещении вершин в пространстве модели. `GL_PROJECTION`: это используется для преобразования 3D-координат в 2D-координаты. `GL_TEXTURE`: это используется для изменения координат текстуры.
251	251
252	252		После того, как вы выбрали матрицу, которую хотите изменить, вы можете вызвать функции, которые изменяют значения матриц. `glLoadIdentity` сбросит матрицу. Поскольку почти все матричные функции умножают текущую матрицу на сгенерированную, иногда необходимо очистить матрицу с помощью этой функции.
253	253
254	254		Чтобы установить перспективу матрицы, используйте функцию `gluPerspective`. Четыре параметра задают поле зрения, соотношение сторон, передний и задний план. Это просто.
255	255
256	256		Теперь вы измените матрицу модели ... на этот раз вы просто установите ее на идентичность.
257	257
258	258		Код рисования для первой фигуры:
259	259
260	260		``` pascal
261	261		procedure DrawGLScene; cdecl;
262	262		begin
263	263		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
264	264
265	265		glLoadIdentity;
266	266		glTranslatef(0, 0, -5);
267	267
268	268		glBegin(GL_TRIANGLES);
269	269		glColor3f(1, 0, 0);
270	270		glVertex3f(-1, -1, 0);
271	271
272	272		glColor3f(0, 1, 0);
273	273		glVertex3f(1, -1, 0);
274	274
275	275		glColor3f(0, 0, 1);
276	276		glVertex3f(0, 1, 0);
277	277		glEnd;
278	278
279	279		glutSwapBuffers;
280	280		end;
281	281		```
282	282
283	283		Мы использовали функцию glClear. Она просто сбрасывает буферы. Следующие две функции пока пропустим.
284	284
285	285		`glBegin` обозначает начало рисования в блок. После нее можно начать ввод вершин. Параметр описывает, что мы будем рисовать:
286	286
287	287		`GL_POINTS`: просто рисуем n точек. Нужно указать n вершин.
288	288
289	289		`GL_LINES`: каждая пара вершин задаст линию. Вершины 2n-1 и 2n задают одну линию. При использовании n вершин получится n/2 линий.
290	290
291	291		`GL_LINE_STRIP`: рисует отрезки из первой вершины через все в последнюю. Получится n-1 линий.
292	292
293	293		`GL_LINE_LOOP`: то же самое, но добавляется отрезок из последней вершины в первую. Получится n линий.
294	294
295	295		`GL_TRIANGLES`: каждые три точки зададут треугольник. Получится n/3 треугольников.
296	296
297	297		`GL_TRIANGLE_STRIP`: рисует связанные треугольники. Каждая вершина после первых двух будет задавать треугольник. При нечетном n вершины n, n+1 и n+2 зададут треугольник. При четном n - n+1, n и n+2. Получится n-2 треугольника.
298	298
299	299		`GL_TRIANGLE_FAN`: тоже рисует связанные треугольники. Каждая вершина после первых двух будет задавать треугольник. Вершины 1, n+1 и n+2 зададут треугольник. Получится n-2 треугольников.
300	300
301	301		`GL_QUADS`: каждые четыре вершины рисуют четырехугольник. Получится n/4 четырехугольников.
302	302
303	303		`GL_QUAD_STRIP`: рисует связанные четырехугольники. Каждая пара вершин после первой пары будет задавать четырехугольник. Вершины 2n-1, 2n, 2n+2 и 2n+1 задают четырехугольник n. n/2-1 четырехугольников получится. Обратите внимание, что порядок, в котором вершины используются для построения четырехугольника из ленты данных отличается от используемого с независимыми данными.
304	304
305	305		`GL_POLYGON`: рисует один выпуклый многоугольник. Вершины определяют этот полигон.
306	306
307	307		![](/wiki-images/f/f3/SimpleShapePic1.jpg) Нарисуем один треугольник с помощью `GL_TRIANGLES`. Функция `glVertex3f` задаёт положение вершины. Есть еще glVertex* функции. Единственное отличие состоит в количестве и типе параметров, которые они принимают. Например, `glVertex2i` принимает два параметра (x и y) типа integer. `glVertex3f` это обычно то, что вам нужно.
308	308
309	309		Перед `glVertex` можно установить цвет, материал, текстуру... Для простоты просто укажем цвет для каждой вершины. Цвет задаётся с помощью функции `glColor3f`. `glColor` также может принимать разные параметры, аналогично `glVertex`.
310	310
311	311		В коде мы можем увидеть, что Z имеет значение 0 для всех вершин. Поскольку передний план установлен как 0.1, треугольник не будет видно. Тут как раз нужны те две функции, которые мы пропустили. Вы уже знаете, что функция `glLoadIdentity` сбрасывает матрицу. `glTranslatef` перемещает треугольник на X, Y и Z, которые вы зададите. Если установить Z как -5 (отрицательный Z будет находиться дальше от камеры), то все вершины будут на 5 единиц дальше от камеры, и треугольник будет видно.
312	312
313	313		После завершения рисования вызовите функцию `glEnd`. Если хотите, то можете начать новое рисование с помощью `glBegin`.
314	314
315	315		Скачать исходный код, исполняемые файлы linux или windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
316	316
317	317		## Использование списков отображения
318	318
319	319		Иногда вам будет необходимо отобразить один и тот же объект на сцене несколько раз. OpenGL имеет возможность создавать списки отображения, которые также создают рисунок немного быстрее. Создать этот список очень легко. Просто задать вершины и заключить их между `glNewList` и `glEndList`.
320	320
321	321		``` pascal
322	322		const
323	323		LIST_OBJECT = 1;
324	324
325	325		procedure CreateList;
326	326		begin
327	327		glNewList(LIST_OBJECT, GL_COMPILE);
328	328		glBegin(GL_TRIANGLE_FAN);
329	329		glColor3f(1, 0, 0);
330	330		glVertex3f(0, 0.5, 0);
331	331
332	332		glColor3f(1, 1, 0);
333	333		glVertex3f(-0.5, -0.5, 0.5);
334	334
335	335		glColor3f(1, 1, 1);
336	336		glVertex3f(0.5, -0.5, 0.5);
337	337
338	338		glColor3f(0, 1, 1);
339	339		glVertex3f(0.5, -0.5, -0.5);
340	340
341	341		glColor3f(0, 0, 1);
342	342		glVertex3f(-0.5, -0.5, -0.5);
343	343
344	344		glColor3f(0, 1, 0);
345	345		glVertex3f(-0.5, -0.5, 0.5);
346	346		glEnd;
347	347
348	348		glBegin(GL_QUADS);
349	349		glColor3f(1, 1, 0);
350	350		glVertex3f(-0.5, -0.5, 0.5);
351	351
352	352		glColor3f(1, 1, 1);
353	353		glVertex3f(0.5, -0.5, 0.5);
354	354
355	355		glColor3f(0, 1, 1);
356	356		glVertex3f(0.5, -0.5, -0.5);
357	357
358	358		glColor3f(0, 0, 1);
359	359		glVertex3f(-0.5, -0.5, -0.5);
360	360
361	361		glColor3f(0, 1, 0);
362	362		glVertex3f(-0.5, -0.5, 0.5);
363	363		glEnd;
364	364		glEndList;
365	365		end;
366	366		```
367	367
368	368		`glNewList` создаёт новый список, и все функции рисования будут записаны, пока не вызовется `glEndList`.
369	369
370	370		Первый параметр функции `glNewList` задаёт ID списка. Каждый список определяется по его идентификатору. Если список с заданным ID уже существует, то он очистится перед записью. Если второй параметр `GL_COMPILE`, то все функции рисования просто записываются, если это `GL_COMPILE_AND_EXECUTE`, то они записываются и выполняются автоматически.
371	371
372	372		Функция `glIsList` поможет вам со списками. Она сообщает, существует ли список с таким ID.
373	373
374	374		Еще одна полезная функция - это `glGenLists`. Он создает несколько пустых списков отображения. Вы задаёте количество нужных списков и получаете номер первого из них. Если вам нужно создать n списков и получить r ID, получатся списки: r, r+1, r+2,..., r+n-1
375	375
376	376		Все созданные списки должны быть удалены. Для этого при выходе из программы вы должны сделать следующее:
377	377
378	378		``` pascal
379	379		procedure GLKeyboard(Key: Byte; X, Y: Longint); cdecl;
380	380		begin
381	381		if Key = 27 then
382	382		begin
383	383		glDeleteLists(LIST_OBJECT, 1);
384	384		Halt(0);
385	385		end;
386	386		end;
387	387		```
388	388
389	389		`glDeleteLists` принимает 2 параметра, ID списка отображения и количество списков для удаления. Если ID - r и количество списков для удаления n, удаляются следующие листы: r, r+1, r+2,..., r+n-1
390	390
391	391		Теперь вы знаете, как создавать и удалять списки отображения. Попробуем их применить:
392	392
393	393		``` pascal
394	394		procedure DrawGLScene; cdecl;
395	395		begin
396	396		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
397	397
398	398		glLoadIdentity;
399	399		glTranslatef(-2, 0, -5);
400	400		glRotatef(40, 1, 0, 1);
401	401		glCallList(LIST_OBJECT);
402	402
403	403		glLoadIdentity;
404	404		glTranslatef(1, -2, -10);
405	405		glRotatef(62, 0, 1, 0);
406	406		glCallList(LIST_OBJECT);
407	407
408	408		glLoadIdentity;
409	409		glTranslatef(-4, 0.5, -15);
410	410		glRotatef(200, 1, 0, 0);
411	411		glCallList(LIST_OBJECT);
412	412
413	413		glutSwapBuffers;
414	414		end;
415	415		```
416	416
417	417		![](/wiki-images/a/a5/DisplayListsPic1.jpg) Используйте `glCallList` для рисования одного списка. Прежде, чем делать список отображения, вы меняли модели матрицы и рисовали объект в разных местах. Иногда нужно рисовать несколько списков одновременно. Это возможно при использовании функции `glCallLists`. Она принимает количество списков, которые вы хотите нарисовать, тип массива, в котором содержатся ID и массив с идентификаторами списков. Тип может принимать одно из следующих значений:
418	418
419	419		`GL_BYTE`: список обрабатывается как массив байтов со знаком, каждый в диапазоне от -128 до 127.
420	420
421	421		`GL_UNSIGNED_BYTE`: список обрабатывается как массив байтов без знака, каждый в диапазоне от 0 до 255.
422	422
423	423		`GL_SHORT`: Список обрабатывается как массив двухбайтовых целых чисел со знаком, каждое из которых находится в диапазоне от -32768 до 32767.
424	424
425	425		`GL_UNSIGNED_SHORT`: Список обрабатывается как массив двухбайтовых целых чисел без знака, каждое из которых находится в диапазоне от 0 до 65535.
426	426
427	427		`GL_INT`: списки обрабатываются как массив четырехбайтовых целых чисел со знаком.
428	428
429	429		`GL_UNSIGNED_INT`: Список обрабатывается как массив беззнаковых четырехбайтовых целых чисел.
430	430
431	431		`GL_FLOAT`: Список обрабатывается как массив четырехбайтовых значений с плавающей точкой.
432	432
433	433		`GL_2_BYTES`: Список обрабатывается как массив байтов без знака. Каждая пара байтов определяет один идентификатор списка отображения. Значение пары вычисляется как 256-кратное значение без знака первого байта плюс значение без знака второго байта.
434	434
435	435		`GL_3_BYTES`: Список обрабатывается как массив байтов без знака. Каждый триплет байтов определяет один идентификатор списка отображения. Значение триплета вычисляется как 65536, умноженное на значение без знака первого байта, плюс 256 раз без знака без знака второго байта, плюс значение без знака третьего байта.
436	436
437	437		`GL_4_BYTES`: Список обрабатывается как массив байтов без знака. Каждая четверка байтов задает один идентификатор списка отображения. Значение четверки вычисляется как 16777216 раз значение без знака первого байта, плюс 65536 раз значение без знака второго байта, плюс 256 раз значение без знака третьего байта, плюс значение без знака четвертого байта.
438	438
439	439		Это пока. Следующий урок покажет, как создать маленькую планетную систему. Мы поговорим о матрицах и о том, как сделать анимированную сцену, которая не зависит от количества кадров в секунду.
440	440
441	441		Скачать исходный код, исполняемые файлы linux или windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
442	442
443	443		## Анимация в полноэкраном режиме
444	444
445	445		Переход в полноэкранный режим в GLUT прост. Измените основную часть программы:
446	446
447	447		``` pascal
448	448		const
449	449		FSMode = '800x600:32@75';
450	450
451	451		begin
452	452		glutInitPascal(False);
453	453		glutInitDisplayMode(GLUT_DOUBLE or GLUT_RGB or GLUT_DEPTH);
454	454		glutGameModeString(FSMode);
455	455		glutEnterGameMode;
456	456		glutSetCursor(GLUT_CURSOR_NONE);
457	457
458	458		InitializeGL;
459	459
460	460		glutDisplayFunc(@DrawGLScene);
461	461		glutReshapeFunc(@ReSizeGLScene);
462	462		glutKeyboardFunc(@GLKeyboard);
463	463		glutIdleFunc(@DrawGLScene);
464	464
465	465		glutMainLoop;
466	466		end.
467	467		```
468	468
469	469		Так как нам не нужно, чтобы GLUT разбирал командную строку, то на этот раз на glutInitPascal стави параметр false. Также не нужен код для создания окна. Функцией `glutEnterGameMode` GLUT автоматически создаст окно на весь экран. Чтобы указать желаемый режим, через функцию `glutGameModeString`передаём нужные параметры экрана. Format of that string is:
470	470
471	471		Так как в этот раз мы не хотим, чтобы GLUT анализировал командную строку, мы вызываем `glutInitPascal` с параметром False. Как видите, нет кода для создания окна. GLUT имеет `glutEnterGameMode`, который создает полноразмерное окно. Чтобы указать, какой полноэкранный режим вы хотите, вы вызываете функцию `glutGameModeString`, которая принимает строку, которая определяет режим, который вам нравится.
472	472
473	473		Формат этой строки:
474	474
475	475		``` pascal
476	476		[ширина "x" высота][":" цвет. палитра]["@" Гц]
477	477		```
478	478
479	479		В строке FSMode мы задали разрешение экрана 800x600, 32-битнкю цветовую палитру и частоту обновления экрана 75Гц. Можно пропустить один из элементов. Если вы пропустите разрешение, GLUT будет пытаться использовать текущее или самый низкое из тех, которые можно установить. То же для других параметров.
480	480
481	481		В строке `FSMode` мы объявили, что полноэкранный режим должен быть 800x600, с 32-битной палитрой и обновлением 75 Гц. Можно пропустить одну из групп. Если вы опустите размер, GLUT попытается использовать текущий или первый наименьший, который может работать. Эта политика используется и для других параметров.
482	482
483	483		Обычно в полноэкранном режиме курсор не виден. Чтобы скрыть курсор, вы должны использовать функцию `glutSetCursor`. Она принимает только один параметр, который описывает курсор, который вы хотели бы видеть:
484	484
485	485		``` pascal
486	486		GLUT_CURSOR_RIGHT_ARROW
487	487		GLUT_CURSOR_LEFT_ARROW
488	488		GLUT_CURSOR_INFO
489	489		GLUT_CURSOR_DESTROY
490	490		GLUT_CURSOR_HELP
491	491		GLUT_CURSOR_CYCLE
492	492		GLUT_CURSOR_SPRAY
493	493		GLUT_CURSOR_WAIT
494	494		GLUT_CURSOR_TEXT
495	495		GLUT_CURSOR_CROSSHAIR
496	496		GLUT_CURSOR_UP_DOWN
497	497		GLUT_CURSOR_LEFT_RIGHT
498	498		GLUT_CURSOR_TOP_SIDE
499	499		GLUT_CURSOR_BOTTOM_SIDE
500	500		GLUT_CURSOR_LEFT_SIDE
501	501		GLUT_CURSOR_RIGHT_SIDE
502	502		GLUT_CURSOR_TOP_LEFT_CORNER
503	503		GLUT_CURSOR_TOP_RIGHT_CORNER
504	504		GLUT_CURSOR_BOTTOM_RIGHT_CORNER
505	505		GLUT_CURSOR_BOTTOM_LEFT_CORNER
506	506		GLUT_CURSOR_FULL_CROSSHAIR
507	507		GLUT_CURSOR_NONE
508	508		GLUT_CURSOR_INHERIT
509	509		```
510	510
511	511		`glutIdleFunc` определяет функцию обратного вызова, которую вы захотите вызывать каждый раз, когда у вашей программы нет сообщений для обработки. Так как мы просто хотим рендерить новый кадр, если ничего не нужно делать, просто установите функцию ожидания в `DrawGLScene`. Некоторые другие учебные пособия показывают, что функция бездействия должна отправлять сообщение об обновлении вместо рисования, но в этом случае у меня на 50-100 кадров меньше, чем при использовании описанного мной метода.
512	512
513	513		Теперь давайте посмотрим на завершение программы, где вам нужно выйти из полноэкранного режима:
514	514
515	515		``` pascal
516	516		procedure GLKeyboard(Key: Byte; X, Y: Longint); cdecl;
517	517		begin
518	518		if Key = 27 then
519	519		begin
520	520		glutLeaveGameMode;
521	521		Halt(0);
522	522		end;
523	523		end;
524	524		```
525	525
526	526		Как видите, все, что вам нужно сделать, это вызвать `glutLeaveGameMode`.
527	527
528	528		Теперь мы представим некоторые новые матричные функции. Во-первых, давайте изменим функцию `ReSizeGLScene`:
529	529
530	530		``` pascal
531	531		procedure ReSizeGLScene(Width, Height: Integer); cdecl;
532	532		begin
533	533		.
534	534		.
535	535		.
536	536
537	537		glMatrixMode(GL_MODELVIEW);
538	538		glLoadIdentity;
539	539		gluLookAt(0, 20, 25, 0, 0, 0, 0, 1, 0);
540	540		end;
541	541		```
542	542
543	543		`gluLookAt` создает матрицу, которая будет определять, откуда вы смотрите на объекты. Первые 3 параметра - это координаты X, Y и Z положения камеры. Следующие 3 параметра - это координаты X, Y и Z точки, на которую смотрит камера, а последние 3 параметра определяют вектор «вверх» (где «вверх» для камеры). Обычно up - это положительная ось y.
544	544
545	545		Хорошо, давайте сейчас порисуем. Поскольку вы устанавливаете матрицу с помощью `gluLookAt`, которая должна использоваться со всеми объектами, вы не можете просто использовать `glLoadIdentity` для сброса матрицы для следующего объекта ... вы сохраните предыдущее состояние матрицы и восстановите его после отрисовки объекта:
546	546
547	547		``` pascal
548	548		procedure DrawGLScene; cdecl;
549	549		var
550	550		T: Single;
551	551		begin
552	552		T := glutGet(GLUT_ELAPSED_TIME) / 1000;
553	553		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
554	554
555	555		glPushMatrix;
556	556		glRotatef(5 * T, 0, 1, 0);
557	557		glColor3f(1, 1, 0);
558	558		glutWireSphere(2, 20, 20);
559	559		glPopMatrix;
560	560
561	561		glPushMatrix;
562	562		glRotatef(90 * T, 0, 1, 0);
563	563		glTranslatef(5, 0, 0);
564	564		glRotatef(40 * T, 0, 1, 0);
565	565		glColor3f(1, 0, 0);
566	566		glutWireSphere(0.6, 10, 10);
567	567		glPopMatrix;
568	568
569	569		glPushMatrix;
570	570		glRotatef(60 * T, 0, 1, 0);
571	571		glTranslatef(-3, 0, 9);
572	572		glRotatef(50 * T, 0, 1, 0);
573	573		glColor3f(0, 1, 0);
574	574		glutWireSphere(1, 16, 16);
575	575
576	576		glPushMatrix;
577	577		glRotatef(360 * T, 0, 1, 0);
578	578		glTranslatef(-1.7, 0, 0);
579	579		glRotatef(50 * T, 0, 1, 0);
580	580		glColor3f(0, 0, 1);
581	581		glutWireSphere(0.4, 10, 10);
582	582		glPopMatrix;
583	583
584	584		glPopMatrix;
585	585
586	586		glutSwapBuffers;
587	587		end;
588	588		```
589	589
590		-	~~<figure>~~
591		-	~~<img src="FullScreenAnimationPic1.jpg" title="FullScreenAnimationPic1.jpg" />~~
592		-	~~<figcaption>FullScreenAnimationPic1.jpg</figcaption>~~
593		-	~~</figure>~~
	590	+	![](/wiki-images/5/51/FullScreenAnimationPic1.jpg)
594	591
595	592		`glPushMatrix` и `glPopMatrix` используются для сохранения и восстановления состояния матрицы. Как видите, мы сохраняем состояние матрицы, затем меняем матрицу, чтобы нарисовать объект в нужном месте, а затем восстанавливаем старое состояние матрицы.
596	593
597	594		Вы можете спросить, для чего нужна переменная `T`? Ну, она используется для определения скорости анимации. Каждое изменение, зависящее от времени, умножается на `T`. Таким образом, скорость анимации постоянна на каждой частоте кадров.
598	595
599	596		Функция `glutGet` с параметром `GLUT_ELAPSED_TIME` возвращает время в миллисекундах из `glutInit`. Разделив ее значение на 1000, мы получим время в секундах.
600	597
601	598		Функция `glRotatef` создает матрицу вращения. Первый параметр - это угол в градусах, а последние 3 параметра определяют ось, вокруг которой будет выполняться вращение. Поскольку вы умножили угол на `T`, объект будет повернут на этот угол ровно за 1 секунду.
602	599
603	600		Загрузите исходный код, исполняемый файл linux или исполняемый файл windows из [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
604	601
605	602		## Освещение
606	603
607	604		Этот урок познакомит вас с освещением сцены. Вы сделаете вращающийся куб и один источник света, который добавит реалистичности сцене, но сначала давайте сделаем несколько вспомогательных модулей.
608	605
609	606		На данный момент урок будет иметь только базовые функции, которые помогут нам получить текущее время и дельту (время, прошедшее от одного рендеринга до другого вызова рендеринга), и рассчитать количество кадров в секунду.
610	607
611	608		``` pascal
612	609		unit utils;
613	610
614	611		{$mode objfpc}{$H+}
615	612
616	613		interface
617	614
618	615		uses
619	616		glut;
620	617
621	618		function GetTotalTime: Single;
622	619		function GetDeltaTime: Single;
623	620		procedure FrameRendered(Count: Integer = 1);
624	621		function GetFPS: Single;
625	622
626	623		implementation
627	624
628	625		var
629	626		OldTime: Integer = 0;
630	627		FPSTime: Integer = 0;
631	628		FPSCount: Integer = 0;
632	629
633	630		function GetTotalTime: Single;
634	631		begin
635	632		Result := glutGet(GLUT_ELAPSED_TIME) / 1000;
636	633		end;
637	634
638	635		function GetDeltaTime: Single;
639	636		var
640	637		NewTime: Integer;
641	638		begin
642	639		NewTime := glutGet(GLUT_ELAPSED_TIME);
643	640		Result := (NewTime - OldTime) / 1000;
644	641		OldTime := NewTime;
645	642		end;
646	643
647	644		procedure FrameRendered(Count: Integer);
648	645		begin
649	646		Inc(FPSCount, Count);
650	647		end;
651	648
652	649		function GetFPS: Single;
653	650		var
654	651		NewTime: Integer;
655	652		begin
656	653		NewTime := glutGet(GLUT_ELAPSED_TIME);
657	654
658	655		Result := FPSCount / ((NewTime - FPSTime) / 1000);
659	656
660	657		FPSTime := NewTime;
661	658		FPSCount := 0;
662	659		end;
663	660
664	661		end.
665	662		```
666	663
667	664		Как видите, в этом модуле нет ничего сложного. Время просто сохраняется между вызовами, а разница возвращается. FrameRendered должен вызываться каждый раз, когда вы рисуете сцену, чтобы функция могла рассчитывать FPS.
668	665
669	666		Теперь давайте повеселимся с освещением. В OpenGL есть несколько типов света: ambient (окружающий), diffuse (рассеянный), point(точечный), spot (пятно), specular (зеркальный) и emissive (излучение).
670	667
671	668		Окружающий свет (ambient) - это что-то вроде Солнца. Когда солнечные лучи проходят через окно комнаты, они ударяются о стены и отражаются во всех направлениях, что в среднем осветляет всю комнату. Все вершины освещены окружающим светом.
672	669
673	670		Рассеянный свет(diffuse) может быть представлен как параллельные световые лучи, исходящие издалека. Они будут освещать только вершины, ориентированные на источник света.
674	671
675	672		Точечный свет(point) освещает все вокруг себя. Он похож на огненный шар, он посылает световые лучи вокруг себя и освещает вершины, которые ориентированы на источник света и достаточно близки.
676	673
677	674		Пятно (spot) - как свет от фонарика. Это просто точечный источник света с небольшим радиусом светового конуса. Все вершины, которые попадают внутрь конуса и находятся достаточно близко, подсвечиваются.
678	675
679	676		Зеркальный свет (specular), как и рассеянный свет, является направленным типом света. Это происходит из одного конкретного направления. Разница между ними заключается в том, что зеркальный свет отражается от поверхности острым и равномерным образом. Рендеринг зеркального света зависит от угла между зрителем и источником света. С точки зрения зрителя зеркальный свет создает выделенную область на поверхности наблюдаемого объекта, известную как зеркальное выделение или зеркальное отражение.
680	677
681	678		Излучение (emissive) - свет немного отличается от любых других ранее объясненных компонентов света. Этот свет исходит от объекта, который вы рисуете, но не освещаете другие объекты поблизости.
682	679
683	680		Для простоты мы будем использовать только рассеянный свет в этом уроке. Позже, некоторые другие источники света могут появиться в уроках :)
684	681
685	682		Давайте посмотрим, как включить освещение в сцене:
686	683
687	684		``` pascal
688	685		const
689	686		DiffuseLight: array[0..3] of GLfloat = (0.8, 0.8, 0.8, 1);
690	687
691	688		glEnable(GL_LIGHTING);
692	689		glLightfv(GL_LIGHT0, GL_DIFFUSE, DiffuseLight);
693	690		glEnable(GL_LIGHT0);
694	691		```
695	692
696	693		Как видите, мы включаем подсветку в OpenGL, чтобы свет влиял на сцену, которую вы рендерили. Параметры освещения задаются функцией `glLightfv`. Потребуется 3 параметра ... один для числа освещения, которое вы хотите изменить (OpenGL поддерживает до 8 источников света), другой сообщает OpenGL, какой параметр освещения изменить, а последний - новый параметр для освещения. В этом уроке вы установите только рассеянный свет для освещения. После этого вы можете включить освещение, и на сцене будет свет ... но ... это еще не все.
697	694
698	695		Подробнее о `glLightfv`: <http://www.opengl.org//documentation/specs/man_pages/hardcopy/GL/html/gl/light.html>
699	696
700	697		Если вы хотите использовать источники света, вы не можете просто задать цвет для вершины ... вы также должны задать и материал для вершин. Давайте настроим материал для рисования:
701	698
702	699		``` pascal
703	700		glEnable(GL_COLOR_MATERIAL);
704	701		glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
705	702		```
706	703
707		-	~~<figure>~~
708		-	~~<img src="LightPic1.jpg" title="LightPic1.jpg" />~~
709		-	~~<figcaption>LightPic1.jpg</figcaption>~~
710		-	~~</figure>~~
	704	+	![](/wiki-images/e/ed/LightPic1.jpg)
711	705
712	706		Вы ожидали чего-то более сложного? :) Ну, этот код позволит нам использовать функцию `glColor`, чтобы задать материал для вершин. Используя функцию `glEnable` и флаг `GL_COLOR_MATERIAL`, вы можете определить, какие свойства материала будут изменять `glColor`. `glColorMaterial (GL_FRONT, GL_AMBIENT_AND_DIFFUSE)` сообщает OpenGL, что `glColor` изменяет окружающий и рассеянный материал. Мы обсудим материалы больше в следующих уроках.
713	707
714	708		Еще одна вещь, которая важна при использовании источников света ... каждая вершина должна иметь нормаль, связанную с ней. Нормаль используется для определения направления вершины, чтобы свет можно было правильно рассчитать. Вы будете использовать функцию GLUT, чтобы нарисовать куб, и он предоставит нам нормали, так что на этот раз мы просто пройдемся по нормали.
715	709
716	710		После всех этих настроек, свет будет сиять в вашем кубе :)
717	711
718	712		Часть текста скопирована из [The OpenGL Light Bible](http://www.falloutsoftware.com/tutorials/gl/gl8.htm)
719	713
720	714		Скачать исходный код, исполняемые файлы linux или windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
721	715
722	716		## Растровые шрифты
723	717
724	718		Игры и программы, как правило, должны писать текст на экране. GLUT предоставляет несколько функций, которые не зависят от платформы, для рисования символов.
725	719
726	720		Сначала мы покажем, как использовать стандартные растровые шрифты. Почти все дополнения кода будут сделаны в модуле utils.pas.
727	721
728	722		Поскольку текст будет отображаться в 2D, нам нужно знать ширину и высоту области просмотра ... поэтому мы напишем две функции для этого:
729	723
730	724		``` pascal
731	725		function glGetViewportWidth: Integer;
732	726		var
733	727		Rect: array[0..3] of Integer;
734	728		begin
735	729		glGetIntegerv(GL_VIEWPORT, @Rect);
736	730		Result := Rect[2] - Rect[0];
737	731		end;
738	732
739	733		function glGetViewportHeight: Integer;
740	734		var
741	735		Rect: array[0..3] of Integer;
742	736		begin
743	737		glGetIntegerv(GL_VIEWPORT, @Rect);
744	738		Result := Rect[3] - Rect[1];
745	739		end;
746	740		```
747	741
748	742		Мы просто получаем left/right, top/bottom и вычисляем width/height, вычитая их.
749	743
750	744		Должны быть функции для входа и выхода из режима 2D:
751	745
752	746		``` pascal
753	747		procedure glEnter2D;
754	748		begin
755	749		glMatrixMode(GL_PROJECTION);
756	750		glPushMatrix;
757	751		glLoadIdentity;
758	752		gluOrtho2D(0, glGetViewportWidth, 0, glGetViewportHeight);
759	753
760	754		glMatrixMode(GL_MODELVIEW);
761	755		glPushMatrix;
762	756		glLoadIdentity;
763	757
764	758		glDisable(GL_DEPTH_TEST);
765	759		end;
766	760
767	761		procedure glLeave2D;
768	762		begin
769	763		glMatrixMode(GL_PROJECTION);
770	764		glPopMatrix;
771	765		glMatrixMode(GL_MODELVIEW);
772	766		glPopMatrix;
773	767
774	768		glEnable(GL_DEPTH_TEST);
775	769		end;
776	770		```
777	771
778	772		При входе в режим 2D мы сохраняем текущие матрицы и устанавливаем 2D-матрицу с помощью функции `gluOrtho2D`. Таким образом, если мы нарисуем какую-либо штуку в координатах (100,100), она будет нарисована точно на 100 пикселей от левого края окна и на 100 пикселей от нижнего края формы (положительные значения по оси Y направлены вверх). Также мы отключаем ZBuffer. Таким образом, текст не изменит ZBuffer.
779	773
780	774		Выход из режима 2D просто возвращает старые матрицы и включает ZBuffer.
781	775
782	776		Теперь мы можем создать функцию для рисования текста:
783	777
784	778		``` pascal
785	779		procedure glWrite(X, Y: GLfloat; Font: Pointer; Text: String);
786	780		var
787	781		I: Integer;
788	782		begin
789	783		glRasterPos2f(X, Y);
790	784		for I := 1 to Length(Text) do
791	785		glutBitmapCharacter(Font, Integer(Text[I]));
792	786		end;
793	787		```
794	788
795	789		`glutBitmapCharacter` может рисовать только один символ выбранного шрифта. Первый параметр - желаемый шрифт (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 или GLUT_BITMAP_HELVETICA_18) и другие - являются символом.
796	790
797	791		Символ будет нарисован в текущей позиции растра. Чтобы установить желаемую позицию растра, мы вызываем функцию `glRasterPos`. `glRasterPos` может обрабатывать различные количества и типы параметров так же, как функция `glVertex`. Указанная координата преобразуется моделью и матрицей проекции, чтобы получить двухмерную координату, в которой будет находиться новая позиция растра. Поскольку мы вошли в режим 2D, координаты X и Y являются фактическими координатами 2D, в которых будет происходить рисование.
798	792
799	793		Эти новые функции сделают рисование текста очень простым:
800	794
801	795		``` pascal
802	796		procedure DrawGLScene; cdecl;
803	797		begin
804	798		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
805	799
806	800		glLoadIdentity;
807	801		glTranslatef(0, 0, -5);
808	802		glRotatef(GetTotalTime * 10, 0, 0.5, 0.5);
809	803
810	804		glColor3f(1, 0, 0);
811	805		glutSolidCube(2);
812	806
813	807		glEnter2D;
814	808
815	809		glColor3f(0.2, 0.8 + 0.2 * Sin(GetTotalTime * 5), 0);
816	810		glWrite(20, glGetViewportHeight - 20, GLUT_BITMAP_8_BY_13,
817	811		Format('OpenGL Tutorial :: Bitmap Fonts :: FPS - %.2f FPS', [FPS]));
818	812
819	813		glColor3f(1, 1, 1);
820	814		glWrite(50, glGetViewportHeight - 60, GLUT_BITMAP_9_BY_15, 'GLUT_BITMAP_9_BY_15');
821	815		glWrite(50, glGetViewportHeight - 90, GLUT_BITMAP_8_BY_13, 'GLUT_BITMAP_8_BY_13');
822	816		glWrite(50, glGetViewportHeight - 120, GLUT_BITMAP_TIMES_ROMAN_10, 'GLUT_BITMAP_TIMES_ROMAN_10');
823	817		glWrite(50, glGetViewportHeight - 150, GLUT_BITMAP_TIMES_ROMAN_24, 'GLUT_BITMAP_TIMES_ROMAN_24');
824	818		glWrite(50, glGetViewportHeight - 180, GLUT_BITMAP_HELVETICA_10, 'GLUT_BITMAP_HELVETICA_10');
825	819		glWrite(50, glGetViewportHeight - 210, GLUT_BITMAP_HELVETICA_12, 'GLUT_BITMAP_HELVETICA_12');
826	820		glWrite(50, glGetViewportHeight - 240, GLUT_BITMAP_HELVETICA_18, 'GLUT_BITMAP_HELVETICA_18');
827	821
828	822		glColor3f(0.5, 0.5, 1);
829	823		glWrite(
830	824		glGetViewportWidth - glutBitmapLength(GLUT_BITMAP_9_BY_15, LazText) - 5,
831	825		10, GLUT_BITMAP_9_BY_15, LazText);
832	826
833	827		glLeave2D;
834	828
835	829		glutSwapBuffers;
836	830
837	831		FrameRendered;
838	832		end;
839	833		```
840	834
841		-	~~<figure>~~
842		-	~~<img src="BitmapFontsPic1.jpg" title="BitmapFontsPic1.jpg" />~~
843		-	~~<figcaption>BitmapFontsPic1.jpg</figcaption>~~
844		-	~~</figure>~~
	835	+	![](/wiki-images/b/ba/BitmapFontsPic1.jpg)
845	836
846	837		Мы рисуем красный куб и поворачиваем его, а также немного текста, чтобы показать, как выглядят различные растровые шрифты. Функция `glutBitmapLength` используется для определения ширины строки, чтобы ее можно было выровнять вправо. Код может быть легко изменен для выравнивая текста по центру.
847	838
848	839		> Note: Посмотрите, как куб выглядит без света.
849	840
850	841		Загрузите исходный код, исполняемый файл под Linux или Windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
851	842
852	843		## Текстуры
853	844
854	845		Пришло время использовать текстуры :)
855	846
856	847		Этот урок покажет, как рисовать текстурированные полигоны и как смешивать текстуры, используя технику многопроходности. Поскольку в OpenGL нет встроенного механизма загрузки текстур, мы будем использовать внешнюю библиотеку: [Vampyre Imaging Library](http://imaginglib.sourceforge.net/). Мы будем использовать только вспомогательные функции OpenGL, но вам может пригодиться эта библиотека для некоторых других целей.
857	848
858	849		Давайте начнем ... мы создадим список отображения для рисования текстурированного прямоугольника:
859	850
860	851		``` pascal
861	852		procedure CreateList;
862	853		begin
863	854		glNewList(LIST_OBJECT, GL_COMPILE);
864	855		glBegin(GL_QUADS);
865	856		glTexCoord2f(1, 0);
866	857		glVertex3f( 2, 2, 0);
867	858		glTexCoord2f(0, 0);
868	859		glVertex3f(-2, 2, 0);
869	860		glTexCoord2f(0, 1);
870	861		glVertex3f(-2,-2, 0);
871	862		glTexCoord2f(1, 1);
872	863		glVertex3f( 2,-2, 0);
873	864		glEnd;
874	865		glEndList;
875	866		end;
876	867		```
877	868
878	869		Обратите внимание на функции `glTexCoord`. Они используются, чтобы указать, какая часть текстуры назначена вершине. Координаты, определенные в этих функциях, имеют значения от 0 до 1 (допустимы значения больше 1, но они могут давать разные результаты). 0 - это первый пиксель, а 1 - последний. Таким образом, 0.5 будет прямо в середине текстуры.
879	870
880	871		Загрузка текстур чрезвычайно проста с Vampyre Imaging Library:
881	872
882	873		``` pascal
883	874		var
884	875		Tex1, Tex2: GLuint;
885	876
886	877		procedure InitializeGL;
887	878		begin
888	879		glClearColor(0, 0, 0, 0);
889	880		Tex1 := LoadGLTextureFromFile('ashwood.bmp');
890	881		Tex2 := LoadGLTextureFromFile('Flare.bmp');
891	882		glEnable(GL_TEXTURE_2D);
892	883		end;
893	884		```
894	885
895	886		`LoadGLTextureFromFile` загружает текстуру из файла и возвращает ее ID. Когда текстура загружена, она уже настроена на рендеринг. Последняя строка просто включает 2D текстуры.
896	887
897	888		Чтобы нарисовать текстурированный многоугольник, вы должны связать текстуру и установить координаты текстуры (координаты текстуры задаются в списке отображения в этом уроке):
898	889
899	890		``` pascal
900	891		...
901	892		glLoadIdentity;
902	893		glTranslatef(-5, 0, -15);
903	894		glBindTexture(GL_TEXTURE_2D, Tex1);
904	895		glCallList(LIST_OBJECT);
905	896		...
906	897		```
907	898
908	899		Функция `glBindTexture` используется для выбора текстуры. Когда вы рисуете полигоны, на них будет выделена текстура. Это так просто :)
909	900
910	901		Итак, использовать одну текстуру легко ... но как смешать две текстуры? Обычно вы рисуете полигон один раз с одной текстурой, настраиваете параметры смешивания и еще раз рисуете полигон с другой текстурой. Таким способом вы можете смешивать текстуры. Давайте посмотрим, как выглядит код для этого:
911	902
912	903		``` pascal
913	904		...
914	905		glLoadIdentity;
915	906		glTranslatef(5, 0, -15);
916	907		glBindTexture(GL_TEXTURE_2D, Tex1);
917	908		glCallList(LIST_OBJECT);
918	909
919	910		glEnable(GL_BLEND);
920	911		glBlendFunc(GL_ZERO, GL_SRC_COLOR);
921	912		glLoadIdentity;
922	913		glTranslatef(5, 0, -15);
923	914		glBindTexture(GL_TEXTURE_2D, Tex2);
924	915		glCallList(LIST_OBJECT);
925	916		glDisable(GL_BLEND);
926	917		...
927	918		```
928	919
929	920		Как видите, полигон рисуется впервые, как мы уже знаем. Перед вторым рисованием мы включаем смешивание, вызывая `glEnable(GL_BLEND)`. Смешивание означает, что конечный цвет пикселя рассчитывается следующим образом:
930	921
931	922		``` pascal
932	923		DrawingColor * SRCBLEND + BackgroundColor * DESTBLEND
933	924		```
934	925
935	926		`SRCBLEND` и `DESTBLEND` определяются с помощью функции `glBlendFunc`. В этом уроке мы устанавливаем для `SRCBLEND` значение `GL_ZERO` (ноль) и для `DESTBLENT` значение `GL_SRC_COLOR (DrawingColor)`, а затем окончательный цвет:
936	927
937	928		``` pascal
938	929		DrawingColor * 0 + BackgroundColor * DrawingColor
939	930		```
940	931
941		-	~~<figure>~~
942		-	~~<img src="TexturesPic1.jpg" title="TexturesPic1.jpg" />~~
943		-	~~<figcaption>TexturesPic1.jpg</figcaption>~~
944		-	~~</figure>~~
	932	+	![](/wiki-images/d/d4/TexturesPic1.jpg)
945	933
946	934		Это означает, что фон будет темнее, когда вы рисуете темными цветами ... когда вы рисуете белым цветом, цвет фона не изменится. Результат будет выглядеть следующим образом.
947	935
948	936		В следующий раз мы будем использовать расширения, чтобы показать, как использовать однопроходное мультитекстурирование.
949	937
950	938		Загрузите исходный код, исполняемый файл для linux или windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
951	939
952	940		## Мультитекстурирование (расширения)
953	941
954	942		Когда вы уже знаете многопроходное мультитекстурирование, однопроходный процесс очень прост. Текстурирование разделено на этапы. Первый этап настраивает и рисует первую текстуру, второй этап рисует еще одну и так далее. Все, что вам нужно сделать, это настроить этапы текстуры и визуализации объекта.
955	943
956	944		Давайте посмотрим, как выглядит код:
957	945
958	946		``` pascal
959	947		procedure InitializeGL;
960	948		begin
961	949		Load_GL_ARB_multitexture;
962	950		glClearColor(0, 0, 0, 0);
963	951		Tex1 := LoadGLTextureFromFile('Lazarus.bmp');
964	952		Tex2 := LoadGLTextureFromFile('Mask.bmp');
965	953		glActiveTextureARB(GL_TEXTURE0_ARB);
966	954		glEnable(GL_TEXTURE_2D);
967	955		glBindTexture(GL_TEXTURE_2D, Tex1);
968	956		glActiveTextureARB(GL_TEXTURE1_ARB);
969	957		glEnable(GL_TEXTURE_2D);
970	958		glBindTexture(GL_TEXTURE_2D, Tex2);
971	959		end;
972	960		```
973	961
974	962		Для начала нам нужно загрузить расширение OpenGL, которое позволит нам использовать мультитекстурные функции. `Load_GL_ARB_multitexture` попытается загрузить эти расширения и вернет TRUE, если операция прошла успешно.
975	963
976	964		Чтобы выбрать стадию текстуры, над которой вы хотите работать, используйте функцию `glActiveTextureARB`. Она принимает только один параметр, который определяет, какая стадия вам нужна. После этого все текстурные функции (включение, отключение, связывание, создание ...) будут влиять на этот этап.
977	965
978	966		Поскольку мы настраиваем все в функции инициализации, все, что нам нужно сделать, это нарисовать объект:
979	967
980	968		``` pascal
981	969		procedure DrawGLScene; cdecl;
982	970		begin
983	971		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
984	972
985	973		glLoadIdentity;
986	974		glTranslatef(0, 0, -5);
987	975
988	976		glBegin(GL_QUADS);
989	977		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
990	978		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1, 0);
991	979		glVertex3f(2.516, 2, 0);
992	980		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
993	981		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, 0);
994	982		glVertex3f(-2.516, 2, 0);
995	983		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
996	984		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0, 1);
997	985		glVertex3f(-2.516,-2, 0);
998	986		glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
999	987		glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 1, 1);
1000	988		glVertex3f(2.516,-2, 0);
1001	989		glEnd;
1002	990
1003	991		glutSwapBuffers;
1004	992		end;
1005	993		```
1006	994
1007	995		![](/wiki-images/5/52/MultitexturePic1.jpg) Как видите, разница только в определении текстурных координат. Теперь мы используем функцию `glMultiTexCoord2fARB`, которая принимает стадию текстуры и координаты текстуры. Все остальное без изменений.
1008	996
1009	997		Сегодня почти все графические карты поддерживают как минимум 2 стадии текстур. Использование однопроходного мультитекстурирования выполняется быстрее, чем многопроходная версия, поскольку объекты рисуются только один раз за раз. Если оборудование поддерживает однопроходное мультитекстурирование (`Load_GL_ARB_multitexture` возвращает TRUE), используйте его.
1010	998
1011	999		Загрузите исходный код, исполняемый файл под linux или windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
1012	1000
1013	1001		## Рендеринг в текстуру
1014	1002
1015	1003		Этот будет кратко. OpenGL может захватывать текущую сцену в текстуру, чтобы вы могли использовать ее для текстурирования других объектов (экран телевизора, зеркало или что-то еще). Итак, просто визуализируйте сцену в текстуру и примените ее к вращающейся плоскости.
1016	1004
1017	1005		Сначала мы должны создать пустую текстуру, которую мы будем использовать для захвата сцены:
1018	1006
1019	1007		``` pascal
1020	1008		procedure SetupRenderTexture;
1021	1009		var
1022	1010		Data: Pointer;
1023	1011		begin
1024	1012		GetMem(Data, 2562563);
1025	1013		glGenTextures(1, @RenderTexture);
1026	1014		glBindTexture(GL_TEXTURE_2D, RenderTexture);
1027	1015		glTexImage2D(GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, Data);
1028	1016		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1029	1017		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1030	1018		FreeMem(Data);
1031	1019		end;
1032	1020		```
1033	1021
1034	1022		Создается буфер для изображения размером 256 * 256 RGB, который используется для настройки 2D-текстуры.
1035	1023
1036	1024		Основная часть - в функции рисования:
1037	1025
1038	1026		``` pascal
1039	1027		procedure DrawGLScene; cdecl;
1040	1028		var
1041	1029		TotalTime: Single;
1042	1030		begin
1043	1031		glClearColor(0, 0, 0, 0);
1044	1032		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
1045	1033		glEnable(GL_LIGHTING);
1046	1034		glDisable(GL_TEXTURE_2D);
1047	1035		glViewport(0, 0, 256, 256);
1048	1036
1049	1037		TotalTime := GetTotalTime;
1050	1038
1051	1039		glLoadIdentity;
1052	1040		glTranslatef(0, 0, -5);
1053	1041		glRotatef(50 * TotalTime, 1, 0, 0);
1054	1042		glRotatef(100 * TotalTime, 0, 1, 0);
1055	1043		glRotatef(50 * TotalTime, 0, 0, 1);
1056	1044
1057	1045		glColor3f(1, 1, 1);
1058	1046		glutSolidCube(2);
1059	1047
1060	1048		glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 0, 0, 256, 256, 0);
1061	1049
1062	1050		glClearColor(0.18, 0.20, 0.66, 0);
1063	1051		glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
1064	1052		glDisable(GL_LIGHTING);
1065	1053		glEnable(GL_TEXTURE_2D);
1066	1054		glViewport(0, 0, AppWidth, AppHeight);
1067	1055
1068	1056		glLoadIdentity;
1069	1057		glTranslatef(0, 0, -7);
1070	1058		glRotatef(20 * TotalTime, 1, 0, 0);
1071	1059		glRotatef(50 * TotalTime, 0, 1, 0);
1072	1060
1073	1061		glBegin(GL_QUADS);
1074	1062		glTexCoord2f(1, 0);
1075	1063		glVertex3f(2, 2, 0);
1076	1064		glTexCoord2f(0, 0);
1077	1065		glVertex3f(-2, 2, 0);
1078	1066		glTexCoord2f(0, 1);
1079	1067		glVertex3f(-2,-2, 0);
1080	1068		glTexCoord2f(1, 1);
1081	1069		glVertex3f(2,-2, 0);
1082	1070		glEnd;
1083	1071
1084	1072		glutSwapBuffers;
1085	1073		end;
1086	1074		```
1087	1075
1088	1076		![](/wiki-images/6/6e/RenderToTexturePic1.jpg) Во-первых, все настроено для сцены, которая будет захвачена. Окно просмотра уменьшено до 256*256, поэтому оно будет вписываться в текстуру, и сцена будет прорисована. `glCopyTexImage2D` используется для захвата сцены в текущую выбранную текстуру.
1089	1077
1090	1078		Когда у нас есть сцена, захваченная в текстуру, все может быть очищено снова, область просмотра может быть возвращена к исходному размеру, а финальная сцена рисуется с использованием предыдущей сцены в качестве текстуры.
1091	1079
1092	1080		> Note: Захваченную текстуру можно сохранить с помощью функции `SaveGLTextureToFile` из [Vampyre Imaging Library](http://imaginglib.sourceforge.net/).
1093	1081
1094	1082		Загрузите исходный код, исполняемый файл для linux или windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
1095	1083
1096	1084		## Массив вершин
1097	1085
1098	1086		OpenGL способен отображать примитивы, используя данные, которые хранятся в буферах, вызванных вызовом `glVertex`. Буферы могут использоваться для определения координат вершин и текстур, а также цветов (индекс и RGBA), нормалей и флагов ребер.
1099	1087
1100	1088		В этом уроке будут использоваться только вершинные и цветовые буферы, и мы покажем неиндексированное и индексированное рисование. Неиндексированный режим рисует буферы в виде потоков. Индексированный режим будет рисовать элементы буфера в порядке, определенном в индексе буфера. Но хватит говорить ... давайте начнем кодить.
1101	1089
1102	1090		Для начала давайте определим некоторые типы и константы:
1103	1091
1104	1092		``` pascal
1105	1093		type
1106	1094		TVertex3f = record
1107	1095		X, Y, Z: Single;
1108	1096		end;
1109	1097
1110	1098		TColor3f = record
1111	1099		R, G, B: Single;
1112	1100		end;
1113	1101
1114	1102		VertexBuffer: array [0..5] of TVertex3f = (
1115	1103		(X : 1; Y : 1; Z : 0),
1116	1104		(X : -1; Y : 1; Z : 0),
1117	1105		(X : -1; Y : -1; Z : 0),
1118	1106		(X : 1; Y : 1; Z : 0),
1119	1107		(X : -1; Y : -1; Z : 0),
1120	1108		(X : 1; Y : -1; Z : 0)
1121	1109		);
1122	1110		ColorBuffer: array [0..5] of TColor3f = (
1123	1111		(R : 1; G : 0; B : 1),
1124	1112		(R : 0; G : 0; B : 1),
1125	1113		(R : 0; G : 1; B : 0),
1126	1114		(R : 1; G : 0; B : 1),
1127	1115		(R : 0; G : 1; B : 0),
1128	1116		(R : 1; G : 1; B : 0)
1129	1117		);
1130	1118		```
1131	1119
1132	1120		У нас есть два буфера. Один для координат вершин и один для цветов вершин. Эти 6 вершин определяют 2х треугольников, которые образуют прямоугольник.
1133	1121
1134	1122		Рисовать примитивы с помощью буферов легко:
1135	1123
1136	1124		``` pascal
1137	1125		glEnableClientState(GL_VERTEX_ARRAY);
1138	1126		glEnableClientState(GL_COLOR_ARRAY);
1139	1127		glVertexPointer(3, GL_FLOAT, 0, @VertexBuffer[0]);
1140	1128		glColorPointer(3, GL_FLOAT, 0, @ColorBuffer[0]);
1141	1129
1142	1130		glDrawArrays(GL_TRIANGLES, 0, Length(VertexBuffer));
1143	1131
1144	1132		glDisableClientState(GL_VERTEX_ARRAY);
1145	1133		glDisableClientState(GL_COLOR_ARRAY);
1146	1134		```
1147	1135
1148	1136		Сначала мы включаем буферы, которые мы хотим использовать, используя функцию `glEnableClientState`. Затем мы можем выбрать буферы, которые мы хотим использовать. Каждый тип буфера имеет собственную функцию для выбора (`glColorPointer`, `glEdgeFlagPointer`, `glIndexPointer`, `glNormalPointer`, `glTexCoordPointer`, `glVertexPointer`).
1149	1137
1150	1138		Первый параметр в этих функциях определяет, сколько чисел содержит каждый элемент. Например, давайте возьмем буфер вершин. Если этот параметр равен 2, то OpenGL ожидает, что каждый элемент в буфере содержит координаты x и y. Если этот параметр равен, например, 4, то каждый элемент должен содержать координаты x, y, z и w. Следующий параметр определяет, какой тип элемента данных содержит (GL_BYTE, GL_UNSIGNED_BYTE, GL_SHORT, GL_UNSIGNED_SHORT, GL_INT, GL_UNSIGNED_INT, GL_FLOAT или GL_DOUBLE). Далее определяется количество байтов между каждым элементом. Таким образом, вы можете иметь буфер, который содержит координаты вершины и некоторые пользовательские данные.
1151	1139
1152	1140		Для произвольного типа данных этот параметр может быть рассчитан следующим образом:
1153	1141
1154	1142		``` pascal
1155	1143		type
1156	1144		TBufferData = record
1157	1145		DataBefore: TDataBefore;
1158	1146		Vertex: TVertex;
1159	1147		DataAfter: TDataAfter;
1160	1148		end;
1161	1149		```
1162	1150
1163	1151		`Байты между элементами = SizeOf(TDataBefore) + SizeOf(TDataAfter)`
1164	1152
1165	1153		Последний параметр - указатель на начало буфера.
1166	1154
1167	1155		Когда буферы выбраны, мы можем нарисовать их, используя функции `glDrawArrays`. Все включенные буферы используются для рисования примитивов. Тип создаваемых полигонов определяется в первом параметре (так же, как в функции `glBegin`). Следующие два определяют подмножество буфера, который используется для рисования (start и count).
1168	1156
1169	1157		Когда буферы не нужны, вы можете отключить их.
1170	1158
1171	1159		Чтобы продемонстрировать индексированный режим, я создал простой класс сетки, который может загружать данные вершин, цветов и индексов из внешних файлов:
1172	1160
1173	1161		``` pascal
1174	1162		type
1175	1163		TMesh = class
1176	1164		private
1177	1165		FVertices: array of TVertex3f;
1178	1166		FColors: array of TColor3f;
1179	1167		FIndices: array of Integer;
1180	1168		procedure FreeBuffers;
1181	1169		public
1182	1170		constructor Create;
1183	1171		destructor Destroy; override;
1184	1172		procedure LoadMesh(FileName: String);
1185	1173		procedure DrawMesh;
1186	1174		end;
1187	1175		```
1188	1176
1189	1177		Поле FVertices будет содержать данные о вершинах, поле FColors - данные о цвете, и поле FIndices - данные об индексах при загрузке внешнего файла.
1190	1178
1191	1179		Сначала мы напишем некоторый код, который занимается созданием и уничтожением класса:
1192	1180
1193	1181		``` pascal
1194	1182		procedure TMesh.FreeBuffers;
1195	1183		begin
1196	1184		FVertices := nil;
1197	1185		FColors := nil;
1198	1186		FIndices := nil;
1199	1187		end;
1200	1188
1201	1189		constructor TMesh.Create;
1202	1190		begin
1203	1191		FreeBuffers;
1204	1192		end;
1205	1193
1206	1194		destructor TMesh.Destroy;
1207	1195		begin
1208	1196		FreeBuffers;
1209	1197		inherited Destroy;
1210	1198		end;
1211	1199		```
1212	1200
1213	1201		Файл, который будет содержать данные сетки, является простым текстовым файлом. Первая строка будет содержать количество вершин и индексов, разделенных пробелом. После этого ряда появятся строки для каждой вершины и цвета. X, Y, Z, R, G и B все разделены пробелом. В конце будут строки для индексов ... каждый номер индекса будет записан в своей собственной строке ... поэтому для одного треугольника файл данных будет выглядеть примерно так:
1214	1202
1215	1203		``` pascal
1216	1204		3 3
1217	1205		-1 -1 0 1 1 1
1218	1206		1 -1 0 1 1 1
1219	1207		0 1 0 1 1 1
1220	1208		0
1221	1209		1
1222	1210		2
1223	1211		```
1224	1212
1225	1213		Это означает, что в файле определены 3 вершины и 3 индекса. Первая вершина имеет значения -1, -1, 0 и цвет, имеющий значения 1, 1, 1 и т.д. Индексы определяют тот порядок, в котором рисуются вершины (в этом случае вершины рисуются в том же порядке, в котором они определены).
1226	1214
1227	1215		Код для загрузки этих данных будет выглядеть так:
1228	1216
1229	1217		``` pascal
1230	1218		procedure TMesh.LoadMesh(FileName: String);
1231	1219		var
1232	1220		MeshFile: TextFile;
1233	1221		VertexCount, IndexCount: Integer;
1234	1222		iV, iI: Integer;
1235	1223		begin
1236	1224		FreeBuffers;
1237	1225
1238	1226		AssignFile(MeshFile, FileName);
1239	1227		Reset(MeshFile);
1240	1228
1241	1229		ReadLn(MeshFile, VertexCount, IndexCount);
1242	1230
1243	1231		SetLength(FVertices, VertexCount);
1244	1232		SetLength(FColors, VertexCount);
1245	1233		SetLength(FIndices, IndexCount);
1246	1234
1247	1235		for iV := 0 to VertexCount - 1 do
1248	1236		ReadLn(MeshFile,
1249	1237		FVertices[iV].X, FVertices[iV].Y, FVertices[iV].Z,
1250	1238		FColors[iV].R, FColors[iV].G, FColors[iV].B);
1251	1239
1252	1240		for iI := 0 to IndexCount - 1 do
1253	1241		ReadLn(MeshFile, FIndices[iI]);
1254	1242
1255	1243		CloseFile(MeshFile);
1256	1244		end;
1257	1245		```
1258	1246
1259	1247		После загрузки данных у нас есть все для рисования:
1260	1248
1261	1249		``` pascal
1262	1250		procedure TMesh.DrawMesh;
1263	1251		begin
1264	1252		glEnableClientState(GL_VERTEX_ARRAY);
1265	1253		glEnableClientState(GL_COLOR_ARRAY);
1266	1254		glVertexPointer(3, GL_FLOAT, 0, @FVertices[0]);
1267	1255		glColorPointer(3, GL_FLOAT, 0, @FColors[0]);
1268	1256
1269	1257		glDrawElements(GL_TRIANGLES, Length(FIndices), GL_UNSIGNED_INT, @FIndices[0]);
1270	1258
1271	1259		glDisableClientState(GL_VERTEX_ARRAY);
1272	1260		glDisableClientState(GL_COLOR_ARRAY);
1273	1261		end;
1274	1262		```
1275	1263
1276	1264		Как видите, почти все то же самое, что и для неиндексированного рисования, за исключением функции, которая фактически рисует многоугольники. В этом случае мы используем функцию `glDrawElements`. Для этого мы указываем, какой тип полигонов мы хотим нарисовать, сколько индексов находится в буфере индекса, тип данных в буфере индекса и указатель на начало буфера индекса.
1277	1265
1278	1266		![](/wiki-images/7/77/VertexArrayPic1.jpg)Полный исходный код поставляется с файлом данных сетки, который этот класс может использовать для создания прямоугольника, идентичного прямоугольнику, нарисованному в неиндексированном режиме. Файл данных сетки выглядит так:
1279	1267
1280	1268		``` pascal
1281	1269		4 6
1282	1270		1 1 0 1 0 1
1283	1271		-1 1 0 0 0 1
1284	1272		-1 -1 0 0 1 0
1285	1273		1 -1 0 1 1 0
1286	1274		0
1287	1275		1
1288	1276		2
1289	1277		0
1290	1278		2
1291	1279		3
1292	1280		```
1293	1281
1294	1282		Как видите, есть данные только для 4 вершин и 6 индексов. Итак, первый треугольник определяется вершинами 0, 1 и 2, а второй - вершинами 0, 2 и 3. Используя индексированный режим, нам не нужно дублировать вершины.
1295	1283
1296	1284		Загрузите исходный код, исполняемый файл для linux или windows с [Lazarus CCR SourceForge](http://sourceforge.net/project/showfiles.php?group_id=92177&package_id=199145).
1297	1285
1298	1286		# Современный OpenGL с использованием MacOS
1299	1287
1300	1288		Отличная особенность Lazarus - «написав однажды, компилируй где угодно», где код должен работать как на MacOS, так и на Linux или Windows. Однако для поддержки всех трех из этих систем вам необходимо решить, поддерживать ли только устаревший OpenGL или использовать профиль «OpenGL Core».
1301	1289
1302	1290		Для пользователей Linux и Windows последние версии OpenGL представляют собой расширенный набор старых версий. Поэтому пользователь Linux может смешивать и сопоставлять старый код OpenGL с современными шейдерами. Но только не для случая с пользователями Macintosh MacOS (OSX).
1303	1291
1304	1292		MacOS обеспечивает две формы поддержки: унаследованный режим поддерживает все функции OpenGL до 2.1 (и GLSL 1.2). Кроме того, пользователь может выбрать современную core-версию OpenGL (тогда как большинство пользователей Linux и Windows имеют доступ к «совместимым» версиям OpenGL).
1305	1293
1306	1294		[Сore-версия OpenGL](https://prideout.net/modern-opengl-prezo/) удаляет многие устаревшие унаследованные функции. Это означает, что все приведенные выше учебники будут компилироваться только в устаревшем режиме MacOS. Режим ядра не имеет конвейера с фиксированными функциями, и поэтому разработчик должен написать свои собственные шейдеры. Кроме того, режим Core удаляет некоторые базовые примитивы, такие как [`GL_QUADS`](https://www.khronos.org/opengl/wiki/Legacy_OpenGL), поэтому квадрат необходимо заменить двумя треугольниками (это действительно имеет смысл: все вершины треугольника копланарны (расположены в одной плоскости), но это не обязательно имеет место для четырехугольника, точно так же, как каждая ножка треноги всегда будет касаться земли, в то время как 4х-ногая табуретка может колебаться, если одна нога короче других).
1307	1295
1308	1296		Преимущество базовой модели состоит в том, что она проста и, как правило, легко адаптируется к мобильным устройствам (которые используют аналогичную встроенную форму OpenGL). См. [веб-сайт Apple](Https://developer.apple.com/opengl/capabilities/), чтобы увидеть OpenGL, поддерживаемый вашей операционной системой. Еще одна проблема заключается в том, что основные режимы OpenGL поддерживаются только в наборе виджетов Cocoa, поэтому вы не можете использовать набор виджетов Carbon (который в настоящее время используется по умолчанию в Lazarus).
1309	1297
1310	1298		Три демонстрационных проекта доступны на [Github OpenGLCoreTutorials](https://github.com/neurolabusc/OpenGLCoreTutorials) и будут компилироваться с использованием Lazarus 1.6.2 или более поздней версии для Linux, Windows или MacOS.
1311	1299
1312	1300		# See also
1313	1301
1314	1302		- [[Creating bindings for C libraries/ru\|Создание привязок для библиотек C]]
1315	1303		- [[OpenGL]]
1316	1304
1317	1305		# Внешние ссылки
1318	1306
1319	1307		- [OpenGL Light Tutorial](http://www.falloutsoftware.com/tutorials/gl/gl8.htm) - Учебное пособие по OpenGL, в котором описывается, как создавать источники света и управлять ими, а также справляться с отражениями поверхности полигона с помощью нормалей.
1320	1308		- [opengles3-book](https://github.com/danginsburg/opengles3-book)
1321	1309		- [opengl-tutorials](https://github.com/zilongshanren/opengl-tutorials)
1322	1310
1323	1311		---
1324	1312		From the Free Pascal wiki, page "OpenGL Tutorial/ru", as it stood on 2019-11-06 after a change by Zoltanleo, 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).
1325	1313		Category: Code/ru
1326	1314		Category: Example programs/ru
1327	1315		Category: Graphics/ru
1328	1316		Category: OpenGL/ru
1329	1317		Category: Russian
1330	1318		Category: Russian (unfinished translation)
1331	1319		Category: Tutorials/ru

Back to history