Вы читаете мой первый урок по 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");
Студенты, аспиранты, молодые ученые, использующие базу знаний в своей учебе и работе, будут вам очень благодарны.
Размещено на 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, изучим библиотеки 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 переопределены стандартные типы, включая встроенные. Это сделано для переносимости программного кода на другие платформы. В принципе, нет ничего сложного, чтобы запомнить эти типы и их значения.
Например, тип GLint соответствует стандартному int:
typedef int GLint;аналогично:
typedef unsigned int GLuint; typedef float GLfloat; typedef double GLdouble; typedef void GLvoid;
Эти типы объявлены в GL.h. Имена всех этих типов начинаются с GL. Рекомендуется с функциями OpenGL использовать эти типы.
Многие функции OpenGL - вариации друг друга, различаясь только типами данных и их аргументами. Конечно же, этого не было бы, если бы OpenGL изначально был сделан для языков, поддерживающих перегрузку функций, таких как C++.
Чтобы не было путаницы в именах функций, ввели несколько договорённостей (правил), по которым строится имя функции OpenGL.
Во-первых, все имена функций OpenGL начинаются с приставки gl. Например,
GlBegin();
glEng();
Во-вторых, если набор функций имеют одинаковый смысл и различаются только количеством и типами параметров, то имя таких функций записывают в виде:
GlОбщая_часть_имени_функции[n],
где n - количество параметров, type - тип параметров.
Например:
glVertex2d(1 .0 , 0 .5 ) ; // 2d означает: 2 параметра типа GLdouble glVertex3f(1 .0 f, 0 .5 f, 0 .0 f) ; // 3f означает: 3 параметра типа GLfloat glColor3ub(127 , 0 , 255 ) ; // 3ub означает: 3 параметра типа GLubyte
Ниже в таблице приведены значения сокращений для type:
| i | GLint |
| ui | GLuint |
| f | GLfloat |
| d | GLdouble |
| s | GLshort |
| us | GLushort |
| b | GLbyte |
| ub | GLubyte |
| v | массив |
В различных документациях по OpenGL, чтобы не перечислять все функции одного семейства, принято записывать только имя общей части всех функций семейства и в конце ставить звёздочку "*". Например, функции, задающие координаты вершин записывают так:
GlVertex*
Команды OpenGL интерпретируются моделью client/server.
Код приложения (client) выдаёт команды, которые интерпретируются и обрабатываются.
OpenGL (server) может оперировать или не оперировать на компьютере как клиент. Сервер может содержать несколько контекстов OpenGL. Клиент может подключаться к любому из этих контекстов.
Оконная система выделяет буфер кадра (frame buffer). Она определяет, какая часть буфера кадра модели может быть доступна в данное время для OpenGL, и уведомляет OpenGL, как эти порции структурированы. Поэтому OpenGL не имеет команд, конфигурирующих буфер кадра или инициализирующие OpenGL.
Помимо функций OpenGL и функций, предоставляемых операционной системой, часто для работы с OpenGL используют дополнительные библиотеки.
Библиотеки не вносят каких-либо новых возможностей в сам OpenGL. Их назначение, это упрощение кода. Библиотеки избавляют от написания программистами часто встречаемых функций.
Дополнительные библиотеки рекомендуется использовать крайне осторожно. Проблемы могут возникнуть при переносе вашего кода на другую платформу. Обычно их используют для небольших и тестовых программ. В крупных проектах от этих библиотек отказываются, оставляя предпочтение чистому OpenGL.
Наиболее известные библиотеки:
Утилитная библиотека glu предоставляет функции, работающие с матрицами, с координатными системами, с кривыми и поверхностями NURBS и т.п.
Эта библиотека поставляется почти со всеми реализациями OpenGL, в частности с MS Visual C++.
Для того чтобы её использовать, нужно в исходном файле включить заголовочный файл glu.h:
#includeи включить для линковки статическую библиотеку glu32.lib в ваш проект.
Имена функций в этой утилитной библиотеки начинаются на glu, например,
GluPerspective();
Вспомогательная библиотека glaux содержит функции, создающие простые трёхмерные геометрические объекты, такие как сфера, куб, параллелепипед, цилиндр, конус и пр., функции, загружающие изображения из файлов, функции, работающие с окном вывода графики и т.д.
Эта библиотека используется реже, и описание функций не включено в MSDN. Файлы для работы с библиотекой также поставляются с MS Visual C++.
Для того чтобы её использовать, нужно в исходном файле включить заголовочный файл glaux.h:
#includeи включить для линковки статическую библиотеку glaux.lib в ваш проект.
Имена функций в этой утилитной библиотеки начинаются на aux, например,
AuxSolidCube();
Независимый от оконной операционной системы инструмент для создания OpenGL программ. Предоставляет простую реализацию оконного интерфейса. Эта библиотека освобождает от инициализационных подготовок приложения, может генерировать геометрические объекты и пр.
Для того чтобы её использовать, нужно в исходном файле включить заголовочный файл glut.h и включить для линковки статическую библиотеку glut32.lib в ваш проект.
Кроме того, у вас должна быть динамически подключаемая библиотека glut32.dll.
Обычно область, в которой необходимо определить наличие объектов (область выбора объектов), определяется как фрагмент проекции сцены. Например, пользователь на изображении проекции выделяет с помощью манипулятора (например, указателя типа "мышь") прямоугольную область или просто щелкает кнопкой "мыши", определяя, таким образом, область выбора.
Так как в этих случаях область выбора определяется на проекции трехмерной сцены, то необходимо определить соответствующую ей область трехмерной сцены (сцена выбора). Сцена выбора будет зависеть от нескольких факторов: используемой проекции, размеров сцены и области вывода.
Для определения трехмерной области выбора на основании прямоугольного фрагмента проекции сцены необходима информация о матрице проекции. Для этого можно использовать некоторые функции из библиотеки GLUT , которая является надстройкой над библиотекой OpenGL и предоставляет ряд дополнительных возможностей.
В библиотеке OpenTK функции библиотеки GLUT находятся в классе Glu в пространстве имен Tao .OpenGL (C#). В Object Pascal все функции и процедуры библиотеки GLUT имеют префикс "glu" , что позволяет их отличать от процедур и функций OpenGL .
Для формирования матрицы проекции на основе выбранного фрагмента проекции сцены можно использовать команду PickMatrix библиотеки GLUT :
C#: void gluPickMatrix(double x, double y, double width, double height, int viewport); Object Pascal: procedure gluPickMatrix(x,y,width,height: GLdouble; viewport: PGLint);
Команда PickMatrix библиотеки GLUT изменяет текущую матрицу таким образом, чтобы размер области сцены соответствовал области выбора, определённой в координатах проекции этой сцены. Команды имеет следующие параметры:
Команда должна быть выполнена перед выполнением команд Ortho или Frushtum , с помощью которых формируется матрица проекции.
Для перевода библиотеки в режим выбора используется команда RenderMode :
C#: int RenderMode(RenderingMode mode); Object Pascal: function glRenderMode(mode: GLenum): GLint;
Параметр mode определяет режим работы библиотеки OpenGL и может принимать одно из трех значений:
| Описание | Значение | |
|---|---|---|
| Библиотека OpenTK, C# | Object Pascal | |
| Режим выбора, данное значение используется для перевода библиотеки в режим выбора. | RenderingMode.Select | GL_SELECT |
| Режим формирования изображения сцены. Этот режим используется по умолчанию после инициализации библиотеки OpenGL. Именно в этом режиме выполняется формирование изображения библиотекой OpenGL. | RenderingMode.Render | GL_RENDER |
| Режим обратной связи. | RenderingMode.Feedback | GL_FEEDBACK |
После переключения в режим выбора библиотека OpenGL не формирует изображение до тех пор, пока режим не будет изменен на режим формирования изображения сцены с помощью команды RenderMode со значением параметра RenderingMode.Render на C# и GL_RENDER на Object Pascal.
Как уже обсуждалось выше, в режиме выбора изображение не формируется. Команды формирования изображения в этом режиме используются для определения объектов, попадающих в область выбора.
Так как объекты, с которыми работает пользователь, обычно формируются из множества различных примитивов, то для определения выбранного объекта используется стек имен. Имена представляют собой целочисленные значения. Перед началом вывода очередного объекта в стек имен помещается имя (номер) этого объекта. Если при формировании объекта библиотека обнаруживает, что примитивы этого объекта попадают в область выбора, то содержание стека имен копируется в буфер выбора (вместе с некоторой дополнительной информацией), инициализированного с помощью команды SelectBuffer . При попадании в область сцены примитивов другого именованного объекта, содержание стека имен так же будет скопировано в буфер выбора. Таким образом, могут быть получены имена (номера) объектов, которые полностью или частично попали в область выбора. Необходимо учитывать, что для корректного определения выбранных объектов необходимо, чтобы координатные преобразования объектов, совпадали с теми, которые выполнялись при формировании изображения сцены.
Для работы со стеком имен используются несколько команд. Очистка стека имён выполняется с помощью команды InitNames :
C#: void InitNames(); Object Pascal: procedure glInitNames;
Помещение имени в стек выполняется с помощью команды PushName :
C#: void PushName(uint name); Object Pascal: procedure glPushName(name: GLuint);
Имя передается в качестве параметра команды.
Перед использованием стека имен он должен быть инициализирован с помощью команды InitNames . Затем в стек необходимо поместить один элемент с помощью команды PushName . Перед формированием каждого из объектов единственный элемент стека имен будет заменяться на имя формируемого объекта с помощью команды LoadName . Процедура заменяет последний элемент в стеке имен на заданный в качестве параметра. Таким образом, инициализация и использование стека имен схематически можно представить следующим образом:
InitNames; PushName(0); … LoadName(1); //формирование объекта № 1 LoadName(2); //формирование объекта № 2 LoadName(3); //формирование объекта № 3 //и т.д. Листинг 10.7. Схема использования стека имен для выбора объектов
