В этом разделе мы научимся создавать трехмерные изображения с помощью функций библиотеки 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.
Знакомство с OpenGL нужно начать с того, что OpenGL - это спецификация . Т.е. OpenGL лишь определяет набор обязательных возможностей. Реализация же зависит от конкретной платформы.
- glBegin(GL_QUADS) ;
- glVertex2i(250 , 450 ) ;
- glVertex2i(250 , 150 ) ;
- glVertex2i(550 , 150 ) ;
- glVertex2i(550 , 450 ) ;
- glEnd() ;
- int main (int argc, char * argv )
- glutInit(& argc, argv) ;
- glutInitDisplayMode(GLUT_DOUBLE| GLUT_RGBA) ; /*Включаем двойную буферизацию и четырехкомпонентный цвет*/
- glutInitWindowSize(800 , 600 ) ;
- glutCreateWindow(«OpenGL lesson 1» ) ;
- glutReshapeFunc(reshape) ;
- glutDisplayFunc(display) ;
- glutMainLoop() ;
- return 0 ;
- void reshape(int w, int h)
- glViewport(0 , 0 , w, h) ;
- glMatrixMode(GL_PROJECTION) ;
- glLoadIdentity() ;
- gluOrtho2D(0 , w, 0 , h) ;
- glMatrixMode(GL_MODELVIEW) ;
- glLoadIdentity() ;
- void display()
- glClear(GL_COLOR_BUFFER_BIT) ;
- glBegin(GL_QUADS) ;
- glColor3f(1.0 , 1.0 , 1.0 ) ;
- glVertex2i(250 , 450 ) ;
- glColor3f(0.0 , 0.0 , 1.0 ) ;
- glVertex2i(250 , 150 ) ;
- glColor3f(0.0 , 1.0 , 0.0 ) ;
- glVertex2i(550 , 150 ) ;
- glColor3f(1.0 , 0.0 , 0.0 ) ;
- glVertex2i(550 , 450 ) ;
- glEnd() ;
- glutSwapBuffers() ;
Вы читаете мой первый урок по OpenGL!
Прежде чем начинать изучать сам OpenGL, мне кажется, лучше рассказать вам как компилировать код, запускать его и самое главное - как экспериментировать с исходными кодами, приведенными в этих уроках.
Данные уроки ориентируются на читателя без особых познаний в программировании. Конечно, знание какого-либо языка программирования(C, Java, Lisp, JavaSript) будет огромным плюсом, но это не обязательно, просто вам придется изучать два предмета одновременно – 3д графику и программирование.
Весь код в данных уроках написан на C++ в максимально простом стиле. Никаких шаблонов, классов и арифметики с указателями. Поэтому глядя на код вы сможете понять что он делает, даже если знакомы лишь с JavaSript.
Данные уроки предполагают, что вы ничего не знаете про 3д графику. Но если вы читали уроки по OpenGL и встречали что-то наподобие glBegin(),то забудьте это. Тут мы будем изучать OpenGL 3 и 4, а то, что вы читали относиться к OpenGL 1 или 2. Поэтому рекомендую вам забыть все, что вы знали раньше, иначе ваши мозги начнут плавиться от нестыковок.
Код из данных уроков можно скомпилировать под Windows, Linux. Чтобы начать компилировать код под любую из платформ, нужно сделать следующее:
Ниже я привел более детализированное описание сборки проектов под каждую из платформ. Но в зависимости от версии ОС скриншоты могут слегка отличатся от того, что будет у вас на экране, но в целом, все должно быть приблизительно таким.
В мире существует громадное число разных вариаций линукса, поэтому мне совсем не хочется приводить примеры сборки проекта под каждую. Если что-то не получается, как написано ниже, почитайте документацию, или поищите в интернете.
Мне очень нравится использовать IDE QtCreator. Данная IDE умеет из коробки работать с CMake и предоставляет кучу других плюшек, таких как отладка автодополнение итд.
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");
Решили изучить OpenGL, но знаете, с чего начать? Сделали подборку материалов.
OpenGL (открытая графическая библиотека) - один из наиболее популярных графических стандартов для работы с графикой. Программы, написанные с её помощью можно переносить практически на любые платформы, получая одинаковый результат. OpenGL позволяет не писать программы под оборудование, а воспользоваться существующими разработками. Разрабатывает OpenGL компания Silicon Graphics, при сотрудничестве с другим технологическими гигантами.
С точки зрения программирования, OpenGL - это программный интерфейс для растровой графики, таких как графические ускорители. Он включает в себя около 150 различных команд, с помощью которых программист может определять различные объекты и производить рендеринг.
Книга - официальное руководство по изучению OpenGL. Последние издания практически полностью отличаются от первоначальных вариантов, автор обновляет её в соответствии с изменениями версий. По мнению сотен специалистов, работающих с Open GL, эта книга является первым, что должен взять в руки желающий изучить технологию.
В этой книге рассматривается весь спектр приемов программирования на GLSL, начиная с базовых видов шейдеров – вершинных и фрагментных, – и заканчивая геометрическими, вычислительными и шейдерами тесселяции. Прочтя ее, вы сможете задействовать GPU для решения самых разных задач.
В данной книге автор рассматривает весь API и язык для написания шейдеров. Также вы найдете советы по оптимизации быстродействия, максимизации эффективности работы API и GPU и полном использовании OpenGL ES в широком спектре приложений.
В книге рассмотрены способы работы с компьютерной графикой, частые проблемы, приведены примеры программ на C++.
Книга предназначена для введение в компьютерную графику на базовом уровне. Авторы рассказывают про математические основы компьютерной графики с акцентом на то, как применять эти основы для разработки эффективного кода.
Эта книга предназначена для всех студентов, изучающих информатику и программирование углубленно. Компьютерная анимация и графика - уже не так сложно, как раньше. Следуя своему утверждению, автор написал книгу максимально понятным языком.
В этой главе рассмотрим рендеринг трехмерной графики с помощью библиотеки 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, переданных в виде массива (т.е. функция при вызове получает всего один аргумент - адрес массива).
