Уроки по OpenGL
OpenGL (англ. «Open Graphics Library») в большинстве случаев рассматривается как API, предоставляющий большой набор функций, которые мы можем использовать для управления графикой и изображениями. Если конкретнее, то OpenGL является спецификацией, разработанной и поддерживаемой Khronos Group.
Независимо от того, пытаетесь ли вы изучить OpenGL в образовательных/карьерных целях или просто ищете новое хобби, эти бесплатные уроки по графическому программированию научат вас основам и всем необходимым деталям работы с OpenGL. Цель этого туториала — показать вам всё, что есть в современном OpenGL, простым для понимания способом с наглядными примерами, а также предоставить бэкграунд для ваших последующих исследований/углублений в эту тему.
Эти уроки нацелены как на тех людей, которые не имеют опыта в графическом программировании, так и на более опытных программистов, которым было бы интересно почитать и систематизировать свои знания. В этом туториале по OpenGL также обсуждаются практические концепции, которые при щепотке дополнительной креативности смогут превратить ваши идеи в настоящие 3D-приложения. Если всё это еще вас не отпугнуло, то я приглашаю вас вместе с собой в это путешествие.
Чему вы научитесь?
Изучение (и использование) OpenGL требует глубоких знаний графического программирования и понимания того, как OpenGL работает «под капотом», чтобы реально извлечь максимальную пользу из вашего предстоящего опыта. Поэтому мы начнем с обсуждения основных графических аспектов, выяснения фактической работы OpenGL для прорисовки пикселей на вашем экране, а также того, как мы можем использовать эти знания для создания каких-то необычных эффектов.
Помимо основного базиса, мы также обсудим множество полезных техник, которые вы сможете использовать для своих приложений, таких как перемещение сцены, создание красивого освещения, загрузка пользовательских объектов из программ моделирования, применение постобработки и многих других. Мы также создадим с вами небольшую игру, применив полученные знания по OpenGL, так что вы действительно прочувствуете, каково это быть графическим разработчиком.
Поскольку OpenGL является графическим API, а не собственно платформой, то для работы с ним потребуется язык программирования. В нашем случае, это язык C++, поэтому вам понадобятся знания по C++. Вам не обязательно быть экспертом по C++, но вы должны уметь написать что-то большее, чем программу «Hello, world!». Для получения дополнительных знаний отлично подойдут уроки по С++ на Ravesli, где каждая тема объясняется отдельным уроком, и куда вы всегда сможете обратиться за детальным разъяснением.
Кроме того, на данных уроках будет использоваться математика (линейная алгебра и геометрия вместе с тригонометрией), которую я также буду стараться объяснять по мере необходимости. Однако, я не являюсь профессиональным математиком, поэтому, хоть мои объяснения и могут быть понятными, они, скорее всего, будут неполными. Поэтому, где это необходимо, я буду указывать хорошие ресурсы, которые объясняют материал более подробно. Не пугайтесь момента с математикой, всё не так уж и страшно Большая часть функционала, с которым мы будем работать, не потребует от вас понимания всей подноготной математики, если вы знаете, как её использовать.
Структура уроков
Наш учебный путь разбит на последовательные главы. Каждая из глав содержит уроки, на которых мы подробно будем рассматривать различные концепции. Поскольку уроки являются последовательными, то лучше всего начинать с самого начала, так как на каждом следующем уроке используются концепции, которые рассматривались на предыдущем.
Ravesli/OpenGL
If nothing happens, download GitHub Desktop and try again.
Launching GitHub Desktop
If nothing happens, download GitHub Desktop and try again.
Launching Xcode
If nothing happens, download Xcode and try again.
Launching Visual Studio Code
Your codespace will open once ready.
There was a problem preparing your codespace, please try again.
Latest commit
Git stats
Files
Failed to load latest commit information.
README.md
Уроки по OpenGL
Независимо от того, пытаетесь ли вы изучить OpenGL в образовательных/карьерных целях или просто ищете новое хобби, эти бесплатные уроки по графическому программированию научат вас основам и всем необходимым деталям работы с OpenGL. Цель этого туториала — показать вам всё, что есть в современном OpenGL, простым для понимания способом с наглядными примерами, а также предоставить бэкграунд для ваших последующих исследований/углублений в эту тему.
Эти уроки нацелены как на тех людей, которые не имеют опыта в графическом программировании, так и на более опытных программистов, которым было бы интересно почитать и систематизировать свои знания. В этом туториале по OpenGL также обсуждаются практические концепции, которые при щепотке дополнительной креативности смогут превратить ваши идеи в настоящие 3D-приложения. Если всё это еще вас не отпугнуло, то я приглашаю вас вместе с собой в это путешествие.
Чему вы научитесь?
Изучение (и использование) OpenGL требует глубоких знаний графического программирования и понятия того, как OpenGL работает «под капотом», чтобы реально извлечь максимальную пользу из вашего предстоящего опыта. Поэтому мы начнем с обсуждения основных графических аспектов и того, как OpenGL фактически рисует пиксели на вашем экране, и то, как мы можем использовать эти знания для создания каких-то необычных эффектов.
Поскольку OpenGL является графическим API, а не, собственно, платформой, то для работы с ним потребуется язык программирования. В нашем случае, это язык C++, поэтому вам понадобятся знания по C++. Вам не обязательно быть экспертом по C++, но вы должны уметь написать что-то большее, чем программу «Hello, world!». Для получения дополнительных знаний отлично подойдут уроки по С++ на Ravesli — https://ravesli.com/uroki-cpp/, где каждая тема объясняется отдельным уроком и куда вы всегда сможете обратиться за детальным разъяснением.
Наш учебный путь разбит на последовательные главы. Каждая из глав содержит уроки, на которых мы подробно будем рассматривать различные концепции. Поскольку уроки являются последовательными, то лучше всего начинать с самого начала, так как на каждом следующем уроке используются концепции, которые рассматривались на предыдущем.
Что нужно знать перед изучением opengl
В статье мы познакомимся со стандартом OpenGL и напишем простейшее приложение, использующее API OpenGL.
Содержание
Клонируем репозиторий, создаём ветку
Для освоения OpenGL мы будем использовать репозиторий с примерами cg-course-2018/QtLabs2D. Если вы ещё не клонировали к себе этот репозиторий, клонируйте его. После этого вы можете переключиться на ветку stable в интерфейсе своего клиента git или в консоли.
Вы должны переключиться в существующую ветку, а не в новую. Возможно, перед началом потребуется синхронизировать репозитории ( git fetch origin ).
Теперь на основе ветки stable создайте ветку tmp_
Ветку не нужно будет отправлять на удалённый репозиторий. Она временная.
Что такое OpenGL
OpenGL — это стандарт API для рисования трёхмерной графики. В нашем курсе будем использовать OpenGL 3.x — примерно то же самое, что GLES 2.x или WebGL 1.
Посмотрите на общую историю версий графических API, чтобы понять, где мы находимся:
За годы, прошедшие между OpenGL 1.x и OpenGL 3.x, представления программистов о 3D-графике изменились кардинально. Было обнаружено, что программный интерфейс, разработанный для OpenGL 1.0, имеет недостаточную гибкость и потворствует потерям производительности при рисовании графики. Начиная с OpenGL 3.0, была представлена полностью новая модель программирования с использованием OpenGL, а старый способ был объявлен устаревшим.
В последующие годы появились очередные новшества, такие как OpenGL 4.x и Vulkan. Они нацелены на сверхбыстрый параллелизм при вычислениях и на нестандартные применения видеокарт (например, для выполнения расчётов общего назначения с помощью Computing Shaders). Если же вы хотите изучить именно графику, не стоит оглядываться на OpenGL 4 и Vulkan: их использование даже в минимальных примерах требует прекрасного понимания 3D-графики, умения качественно писать многопоточный и асинхронный код, глубоких знаний в системном программировании.
OpenGL спроектирован для видеокарт
Это означает, что в OpenGL приложениях изображение рисует не центральный процессор, а множество узкоспециализированных процессоров внутри видеокарты. В редких случаях используется медленная программная растеризация: в этом случае изображение рисует центральный процессор в несколько потоков.
Современные видеокарты предоставляют огромные вычислительные возможности благодаря параллельной обработке вершин и фрагментов. Это хорошо показано на видео “CPU vs GPU” от NVIDIA:
Возможности OpenGL на конкретном компьютере зависят от операционной системы и от производителя драйвера. OpenGL на Linux и на Windows имеют разные возможности. OpenGL в драйверах от NVIDIA и в драйверах от Intel также различаются. Тем не менее, можно писать код, одинаково качественно работающий на любой реализации OpenGL — для этого нужно соблюдать стандарты и внимательно читать документацию используемых функций OpenGL.
Создаём сцену для работы с OpenGL
В наборе проектов QtLabs2D из шаблона Qt GUI Application создайте новый проект приложения с названием “Sample05”:
Удалите все файлы, кроме “main.cpp”. Перейдите к настройкам проекта и добавьте в пути поиска заголовочных файлов путь к корню репозитория. Это можно сделать, используя переменную SolutionDir:
Затем нужно добавить ссылку на проект libplatform, чтобы система сборки автоматически выполняла компоновку с ним.
Затем перепишите в “main.cpp” следующий код:
Наконец, соберите и запустите проект “Sample05”. Программа должна собраться успешно, после запуска программы отобразится окно размерами 800×600 (вероятно, залитое чёрным цветом).
Теперь создадим и подключим класс сцены. Создайте в проекте заголовок и “*.cpp” файл для класса SimpleScene.
В заголовке “SimpleScene.h” вам нужно подключить заголовок <libplatform/IRenderScene.h> , и затем перегрузить методы интерфейса IRenderScene:
Реализация класса пока что будет пустой:
Теперь можно передать объект класса сцены объекту окна. В функции main добавьте соответствующую инструкцию:
Путаница версий OpenGL
Интерфейс OpenGL состоит из функций и констант. В новых версиях OpenGL старые функции и константы исчезали (в режиме Core Profile) либо оставались в роли устаревших (в режиме Compatibility Profile).
Для использования OpenGL предоставляется заголовок <GL/gl.h> . Какую версию OpenGL вы увидите в этом заголовке?
- На Windows: OpenGL 1.1, API 1997-го года
- На Android/iOS: зависит от версии NDK/SDK
- На Linux/Mac OSX: зависит от способа подключения заголовка (набора макросов) и версии ОС
Реализацию OpenGL предоставляет видеодрайвер. Это означает, что на Windows с современной видеокартой NVIDIA вам может быть доступна последняя версия OpenGL, а с древней видеокартой — только версия 2.0 или даже 1.1.
На современных Linux/Mac OSX ситуация лучше: если видеокарта устаревшая, то новые возможности OpenGL буду эмулироваться программно. Это работает медленнее и нагружает центральный процессор, зато вам доступна новая версия OpenGL.
Как использовать OpenGL без привязки к версии платформы? Для этой в Qt5 есть класс QOpenGLFunctions_3_3_Core (и серия похожих классов). Вы можете унаследовать от него свой класс сцены
Также добавьте инициализацию функций OpenGL в метод initialize:
Устанавливаем glm
Для установки библиотек мы будем использовать пакетный менеджер vcpkg. Пакетный менеджер vcpkg распространяется в исходниках и собирается на машине разработчика. Для сборки потребуется установленная Visual Studio с инструментами C++ разработчика.
Порядок установки описан в консольных командах:
После того, как вы получили vcpkg.exe , вы можете устанавливать пакеты командой install .
В частности, нам потребуется установить GLBinding и GLM:
В команде, представленной выше, имена пакетов перечисляются по порядку, а в качестве суффикса используется так называемый “триплет”: имя_пакета:триплет .
- Имя пакета задаёт одно из множества имён доступных библиотек, полный список есть в блоге Visual C++ Team
- Триплет задаёт архитектуру и режим сборки
Для удобства использования пакетов vcpkg вы можете включить режим интеграции для всех проектов на своей машине одной командой:
Как работает OpenGL
В основном OpenGL оперирует треугольниками, изображениями и состояниями драйвера рисования. Если упростить схему работы, останется пять ключевых шагов рисования каждого объекта на экране. Рассмотрим все эти шаги.
Шаг №1 — загрузка вершин примитивов
Программист передаёт из управляющей программы массивы данных, описывающих вершины графических примитивов, то есть треугольников, линий или точек (чаще всего треугольников). Каждая фигура и каждая поверхность будет нарисована с помощью примитивов. На рисунке показано, как разбить сектор эллипса на треугольники:
Шаг №2 — обработка вершин примитивов вершинным шейдером
На втором шаге выполняется вершинный шейдер (англ. vertex shader): он получает на вход все данные одной из вершин, а на выход обязан предоставить четырёхкомпонентный вектор с координатами вершины и набор любых других данных для фрагментного шейдера:
Программист заранее указывает свой вершинный шейдер. Его пишут на специальном языке GLSL, затем он компилируется видеодрайвером и выполняется прямо на видеокарте.
Шаг №3 — интерполяция атрибутов вершин и фрагментация примитивов
Представьте, что вы рисуете треугольник на клетчатой бумаге. Какие-то клетки будут зарисованы полностью, другие — только частично, а оставшиеся не будут зарисованы вообще. Точно так же видеокарта должна определить, в какие пиксели попадает треугольник. Эти пиксели называются фрагментами.
Представьте, что вы захотели сделать треугольник разноцветным, с плавным переходом от жёлтого цвета по левому краю в красный цвет на правом. В OpenGL это выполняется автоматически:
- вы указываете разные цвета для каждой из вершин треугольника
- на шаге №3 видеокарта выполняет в каждом фрагменте линейную интерполяцию, вычисляя взвешенное значение цвета или любого другого атрибута
Линейная интерполяция — это интерполяция с линейным (равномерным) изменением свойства от вершины A к вершине B. Возьмём условный параметр t ∈ [0..1] , описанный следующим образом:
- для фрагмента, содержащего вершину A, t = 0
- для фрагмента, содержащего вершину B, t = 1
- для фрагмента, лежащего между A и B ровно посередине, t = 0.5
- и так далее для всех фрагментов между A и B
Линейно интерполированное свойство фрагмента будет вычисляться по формуле: p(t) = pA ∙ (1 — t) + pB ∙ t . Легко заметить, что эта формула работает для самих вершин A и B:
- для вершины A: p(0) = pA ∙ (1 — 0) + pB ∙ 0 = pA
- для вершины B: p(1) = pA ∙ (1 — 1) + pB ∙ 1 = pB
Конечный результат линейной интерполяции RGBA-цвета от вершин по всему треугольнику показан на рисунке:
Шаг №4 — обработка фрагментов фрагментным шейдером
На данном шаге снова вызывается пользовательский код в составе фрагментного шейдера (англ. fragment shader). Его также пишут на языке GLSL. Фрагментный шейдер получает на вход всё, что вершинный шейдер ему передал, но в преобразованном виде. Допустим, вершинный шейдер сохранил для фрагментного цвет вершины — но фрагментный шейдер оперирует фрагментами, и поэтому переданные данные также проходят линейную интерполяцию.
Шаг №5 — проверки, смешивание цвета и запись в буфер кадра
На последнем шаге фрагмент проходит ряд тестов — в каждом из них видеокарта проверяет, должен ли фрагмент попасть в кадр. Например, в 3D пространстве фрагмент может быть закрыт другим геометрическим телом, и это выявляется в тесте глубины (англ. depth test).
Если проверка пройдена (что в 2D графике случается почти всегда), то фрагмент записывается в пиксель кадра. Перед эти выполняется смешивание, позволяющее наложить полупрозрачный пиксель на существующий фон кадра.
Конвейер в целом
Все шаги конвейера изображены на единой схеме, взятой из статьи An intro to modern OpenGL. Chapter 1: The Graphics Pipeline:
Подготовка: RandomColorGenerator
Чтобы продемонстрировать работу интерполяции атрибутов вершин, мы будем генерировать цвета вершин случайным образом. Для этого создайте класс RandomColorGenerator. Объявление будет следующим:
Реализация генератора случайных цветов будет всего лишь выбирать цвет из готовой палитры:
Запускаем конвейер
Перейдите к “SimpleScene.cpp” и добавьте подключение заголовков glm. Заголовки пригодятся нам для работы с векторной алгеброй.
Создайте анонимное пространство имён и добавьте в него константы-строки, содержащие исходные коды вершинного и фрагментного шейдеров.
Анонимное пространство имён прячет константы и функции от других единиц трансляции (cpp-файлов), тем самым избавляя вас от неожиданных конфликтов имён функций.
Компиляция шейдеров
Что такое шейдер? Это маленькая программа на языке GLSL (расшифровывается OpenGL Shading Language). Задача программы зависит от типа шейдера: вершинный шейдер трансформирует вершины, фрагментный шейдер вычисляет цвет фрагмента фигуры. Шейдер работает как чистая функция: один вход, один выход и никаких состояний (вы не можете ничего запомнить между двумя вызовами шейдера).
Компиляция шейдера выполняется во время выполнения вашей программы. Компилятор шейдеров находится в ядре видеодрайвера. Руководит компиляцией ваша программа. В OpenGL разделены понятия “шейдер” и “программа”. Программа состоит из нескольких разнотипных шейдеров. Минимальная программа в OpenGL Core Profile состоит из вершинного и фрагментного шейдеров.
Общая схема компиляции шейдеров изображена ниже.
Для сборки шейдера мы будем использовать API OpenGL. Примерная схема вызовов (без обработки ошибок) выглядит следующим образом:
Добавьте классу SimpleScene три поля:
После этого в метод initialize() добавьте вызов нового приватного метода initializeShaders() , в котором будет размещена компиляция шейдеров и компоновка программы:
Приватный метод compileShader будет выполнять компиляцию шейдера и проверку статуса компиляции:
Приватный метод linkProgram выполняет компоновку программы из шейдеров:
В конце добавьте в деструктор SimpleScene удаление шейдерной программы и шейдеров:
Вершинные данные
В старых версиях OpenGL существовали стандартные атрибуты (свойства) вершин: координаты, текстурные координаты, цвет и так далее. Однако, стандартизация ограничивала возможности программиста. Поэтому в современном OpenGL вершина может иметь какие угодно числовые или векторные величины, описывающие её содержимое. Способ интерпретации вершинных данных вы определяете самостоятельно в шейдерах.
Наши шейдеры ожидают два атрибута на каждую вершину: двумерные координаты и четырёхмерный цвет (RGBA). Поэтому мы поместим в начале заголовка “SimpleScene.h” определение структуры, которую мы назовём VertexP2C4:
Далее мы должны сообщить драйверу видеокарты смещения атрибутов вершины в памяти. Дело в том, что на видеокарту мы будем загружать целые массивы вершин, и внутри массива будут так называемые interleaved массивы атрибутов. Другими словами, несколько массивов атрибутов как будто бы сплетены в единый массив вершинных данных:
Во время компиляции шейдера видеодрайвер назначил каждому атрибуту его собственный целочисленный идентификатор. Мы должны получить у шейдерной программы идентификаторы атрибутов, а затем для каждого атрибута указать смещения в памяти, с помощью которых OpenGL сможет в непрерывном массиве памяти найти нужные байты. Этим займётся приватный метод bindVertexData:
Vertex Buffer Object и Vertex Array Object
Vertex Buffer Object — это объект видеодрайвера, представляющий область пользовательских данных на видеокарте. Для программиста VBO доступен в виде целочисленного идентификатора.
Чтобы хранить целочисленный идентификатор VBO, добавьте в SimpleScene поле GLuint m_vbo = 0; .
Кроме того, мы будем хранить Vertex Array Object — объект, позволяющий оптимизировать смену состояний видеодрайвера. Пока что мы используем VAO просто потому, что OpenGL требует хотя бы одного VAO, поэтому добавьте в класс ещё одно поле: GLuint m_vao = 0;
Затем в функцию initialize добавьте инициализацию VBO и VAO:
В конце добавьте деструктор классу SimpleScene, который будет очищать данные:
Триангуляция пятиугольника
Среди всех многоугольников в компьютерной графике предпочитают выпуклые многоугольники (англ. convex), т.к. их проще всего разделить на треугольники. Согласно википедии:
Выпуклым многоугольником называется многоугольник, все точки которого лежат по одну сторону от любой прямой, проходящей через две его соседние вершины.
Благодаря этому мы можем разделить выпуклый многоугольник на треугольники с помощью центральной точки. Таким образом мы создадим своего рода веер треугольников.
Следует учесть, что многие вершины будут продублированы — каждая внешняя вершина входит в состав двух треугольников, но при этом треугольники могут иметь разный цвет, а цвета определяются вершинами.
Добавьте в анонимное пространство имён функции триангуляции многоугольника:
Триангуляция круга
Разделить круг на треугольники легко с помощью тригонометрии: достаточно пройтись по углам от 0° до 360° с некоторым шагом, например, 1°. Каждый угол вместе с радиусом задаёт точку в полярных координатах.
Перевести полярные координаты в декартовы очень легко — достаточно вспомнить одно из определений синуса и косинуса:
Декартовы координаты по-английски называются Эвклидовыми (euclidean), и мы назовём функцию соответствующе:
Теперь мы можем описать функцию для триангуляции круга:
Выполняем триангуляцию двух фигур
Теперь мы можем триангулировать фигуры, чтобы получить результат, который вы видите на скриншоте:
Прежде всего добавьте в SimpleScene новое поле size_t m_vertexCount = 0; — позже число треугольников потребуется нам для рисования.
Добавим в main следующий код в метод initializeShapes, вызов которого надо поместить в конец метода initialize:
Устанавливаем матрицу проецирования
Казалось бы, что может быть проще, чем наложить виртуальные координаты холста на координаты окна? Однако, OpenGL устроен иначе: он рассчитан на 3D графику, в которой координаты виртуального мира не совпадают с координатами окна. Более того, начало координат OpenGL находится в нижнем левом углу, а не в верхнем левом!
Ради нужд 3D графики все координаты вершин проецируются внутрь куба размерами 2x2x2 условных единиц с помощью матрицы проецирования. Поскольку мы хотим получить 2D координаты, да ещё и совмещённые с привычными координатами окна, нам нужна матрица ортографического проецирования, которая растянет координаты вершин обратно из куба 2x2x2 в координаты окна. Для этой цели мы напишем метод setProjectionMatrix , выполняющий две задачи:
- вычислить матрицу ортографического проецирования из куба на координаты окна с помощью функции glm::ortho
- установить эту матрицу как константу в шейдерной программе с помощью glUniformMatrix4fv
Реализуем метод redraw
Метод redraw будет с использованием полученных размеров окна устанавливать так называемый Viewport, привязывать шейдерную программу и VAO, а затем очищать изображение, устанавливать матрицу проецирования, наконец, вызывать glDrawArrays для рисования всех примитивов.
learnopengl. Урок 1.1 — OpenGL
Здравствуйте. Несколько недель назад я начинал серию переводов статей по изучению OpenGL. Но на 4 статье один хабровчанин заметил, что мои переводы могут нарушать лицензию, по которой распространяются учебные материалы, предоставленные в исходной статье. И действительно, мои переводы нарушали лицензию. Для разрешения этой проблемы я обратился к авторам того набора уроков, но так и не смог добиться нормального ответа. По этой причине я связался с автором другого, не менее (а возможно даже и более) крутого, набора уроков по OpenGL: Joey de Vries. И он дал полное разрешение на перевод его набора уроков. Его уроки гораздо более обширные, чем прошлый набор, поэтому эти переводы растянутся на долго. И я обещаю, будет интересно. Заинтересовавшихся прошу под кат.
Также я встал на распутье: либо я опишу все основы вроде создания окна и контекста в одной статье, чтобы не плодить статьи, но в таком случае такую огромную статью не всякий осилит; либо я также как и раньше буду переводить, опираясь на иерархию оригинала. Я решил выбрать второй вариант.
На счет уроков по Vulkan: к сожалению мне тяжело сейчас написать уроки по данному API по причине скудной видеокарты на данный момент, которая просто не поддерживает Vulkan API, поэтому уроки по данному API будут только после обновления видеокарты.
Часть 1.1 — OpenGL
Вступление
Прежде чем мы начнем наше путешествие нам стоило бы разобраться что такое OpenGL. В основном под OpenGL понимают API (Интерфейс Программирования Приложений), который предоставляет большой набор функций, которые мы можем использовать для управления графикой и изображениями. Но на самом деле OpenGL это скорее спецификация, разработанная и поддерживаемая Khronos Group.
Спецификация OpenGL описывает каким будет результат выполнения каждой конкретной функции и что она должна делать. А уже реализация этих спецификаций лежит на плечах разработчиков. И поскольку спецификация не описывает детали реализации, соответственно имеют право на существование различные реализации OpenGL, по крайней мере пока они соответствуют спецификациям.
Люди, разрабатывающие OpenGL библиотеки, зачастую, являются производителями видеокарт. Каждая видеокарта, которую вы покупаете, поддерживает конкретные версии OpenGL из набора библиотек, разработанных для данной серии видеокарт. При использовании Apple системы, OpenGL библиотеки поддерживаются Apple, под Linux существуют комбинации версий от поставщиков и пользовательских адаптаций этих библиотек. Это также означает, что если используемая вами версия OpenGL показывает странное поведение, значит, с большой вероятностью — это ошибка производителей видеокарт.
Khronos выложила в публичный доступ все спецификации для всех версий OpenGL. Заинтересовавшийся читатель может найти спецификации OpenGL 3.3 (именно эту версию OpenGL мы будем использовать) здесь. Спецификации отлично показывают правила работы всех функций.
Core-profile и Immediate mode (Мгновенный режим)
Раньше, использование OpenGL предполагало разработку в Immediate mode (также известен как фиксированный конвейер (fixed function pipeline)), которая была проста в использовании для рисования графики. Большинство функционала OpenGL было скрыто в библиотеках и у разработчиков не было свободы в понимании вычислений, производимых OpenGL.
Разработчики требовали большей гибкости в разработке и позже спецификация стала более гибкой, а разработчики получили больше контроля над процессом отрисовки их графики. Immediate mode был прост в использовании и понимании, но он был крайне неэффективным. По этой причине спецификация указала Immediate mode как устаревший, и начиная с версии 3.2 начала мотивировать программистов использовать Core-profile режим, который исключал весь устаревший функционал.
При использовании core-profile, OpenGL заставляет нас пользоваться современными практиками. Когда мы пытаемся использовать устаревшие функции, OpenGL выбрасывает ошибку и прекращает отрисовку. Преимущества использования современных практик — это гибкость и эффективность, но к сожалению бОльшая сложность в изучении. Immediate mode является бОльшей абстракцией и он скрывает большое количество реальной работы, выполняемой OpenGL и поэтому его было легко изучать, но трудно разобраться, как OpenGL на самом деле работает. Современный подход требует от разработчика полного понимания OpenGL и графического программирования в целом и хоть это немного сложнее, такая схема позволяет добиться большей гибкости, эффективности.
Это причина, почему наши уроки основаны на Core-Profile OpenGL версии 3.3.
Хоть он немного и сложнее, но это того стоит.
Сейчас уже вышли гораздо более новые версии OpenGL (на момент написания 4.5) и вы можете спросить: зачем мы должны изучать OpenGL 3.3, когда уже вышел 4.5? Ответ довольно прост. Все старшие версии OpenGL, начиная от версии 3.3 не добавляют различные полезные возможности без изменения основной механики. Новые версии просто предоставляют немного более эффективные или более удобные способы выполнения одних и тех же операций. В результате все концепты и техники, применимые к OpenGL 3.3 можно применить к новым версиям OpenGL.
Расширения
Отличной возможностью OpenGL является поддержка расширений. В то время, когда производители видеокарт представляют новую технологию или новую обширную оптимизацию для отрисовки, в драйверах появляется расширение, относящееся к этому событию. Если аппаратное обеспечение, на котором запущено приложение, поддерживает расширение, значит разработчик может использовать функционал, предоставляемый этим расширением для более продвинутой, или эффективной отрисовки графики. Таким образом графический программист может использовать новые технологии без ожидания их реализация в новых версиях OpenGL, просто проверив поддержку технологии видеокартой. Зачастую, если какое-то расширение пользуется большим спросом, его реализуют как часть следующей версии OpenGL.
Разработчику надо лишь проверить доступность расширения (или использовать библиотеку расширения). Такой подход позволяет программисту выполнять действия более эффективно, основываясь на имеющихся у него расширениях:
C OpenGL 3.3 нам редко будут нужны расширения, но когда будут нужны, необходимые инструкции будут предоставлены.
Конечный автомат
OpenGL по своей сути — это большой конечный автомат: набор переменных, определяющий поведение OpenGL. Под состоянием OpenGL в основном имеется ввиду контекст OpenGL. В процессе использования OpenGL, мы часто изменяем состояния, устанавливая некоторых опции, управляем буферами, а затем отрисовываем, используя текущий контекст.
Когда мы говорим OpenGL, что мы хотим начать отрисовывать, к примеру, линии, вместо треугольников, то мы меняем состояние OpenGL, изменяя опцию, отвечающую за то как OpenGL должен рисовать. После изменения состояния OpenGL, на отрисовку линий, все последующие функции отрисовки будут отрисовывать линии вместо треугольников.
Во время работы с OpenGL мы будем проходить через несколько меняющих состояния функций, которые будут менять контекст, и через несколько меняющий состояния функций, выполняющие действия в зависимости от текущего состояния OpenGL. До тех пор, пока вы держите в голове тот факт, что OpenGL — это большой конечный автомат, большинство функционала будет вам понятна.
Объекты
Библиотеки OpenGL написаны на C и имеют множественные ответвления, но в основном это C библиотека. Поскольку большинство конструкций из языка C не транслируется в высокоуровневые языки OpenGL был разработан с использованием большого количества абстракций. Одной из таких абстракций является система объектов в OpenGL.
Объект в OpenGL — это набор опций, которые представляют подмножество состояний OpenGL. К примеру мы можем создать объект, описывающий конфигурацию отрисовки окна; мы можем задать размер, количество цветов и так далее. Такой объект можно представить C-подобной структурой:
Каждый раз, когда мы хотим использовать объекты в основном мы запишем это как-то так:
Этот небольшой участок кода — то, что вы будете часто встречать во время работы с OpenGL. В начале мы создаем объект и сохраняем ссылку на него в виде идентификационного номера (id). (Реальные данные объекта спрятаны в реализации). Затем мы привязываем объект к требуемой части контекста (Расположение целевого объекта окна из примера задано, как `GL_WINDOW_TARGET`). Затем мы устанавливаем значения опций окна и, в конце концов, отвязываем объект, установив id в 0. Значения, установленные нами продолжают храниться в объекте, доступ к которому мы можем получить через objectId и восстановить их снова привязав объект к GL_WINDOW_TARGET.
Основная фишка этих объектов состоит в том, что мы можем объявлять множество объектов в нашем приложении, задавать их опции и когда бы мы не запускали операции с использованием состояния OpenGL мы можем просто привязать объект с нашими предпочитаемыми настройками. К примеру этом могут быть объекты с данными 3D модели или нечто, что мы хотим на этой модели отрисовать. Владение несколькими объектами позволяет просто переключаться между ними в процессе отрисовки.
Давайте начнем
Теперь вы немного узнали про OpenGL как о спецификации, так и о библиотеке. Узнали примерный алгоритм работы и несколько особенностей, используемых OpenGL. Не расстраивайтесь, если что-то недопоняли, далее мы пошагово пройдемся по всем этапам и вы увидите достаточно примеров, чтобы разобраться во всех хитросплетениях OpenGL. Если вы уже готовы начать — то мы можем начать создавать OpenGL контекст и наше первое окно прямо тут.