Міністерство освіти і науки України
Луганський національний педагогічний університет імені Тараса Шевченка
Інститут економіки та бізнесу
Курсова робота
На тему:
Використання OpenGL
Виконав
Студент 3 курсу
Кравченко О.С.
Перевірив
Кутепова Л.М.
Луганськ 2004

Зміст
1.1. Програмний код OpenGL .. 5
1.2. Синтаксис команд OpenGL .. 8
1.3 OpenGL як кінцевий автомат. 10
1.4. Конвеєр візуалізації OpenGL .. 11
1.4.1. Конвеєр. 11
1.4.2 Списки виводу. 12
1.4.3 Обчислювачі. 13
1.4.4 Операції обробки вершин. 13
1.4.5 Складання примітивів. 13
1.4.6 Операції обробки пікселів. 14
1.4.7 Складання текстури .. 15
1.4.8. Растеризация. 15
1.4.9 Операції обробки фрагментів. 16
2 Бібліотеки, пов'язані з OpenGL .. 17
2.1 Бібліотека OpenGL .. 17
2.2. Підключаються файли .. 19
2.3 GLUT, інструментарій утиліт бібліотеки OpenGL .. 20
2.3.1. Інструментарій бібліотек. 20
2.3.2 Управління вікнами. 21
2.3.3 Функція зворотного виклику відображення. 22
2.3.4. Виконання програми .. 23
2.3.4 Обробка подій введення даних користувачем .. 25
2.3.5 Управління фоновим процесом .. 25
2.3.6 Малювання тривимірних об'єктів. 26
3. Анімація. 27
3.1. анімація комп'ютерної графіки. 27
3.2 Оновлення інформації, що відображається під час паузи .. 30

Введення
Бібліотека OpenGL являє собою програмний інтерфейс для апаратного забезпечення машинної графіки. Цей інтерфейс складається приблизно з 250 окремих команд (майже 200 команд у ядрі OpenGL і ще 50 команд у бібліотеці утиліт OpenGL), які використовуються для того, щоб визначити об'єкти та операції, необхідні для створення інтерактивних тривимірних прикладних програм.
Бібліотека OpenGL розроблена в якості низькорівневого, апаратно-незалежного інтерфейсу, що допускає реалізацію на безлічі різних апаратних платформ. Для того щоб досягти цих якостей, до складу бібліотеки OpenGL не включені ніякі команди для виконання завдань роботи з вікнами або для отримання користувацького введення; замість цього ви повинні працювати через будь-яку систему управління вікнами, яка працює з конкретними апаратними засобами. Точно так само бібліотека OpenGL не надає команди високого рівня для опису моделей тривимірних об'єктів. Такі команди могли б дозволити визначати щодо складні форми, наприклад, автомобілі, частини тіла, літаки або молекули. При використанні бібліотеки OpenGL ви повинні створювати потрібну модель з обмеженого набору геометричних примітивів - точок, ліній та багатокутників.
Більш складна бібліотека, яка забезпечує ці функціональні можливості, звичайно, могла б бути створена поверх бібліотеки OpenGL. Бібліотека утиліт OpenGL (GLU - OpenGL Utility Library) надає безліч можливостей моделювання, таких як поверхні другого порядку і NURBS-кривих і поверхонь (NURBS - Non-Uniform, Rational B-Spline - нерівномірний раціональний По-сплайн). Бібліотека GLU являє собою стандартну частину кожної реалізації OpenGL. Існують також набори інструментів більш високого рівня, такі як FSG (Fahrenheit Scene Graph), які є надбудовою бібліотеки OpenGL, і самостійно доступні для безлічі реалізацій бібліотеки OpenGL.

1.1. Програмний код OpenGL

Оскільки за допомогою графічної системи OpenGL можна вирішити так багато завдань, OpenGL-програма може бути досить важким для розуміння. Однак основна структура корисної програми може бути проста: її завдання полягають у тому, щоб ініціалізувати деякі стану, які керують тим, як бібліотека OpenGL виконує візуалізацію, і визначити об'єкти, які будуть візуалізовані.
Перш ніж приступити до аналізу деякого програмного коду OpenGL, давайте познайомимося з декількома термінами. Візуалізація, з її використанням ви вже стикалися, являє собою процес, за допомогою якого комп'ютер створює зображення з моделей. Ці моделі, або об'єкти, створюються з геометричних примітивів, - точок, ліній і багатокутників, - які визначаються їх вершинами.
Кінцеве візуалізоване зображення складається з пікселів, що виводяться на екран; піксель являє собою найменший видимий елемент, який апаратні засоби відображення можуть помістити на екран.
Інформація про пікселях (наприклад, який колір передбачається для цих пікселів) організована в пам'яті у вигляді бітових площин. Бітова площина являє собою область пам'яті, яка містить один біт інформації для кожного пікселя на екрані; цей біт міг би вказувати, наприклад, на те, що конкретний піксель, як передбачається, є червоним. Бітові площині, у свою чергу, організовані в буфер кадру, який містить всю інформацію, необхідну графічному дисплею для того, щоб керувати кольором і яскравістю всіх пікселів на екрані.
Приклад 1. демонструє візуалізацію білого прямокутника на чорному тлі, як це показано на малюнку 1.

Приклад 1. Фрагмент програмного коду OpenGL
finclude <whateverYouNeed.h>,
main () {
InitializeAWindowPlease ();
glClearColor (0.0, 0.0, 0.0, 0.0); glClear (GL_COLOR_BUFFER_BIT); glColor3f (1.0, 1.0, 1.0);
glOrtho (0.0, 1.0, 0.0, 1.0, -1.0, 1.0); glBegin (GL_POLYGON);
glVertex3f (0.25, 0.25, 0.0);
glVertex3f (0.75, 0.25, 0.0);
glVertex3f (0.75, 0.75, 0.0);
glVertex3f (0.25, 0.75, 0.0); glEnd (); glFlush ();
UpdateTheWindowAndCheckForEvents ();}
Перший рядок функції main () ініціалізує певне вікно на екрані: функція InitializeAWindowPlease () використовується в даному випадку в якості мітки-"заповнювача" для підпрограм специфічних віконних систем, які в загальному випадку не є викликами OpenGL. Наступні два рядки містять команди OpenGL, які встановлюють чорний колір фону для вікна: функція glCIearCoIor () визначає те, який колір тла буде встановлений для вікна, а функція glClear () фактично встановлює колір вікна. Як тільки колір фону встановлено, вікно заливається цим кольором кожного разу, коли викликається функція glClear (). Цей колір фону може бути змінений за допомогою другого виклику функції glClearColor (). Точно так само функція glColor3f () встановлює те, який колір слід використовувати для промальовування об'єктів на екрані - в даному випадку цей колір є білим. Всі об'єкти, що виводяться на екран після цього моменту, використовують даний колір до тих пір, поки він не буде змінений за допомогою наступного виклику команди установки кольору.
Наступна функція OpenGL, використовувана в даній програмі, glOrtho (), визначає систему координат, яку OpenGL приймає для промальовування остаточного зображення, і те, як це зображення відображається на екрані. Виклики, укладені між функціями glBegin () і glЈnd (), визначають об'єкт, який буде виведений на екран, в розглянутому прикладі це багатокутник з чотирма вершинами. "Кути" багатокутника визначаються за допомогою функції glVertex3f (). Як ви, напевно, вже здогадалися, виходячи з значень параметрів цієї функції, які представляють собою координати (х, у, z), даний багатокутник є прямокутником, розташованим на площині z (z - 0).
Нарешті, функція gIFlush () гарантує, що команди промальовування фактично виконуються, а не просто зберігаються в деякому буфері, чекаючи додаткових команд OpenGL. Підпрограма-"заповнювач" UpdateTheWindowAndCheckForEvents () управляє вмістом вікна і починає обробку подій.

1.2. Синтаксис команд OpenGL

Як ви, ймовірно, могли помітити з прикладу простої програми, наведеного в попередньому розділі, команди бібліотеки OpenGL використовують префікс gl. Кожне слово, що становить найменування команди, починається з великої літери (згадайте, наприклад, функцію glClearColor ()). Точно так само імена констант, визначених у бібліотеці OpenGL, починаються з префікса GL_, записуються цілком заголовними буквами і використовують символи підкреслення, щоб розділити окремі слова (наприклад, GL__COLOR_BUFFER_BIT).
Ви, ймовірно, також змогли помітити деякі символи, які здалися вам сторонніми, вони додаються в кінець найменування деяких команд (наприклад, 3f у функціях glColor3f () і glVertex3f ()). Дійсно, частина Color в найменуванні функції glColor3f () достатня для того, щоб визначити цю команду як команду, яка встановлює поточний колір. Однак було визначено кілька таких команд, щоб можна було використовувати їх з різними типами параметрів. Зокрема, частина 3 суфікса вказує, що для цієї команди задаються три параметри, інша версія команди Color використовує чотири параметри. Частина f суфікса вказує на те, що параметри даної команди представляють собою числа з плаваючою крапкою. Наявність різних форматів дозволяє бібліотеці OpenGL приймати дані користувача в його власному форматі даних.
Деякі команди бібліотеки OpenGL допускають використання 8 різних типів даних як своїх параметрів. Літери, які використовуються в якості суфіксів для того, щоб визначити ці типи даних для реалізації ISO З бібліотеки OpenGL, представлені в Таблиці 1.1; там же приведені відповідні визначення типів у бібліотеці OpenGL. Конкретна реалізація бібліотеки OpenGL, яку ви використовуєте, може не збігатися в точності з наведеною схемою, наприклад, реалізації для мов програмування C + + або Ada, не вимагають цього.

Тип даних	Типовий відповідний тип даних мови програмування З	Визначення типів даних бібліотеки OpenGL
8-розрядне ціле	signed char	GLbyte
16-розрядне ціле	short	GLshort
32-розрядне ціле	Int або long	GLint, GLsizei
32-розрядне число з плаваючою точкою	float	GLfloat, GLclampf
64-розрядне число з плаваючою точкою	double	GLdouble, GLclampd
8-розрядне беззнаковое ціле	unsigned char	GLubyte, GLboolean
16-розрядне беззнаковое ціле	unsigned short	GLushort
32-розрядне беззнаковое ціле	unsignedint або unsigned long	GLuint, GLenum, GLbitfield

Таблиця 1.1 Суфікси найменувань команд і типи даних параметрів
Таким чином, дві команди
glVertex2i (1,3); glVertex2f (1.0, 3.0);
є еквівалентними, за винятком того, що перша з них визначає координати вершини як 32-розрядні цілі числа, а друга визначають їх як числа з плаваючою точкою з одинарною точністю.
Назви деяких команд бібліотеки OpenGL можуть мати заключний символ v, який вказує на те, що дана команда бере покажчик на вектор (або масив) значень, а не набір індивідуальних параметрів. Багато команд мають як векторні, так і невекторние версії, але деякі команди беруть лише індивідуальні параметри, тоді як інші команди вимагають, щоб, принаймні, деякі з їхніх параметрів були визначені як вектори. Наступні рядки показують, як можна було б використовувати векторну і невекторную версію команди, яка встановлює поточний колір:
glColor3f (1.0, 0.0, 0.0);
gLfloat color_array [] = {1.0, 0.0, 0.0); glColor3fv (color_array);
Нарешті, бібліотека OpenGL визначає тип даних GLvoid. Цей тип даних найбільш часто використовується для тих команд бібліотеки OpenGL, які приймають в якості параметрів покажчики на масиви значень.

1.3 OpenGL як кінцевий автомат

Графічна система OpenGL являє собою кінцевий автомат. Ви перекладаєте цей автомат в різні стани (або режими), які потім залишаються в силі до тих пір, поки ви не зміните їх. Як вже було показано вище, поточний колір представляє собою змінну стану. Можна встановити в якості поточного білий, червоний, або будь-який інший колір, і після цього кожен об'єкт буде виводитися на екран з цим кольором до тих пір, поки ви не встановите для поточного кольору якесь інше значення. Поточний колір є лише однією з безлічі змінних стану, які підтримує бібліотека OpenGL. Інші змінні стану керують такими речами, як поточна візуалізація та перетворення проектування, шаблони штрихування ліній і багатокутників, режими виведення багатокутників на екран, угоди щодо упаковки пікселів, місце розташування і характеристики джерел освітлення, а також властивості матеріалів об'єктів, що виводяться на екран. Безліч змінних стану відносяться до режимів, які включаються або вимикаються за допомогою команд glEnable () або glDisable () відповідно.
Кожна змінна стану або режим мають значення за замовчуванням, і в будь-який момент часу можна запитати у системи поточні значення кожної з цих змінних. Як правило, для цього використовується одна з шести команд, які перераховані далі: glGetBooleanv (), glGetDoubIev (), glGetFloatv (), glGetlntegerv (), glGetPointerv () або gIIsEnabled (). To, яку з цих команд слід вибрати, залежить від того, у вигляді якого типу даних ви хочете отримати відповідь. Для деяких змінних стану використовують більш конкретні команди запиту (такі як glGetLight * (), glGetError () або glGetPolygonStipple ()). Крім цього, можна зберегти набір змінних станів в стеку атрибутів за допомогою команд glPushAttrib () або gIPushCIientAttrib (), тимчасово змінити їх, а потім відновити значення цих змінних за допомогою команд glPopAttrib () або glPopClienlAttrib (). Для тимчасових змін стану необхідно використовувати саме ці команди, а не будь-які з команд запиту, тому що вони більш ефективні.

1.4. Конвеєр візуалізації OpenGL

1.4.1. Конвеєр

Більшість реалізацій бібліотеки OpenGL має однаковий порядок операцій, певну послідовність стадій обробки, яка називається конвеєром візуалізації OpenGL. Цей порядок функціонування, показаний на малюнку 1.2, не є строгим правилом реалізації бібліотеки OpenGL, проте він представляє собою надійне керівництво для передбачення результату роботи OpenGL.
Наступна діаграма демонструє концепцію складального конвеєра Генрі Форда, яку бібліотека OpenGL використовує для обробки даних. Геометричні дані (вершини, прямі і багатокутники) проходять через послідовність блоків, до числа яких входять обчислювачі та операції обробки вершин, в той час як піксельні дані (пікселі, зображення і растрові образи) для певної частини процесу візуалізації обробляються по-іншому. Обидва типи даних піддаються одним і тим же заключним операціях (операції растеризації та пофрагментной обробки), перш ніж підсумкові піксельні дані записуються в буфер кадру.

Рис. 1.2 Конвеєр візуалізації

1.4.2 Списки виведення

Всі дані, незалежно від того, описують вони геометрію або пікселі, можуть бути збережені у списку виводу для поточного або пізнішого використання. (Альтернативою збереження даних у списку висновку є негайна обробка даних, вона також відома під назвою безпосередній режим роботи.) Після того як список висновку був створений, збережені дані посилаються з цього списку висновку точно так само, як якщо б вони були послані прикладної програмою в безпосередньому режимі роботи.

1.4.3 Обчислювачі

Всі геометричні примітиви, в кінцевому рахунку, описуються вершинами. Параметричні криві і поверхні можуть бути першими описані контрольними точками і поліноміальними функціями, які називаються базовими функціями. Обчислювачі надають метод отримання вершин, використовуваний для представлення поверхні по контрольних точках. Таким методом є поліноміальний відображення, яке може формувати нормаль до поверхні, координати текстури, кольору і значення просторових координат по контрольним точкам.

1.4.4 Операції обробки вершин

Для даних по вершинах наступній є стадія "операцій обробки вершин", яка перетворює вершини в примітиви. Деякі типи даних по вершинах (наприклад, просторові координати) перетворюються в матриці чисел з плаваючою точкою розміром 4x4. Просторові координати проектуються з положення в тривимірному просторі в положення на вашому екрані.

void display (void)
/ * Очистити всі пікселі * /
glClear (GL_COLOR_BUFFER_BIT);
/ * Намалювати білий багатокутник (прямокутник) з кутами,
розташованими в точках з координатами (0.25, 0.25, 0.0)
і (0.75, 0.75, 0.0) * /
glColor3f (1.0, 1.0, 1.0); glBegin (GL_POLYGON);
glVertex3f (0.25, 0.25, 0.0);
glVertex3f (0.75, 0.25, 0.0);
glVertex3f (0.75, 0.75, 0.0);
glVertex3f (0.25, 0.75, 0.0); glEnd ();
/ * He чекати! Запустити обробку буферізірованний
* Підпрограм OpenGL * /
glFlushO;}
void init (void) {
/ * Встановити колір очищення (колір фону) * /
glClearColor (0.0, 0.0, 0.0, 0.0);
/ * Ініціалізувати Популярні значення * /
glMatrixMode (GL_PROJECTION);
glLoadldentity ();
glOrtho (0.0, 1.0, 0.0, 1.0, -1.0, 1.0);} / *
Оголосити початковий розмір вікна, його положення на екрані і режим відображення (одинарна буферизація і режим RGBA).
Відкрити вікно зі словом "hello" в рядку заголовка. Викликати підпрограми ініціалізації. Зареєструвати функцію зворотного виклику для відображення графіки. Увійти в основний цикл і обробляти події .* /
int main (int argc, char ** argv) {
glutInit (Sargc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (250, 250);
glutInitWindowPosition (100, 100);
glutCreateWindow ("hello");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0; / * Мова програмування С, згідно з ISO, вимагає, щоб функція main повертала значення типу int. * /}

2.3.4 Обробка подій введення даних користувачем

Для того щоб зареєструвати зворотний виклик команд, які викликаються в тому випадку, коли відбуваються зазначені події, можна скористатися наступними підпрограмами.
Підпрограма glutReshapeFunc (void (* func) (int w, int h)) вказує на те, яка саме дія повинна бути виконана при зміні розміру вікна.
Підпрограми glutKeyboardFunc (void (* / «wc) (unsigned char key, int x, int у)) іglutMouseFunc (void (* func) (int button, int state, int x, int у)) дозволяють зв'язувати певну клавішу клавіатури або кнопку миші з підпрограмою, яка викликається, коли дана клавіша або кнопка миші натискається або відпускається користувачем.
Підпрограма glutMotionFunc (void (* func) (int x, int у)) реєструє деяку підпрограму для зворотного виклику при переміщенні миші з натиснутою кнопкою.

2.3.5 Управління фоновим процесом

Можна визначити деяку функцію, яка повинна бути виконана за допомогою підпрограми glutIdleFunc (void (* / «nc) (void)) у тому випадку, якщо не очікуються
ніякі інші події, наприклад, коли цикл обробки подій в іншому випадку перейшов би в стан простою. Ця підпрограма в якості свого єдиного параметра приймає покажчик на дану функцію. Для того щоб відключити виконання цієї функції, передайте їй значення NULL (нуль).

2.3.6 Малювання тривимірних об'єктів

Бібліотека GLUT включає в себе кілька підпрограм для малювання перерахованих нижче тривимірних об'єктів:

Конус	Ікосаедр	Чайник
Куб	Октаедр	Тетраедр
Додекаедр	Сфера	Тор

Ви можете намалювати ці об'єкти у вигляді каркасних моделей або у вигляді суцільних зафарбованих об'єктів з певними нормалями до поверхонь. Наприклад, підпрограми для куба і сфери мають наступний синтаксис:
void glutWireCube (GLdouble size);
void glutSolidCube (GLdouble size);
void glutWireSphere (GLdouble radius, GLint slices, GLint stacks);
void glutSolidSphere (GLdouble radius, GLint slices, GLint stacks);
Всі ці моделі малюються центрованими щодо початку світової системи координат.

3. Анімація

3.1. Анімація комп'ютерної графіки

Одна з найбільш захоплюючих речей, яку ви можете зробити в області комп'ютерної графіки, - це малювання рухомих зображень. Незалежно від того, чи є ви інженером, які намагаються побачити всі сторони розробляється механічного вузла, пілотом, що вивчають з використанням моделювання процес пілотування літака, або ж просто пристрасним любителем комп'ютерних ігор, очевидно, що анімація є важливою складовою частиною комп'ютерної графіки.
У кінотеатрі ілюзія руху досягається за рахунок використання послідовності зображень і проектування їх на екран з частотою 24 кадру в секунду. Кожен кадр послідовно переміщається в положення позаду об'єктива, затвор відкривається, і даний кадр відображається на екрані. Затвор на мить закривається, в той час як плівка простягається до наступного кадру, потім на екрані відображається цей наступний кадр, і так далі. Хоча кожну секунду ви спостерігаєте на екрані 24 різні кадру, ваш мозок змішує всі ці кадри в "безперервну" анімацію. (Старі фільми Чарлі Чапліна знімалися з частотою 16 кадрів в секунду і при відтворенні фігури рухалися помітними різкими поштовхами.) Екран в комп'ютерній графіці зазвичай оновлюється (перемальовує зображення) приблизно від 60 до 76 разів на секунду, а іноді прикладні програми забезпечують навіть приблизно 120 оновлень в секунду. Очевидно, що анімація з частотою 60 кадрів в секунду виглядає більш "гладкої", ніж при частоті 30 кадрів в секунду, а 120
кадрів в секунду помітно краще, ніж 60 кадрів в секунду. Однак частоти регенерації, що перевищують 120 кадрів в секунду, можуть бути за межами точки зменшення повторної появи, залежно від меж сприйняття.
Основна причина того, що технологія проектування кінофільму працює, полягає в тому, що кожен кадр є закінченим у момент його відображення на екрані. Припустимо, що ви намагаєтеся зробити комп'ютерну анімацію зі свого кінофільму, що складається з одного мільйона кадрів, за допомогою програми, подібної наведеному нижче фрагменту псевдокоду:
відкрити вікно ();
for (i = 0; i <1000000; i + +) {
очистити вікно ();
нарісовать_кадр (i);
подождать_пока_не_закончится_интервал_в_1_24__долю_секунды ();)
Якщо ви додасте час, який потрібно вашої обчислювальної системи для того, щоб очистити екран і намалювати типовий кадр, то наведена вище програма показує все більш тривожні результати залежно від того, наскільки близько підходить час, необхідний їй для очищення екрана й промальовування кадру до 1 / 24 частці секунди. Припустимо, що процедура малювання в цій програмі майже повністю займає 1 / 24 частку секунди. Елементи, намальовані на самому початку, видимі протягом повної 1 / 24 частки секунди і представляють суцільне зображення на екрані; елементи, намальовані наприкінці розглянутого інтервалу, негайно очищаються, як тільки програма запускається для малювання наступного кадру. Вони являють собою в кращому разі щось на кшталт примарного зображення, оскільки більшу частину інтервалу в 1 / 24 секунди ваше око розглядає очищений фон замість тих елементів, які, на жаль, для них, були намальовані останніми. Проблема в даному випадку полягає в тому, що наведена вище програма не відображає повністю намальовані кадри; замість цього ви спостерігаєте процес малювання в його розвитку.
Більшість реалізацій бібліотеки OpenGL забезпечує подвійну буферизацію - апаратну або програмну, яка надає два готових буфера з кольоровими зображеннями. Зображення з одного буфера відображається на екрані, в той час як в іншому буфері малюється нове зображення. Коли малювання чергового кадру завершується, ці два буфери міняються місцями, і той буфер, що містив відображуване зображення, тепер використовується для малювання, і навпаки. Це схоже на роботу кінопроектора, плівка в якому містить всього два кадри і склеєна в пастку, в той час як один проектується на екран, кіномеханік відчайдушно стирає і перемальовує невидимий глядачеві кадр. Якщо кіномеханік працює досить швидко, то глядач не помічає різниці між таким "кінопроектором" і реальною системою, в якій всі кадри вже намальовані, і кінопроектор просто відображає їх один за іншим. При використанні подвійний буферизації кожен кадр відображається лише тоді, коли його малювання завершене; глядач ніколи не побачить частково намальованого кадру.
Псевдокод зміненої версії наведеної вище програми, яка відображає плавно анімовану графіку, використовуючи при цьому подвійну буферизацію, міг би виглядати наступним чином:
открыть_окно_в_режиме_двойной_буфериэации (); for (i = 0; i <1000000; i + +) {
очіс1іть_окно ();
нарісовать_кадр (i);
поменять_буфери_местамі ();}

3.2 Оновлення інформації, що відображається під час паузи

Для деяких реалізацій бібліотеки OpenGL на додаток до простої зміни місць відображуваного і малюється буферів, підпрограма поменять_буфери_местамі () очікує, поки не закінчиться поточний період оновлення інформації, що відображається для того, щоб інформація з попереднього буфера був відображена повністю. Ця підпрограма також дозволяє новому буферу бути повністю відображеним, починаючи з початку. Приймаючи, що ваша обчислювальна система забезпечує оновлення відображення 60 разів на секунду, отримаємо, що максимальна швидкість передачі кадрів, якою можна досягти - 60 кадрів в секунду (fps - frames per second). Це означає, що, якщо всі кадри можуть бути очищені і намальовані протягом 1 / 60 частки секунди, то ваша анімація при даній швидкості буде відтворюватися плавно.
У подібних системах часто буває так, що кадр виявляється занадто складним для того, щоб бути намальованим протягом 1 / 60 частки секунди, і, таким чином, кожен кадр відображається більше одного разу. Якщо, наприклад, потрібно 1 / 45 частка секунди для того, щоб намалювати деякий кадр, ви задаєте швидкість передачі кадрів дорівнює 30 fps, і тоді графічне зображення "простоює" протягом 1 / 30 - 1 / 45 = 1 / 90 частки секунди на кожен кадр, або третину всього часу відображення.
Крім того, частота відновлення відображається відеоінформації є постійною величиною, яка може мати деякі несподівані наслідки з точки зору продуктивності. Наприклад, при періоді оновлення інформації, яка відображається на моніторі, що дорівнює 1 / 60 частки секунди і при постійній швидкості передачі кадрів ви можете працювати зі швидкостями 60 fps, 30 fps, 20 fps, 15 fps, 12 fps і т. д. (60 / 1, 60 / 2, 60 / 3, 60 / 4, 60 / 5, і т. д.). Це означає, що якщо ви пишете прикладну програму і поступово додаєте до неї нові функціональні можливості (припустимо, що ця програма - імітатор польоту, і ви додаєте наземний пейзаж), то спочатку кожна нова додається деталь не буде надавати ніякого ефекту на сумарну продуктивність - ви все одно отримуєте швидкість передачі кадру, що дорівнює 60 fps. Потім, коли ви додаєте ще одну нову деталь, система вже не може намалювати все це протягом 1 / 60 частки секунди, і анімація різко сповільнюється - з 60 fps до 30 fps, оскільки вона пропускає перший можливий момент зміни буферів. Аналогічна ситуація відбувається, коли час малювання одного кадру стає більше, ніж 1 / 30 частка секунди - швидкість передачі кадрів анімації стрибком зменшується від 30 fps до 20 fps.
Якщо складність сцени така, що час її малювання виявляється близько до будь-якого з цих "чарівних" інтервалів часу (1 / 60 частка секунди, 2 / 60 частки секунди, 3 / 60 частки секунди і т. д. в розглянутому прикладі), то з -за наявності випадкової зміни деякі кадри будуть йти трохи швидше, а деякі - трохи повільніше. У результаті швидкість передачі кадрів стає непостійною, що візуально може бути неприємно. У цьому випадку, якщо ви не можете спростити сцену так,
щоб всі кадри малювалися досить швидко, можливо, краще було б навмисно додати крихітну затримку для того, щоб мати упевненість, що всі кадри пропущені, задаючи при цьому постійну, більш повільну швидкість передачі кадрів. Якщо ж кадри мають істотно відрізняється ступінь складності, тоді, можливо, вам буде потрібно більш складний підхід до вирішення цієї проблеми.
Рух = Перемальовування зображення + Перестановка буферів
Структура реальних програм анімації не надто відрізняється від наведеного опису. Зазвичай простіше перемальовувати буфер цілком з чистого листа для кожного кадру, ніж з'ясовувати, які частини кадру вимагають зміни. Це положення особливо справедливо для таких прикладних програм, як тривимірні імітатори польоту, де найменшу зміну орієнтації літака змінює позицію всього виду з вікна пілотської кабіни.
У більшості видів анімації об'єкти на сцені просто перемальовувався з різними перетвореннями: переміщається точка спостереження глядача або автомобіль трохи проїжджає по дорозі, або який-небудь об'єкт повертається на невеликий кут. Якщо для операцій, не пов'язаних з малюванням, потрібно істотний обсяг повторних обчислень, то досяжна швидкість передачі кадрів часто сповільнюється. Слід мати на увазі, однак, що для виконання таких обчислень після виконання підпрограми поменять_буфери_местамі () часто може використовуватися час простою.
Бібліотека OpenGL не має у своєму складі команди типу "поменять_буфери_-місцями ()", оскільки така функціональна можливість могла б бути доступна не для всіх апаратних засобів і, в будь-якому разі, її реалізація істотно залежить від використовуваної віконної системи. Наприклад, якщо ви використовуєте оболонку X Window System та звертаєтеся до неї безпосередньо, то можна було б скористатися наступною підпрограмою з бібліотеки GLX:
void glXSwapBuffers (Display * dpy, Window window);
(Еквівалентні підпрограми для інших віконних систем наведені в Додатку С.)
Якщо ви використовуєте бібліотеку GLUT, то ви, можливо, захочете викликати наступну підпрограму:
void glutSwapBuffers (void);
Приклад 3 ілюструє використання підпрограми glutSwapBuffers () для малювання обертового квадрата, як це показано на малюнку 3. Цей приклад також демонструє те, як слід використовувати бібліотеку GLUT для контролю стану пристрої введення даних, а також для включення і виключення функції простою. У наведеному прикладі кнопки миші включають і відключають обертання квадрата.

Приклад 3 Програма з використанням подвійної буферизації: double.c
# Include <stdlib.h> # include <GL/glut.h>
static GLfloat spin = 0.0;
void init (void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);} void display (void)
{
glClear (GL_COLOR_BUFFER_BIT);
glPushMatrix ();
glRotatef (spin, 0.0, 0.0, 1.0);
glColor3f (1.0, 1.0, 1.0);
glRectf (-25.0, -25.0, 25.0, 25.0);
glPopMatrix ();
glutSwapBuffers ();)
void spinDisplay (void)
{
spin = spin +2.0;
if (spin> 360.0)
spin = spin - 360.0;
glutPostRedisplay ();}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadldentity ();
glOrtho (-50.0, 50.0, -50.0, 50.0, -1.0, 1.0);
glMatrixMode (GL_MODELVIEW);
glLoadldentity ();
void mouse (int button, int state, int x, int y) {
switch (button) {
case GLUT_LEFT_BUTTON:
if (state == GLUT_DOWN)
glutldleFunc (spinDisplay); break; case GLUT_MIDDLE_BUTTON:
if (state == GLUT_DOWN)
glutldleFunc (NULL); break; default:
break;}}
/ *
Запросити режим відображення з подвійною буферизацией.
Зареєструвати функції зворотного виклику з введення даних від миші * /
int main (int argc, char ** argv) {
glutlnit (Sargc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
glutInitWindowSize (250, 250);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv [0]);
init <);
glutDisplayFunc (display);
glutReshapeFunc (reshape);
glutMouseFunc (mouse);
glutMainLoop ();
return 0;}
Приклад програми, написаної на C, з застосуванням OpenGL.
Програма візуалізує обертається куб. На куб накладені текстури, можливе включення альфа-прозорості під час візуалізації.
# Include <GL/glut.h>
# Include <GL/glaux.h>
# Include <GL/glu.h>
int tex [1];
float xtr, ytr, ztr;
float rotx, roty, rotz;
float LightAmbient [] = {0.5f, 0.5f, 0.5f, 1.0f};
float LightPosition [] = {0.0f, 0.0f, 5.0f, 1.0f}; / / позиція освітлення
float LightDiffuse [] = {1.0f, 1.0f, 1.0f, 1.0f}; / / розсіювання
void LoadTexs () / / ініціалізація і завантаження текстур
{
AUX_RGBImageRec * tex1;
tex1 = auxDIBImageLoad ("droy.bmp");
glGenTextures (1, & tex [0]);
glBindTexture (GL_TEXTURE_2D, tex [0]);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D (GL_TEXTURE_2D, 0, 3, tex1-> sizeX, tex1-> sizeY, 0,
GL_RGB, GL_UNSIGNED_BYTE, tex1-> data);
}
void init ()
{
LoadTexs ();// процедура завантаження текстури
glColor4f (1.0f, 1.0f, 1.0f, 0.5f);
glBlendFunc (GL_SRC_ALPHA, GL_ONE); / / параметри змішування
glEnable (GL_TEXTURE_2D);
glClearColor (0.0, 0.0, 0.0, 0.0); / / колір фону
glClearDepth (1.0);
glDepthFunc (GL_LESS);
glEnable (GL_DEPTH_TEST); / / тест глибини
glShadeModel (GL_SMOOTH);
glTranslatef (0.0f, 0.0f,-5.0f);
glLightfv (GL_LIGHT1, GL_AMBIENT, LightAmbient); / / параметри освітлення
glLightfv (GL_LIGHT1, GL_POSITION, LightPosition);
glLightfv (GL_LIGHT1, GL_DIFFUSE, LightDiffuse);
glEnable (GL_LIGHT1); / / освітлення
glEnable (GL_LIGHTING);
glEnable (GL_COLOR_MATERIAL);
glColorMaterial (GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
}
void display (void)
{
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); / / очищення буфера глибини
glPushMatrix ();// збереження матриці
glTranslatef (xtr, ytr, ztr);
glRotatef (rotx, 1.0,0.0,0.0);
glRotatef (roty, 0.0,1.0,0.0);
glRotatef (rotz, 0.0,0.0,1.0);
glBegin (GL_QUADS);
glNormal3f (0.0f, 0.0f, 1.0f); / / Передня грань
glTexCoord2f (0.0f, 0.0f); glVertex3f (-1.0f,-1.0f, 1.0f); / / Низ ліво
glTexCoord2f (1.0f, 0.0f); glVertex3f (1.0f,-1.0f, 1.0f); / / Низ право
glTexCoord2f (1.0f, 1.0f); glVertex3f (1.0f, 1.0f, 1.0f); / / Верх право
glTexCoord2f (0.0f, 1.0f); glVertex3f (-1.0f, 1.0f, 1.0f); / / Верх ліво
glNormal3f (0.0f, 0.0f,-1.0f); / / Задня грань
glTexCoord2f (1.0f, 0.0f); glVertex3f (-1.0f,-1.0f,-1.0f); / / Низ право
glTexCoord2f (1.0f, 1.0f); glVertex3f (-1.0f, 1.0f,-1.0f); / / Верх право
glTexCoord2f (0.0f, 1.0f); glVertex3f (1.0f, 1.0f,-1.0f); / / Верх ліво
glTexCoord2f (0.0f, 0.0f); glVertex3f (1.0f,-1.0f,-1.0f); / / Низ ліво
glNormal3f (0.0f, 1.0f, 0.0f); / / Верхня межа
glTexCoord2f (0.0f, 1.0f); glVertex3f (-1.0f, 1.0f,-1.0f); / / Верх ліво
glTexCoord2f (0.0f, 0.0f); glVertex3f (-1.0f, 1.0f, 1.0f); / / Низ ліво
glTexCoord2f (1.0f, 0.0f); glVertex3f (1.0f, 1.0f, 1.0f); / / Низ право
glTexCoord2f (1.0f, 1.0f); glVertex3f (1.0f, 1.0f,-1.0f); / / Верх право
glNormal3f (0.0f,-1.0f, 0.0f); / / Нижня межа
glTexCoord2f (1.0f, 1.0f); glVertex3f (-1.0f,-1.0f,-1.0f); / / Верх право
glTexCoord2f (0.0f, 1.0f); glVertex3f (1.0f,-1.0f,-1.0f); / / Верх ліво
glTexCoord2f (0.0f, 0.0f); glVertex3f (1.0f,-1.0f, 1.0f); / / Низ ліво
glTexCoord2f (1.0f, 0.0f); glVertex3f (-1.0f,-1.0f, 1.0f); / / Низ право
glNormal3f (1.0f, 0.0f, 0.0f); / / Права грань
glTexCoord2f (1.0f, 0.0f); glVertex3f (1.0f,-1.0f,-1.0f); / / Низ право
glTexCoord2f (1.0f, 1.0f); glVertex3f (1.0f, 1.0f,-1.0f); / / Верх право
glTexCoord2f (0.0f, 1.0f); glVertex3f (1.0f, 1.0f, 1.0f); / / Верх ліво
glTexCoord2f (0.0f, 0.0f); glVertex3f (1.0f,-1.0f, 1.0f); / / Низ ліво
glNormal3f (-1.0f, 0.0f, 0.0f); / / Ліва грань
glTexCoord2f (0.0f, 0.0f); glVertex3f (-1.0f,-1.0f,-1.0f); / / Низ ліво
glTexCoord2f (1.0f, 0.0f); glVertex3f (-1.0f,-1.0f, 1.0f); / / Низ право
glTexCoord2f (1.0f, 1.0f); glVertex3f (-1.0f, 1.0f, 1.0f); / / Верх право
glTexCoord2f (0.0f, 1.0f); glVertex3f (-1.0f, 1.0f,-1.0f); / / Верх ліво
glEnd ();
glPopMatrix ();// виклик матриці
rotx + = 0.2; / / обертання по осі Х
roty + = 0.1; / / обертання по осі Y
rotz + = 0.3; / / обертання по осі Z
glutSwapBuffers ();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluPerspective (60.0, (GLfloat) w / (GLfloat) h, 1.0, 20.0); / / параметри перспективи
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
gluLookAt (0.0, 1.5, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0); / / точка камери
}
void keyboard (unsigned char key, int x, int y) / / обробник клавіатури
{
switch (key) {
case 27:
exit (0);
break;
case 'e':
glEnable (GL_BLEND); / / застосування альфа-змішування
break;
case 'd':
glDisable (GL_BLEND); / / відключення альфасмешіванія
break;
}
}
int main (int argc, char ** argv)
{
glutInit (& argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH); / / режим екрану
glutInitWindowPosition (0, 0); / / позиція вікна
glutCreateWindow ("DroY Cube (c) 2003 Press 'ESC' to exit");
init ();
glutFullScreen ();// повноекранний режим
glutDisplayFunc (display);
glutReshapeFunc (reshape);
glutKeyboardFunc (keyboard);
glutIdleFunc (display);
glutMainLoop ();
return 0;
}

Список використаної літератури.

1. "Інтерактивна комп'ютерна графіка. Вступний курс на базі OpenGL", Едвард Ейнджел.
2. OpenGL. Офіційне керівництво програміста Ву Мейсон, Нейдер Джекі, Девіс Том, Шрайнер Дейв
3. Тарасов І.А. «Основи програмування OpenGL: навчальний курс».
4. Тихомиров Ю. «Програмування тривимірної графіки».
5. http://www.gamedev.ru Основи OpenGL