Знакомство с OpenGL нужно начать с того, что OpenGL - это спецификация . Т.е. OpenGL лишь определяет набор обязательных возможностей. Реализация же зависит от конкретной платформы.
OpenGL является кроссплатформенным, независимым от языка программирования API для работы с графикой. OpenGL - низкоуровневый API, поэтому для работы с ним неплохо иметь некоторое представление о графике в целом и знать основы линейной алгебры.

Именования

Скажем пару слов об именовании функций в OpenGL. Во-первых имена всех функций, предоставляемых непосредственно OpenGL, начинаются с приставки gl . Во-вторых функции, задающие некоторый параметр, характеризующийся набором чисел (например координату или цвет), имеют суффикс вида [число параметров + тип параметров + представление параметров].

• Число параметров - указывает число принимаемых параметров. Принимает следующие значения: 1 , 2 , 3 , 4
• Тип параметров - указывает тип принимаемых параметров. Возможны следующие значения: b , s , i , f , d , ub , us , ui . Т.е. byte (char в C, 8-битное целое число), short (16-битное целое число), int (32-битное целое число), float (число с плавающей запятой), double (число с плавающей запятой двойной точности), unsigned byte, unsigned short, unsigned int (последние три - беззнаковые целые числа)
• Представление параметров - указывает в каком виде передаются параметры, если каждое число по отдельности, то ничего не пишется, если же параметры передаются в виде массива, то к названию функции дописывается буква v

Пример: glVertex3iv задает координату вершины, состоящую из трех целых чисел, передаваемых в виде указателя на массив.

Графика

Все графические объекты в OpenGL представляют собой набор точек, линий и многоугольников. Существует 10 различных примитивов, при помощи которых строятся все объекты. Как двухмерные, так и трехмерные. Все примитивы в свою очередь задаются точками - вершинами.

• GL_POINTS - каждая вершина задает точку
• GL_LINES - каждая отдельная пара вершин задает линию
• GL_LINE_STRIP - каждая пара вершин задает линию (т.е. конец предыдущей линии является началом следующей)
• GL_LINE_LOOP - аналогично предыдущему за исключением того, что последняя вершина соединяется с первой и получается замкнутая фигура
• GL_TRIANGLES - каждая отдельная тройка вершин задает треугольник
• GL_TRIANGLE_STRIP - каждая следующая вершина задает треугольник вместе с двумя предыдущими (получается лента из треугольников)
• GL_TRIANGLE_FAN - каждый треугольник задается первой вершиной и последующими парами (т.е. треугольники строятся вокруг первой вершины, образуя нечто похожее на диафрагму)
• GL_QUADS - каждые четыре вершины образуют четырехугольник
• GL_QUAD_STRIP - каждая следующая пара вершин образует четырехугольник вместе с парой предыдущих
• GL_POLYGON - задает многоугольник с количеством углов равным количеству заданных вершин

Для задания примитива используется конструкция glBegin (тип_примитива)…glEnd () . Вершины задаются glVertex* . Вершины задаются против часовой стрелки. Координаты задаются от верхнего левого угла окна. Цвет вершины задается командой glColor* . Цвет задается в виде RGB или RGBA. Команда glColor* действует на все вершины, что идут после до тех пор, пока не встретится другая команда glColor* или же на все, если других команд glColor* нет.
Вот код рисующий квадрат с разноцветными вершинами:

1. glBegin(GL_QUADS) ;
2. glVertex2i(250 , 450 ) ;
3. glVertex2i(250 , 150 ) ;
4. glVertex2i(550 , 150 ) ;
5. glVertex2i(550 , 450 ) ;
6. glEnd() ;

Основы программы на OpenGL

Для платформонезависимой работы с окнами можно использовать библиотеку . GLUT упрощает работу с OpenGL.
Для инициализации GLUT в начале программы надо вызвать glutInit (&argc, argv) . Для задания режима дисплея вызывается glutInitDisplayMode (режим) , где режим может принимать следующие значения:

• GLUT_RGBA - включает четырехкомпонентный цвет (используется по умолчанию)
• GLUT_RGB - то же, что и GLUT_RGBA
• GLUT_INDEX - включает индексированный цвет
• GLUT_DOUBLE - включает двойной экранный буфер
• GLUT_SINGLE - включает одиночный экранный буфер (по умолчанию)
• GLUT_DEPTH - включает Z-буфер (буфер глубины)
• GLUT_STENCIL - включает трафаретный буфер
• GLUT_ACCUM - включает буфер накопления
• GLUT_ALPHA - включает альфа-смешивание (прозрачность)
• GLUT_MULTISAMPLE - включает мультисемплинг (сглаживание)
• GLUT_STEREO - включает стерео-изображение

Для выбора нескольких режимов одновременно нужно использовать побитовое ИЛИ "|". Например: glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGBA|GLUT_DEPTH) включает двойную буферизацию, Z-буфер и четырехкомпонентный цвет. Размеры окна задаются glutInitWindowSize (ширина, высота) . Его позиция - glutInitWindowPosition (х, у) . Создается окно функцией glutCreateWindow (заголовок_окна) .
GLUT реализует событийно-управляемый механизм. Т.е. есть главный цикл, который запускается после инициализации, и в нем уже обрабатываются все объявленные события. Например нажатие клавиши на клавиатуре или движение курсора мыши и т.д. Зарегистрировать функции-обработчики событий можно при помощи следующих команд:

• void glutDisplayFunc (void (*func) (void)) - задает функцию рисования изображения
• void glutReshapeFunc (void (*func) (int width, int height)) - задает функцию обработки изменения размеров окна
• void glutVisibilityFunc (void (*func)(int state)) - задает функцию обработки изменения состояния видимости окна
• void glutKeyboardFunc (void (*func)(unsigned char key, int x, int y)) - задает функцию обработки нажатия клавиш клавиатуры (только тех, что генерируют ascii-символы)
• void glutSpecialFunc (void (*func)(int key, int x, int y)) - задает функцию обработки нажатия клавиш клавиатуры (тех, что не генерируют ascii-символы)
• void glutIdleFunc (void (*func) (void)) - задает функцию, вызываемую при отсутствии других событий
• void glutMouseFunc (void (*func) (int button, int state, int x, int y)) - задает функцию, обрабатывающую команды мыши
• void glutMotionFunc (void (*func)(int x, int y)) - задает функцию, обрабатывающую движение курсора мыши, когда зажата какая-либо кнопка мыши
• void glutPassiveMotionFunc (void (*func)(int x, int y)) - задает функцию, обрабатывающую движение курсора мыши, когда не зажато ни одной кнопки мыши
• void glutEntryFunc (void (*func)(int state)) - задает функцию, обрабатывающую движение курсора за пределы окна и его возвращение
• void glutTimerFunc (unsigned int msecs, void (*func)(int value), value) - задает функцию, вызываемую по таймеру

Затем можно запускать главный цикл glutMainLoop () .

Первая программа

Теперь мы знаем основы работы с OpenGL. Можно написать простую программу для закрепления знаний.
Начнем с того, что нужно подключить заголовочный файл GLUT:

Теперь мы уже знаем, что писать в main. Зарегистрируем два обработчика: для рисования содержимого окна и обработки изменения его размеров. Эти два обработчика по сути используются в любой программе, использующей OpenGL и GLUT.

1. int main (int argc, char * argv )
2. glutInit(& argc, argv) ;
3. glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*Включаем двойную буферизацию и четырехкомпонентный цвет*/
4. glutInitWindowSize(800 , 600 ) ;
5. glutCreateWindow(«OpenGL lesson 1» ) ;
6. glutReshapeFunc(reshape) ;
7. glutDisplayFunc(display) ;
8. glutMainLoop() ;
9. return 0 ;

Теперь надо написать функцию-обработчик изменений размеров окна. Зададим область вывода изображения размером со все окно при помощи команды glViewport (х, у, ширина, высота) . Затем загрузим матрицу проекции glMatrixMode (GL_PROJECTION) , заменим ее единичной glLoadIdentity () и установим ортогональную проекцию. И наконец загрузим модельно-видовую матрицу glMatrixMode (GL_MODELVIEW) и заменим ее единичной.
В итоге получим:

1. void reshape(int w, int h)
2. glViewport(0 , 0 , w, h) ;
3. glMatrixMode(GL_PROJECTION) ;
4. glLoadIdentity() ;
5. gluOrtho2D(0 , w, 0 , h) ;
6. glMatrixMode(GL_MODELVIEW) ;
7. glLoadIdentity() ;

Осталось только написать функцию рисования содержимого окна. Рисовать будем тот квадрат, что я приводил выше в качестве примера. Добавить придется совсем немного кода. Во-первых перед рисованием надо очистить различные буфера при помощи glClear (режим) . Используется также как и glutInitDisplayMode. Возможные значения:

• GL_COLOR_BUFFER_BIT - для очистки буфера цвета
• GL_DEPTH_BUFFER_BIT - для очистки буфера глубины
• GL_ACCUM_BUFFER_BIT - для очистки буфера накопления
• GL_STENCIL_BUFFER_BIT - для очистки трафаретного буфера

В нашем случае нужно очистить только буфер цвета, т.к. другие мы не используем. Во-вторых после рисования нужно попросить OpenGL сменить экранные буфера при помощи glutSwapBuffers () , ведь у нас включена двойная буферизация. Все рисуется на скрытом от пользователя буфере и затем происходит смена буферов. Делается это для получения плавной анимации и для того, чтобы не было эффекта мерцания экрана.
Получаем:

1. void display()
2. glClear(GL_COLOR_BUFFER_BIT) ;
3. glBegin(GL_QUADS) ;
4. glColor3f(1.0 , 1.0 , 1.0 ) ;
5. glVertex2i(250 , 450 ) ;
6. glColor3f(0.0 , 0.0 , 1.0 ) ;
7. glVertex2i(250 , 150 ) ;
8. glColor3f(0.0 , 1.0 , 0.0 ) ;
9. glVertex2i(550 , 150 ) ;
10. glColor3f(1.0 , 0.0 , 0.0 ) ;
11. glVertex2i(550 , 450 ) ;
12. glEnd() ;
13. glutSwapBuffers() ;

Итог

Все! Можно компилировать. Должно получиться что-то вроде этого:

ВВЕДЕНИЕ

OpenGL является одним из самых популярных прикладных программных интерфейсов (API - Application Programming Interface) для разработки приложений в области двумерной и трехмерной графики.

Стандарт OpenGL (Open Graphics Library - открытая графическая библиотека) был разработан и утвержден в 1992 году ведущими фирмами в области разработки программного обеспечения как эффективный аппаратно-независимый интерфейс, пригодный для реализации на различных платформах. Основой стандарта стала библиотека IRIS GL, разработанная фирмой Silicon Graphics Inc.

Библиотека насчитывает около 120 различных команд, которые программист использует для задания объектов и операций, необходимых для написания интерактивных графических приложений.

На сегодняшний день графическая система OpenGL поддерживается большинством производителей аппаратных и программных платформ. Эта система доступна тем, кто работает в среде Windows, пользователям компьютеров Apple. Свободно распространяемые коды системы Mesa (пакет API на базе OpenGL) можно компилировать в большинстве операционных систем, в том числе в Linux.

Характерными особенностями OpenGL, которые обеспечили распространение и развитие этого графического стандарта, являются:

Стабильность. Дополнения и изменения в стандарте реализуются таким образом, чтобы сохранить совместимость с разработанным ранее программным обеспечением.

Надежность и переносимость. Приложения, использующие OpenGL, гарантируют одинаковый визуальный результат вне зависимости от типа используемой операционной системы и организации отображения информации. Кроме того, эти приложения могут выполняться как на персональных компьютерах, так и на рабочих станциях и суперкомпьютерах.

Легкость применения. Стандарт OpenGL имеет продуманную структуру и интуитивно понятный интерфейс, что позволяет с меньшими затратами создавать эффективные приложения, содержащие меньше строк кода, чем с использованием других графических библиотек. Необходимые функции для обеспечения совместимости с различным оборудованием реализованы на уровне библиотеки и значительно упрощают разработку приложений.

Наличие хорошего базового пакета для работы с трехмерными приложениями упрощает понимание студентами ключевых тем курса компьютерной графики - моделирование трехмерных объектов, закрашивание, текстурирование, анимацию и т.д. Широкие функциональные возможности OpenGL служат хорошим фундаментом для изложения теоретических и практических аспектов предмета.

ПРОГРАММИРОВАНИЕ С ИСПОЛЬЗОВАНИЕМ БИБЛИОТЕКИ OPENGL

Назначение и возможности библиотеки OpenGL

Для упрощения разработки программ на языке Си++ существует большое количество готовых библиотек с реализацией алгоритмов для конкретных предметных областей, от численных расчетов до распознавания речи. Библиотека OpenGL является одним из самых популярных программных интерфейсов (API) для работы с трехмерной графикой. Стандарт OpenGL был утвержден в 1992 г. ведущими фирмами в области разработки программного обеспечения. Его основой стала библиотека IRIS GL, разработанная фирмой Silicon Graphics на базе концепции графической машины Стэнфордского университета (1982 г.).

OpenGL переводится как Открытая Графическая Библиотека (Open Graphics Library). Программы, использующие OpenGL, гарантируют одинаковый визуальный результат во многих операционных системах - на персональных компьютерах, на рабочих станциях и на суперкомпьютерах.

С точки зрения программиста, OpenGL - это программный интерфейс для графических устройств (например, графических ускорителей). Он включает в себя около 150 различных функций, с помощью которых программист может задавать свойства различных трехмерных и двумерных объектов и выполнять их визуализацию (рендеринг). Т.е. в программе надо задать местоположение объектов в трехмерном пространстве, определить другие параметры (поворот, растяжение), задать свойства объектов (цвет, текстура, материал и т.д.), положение наблюдателя, а затем библиотека OpenGL выполнит генерацию двумерной проекции этой трехмерной сцены.

Можно сказать, что библиотека OpenGL является библиотекой только для визуализации трехмерных сцен (rendering library). Она не поддерживает какие либо периферийные устройства (например, клавиатуру или мышь) и не содержит средств для управления экранными окнами. Обеспечение взаимодействия периферийных устройств с библиотекой OpenGL в конкретной операционной системе является задачей программиста.

Основные возможности OpenGL, предоставляемые программисту, можно разделить на несколько групп:

1. Геометрические и растровые примитивы. На основе этих примитивов строятся все остальные объекты. Геометрические примитивы - это точки, отрезки и многоугольники. Растровыми примитивами являются битовые массивы и изображения.

2. Сплайны. Сплайны применяются для построения гладких кривых по опорным точкам.

3. Видовые и модельные преобразования. Эти преобразования позволяют задавать пространственное расположение объектов, изменять форму объектов и задавать положение камеры, для которой OpenGL строит результирующее проекционное изображение.

4. Работа с цветом. Для операций с цветом в OpenGL есть режим RGBA (красный - зелёный - синий - прозрачность) и индексный режим (цвет задается порядковым номером в палитре).

5. Удаление невидимых линий и поверхностей.

6. Двойная буферизация. В OpenGL доступна и одинарная, и двойная буферизация. Двойная буферизация применяется для устранения мерцания при мультипликации. При этом изображение каждого кадра сначала рисуется в невидимом буфере, а на экран кадр копируется только после того, как полностью нарисован.

7. Наложение текстуры. Текстуры упрощают создание реалистичных сцен. Если на объект, например, сферу, наложить текстуру (некоторое изображение), то объект будет выглядеть иначе (например, сфера будет выглядеть как разноцветный мячик).

8. Сглаживание. Автоматическое сглаживание компенсирует ступенчатость, свойственную растровым дисплеям. При сглаживании отрезков OpenGL изменяет интенсивность и цвет пикселей так, что эти отрезки отображаются на экране без зигзагов".

9. Освещение. Указание расположения, интенсивности и цвета источников света.

10. Специальные эффекты. Например, туман, дым, прозрачность объектов. Эти средства позволяют сделать сцены более реалистичными.

Хотя библиотека OpenGL предоставляет практически все возможности для моделирования и воспроизведения трёхмерных сцен, некоторые графические функции непосредственно в OpenGL недоступны. Например, чтобы задать положение и направление камеры для наблюдения сцены придется рассчитывать проекционную матрицу, что сопряжено с достаточно громоздкими вычислениями. Поэтому для OpenGL существуют так называемые вспомогательные библиотеки.

Одна из этих библиотек называется GLU. Эта библиотека является частью стандарта и поставляется вместе с главной библиотекой OpenGL. В состав GLU входят более сложные функции (например, для создания цилиндра или диска требуется всего одна команда). В библиотеке GLU есть также функции для работы со сплайнами, реализованы дополнительные операции над матрицами и дополнительные виды проекций.

Еще две известные библиотеки - GLUT (для Unix) и GLAUX (для MS Windows). В них реализованы не только дополнительные функции OpenGL (для построения некоторых сложных фигур вроде конуса и тетраэдра), но также есть функции для работы с окнами, клавиатурой и мышью в консольных приложениях. Чтобы работать с OpenGL в конкретной операционной системе (например, Windows или Unix), надо провести некоторую предварительную настройку, которая зависит от операционной системы. GLUT и GLAUX позволяют буквально несколькими командами определить окно, в котором будет работать OpenGL, задать функции для обработки команд от клавиатуры или мыши.

Возможности OpenGL описаны через функции его библиотеки. Все функции можно разделить на пять категорий.

Функции описания примитивов определяют объекты нижнего уровня иерархии (примитивы), которые способна отображать графическая подсистема. В OpenGL в качестве примитивов выступают точки, линии, многоугольники и т.д.

Функции описания источников света служат для описания положения и параметров источников света, расположенных в трехмерной сцене.

Функции задания атрибутов. С помощью задания атрибутов программист определяет, как будут выглядеть на экране отображаемые объекты. Другими словами, если с помощью примитивов определяется, что появится на экране, то атрибуты определяют способ вывода на экран. В качестве атрибутов OpenGL позволяет задавать цвет, характеристики материала, текстуры, параметры освещения.

Функции визуализации позволяет задать положение наблюдателя в виртуальном пространстве, параметры объектива камеры. Зная эти параметры, система сможет не только правильно построить изображение, но и отсечь объекты, оказавшиеся вне поля зрения.

Набор функций геометрических преобразований позволяют программисту выполнять различные преобразования объектов - поворот, перенос, масштабирование.

При этом OpenGL может выполнять дополнительные операции, такие как использование сплайнов для построения линий и поверхностей, удаление невидимых фрагментов изображений, работа с изображениями на уровне пикселей и т.д.

В этой главе рассмотрим рендеринг трехмерной графики с помощью библиотеки OpenGL, изучим библиотеки GLU и GLUT (вместо последней иод Linux используется библиотека FreeGLUT), разберем процесс загрузки текстур с помощью библиотек SOIL и DevIL.

Как уже отмечалось в гл. 9, программисты графики обычно не работают напрямую с GPU. Это связано как с тем, что существует много различных GPU, так и с тем, что низкоуровневая работа с GPU довольно сложна и обычно ею занимаются разработчики драйверов. Вместо этого используют различные API, предоставляющие некоторый интерфейс более высокого уровня для работы с GPU. Этот интерфейс абстрагируется от конкретного GPU (вся работа с которым идет через драйвер, обычно поставляемый производителем GPU), что позволяет писать переносимый код, который будет работать с различными GPU. Также подобный API скрывает от программиста ряд низкоуровневых деталей работы с GPU.

Основными API для программирования трехмерной графики на данный момент являются OpenGL и Dircct3D. Последний ориентирован только на платформу Microsoft Windows. В этой книге рассмотрены основы работы с OpenGL. Это кроссплатформен- ный API, поддерживающий все основные операционные системы (Windows, Linux, Mac OS X) и позволяющий работать с большим количеством различных GPU.

Существует версия API - OpenGL ES, предназначенная для работы на мобильных устройствах. С ее помощью можно делать трехмерную графику для платформ iOS и Android. Кроме того, существует WebGL - библиотека, позволяющая использовать OpenGL ES прямо в окне браузера, применяя для этого javascript. Также существуют привязки для OpenGL, позволяющие работать со всеми основными языками программирования, благодаря чему можно легко использовать OpenGL практически из любого языка программирования.

Основная задача OpenGL - рендеринг двух- и трехмерной графики. При этом данный API вообще не занимается созданием окон для рендеринга, чтением ввода от пользователя и другой подобной и сильно зависящей от конкретной операционной системы работы, поэтому мы будем для этих целей использовать кроссплатформен- ную библиотеку GLUT. Данная библиотека предоставляет простой и удобный способ для создания окон, рендеринга в них посредством OpenGL и получения сообщений от мыши и клавиатуры.

С точки зрения архитектуры OpenGL построен на модели клиент-сервер. При этом сама программа, использующая OpenGL, выступает в роли клиента, a GPU и его драйвер - в роли сервера. Обычно программа выполняется на том же компьютере, где установлен GPU, но это не обязательно.

На практике все выполняемые команды OpenGL буферизуются и уже потом поступают в очередь для передачи на GPU. Таким образом, выполнение CPU команды говорит только о том, что данная команда попала в буфер или была добавлена в очередь; вполне возможно, что GPU ее еще не начал выполнять. В то же время OpenGL можно рассматривать как конечный автомат - у него есть свое состояние. Единственный способ изменить это состояние - использовать команды OpenGL. Между командами состояние OpenGL не изменяется.

Важным понятием в OpenGL являются буферы (рис. 10.1). Для того чтобы осуществлять рендеринг, должны быть созданы необходимые буферы. Буфер цвета используется всегда и для каждого пиксела хранит его цвет как 24-битовое число в формате RGB (по 8 бит на каждый из базовых цветов - красный, зеленый и синий) или как 32-битовое в формате RGBA (к стандартным трем компонентам добавляется четвертая компонента - альфа, задающая непрозрачность).

При использовании метода г-буфера для удаления невидимых поверхностей нужно для каждого пиксела хранить соответствующее ему значение глубины (обычно значение глубины хранится как 16-, 24- и 32-битовое целое число). Соответственно, все значения глубины, взятые вместе, образуют буфер глубины. Также можно использовать буфер трафарета , буфер накопления.

При создании окна, куда будет производиться рендеринг, необходимо создать контекст OpenGL и соответствующие буферы. Сам контекст обычно привязан к текущей нити, поэтому если в приложении используются несколько нитей, то созданный контекст в действительности можно использовать только из той нити, где он был создан.

Обработка данных в OpenGL основана на конвейере рендеринга (см. рис. 9.1). Конвейер определяет основные стадии обработки поступающих данных. Как именно данные будут обрабатываться, зависит от параметров состояния OpenGL, но сами эти стадии и порядок их прохождения строго зафиксированы.

Рис. 10.1.

Для современных GPU две части этого конвейера представлены с помощью программ, выполняющихся на GPU, - шейдеров. Далее будем рассматривать OpenGL версии 2, в которой эти программы необязательно задавать явно: существуют шейдеры, которые работают по умолчанию (г.е. в случае, когда программист явно не задал соответствующие шейдеры). Начиная с версии 3, OpenGL требует обязательного задания шейдеров и частично нарушает совместимость с предыдущими версиями, именно поэтому мы будем рассматривать версию OpenGL 2.

Геометрия задается как набор вершин, образующих различные примитивы (точки, отрезки, треугольники). В каждой вершине помимо ее координат можно задать также ряд дополнительных атрибутов, таких как цвет, нормаль, текстурные координаты. Данные в каждой вершине поступают на вход вершинного шейдера: для каждой вершины выполняется вершинный шейдер и генерирует некоторые выходные значения. Обязательным выходным значением являются однородные координаты вершины после выполнения всех преобразований.

OpenGL использует матрицы 4x4 для преобразования вершин - модельно-видовую матрицу проектирования (рис. 10.2). Если вершинный шейдер не задан явно, то используется вершинный шейдер по умолчанию, который умножает координаты вершины (в виде вектора в однородных координатах) сначала на модельновидовую матрицу, а затем - на матрицу проектирования.

После этого происходит сборка примитивов и их отсечение: все части каждого примитива, выходящие за пределы видимой области {viewing frustum) автоматически обрезаются так, что на следующую стадию конвейера переходят примитивы, полностью содержащиеся внутри области видимости. Далее фиксированная часть конвейера выполняет перспективное деление - вектор в однородных координатах делится на свою четвертую компоненту.

Рис. 10.2.

Если изначально координаты были заданы в своей системе координат, то умножение на модельно-видовую матрицу переводит их в систему координат камеры. Далее умножение на матрицу проектирования приводит координаты в пространство отсечения (clip space). После выполнения перспективного деления получаем нормализованные координаты устройства (normalized device coordinates).

Заключительный шаг - перевод нормализованных координат в координаты в окне, выражаемые в пикселах.

Перед перспективным делением происходит сборка примитивов и последующее отсечение: все, что не попадает в область видимости, отсекается. Далее каждый примитив растеризуется, т.е. переводится в набор фрагментов. Ряд значений, заданных в вершинах, интерполируется, и каждый фрагмент получает соответствующее ему значение. После этого для каждого фрагмента выполняется фрагментный шейдер, задачей которого является вычисление цвета для каждого фрагмента. При этом используются интерполированные значения, возможно обращение к текстурам - заранее подготовленным изображениям, которые накладываются на выводимые примитивы. Отметим, что у каждого фрагмента есть свои координаты на экране и полученное путем интерполяции значение глубины г. Также фрагментный шейдер вместо вычисления цвета фрагмента может явно отбросить весь фрагмент.

На следующем шаге конвейера для каждого фрагмента выполняется группа проверок, каждая из которых может отбросить данный фрагмент. Первая из этих проверок изучает, соответствует ли данный пиксел видимой части окна. Если нет, то этот фрагмент сразу же отбрасывается. Следующий тест проверяет, содержится ли фрагмент внутри заданного прямоугольника (в координатах окна). Также есть тесты трафарета и глубины. Тест трафарета извлекает из буфера трафарета группу битов, соответствующих данному фрагменту, и проверяет выполнение условия для этих битов. Тест глубины выполняет сравнение глубины фрагмента с соответствующим значением из буфера глубины. Каждый из этих тестов может привести к отбрасыванию соответствующего фрагмента. Кроме того, имеется альфа-тест, позволяющий отбрасывать фрагменты, исходя из значения альфа-компоненты ее цвета.

После этого выполняется шаг смешивания цвета фрагмента с цветом, соответствующим данному фрагменту в буфере цвета. Данная операция нужна для поддержки полупрозрачное™.

Вычисление значения цвета может быть проведено с гораздо большей точностью, чем можно сохранить в буфере цвета. Обычно в этом случае происходит просто округление цвета. Использование растрирования (dithering) предоставляет другой вариант: цвет изменяют таким образом, чтобы средний показатель по рядом стоящим пикселам дал нужное значение.

Заключительный шаг - выполнение заданной побитовой логической операции между содержимым буфера цвета и полученным значением цвета. Обратите внимание, что многие из этих тестов и операций могут быть выключены, если в них нет необходимости, - обычно это повышает быстродействие.

Если вы пишете программу, использующую OpenGL на С (или C++), то прежде всего необходимо включить следующий заголовочный файл:

Для обеспечения совместимости и переносимости кода OpenGL вводит ряд своих типов данных, имя каждого из этих типов начинается с префикса GL. GLint соответствует стандартному типу целых чисел, тип GLuint - стандартному типу беззнаковых целых чисел, a GLfloat - типу float. Также OpenGL использует несколько специальных типов, таких как GLsizei, обозначающий тип, используемый для задания размера, и GLclampf, используемый для задания значений с плавающей точкой, лежащих на отрезке .

Также вводится специальный тип GLenum для обозначения типа значений, соответствующих различным константам.

В библиотеке OpenGL (а также в идущих с ней в комплекте библиотеках GLU и GLUT) принято использовать довольно простое соглашение об именовании констант и функций. Имена всех команд (функций) OpenGL начинаются с префикса gl (для функций из библиотек GLU и GLUT - с glu и glut соответственно).

Имена всех констант начинаются с GL_ (соответственно с GLU_ и GLUTJ.

Многие команды OpenGL имеют несколько различных вариантов, отличающихся числом передаваемых аргументов и их типами. В этом случае в имя команды также входит специальный суффикс, содержащий число параметров, и суффикс, задающий их тин. Таким образом, имя команды в OpenGL обычно имеет следующий вид:

glCommand{1 2 3 4}{b s i f d ub us ui}{v}

Необязательная цифра служит для задания количества передаваемых аргументов (в том случае, когда есть версии этой команды с различным числом аргументов). Далее идет необязательный суффикс из одной или двух букв, задающий тип передаваемых аргументов (в том случае, когда существуют версии этой команды, принимающие входные значения различных типов). Суффикс v сообщает о том, что ряд параметров (обычно набор последних параметров) передан в виде массива, - в действительности функция вместо этих параметров получает указатель на этот массив.

Так, в команде glVertex2i два целочисленных аргумента, в команде glColor3f - три аргумента типа float, а в команде glColor4ubv - четыре аргумента типа unsigned byte, переданных в виде массива (т.е. функция при вызове получает всего один аргумент - адрес массива).

Отправить свою хорошую работу в базу знаний просто. Используйте форму, расположенную ниже

Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.

Размещено на http://www.allbest.ru/

OpenGL - это программный интерфейс к графической аппаратуре. Этот интерфейс состоит приблизительно из 250 отдельных команд (около 200 команд в самой OpenGL и еще 50 в библиотеке утилит), которые используются для указания объектов и операций, которые необходимо выполнить, чтобы получить интерактивное приложение, работающее с трехмерной графикой. оpengl программный интерфейс графический

Библиотека OpenGL разработана как обобщенный, независимый интерфейс, который может быть реализован для различного аппаратного обеспечения. По этой причине сама OpenGL не включает функций для создания окон или для захвата пользовательского ввода; для этих операций вы должны использовать средства той операционной системы, в которой вы работаете. По тем же причинам в OpenGL нет высокоуровневых функций для описания моделей трехмерных объектов. Такие команды позволили бы вам описывать относительно сложные фигуры, такие как автомобили, части человеческого тела или молекулы. При использовании библиотеки OpenGL вы должны строить необходимые модели при помощи небольшого набора геометрических примитивов - точек, линий и многоугольников (полигонов).

Тем не менее, библиотека, предоставляющая описанные возможности может быть построена поверх OpenGL. Библиотека утилит OpenGL (OpenGL Utility Library -- GLU) предоставляет множество средств для моделирования, например, квадрические поверхности, кривые и поверхности типа NURBS. GLU - стандартная часть любой реализации OpenGL. Существуют также и более высокоуровневые библиотеки, например, Fahrenheit Scene Graph (FSG), которые построены с использованием OpenGL и распространяются отдельно для многих ее реализаций.

В следующем списке коротко описаны основные графические операции, которые выполняет OpenGL для вывода изображения на экран.

1. Конструирует фигуры из геометрических примитивов, создавая математическое описание объектов (примитивами в OpenGL считаются точки, линии, полигоны, битовые карты и изображения).

2. Позиционирует объекты в трехмерном пространстве и выбирает точку наблюдения для осмотра полученной композиции.

3. Вычисляет цвета для всех объектов. Цвета могут быть определены приложением, получены из расчета условий освещенности, вычислены при помощи текстур, наложенных на объекты или из любой комбинации этих факторов.

4. Преобразует математическое описание объектов и ассоциированной с ними цветовой информации в пиксели на экране. Этот процесс называется растеризацией (или растровой разверткой).

В течение всех этих этапов OpenGL может производить и другие операции, например, удаление частей объектов, скрытых другими объектами. В дополнение к этому, после того, как сцена растеризована, но до того, как она выводится на экран, вы можете производить некоторые операции с пиксельными данными, если это необходимо.

Общий порядок работы с библиотекой OpenGl таков:

1. Инициализировать окно (получить область для вывода изображения)

2. Установить камеру

3. Включить свет (если это необходимо)

4. В цикле начать выводить примитивы (точки, линии, полигоны), предварительно очищая окно от предыдущего рисунка.

Инициализация окна.

Если вы работаете в Visual C++, то окно, создается при помощи функций

auxInitDisplayMode

Основной цикл рисования кадра создается в функции Draw и регистрируется при помощи функции

auxMainLoop(Draw);

static void CALLBACK Draw(void) // создается пользователем

// расположение окна OpenGL на экране

auxInitPosition(100, 100, windowW, windowH);

// установка основных параметров работы OpenGL

// цветовой режим RGB | включение Z-буфера для сортировки по глубине

// |Двойная буферизация

auxInitDisplayMode(AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

// инициализация окна OpenGL с заголовком Title

if(auxInitWindow("Example1") ==GL_FALSE) auxQuit();

// регистрация функции, которая вызывается при перерисовке

// и запуск цикла обработки событий

// Draw() - функция пользователя

auxMainLoop(Draw);

Если вы работаете в Borland C++ Builder, то для инициализации окна, надо получить Handle (уникальный идентификатор окна Windows) того окна, на котором вы будите рисовать. Handle имеется у всех окон-приложений верхнего уровня и у большинства дочерних окон. В наших примерах мы будем рисовать на дочернем окне StaticText.

Далее мы должны создать Контекст рисования (device context) и установить его формат. Для этого инициализируется структуру PIXELFORMATDESCRIPTOR (формат описания пикселей). В этой структуре описывается, требуется ли нам поддержка буфера глубины, двойной буферизации и проч.).

Затем следуют функции:

ChoosePixelFormat

Создается контекст рисования OpenGL:

wglCreateContext(hdc);

А потом связываются контексты OpenGL и Windows:

wglMakeCurrent(hdc, hrc)

void __fastcall TFormMain::FormCreate(TObject *Sender)

// возьмем ХЕНДЛ окошка StaticText

static HWND Handle=a->Handle;

// создадим Хендл места рисования для окна StaticText

hdc = GetDC (Handle) ;

// устанавливаем соответствующие настройки контекста устройства

PIXELFORMATDESCRIPTOR pfd = {

sizeof(PIXELFORMATDESCRIPTOR),

PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,

// выбрать соответствующий формат

PixelFormat = ChoosePixelFormat(hdc, &pfd);

SetPixelFormat(hdc, PixelFormat, &pfd);

// создадим контекст устройства для OpenGL

// используя Хендл места рисования

hrc = wglCreateContext(hdc);

ShowMessage(":-)~ hrc == NULL");

if(wglMakeCurrent(hdc, hrc) == false)

ShowMessage("Could not MakeCurrent");

Установка камеры

По умолчанию камера расположена в начале координат (0, 0, 0), направлена вдоль отрицательного направления оси z, и вектором верхнего направления имеет (0, 1, 0).

Для установки камеры удобно использовать функцию gluLookAt(). Хотя она имеет 9 параметров, в них легко разобраться. Они делятся по три параметра, соответственно для трех точек: Eye (Глаз), Center, Up.

Глаз определяет точку откуда смотрим, Центр - куда смотрим, а вектор верха определяет, где у нас должен быть верх (представьте себе пилота в самолете летящего головой вниз). Вектора удобно заключать в классы с переопределенными операциями.

gluLookAt(e.x,e.y,e.z, c.x,c.y,c.z, u.x,u.y,u.z);

Основной цикл включает в себя следующие этапы рисования кадра:

1. Очистку буферов от рисования предыдущей картинки

2. Функции рисования примитивов

3. Функции завершения рисования и ожидания ответа видеокарты

4. Функции копирования изображения из памяти на экран

Основной цикл не включает в себя обработку событий,таких как нажатие клавиш и изменение размеров окна. Для обработки событий создаются отдельные функции и присоединяются к приложению дополнительно.

Если вы работаете в Visual C, то это осуществляется при помощи функций, прототипы которых описаны в файле glaux.h:

auxReshapeFunc()

Если вы работаете в Borland C, то обработка событий осуществляется традиционным для созданных этой программной средой образом: вы просто выбираете компонент(например, Button1), создаете обработчик (например нажатие клавиши) и внутри описываете тело функции.

Рисование примитивов

Рисование примитивов осуществляется командами glBegin() и glEnd().

Константа переданная функции glBegin определяет тип примитива, который будет рисоваться

Координаты точек задаются трехмерным пространственным вектором вектором. Цвета задаются тремя (RGB) или четырьмя (RGBA) параметрами. В нашем примере значение цветовой составляющей каждого цвета можно варьировать от 0 до 1. Если вы привыкли к значению цветовой составляющей от 0 до 255(MsPaint), то используется функция glColor3ub(255,0,0). Суффикс ub означает unsigned byte.

Освещение в Компьютерной графике имеет 3 составляющие

Фоновое излучение - это свет, который настолько распределен средой (предметами, стенами и так далее), что его направление определить невозможно - кажется, что он исходит отовсюду. Лампа дневного света имеет большой фоновый компонент, поскольку большая часть света, достигающего вашего глаза, сначала отражается от множества поверхностей. Уличный фонарь имеет маленький фоновый компонент: большая часть его света идет в одном направлении, кроме того, поскольку он находится на улице, очень небольшая часть света попадает вам в глаз после того, как отразится от других объектов. Когда фоновый свет падает на поверхность, он одинаково распределяется во всех направлениях.

Диффузный компонент - это свет, идущий из одного направления, таким образом, он выглядит ярче, если падает на поверхность под прямым углом, и выглядит тусклым, если касается ее всего лишь вскользь. Однако, когда он падает на поверхность, он распределяется одинаково во всех направлениях, то есть его яркость одинакова вне зависимости от того, с какой стороны вы смотрите на поверхность. Вероятно, любой свет, исходящий из определенного направления или позиции, имеет диффузный компонент.

Зеркальный свет исходит из определенного направления и отражается от поверхности в определенном направлении. При отражении хорошо сфокусированного лазерного луча от качественного зеркала происходит почти 100 процентное зеркальное отражение. Блестящий метал или пластик имеет высокий зеркальный компонент, а кусок ковра или плюшевая игрушка - нет. Вы можете думать о зеркальности как о том, насколько блестящим выглядит материал.

Помимо фонового, диффузного и зеркального цветов, материалы могут также иметь исходящий цвет, имитирующий свет, исходящий от самого объекта. В модели освещения OpenGLисходящий свет поверхности добавляет объекту интенсивности, но на него не влияют никакие источники света, и он не производит дополнительного света для сцены в целом.

Хотя источник света излучает единое распределение частот, фоновый, диффузный и зеркальный компоненты могут быть различны. Например, если в вашей комнате красные стены и белый свет, то этот свет, отражаясь от стен будет скорее красным, чем белым (несмотря на то, что падающий на стену свет -- белый). OpenGL позволяет устанавливать значения красного, зеленого и синего независимо для каждого компонента света.

Команды, используемые для установления материала таковы:

// экземпляры для источника света и материала

// Включим свет источник номер ноль

glEnable(GL_LIGHT0);

// устанавливаем положение и цветовые составляющие источника света

glLightfv(GL_LIGHT0, GL_POSITION, LL.pos);

glLightfv(GL_LIGHT0, GL_AMBIENT, LL.amb);

glLightfv(GL_LIGHT0, GL_DIFFUSE, LL.dif);

glLightfv(GL_LIGHT0, GL_SPECULAR, LL.spec);

// включим режим затениения/освещения

glEnable(GL_LIGHTING);

// устанавливаем параметры материала обьекта

// на лицевых гранях --- GL_FRONT для задних GL_BACK для обоих - GL_FRONT_AND_BACK

// второй параметр - какая составляющая материала

// можно GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR, GL_EMISSION, GL_SHININESS

// соотв РАССЕЯННЫЙ, ОТРАЖЕННЫЙ, ЗЕРКАЛЬНЫЙ, САМОИЗЛУЧЕНИЯ, показатель зеркального блика

glMaterialfv(GL_FRONT,GL_AMBIENT,MM.amb);

glMaterialfv(GL_FRONT,GL_DIFFUSE,MM.dif);

glMaterialfv(GL_FRONT,GL_SPECULAR,MM.spec);

glMaterialf(GL_FRONT,GL_SHININESS,MM.pos);

glNormal3f(0,0,1);

glBegin(GL_QUADS);

for(i=-10; i<20;i++)

for(j=-10;j<20;j++)

glVertex3f(i,j,0);

glVertex3f(i+1,j,0);

glVertex3f(i+1,j+1,0);

glVertex3f(i,j+1,0);

Заключение

Система OpenGL является гибким процедурным интерфейсом, позволяющим программисту разрабатывать различные приложения с применением трехмерной графики. В стандарте нет регламентаций по описанию структуры графических объектов, главное внимание уделяется описанию процесса их визуализации. Благодаря этому возрастает эффективность работы имеющейся аппаратуры: от простых устройств, использующих только буфер кадра до современных графических систем, способных на аппаратном уровне визуализировать трехмерные объекты. В OpenGL предусмотрены только возможности по выводу изображений, организация ввода целиком отдана на откуп конкретной оконной системе, что позволяет достигать дополнительной аппаратной независимости приложений.

По причине минимального использования сложных структур для представления трехмерных объектов возможно применение OpenGL в качестве основы для построения библиотек управления структурированными объектами. Примерами таких библиотек могут быть объектно-ориентированные инструментальные пакеты, используемые для визуализации и моделирования сложных графических структур

Размещено на Allbest.ru

Подобные документы

Программный код OpenGL. Синтаксис команд OpenGL. OpenGL как конечный автомат. Конвейер визуализации OpenGL. Библиотеки, относящиеся к OpenGL. Библиотека OpenGL. Подключаемые файлы. GLUT, инструментарий утилит библиотеки OpenGL.

курсовая работа , добавлен 01.06.2004


Программирование приложения с использованием библиотеки OpenGL и функции для рисования геометрических объектов. Разработка процедуры визуализации трехмерной сцены и интерфейса пользователя. Логическая структура и функциональная декомпозиция проекта.

курсовая работа , добавлен 23.06.2011


Ознакомление с интерфейсом, основными возможностями и преимуществами использования программы OpenGL - популярной библиотекой для работы с 2D и 3D графикой. Рассмотрение назначения, базовых компонент и правил инициализации программного движка DirectX.

презентация , добавлен 14.08.2013


Создание программы на языке C++ с использованием графических библиотек OpenGL в среде Microsoft Visual Studio. Построение динамического изображения трехмерной модели объекта "Нефтяная платформа". Логическая структура и функциональная декомпозиция проекта.

курсовая работа , добавлен 23.06.2011


Суть программирования с использованием библиотеки OpenGL, его назначение, архитектура, преимущества и базовые возможности. Разработка приложения для построения динамического изображения трехмерной модели объекта "Компьютер", руководство пользователя.

курсовая работа , добавлен 22.06.2011


Работа с цветом с помощью графической библиотеки OpenGL. Программа, отображающая квадрат, с меняющимся цветом, в зависимости от изменения градиентов (R,G,B), треугольник, вершины которого имеют различные цвета, прямоугольную полосу в виде спектра.

контрольная работа , добавлен 21.01.2011


Назначение и стандарты реализации OpenGL для Windows, порядок подключения графической библиотеки. Основные функции и синтаксис команд. Рисование примитивов, видовые и аффинные преобразования. Моделирование двумерных графических объектов и анимации.

лабораторная работа , добавлен 04.07.2009


Основы программирования с использованием библиотеки OpenGL. Приложение для построения динамического изображения модели объекта "Батискаф": разработка процедуры визуализации трехмерной схемы, интерфейса пользователя и подсистемы управления событиями.

курсовая работа , добавлен 26.06.2011


Поняття та сфери використання тривимірної графіки. Описання та характеристика можливостей бібліотеки OpenGL. Загальний опис інтерфейсу мови програмування Borland C++, лістинг програми, що демонструє її можливості. Розрахунок витрат на виконання проекту.

дипломная работа , добавлен 24.06.2015


Разработка компоненты для математических вычислений (операций над матрицами) с использованием технологии OpenGL (сложение, вычитание, умножение, транспонирование, определитель, обратная матрица). Базовые навыки по работе с технологией в среде.Net.

В этом разделе мы научимся создавать трехмерные изображения с помощью функций библиотеки OpenGL, для того чтобы в следующей главе разработать Windows-приложение, которое можно рассматривать как инструмент просмотра результатов научных расчетов. Материал этого раздела позволит вам постепенно войти в курс дела и овладеть очень привлекательной технологией создания и управления трехмерными изображениями. Сначала мы рассмотрим основные возможности библиотеки OpenGL, затем научимся управлять функциями OpenGL на примере простых приложений консольного типа и лишь после этого приступим к разработке Windows-приложения.

Читатель, наверное, знает, что OpenGL это оптимизированная, высокопроизводительная графическая библиотека функций и типов данных для отображения двух-и трехмерной графики. Стандарт OpenGL был утвержден в 1992 г. Он основан на библиотеке IRIS GL, разработанной компанией Silicon Graphics (www.sgi.com). OpenGL поддерживают все платформы. Кроме того, OpenGL поддержана аппаратно. Существуют видеокарты с акселераторами и специализированные SD-карты, которые выполняют примитивы OpenGL на аппаратном уровне.

Материал первой части этого урока навеян очень хорошей книгой (доступной в online-варианте) издательства Addison-Wesley "OpenGL Programming Guide, The Official Guide to Learning OpenGL". Если читатель владеет английским языком, то мы рекомендуем ее прочесть.

Подключаемые библиотеки

Microsoft-реализация OpenGL включает полный набор команд OpenGL, то есть глобальных функций, входящих в ядро библиотеки OPENGL32.LIB и имеющих префикс gl (например, glLineWidth). Заметьте, что функции из ядра библиотеки имеют множество версий, что позволяет задать желаемый параметр или настройку любым удобным вам способом. Посмотрите справку по функциям из семейства glColor*. Оказывается, что задать текущий цвет можно 32 способами. Например, функция:

Void glColorSb(GLbyte red, GLbyte green, GLbyte blue);

Определяет цвет тремя компонентами типа GLbyte, а функция:

Void glColor4dv (const GLdouble *v);

Задает его с помощью адреса массива из четырех компонентов.

С учетом этих вариантов ядро библиотеки содержит более 300 команд. Кроме того, вы можете подключить библиотеку утилит GLU32.LIB, которые дополняют основное ядро. Здесь есть функции управления текстурами, преобразованием координат, генерацией сфер, цилиндров и дисков, сплайновых аппроксимаций кривых и поверхностей (NURBS - Non-Uniform Rational B-Spline ), а также обработки ошибок. Еще одна, дополнительная (auxiliary ) библиотека GLAUX.LIB позволяет простым способом создавать Windows-окна, изображать некоторые SD-объекты, обрабатывать события ввода и управлять фоновым процессом. К сожалению, эта библиотека не документирована. Компания Microsoft не рекомендует пользоваться ею для разработки коммерческих проектов, так как она содержит код цикла обработки сообщений, в который невозможно вставить обработку других произвольных сообщений.

Примечание
Тип GLbyte эквивалентен типу signed char, a GLdouble - типу double. Свои собственные типы используются в целях упрощения переносимости на другие платформы. Список типов OpenGL мы приведем ниже. Четвертый компонент цвета определяет прозрачность цвета, то есть способ смешивания цвета фона с цветом изображения. Некоторые команды OpenGL имеют в конце символ v, который указывает, что ее аргументом должен быть адрес массива (вектора). Вектор в математике - это последовательность чисел (координат), единственным образом задающих элемент векторного пространства. Многие команды имеют несколько версий, позволяя в конечном счете задать вектор разными способами .

Около двадцати Windows GDI-функций создано специально для работы с OpenGL. Большая часть из них имеет префикс wgl (аббревиатура от Windows GL). Эти функции являются аналогами функций с префиксом glx, которые подключают OpenGL к платформе X window System. Наконец, существует несколько Win32-функций для управления форматом пикселов и двойной буферизацией. Они применимы только для специализированных окон OpenGL.