и включить для линковки статическую библиотеку glaux.lib в ваш проект.

Имена функций в этой утилитной библиотеки начинаются на aux, например,

AuxSolidCube();

OpenGL Utility Toolkit (GLUT)

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

Для того чтобы её использовать, нужно в исходном файле включить заголовочный файл glut.h и включить для линковки статическую библиотеку glut32.lib в ваш проект.

Кроме того, у вас должна быть динамически подключаемая библиотека glut32.dll.

Вы читаете мой первый урок по OpenGL!

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

Что нужно знать

Данные уроки ориентируются на читателя без особых познаний в программировании. Конечно, знание какого-либо языка программирования(C, Java, Lisp, JavaSript) будет огромным плюсом, но это не обязательно, просто вам придется изучать два предмета одновременно – 3д графику и программирование.

Весь код в данных уроках написан на C++ в максимально простом стиле. Никаких шаблонов, классов и арифметики с указателями. Поэтому глядя на код вы сможете понять что он делает, даже если знакомы лишь с JavaSript.

Забудьте все, что знали про OpenGL 1/2

Данные уроки предполагают, что вы ничего не знаете про 3д графику. Но если вы читали уроки по OpenGL и встречали что-то наподобие glBegin(),то забудьте это. Тут мы будем изучать OpenGL 3 и 4, а то, что вы читали относиться к OpenGL 1 или 2. Поэтому рекомендую вам забыть все, что вы знали раньше, иначе ваши мозги начнут плавиться от нестыковок.

Сборка проекта

Код из данных уроков можно скомпилировать под Windows, Linux. Чтобы начать компилировать код под любую из платформ, нужно сделать следующее:

1. Обновите драйвера на вашу видеокарту!! Я вас предупредил:)
2. Скачайте компилятор, если у вас его еще нет.
3. Установите CMake
4. Скачайте готовые исходники уроков.
5. Сгенерируйте проект с помощью CMake
6. Соберите проект.
7. Поэкспериментируйте с кодом для лучшего понимания, что там происходит.

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

Сборка под Windows

Сборка под Linux

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

1. Установите последние драйвера на вашу видеокарту. Очень рекомендую не опенсорсные драйвера. Они не входят в состав GNU, но они часто работают гораздо лучше. Если ваша сборка линукса не предоставляет автоматического инсталлятора, попробуйте почитать Ubuntu"s guide.
2. Поставьте компилятор со всеми необходимыми библиотеками и инструментами. Вот список того, что вам нужно: cmake make g++ libx11-dev libgl1-mesa-dev libglu1-mesa-dev libxrandr-dev libxext-dev. Используйте sudo apt-get install ***** или su /yum install ******
3. Скачайте исходники примеров и разархивируйте их в папку, например, ~/Projects/OpenGLTutorials/
4. Зайдите в папку ~/Projects /OpenGLTutorials / и введите следующие команды:

• mkdir build

• cd build

• cmake ..

1. Если предыдущие команды были выполнены успешно, то в папке build/ будет создан makefile
2. введите «make all» и после этого будут скомпилированы все примеры и их зависимости. Если не будет никаких ошибок, то готовые исполняемые файлы будут помещены в папку ~/Projects/OpenGLTutorials/

Мне очень нравится использовать IDE QtCreator. Данная IDE умеет из коробки работать с CMake и предоставляет кучу других плюшек, таких как отладка автодополнение итд.

Инструкция по сборке проекта в QtCreator:

1. В QtCreator нажмите File->Tools->Options->Compile&Execute->CMake

2. Укажите путь к CMake. Скорее всего, это будет /usr/bin/cmake

3. File->Open Project ивыберите tutorials/CMakeLists.txt

4. Укажите build папку, папка желательно должна быть вне папки tutorials.

5. Опционально установите –DCMAKE_BUILD_TYPE=Debug в поле параметры.

6. Щелкните на молоток внизу. После этого примеры можно будет запустить из папки tutorials/

7. Чтобы запустить примеры из QtCreator выберите Projects ->Execution parameters ->Working Directory , и выберите каталог где лежат шэйдеры текстуры и модели. Для урока 2 это будет ~/opengl -tutorial /tutorial02_red_triangle/

Запуск примеров

Как проходить эти уроки

Каждый урок идет вместе с исходным кодом и данными. Все эти файлы можно найти в соответствующем каталоге tutorialXX/.

Но я рекомендую вам не менять в этих файлах ничего, они лишь для справки. Лучше играйтесь в playground/playground.cpp и изменяйте там все что захотите. Если вы что-то сломали и не можете восстановить назад, то можно вернуть этот файл просто скопировав его из любого другого урока.

Пока вы будете читать эти уроки, вам везде будут попадаться кусочки кода. Не стесняйтесь и копируйте их в playground.cpp чтобы пощупать их в действии – эксперименты, это всегда хорошо. Повторю еще раз, не просто читайте готовый код, а пробуйте его запустить. Просто читая исходники, вы не научитесь многому. Даже с простым копипастингом вы получите свой ковш проблем, решая которые, приобретете необходимый опыт.

Открываем окно

Наконец-то! OpenGL!

Хотя, придется еще немного подождать. Во всех уроках 3д операции будут выполнятся на очень низком уровне, поэтому там не будет для вас никакой магии. Однако работа с окнами и сообщениями системы не интересная и скучная, поэтому мы позволим библиотеке GLFW сделать всю грязную работу за нас. Если вам конечно очень сильно хочется, вы можете использовать Win32 Api для Windows или X11 API для Linux, или использовать что-нибудь другое, типа SFML, FreeGLUT, SDL, … почитайте страничку ссылки.

Ладно, давайте уже начнем. Начнем с того, что нам нужно подключить зависимости. Так как нам необходимо выводить сообщения на консоль, мы напишем следующее:

// Подключаем стандартные заголовки

#include

#include

Потом подключаем GLEW

// Нужно не забывать, что GLEW обязательно необходимо подключать перед gl . h или glfw . h

#include

Потом подключаем GLFW. Эта библиотека будет делать всю магию управления окнами.

#include

На данном этапе нам не нужна эта библиотека, но она содержит математические функции и вскоре нам понадобится. Никакой магии в GLM нет, и если вам сильно хочется, вы можете использовать любую другую библиотеку по работе с матрицами и векторами. Мы подключаем «using namespace» для того, чтобы писать «vec3», а не «glm::vec3»

#include

using namespace glm;

Если вы скопируете эти куски кода в playground.cpp, то компилятор начнет возмущаться, что нет функции main(). Поэтому давайте добавим:

int main(){

Сначала лучше бы инициализировать GLFW:

// Инициализируем GLFW

if(!glfwInit())

{

fprintf(stderr, "Failed to initialize GLFW\n");

return -1;

}

А теперь создадим наше OpenGL окошко:

glfwOpenWindowHint ( GLFW _ FSAA _ SAMPLES , 4); // 4 x сглаживание

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); // нам нужен OpenGL 3.3

glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);

glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // нам не нужен старый OpenGL

// Откроем окно и создадим контекст

if(!glfwOpenWindow(1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW))

{

fprintf(stderr, "Failed to open GLFW window\n");

Это стандартное графическое приложением для 2D и 3D-визуализации, разработанного в 1992 году. Opengl поставляется в двух вариантах. Первый из них — «Микрософт OpenGL», который часто включается в «Виндовс» для установки графической карты. Второй — Cosmo OpenGL - предназначен для систем, у которых нет ускоренной видеокарты. Библиотека OpenGL - основное условие работы приложения.

Пользовательский обзор OpenGL

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

OpenGL не зависит от характеристик «Виндовс» каждой операционной системы, но предоставляет специальные подпрограммы для ОС. Она выпускается с огромным перечнем встроенных возможностей, запрашиваемых через API. К ним относятся:

• скрытое удаление поверхности;
• альфа-смешение (прозрачность);
• сглаживание;
• текстурное картирование;
• операции с пикселями;
• просмотр и моделирование трансформаций;
• атмосферные эффекты (туман и дымка).

Silicon Graphics - разработчики передовых графических рабочих станций - инициировала разработку OpenGL. DEC, Intel, IBM, Microsoft и Sun Microsystems вошли в отраслевую комиссию по обзору архитектуры. Разработка приложений, использующих API OpenGL, не несет никаких затрат, кроме обучения. Microsoft предлагает бесплатную загрузку ее библиотек для своих систем.

Набор модулей для Windows

Приложение доступно на многих системах Win32 и Unix. А f90gl — это реализация публичного домена официальных связей Fortran 90 для OpenGL, оформленная в виде базы данных модулей и библиотек, определяющей необходимые интерфейсы для функциональности программы. Сам f90gl был разработан Уильямом Ф. Митчеллом технологического института Гейтерберга в США. До недавнего времени OpenGL LF9x можно было создавать только в виде статически связанных программ, ориентированных на Visual C.

В настоящее время доступен гораздо более дружелюбный метод благодаря усилиям по переносу, реализованным Lawson B. Wakefield из Великобритании. Эта реализация сделала интерфейс OpenGL доступным в рамках WiSK и Winteracter и была выполнена на добровольной, некоммерческой основе. Для подключения библиотеки OpenGL нужны определенные DLL OpenGL, установленные в каталоге Windows SYSTEM32. К ним относятся следующие:

• opengl32.dll;
• glu32.dll;
• glut32.dll.

Первые две из этих библиотек OpenGL (изучить их перед установкой необходимо), являются стандартной частью Windows разных модификаций и Me. Библиотеки и модули f90gl должны быть установлены в LIB-каталоге LF95:

• F90GL.LIB;
• F90GLU.LIB;
• F90GLUT.LIB;
• OPENGL32.LIB;
• GLU32.LIB;
• GLUT32.LIB;
• OPENGL.MOD;
• OPENGL2.MOD;
• OPENGL_KINDS.MOD;
• OPENGL_GLINTERFACES.MOD;
• OPENGL_FWRAP.MOD;
• OPENGL_GLUINTERFACES.MOD;
• OPENGL_GLU.MOD;
• OPENGL_GLUTINTERFACES.MOD;
• OPENGL_GLUT.MOD;
• OPENGL_GL.MODd.

Компиляция и связывание программ f90gl требует, чтобы каталог LF95 LIB указывался в пути модуля компилятора и имена библиотек f90gl для связывания.

Библиотеки изображений

DevIL используется для разработчиков. Он поддерживает множество форматов изображений для чтения и записи, несколько компиляторов и ОС («Виндовс», «Линукс», Мас). Библиотека имеет следующий синтаксис:

1. FreeImage — это кросс-платформенная библиотека OpenGL загрузки изображений с очень широкой поддержкой форматов (включая некоторые HDR-форматы, такие как OpenEXR).
2. OpenImageIO (OIIO) — это библиотека для чтения и записи изображений, а также множество связанных классов, утилит и приложений. Широко используется в анимационных и VFX-студиях по всему миру, а также встроена в несколько коммерческих продуктах.
3. SOIL — это кросс-платформенный загрузчик изображений общего пользования, который чрезвычайно мал. C ++, способный загружать текстуры DDS (DDS9 и DDS10) по лицензии MIT.
4. Glraw предоставляет инструмент командной строки, который преобразует файлы изображений в необработанные, непосредственно содержащие простые текстурные данные.

Импорт активов 3D-файлов

Графическая библиотека OpenGL для импорта активов (Assimp) представлена как библиотека с для импорта разнообразных популярных трехмерных моделей. Самая последняя версия экспортирует 3d-файлы и подходит как конвертер общего назначения. Имеется несколько видов таких библиотек:

1. Может считывать различные форматы 3D-файлов - COLLADA, собственные файлы Blender3D, Wavefront Obj (.obj) и многие другие. Библиотека lib3ds предназначена для чтения 3ds-файлов.
2. Open3mod — это средство просмотра модели на базе Windows. Он загружает все форматы файлов, которые поддерживает Assimp, и идеально подходит для быстрой проверки 3D-активов.
3. AssetKit (In Progress) — библиотека OpenGL импортер/экспортер 3D-ресурсов, утилита, основанная на спецификациях COLLADA/glTF. Главное внимание здесь уделено COLLADA и glTF. Она будет полностью поддерживать форматы 1.4, 1.4.1, 1.5+, а также некоторые другие в качестве библиотеки для загрузки моделей в OpenGL.

Высокопроизводительная 2D/3D-графика

Графическая библиотека OpenGL для Android включает поддержку высокопроизводительной 2D и 3D-графики с открытой библиотекой, в частности API OpenGL ES. Android поддерживает ее как через API-интерфейс инфраструктуры, так и Native Development Kit (NDK). В платформе названной операционной системы есть два фундаментальных класса, которые позволяют создавать и манипулировать графикой с помощью API: GLSurfaceView и GLSurfaceView.Renderer.

Если есть цель использовать OpenGL в приложении для Android, то нужно понимать, как реализовать эти классы в действии. Так, GLSurfaceView может рисовать и манипулировать объектами, используя вызовы API OpenGL аналогично функции SurfaceView. Этот интерфейс определяет методы, необходимые для рисования графики в a GLSurfaceView. И пользователь должен обеспечить реализацию этого интерфейса как отдельный класс и прикрепить к GLSurfaceView экземпляр GLSurfaceView.setRenderer. После того как создан контейнерный вид для OpenGL ES, GLSurfaceView и GLSurfaceView.Renderer, можно начать подключение библиотеки OpenGL и использовать API.

Набор мобильных графических устройств

Реализации приложения различаются для Android-устройств поддерживаемыми расширениями API и включают сжатие текстур и другой набор функций. Android Extension Pack (AEP) поддерживает стандартную базу расширений. Упаковка их вместе способствует последовательному набору функциональности на всех устройствах, позволяя разработчикам в полной мере использовать новейший пакет мобильных графических конструкций.

AEP также улучшает поддержку изображений, буферов хранения шейдеров и счетчиков. Чтобы приложение могло использовать AEP, версия платформы должна поддерживать ее. Нужно также обозначит требование AEP следующим образом: <использует функцию android: name = "android.hardware.opengles.aep" android: required = "true" />

Проверка и выбор версии OpenGL ES

На Android-устройствах доступно несколько версий приложения. Можно указать минимальную версию API, которая требуется приложению в телефоне. Версия API opengl ES 1.0, версия 2.0 и версия 3.0 обеспечивают высокопроизводительные графические интерфейсы для создания 3D-игр, визуализации и пользовательских интерфейсов. Программа для OpenGL ES 2.0 во многом похожа на версию 3.0, представляющую собой надмножество API 2.0 с дополнительными функциями.

Программирование для 1.0 / 1.1 API по сравнению с 2.0 и 3.0 значительно отличается, и поэтому разработчикам следует внимательно изучить некоторые факторы, прежде чем начинать разработку с помощью этих API. Так, в общем, 2 и 3 обеспечивают более быструю графическую производительность, чем API ES 1/1,1. Тем не менее разница в ней может варьироваться в зависимости от устройства Android, на котором работает приложение, из-за различий в реализации аппаратного обеспечения графического конвейера.

Сравнение с драйверами DirectX

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

Библиотеки OpenGL и DirectX (история и перспективы их) связаны с «Микрософт», которая фактически выступила против OpenGL. В 2003 году Microsoft заявила, что ей больше не интересны планы OpenGL. Затем в 2005 году они на презентации в SIGGRAPH сделали заявление, что Windows Vista удалит ее поддержку.

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

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

1. Предоставляет возможность использовать функции графики для оперативных систем, в то время как DirectX предоставляет только моментальные элементы из них в новейших версиях «Виндовс». Технология тесселяции, которую Microsoft разработывал для DirectX 11, была расширением OpenGL в течение трех лет. Путем кропотливого труда удалось добиться того, что DirectX 10 и 11 теперь работают так же быстро, как и OpenGL, и поддерживают почти столько же функций. Однако есть одна большая проблема: они не работают в Windows XP, которой до сих пор пользуются много людей.
2. Кросс-платформенный. Многие пользователи Lugaru работают на Mac, Linux и Windows XP и не могут играть через DirectX. Единственный способ доставить новейшую графику для геймеров Windows XP — через 32bits opengl библиотеки.
3. Лучше для будущего игр. Это некоммерческий открытый стандарт, созданный для того, чтобы пользователи на любой платформе могли получать высококачественную графику, которую предоставиляет их оборудование. Его развитие разрушается сегодня монополистической атакой корпоративного гиганта, пытающегося доминировать в отрасли. Вот почему Direct3D становится единственным игровым графическим API, поддерживаемым в Windows.

C ++ и настройка Visual Studio

Библиотека OpenGL для c имеет бесплатную версию. Специалисты рекомендуют скомпилировать программы, написанные на ANSI C с OpenGL и GLUT, с помощью Dev-C ++.

Bloodshed Dev-C ++ - это бесплатный компилятор C ++ и среды разработки для операционных систем Windows. Как и большинство таких же технических средств, его можно использовать для компиляции ANSI C. Установив файлы заголовков GLUT и библиотеки, его применяют для написания программ. Для реализации этого проекта можно использовать 32-разрядную или 64-разрядную «Виндовс».

Перед тем как подключить к dev c библиотеку OpenGL, понадобятся заголовки glew, которые можно найти на вебсайте sourceforge Extension Wrangler, и версия freeglut для Visual Studio:

1. Нажать ссылку внутри пакета freeglut 3.0.0 MSVC.
2. Ввести имя файла, который нужно скачать.
3. Загрузить его, в папке с freeglut.
4. Извлечь и переименовать в freeglut.
5. Общий каталог для установки: C: \ DEV.
6. Каталог, в котором находятся проекты: C: \ DEV \ visual-studio-c ++.
7. Каталог, в котором находятся библиотеки: C: \ DEV \ Lib Visual Studio.
8. Открыть его и создать пустой проект > «Шаблоны»> Visual C ++> Пустой проект.
9. Затем написать «Имя»: Shapes2D.
10. Местоположение: C: \ dev \ visual-studio-c ++ \.
11. Создать новое решение в OpenGL-библиотеке для Visual Studio. Название решения: BadprogTutorial OK.
12. Проект Shapes2D создан в решении BadprogTutorial.
13. Добавить main.cpp> Кликнуть правой кнопкой мыши «Проект»> «Добавить»> «Новый элемент»> Visual C ++> Файл C ++. Написать имя: main.cpp и добавить.
14. Настроить конфигурации библиотеки GL и OpenGL glut.
15. Кликнуть мышью проект Shapes2D> «Свойства». В левом верхнем углу раскрывающегося меню найти «Конфигурация» и выбрать все конфигурации (вместо Debug).
16. Кликнуть мышью на «Свойства конфигурации»> C / C ++> «Общие»> «Дополнительные каталоги вложений». Справа находится раскрывающееся меню, нажать «Изменить...».
17. Появилось новое окно: «Дополнительные каталоги».
18. Нажать значок «Новая линия»> кнопку обзора и выбрать две следующие папки: C: \ DEV \ Lib \ Glew-1.12.0 \ . C: \ DEV \ Lib \ freeglut-3.0.0 \ .
19. Нажать кнопку ОК. Применить использование библиотеки OpenGL, включая библиотеки, библиотечные папки.
20. Кликнуть правой кнопкой мыши проект Shapes2D> «Свойства» > «Свойства конфигурации»> «Коннектор»> «Общие»> «Дополнительные каталоги библиотек».
21. Справа находится раскрывающееся меню. Нажать на «Изменить...». Появилось новое окно: «Дополнительные библиотеки».
22. Нажать значок «Новая линия»> нажать кнопку обзора> выбрать две следующие папки для 64-разрядной версии: C: \ DEV \ Lib \ Glew-1.12.0 \ Lib \ Release \ x64 и C: \ DEV \ Lib \ freeglut-3.0.0 \ Lib \ x64.
23. Нажать кнопку ОК> применить библиотечные файлы. Кликнуть мышью проект Shapes2D> «Свойства» > «Свойства конфигурации»> «Коннектор»> «Ввод».
24. Справа находится раскрывающееся меню, нажмите «Изменить...».
25. Появилось новое окно: «Дополнительные зависимости». Кликнуите по белой области и напишите: freeglut.lib.
26. Нажать Enter, чтобы перейти к следующей строке: glew32.lib.
27. Нажать «Применить» и ОК.

Теперь Visual Studio IDE готова работать с OpenGL.

Загрузка Dev-C ++

Эти инструкции были протестированы на большом множестве систем Windows, которые поставляются с файлами, необходимыми для OpenGL, но не для файлов, необходимых для GLUT. Dev-C ++ не работает с Vista от Microsoft.

Процедура загрузки:

1. Загрузите Dev-C ++ и установите его.
2. Получите Dev-C ++ 5.0 beta 9.2 (4.9.9.2) (9.0 MB) с Mingw / GCC 3.4.2 (хотя это «бета-версия», она отлично работает).
3. Теперь нужно нажать на SourceForge, чтобы перейти к списку сайтов загрузки, и выбрать один.
4. Сохранить этот файл в таком месте, как C: \ Temp.
5. Когда загрузка будет завершена, нажать кнопку «открыть», чтобы начать процесс установки. Или перейти к C: \ Temp и дважды кликнуть по devcpp4.9.9.2_setup.exe.
6. Выбрать «типичную» установку. Принять предложенный пункт назначения для установки.
7. Ответить: «Да», когда установка спрашивает, хотите ли установить Dev-cpp для всех пользователей. На экране появляется сообщение, что установка завершена. Нажать «Готово». Появится первый экран конфигурации.
8. Выбрать «Английский» и «Новый взгляд». На следующих нескольких экранах нажать «Да». Программа запускается автоматически.
9. Нажать «Файл», затем создать проект.
10. Выбрать имя для проекта (например, «myProject»).
11. Нажать «C Project», «Пустой проект» и ОК.
12. В окне «Создать новый проект» нажать «Сохранить».
13. Нажать «Файл / Новый / Исходный файл» и в «Добавить исходный файл в текущий проект» нажать «Да».
14. Нажать «Файл / Сохранить как» и сохранить файл как «hello.c» (или другое имя). Важно убедиться, что расширение файла.c. С любым другим расширением (например, предлагаемым.cpp) возникнут проблемы с компиляцией.
15. Нажать «Выполнить / Скомпилировать и запустить». Программа компилирует, запускает и записывает свой вывод в окно DOS.
16. Попробовать другой способ запуска программы (после ее компиляции) — запустить окно DOS вне системы Dev-Cpp.
17. Перейти к подкаталогу, в котором содержится проект, и набрать hello.exe.
18. Найти Dev-C ++, указанный в разделе «Программы» из пускового меню.

Теперь пользователь сможет создавать, компилировать и запускать программы C (и C ++). У него будут файлы, библиотеки и dll для OpenGL (и всех других стандартных пакетов), но не GLUT. GLUT управляет окнами и другими компонентами пользовательского интерфейса, необходимыми для него, и их устанавливают отдельно.

Установка и запуск программы на Windows 7

Платформа выполнения для Visual Studio 2010 - Integrated. Среда (IDE), под управлением Windows 7. Вам нужно загрузить и установить Microsoft Visual C ++ 2010 Express. А после того как Visual C ++ будет успешно установлен, следует выполнить следующие действия:

1. Загрузить и распаковать файл freeglut-MSVC-2.8.1-1.
2. Открыть экран приветствия Visual C ++ 2010 из меню «Пуск».
3. Создать новый проект, выбрав File -> New -> Project.
4. Выбрать Win32 на панели «Установленные шаблоны», а затем «Консольное приложение Win32» со следующей панели.
5. Назвать свой проект и выбрать папку, в которую нужно его сохранить.
6. Снять флажок «Создать каталог для решения».
7. Нажать ОК, чтобы открыть окно приветствия мастера и «Параметры приложения» для диалогового окна настроек.
8. Снять флажок «Предварительно скомпилированный заголовок», установить флажок «Пустое проект» и выбрать «Консольное приложение».
9. Нажать «Готово», чтобы увидеть новое окно проекта библиотеки OpenGL для Windows 7.
10. Нажать мышью на Source Files и выбрать Add -> New Item, чтобы открыть диалоговое окно.
11. Выбрать «Код» на панели «Установленные шаблоны» и «Файл C ++» (.cpp) со следующей панели.
12. Назвать свой файл и нажать «Добавить», чтобы увидеть пустую панель кода в окне проекта с названием «Выбранное имя».
13. Сохранить и создайть проект, перейдя в Debug -> Build Solution. Затем выполнить программу с помощью Debug -> Start Debugging.

Если графическая карта не поддерживает OpenGL 4.3, то программы, использующие его, могут компилироваться, но не выполняться, поскольку система не может предоставить контекст рендеринга OpenGL 4.3, заданный командой glutInitContextVersion (4. 3) в основной процедуре. В этом случае можно заменить Version 4.3 на 3.3 или даже на 2.1.

Хотя почти все платформы поддерживают OpenGL API, разработчикам по-прежнему необходимо создавать индивидуальные приложения для разных платформ. Это связано с тем, что графика является лишь частью приложения, а другие компоненты по-прежнему отличаются между платформами. Чтобы исправить это, WebApp был разработан для запуска целых программ в веб-браузере, таких как Chrome и Firefox. Так что одна программа может работать на всех платформах с совместимым браузером.

Между тем на стороне клиента все передается «на лету» с серверов, поэтому дальнейшая установка приложения не требуется. Специальный API под названием WebGL также был создан для Интернета и основан на ES, подмножестве OpenGL, разработанном специально для мобильных устройств. Чтобы достичь аналогичной цели для VR, другой API, называемый WebVR, был разработан, чтобы легко довести опыт VR до браузеров, независимо от платформы.

В этой главе рассмотрим рендеринг трехмерной графики с помощью библиотеки 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, переданных в виде массива (т.е. функция при вызове получает всего один аргумент - адрес массива).

ВВЕДЕНИЕ

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 может выполнять дополнительные операции, такие как использование сплайнов для построения линий и поверхностей, удаление невидимых фрагментов изображений, работа с изображениями на уровне пикселей и т.д.