Что нужно знать перед изучением opengl

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 контекст и наше первое окно прямо тут.

Статья

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

Требования

Никаких особых требований для этих уроков не требуется. Желательно иметь опыт работы с любым языком программирования (C, Java, Lisp, Javascript и т.д.), для того, что бы полностью понимать код, но это не обязательно. Просто будет сложнее учить сразу 2 вещи.

Все уроки написаны на «Легком С++»: Множество усилий было приложено для того, что бы сделать код максимально простым. Нет шаблонов, нет классов, нет указателей. Так Вы сможете понять все, даже если знаете только Java.

Забудьте все

Вам не нужно ничего знать, но если Вы что-то знаете про OpenGL, забудьте это. Если Вы знаете что-то про glBegin(), забудьте это. Здесь Вы будете изучать современный OpenGL (OpenGL 3 и 4), а большинство уроков, которые Вы можете найти в интернете — по старому OpenGL (OpenGL 1 и 2).
Так что забудьте все, что Вы можете знать про OpenGL, иначе у вас мозг вскипит от смешивания разных стандартов.

Сборка

• Обновите драйвера. Вас предупредили
• Скачайте компилятор, если у вас еще нет его
• Установите CMake исходный код уроков
• Сгенерируйте проект с помощью CMake
• Соберите его
• Поиграйтесь с примерами!

Детальнее, алгоритмы сборки под разные платформы представлены ниже:

Сборка под Windows

• Обновить драйвера должно быть просто. Просто скачайте драйвера с сайта AMD или NVidia, в зависимости от вашей видеокарты. Если вы не уверены в том, GPU какой компании у вас стоит: Панель управления -> Система и Безопасность -> Система -> Диспетчер устройств -> Видеочип. Если у вас интегрированная Intel видеокарта — то драйвера зачастую предоставляются производителем (Dell, HP и т.д.)
• Мы советуем использовать Visual Studio 2015 Express for Desktop в качестве компилятора. Вы можете скачать его бесплатно отсюда. Если Вы предпочитаете MinGW, тогда рекомендуем использовать QtCreator. Устанавливайте ПО в зависимости от ваших предпочтений. Дальнейшее указания будут даны для Visual Studio. Адаптируйте их для вашей IDE.
• Скачайте CMake и установите его. и разархивирейте его к примеру в C:\Users\XYZ\Projects\OpenGLTutorials\
• Запустите CMake. В первой строке введите путь до папки с исходниками. В указанной Вами папке должен находиться CMakeLists.txt. Во второй строке укажите путь, в который будут сохранены результаты работы CMake.
  
• Нажмите на кнопку «Configure». Поскольку это первая настройка проекта, CMake спросит, какой компилятор Вы хотите использовать. Выбирайте мудро, основываясь на первом шаге. Если у вас 64 битная версия Windows, Вы можете выбрать 64 битный компилятор. Если Вы не уверены, выбирайте 32 битный.
• Нажимайте на кнопку «Configure» до тех пор, пока все красные строки не пропадут. Далее нажмите на кнопку «Generate». Проект Visual Studio создан. Теперь Вы можете забыть про CMake.
• Откройте папку, которую Вы указали во второй строке. Найдите там файл Tutorials.sln. Откройте его с помощью Visual Studio.
  
• В меню «Build» нажмите «Build All». Все уроки и зависимости скомпилированы. Все исполняемые файлы были скопированы в папку с уроком. Надеюсь ошибок не возникло.
• Откройте файл playground.exe и появится черное окно.

Сборка под Linux

• Установите последние драйвера. Мы крайне рекомендуем бинарные драйвера с закрытым исходным кодом. Они не открытые, но они работают. Если ваш дистрибутив не предоставляет автоматическую установку, попробуйте урок с сайта Ubuntu.
• Установите необходимые компиляторы, инструменты и библиотеки. Полный список: cmake make G++ libx11-dev libxi-dev libgl1-mesa-dev libglu1-mesa-dev libxrandr-dev libxext-dev libxi-dev. или и разархивируйте его.
• Перейдите в папку с проектом и выполните следующие команды:
• mkdir build
• cd build
• cmake ..
• Makefile был создан в build папке.
• Команда «make all» соберет все уроки и их зависимости. Все исполняемые файлы будут скопированы в папку с проектом.
• Запустите файла ./playground. Должно появиться черное окно.

• В QtCreator откройте File -> Tools -> Options -> Compile&Execute -> CMake
• Установите путь до CMake. Зачастую это /usr/bin/cmake
• File -> Open Project; Выберите tutorials/CMakeLists.txt
• Выберите папку для сборки. Желательно она должна быть вне папки tutorials.
• Можете установить флаг -DCMAKE_BUILD_TYPE=Debug в параметрах.
• Нажмите на Молот внизу. Все уроки будут собраны
• Для запуска уроков из QtCreator, нажмите на Projects -> Execution parameters -> Working Directory и выберите папку, где находятся шейдеры, текстуры и модели.

Сборка под Mac

• Установите XCode из Mac App Store и установите .dmg файл. Вам не надо устанавливать инструменты коммандной строки и разархивируйте их
• Запустите CMake (Applications -> CMake). А первой строке укажите путь до проекта. В этой папке должен находиться файл CMakeLists.txtю Во второй строке укажите путь до папки в которую будут сохранены результаты работы CMake.
• Нажмите на кнопку «Configure». Поскольку это первая настройка проекта, CMake спросит, какой компилятор Вы хотите использовать. Выберите XCode.
• Нажимайте на кнопку «Configure» до тех пор, пока не пропадут все красные строки. Нажмите на «Generate». Все, ваш проект XCode создан. Можете забыть про CMake.
• Откройте папку, путь до которой Вы прописывали во второй строке. Найдите там файл Tutorials.xcodeproj. Откройте его.
• Выберите какой-нибудь урок и запустите его с помощью кнопки Run
  

Заметка к Code::Blocks

В связи с 2 багами (один в Code::Blocks, один в CMake), Вам потребуется изменить настройки в Project->Build Options->Make commands следующим образом:

Также Вам придется настроить рабочую директорию самостоятельно: Project -> Properties -> Build targets -> tutorial N -> Рабочая папка.

Запуск уроков

Рабочими директориями всех скомпилированных уроков должны быть папки с исполняемыми файлами.

Как следовать урокам

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

Открытие окна

Вот мы и добрались до OpenGL кода! Ну то есть не совсем. Все другие уроки показывают низкоуровневый путь для выполнения тех или иных действий, для того, что бы Вы видели, что никакой магии не происходит. Но это скучно и бесполезно, поэтому мы будем использовать стороннюю библиотеку GLFW для предоставления магии. Если Вам очень хочется — Вы можете использовать Win32 API под Windows, X11 API под Linux и Cocoa API под Mac; ну или воспользоваться другой высокоуровневой библиотекой, вроде SFML, FreeGLUT, SDL и т.д.

Что же, начем. В начале разберемся с зависимостями: нам потребуется некоторый базовый функционал для вывода сообщений в консоль:

Далее подключаем GLEW. Эта библиотека предоставляет немного магии, но оставим это на потом:

Мы решили, что будем использовать GLFW для работы с окном и клавиатурой, поэтому подключаем и ее:

Следующая библиотека сейчас нам не понадобится, но она предоставляет функционал для работы с 3D математикой. Очень скоро она нам понадобится. В GLM нет никакой магии, если хотите — можете написать свою собственную библиотеку для работы с 3D математикой. Директива «using namespace» нужна для того, что бы можно было писать просто «vec3» вместо «glm::vec3»:

Если Вы скопировали вышеуказанный код в playground и попытались его запустить — то компилятор Вам сообщит, что нет функции main. Что же, давайте добавим ее:

Для начала инициализируем GLFW:

Теперь мы можем создать наше OpenGL окно!

Соберите этот код и запустите. Должно появиться черное окно и сразу закрыться. Ну конечно! Нам требуется подождать пока пользователь не нажмет Escape:

На этом заканчивается первый урок! Во 2 уроке Вы научитесь рисовать треугольник.

Unick-soft

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

Что такое OpenGL

OpenGL — кросс-платформенная библиотека для 2D и 3D графики. В настоящее время используется для разработки приложений для Mac OS X, iOS, Android, Linux, конкурирует с DirectX для Windows. OpenGL используют не только для разработки игр, но и для приложений, работающих с 3D-графикой: СAD-системы, 3D редакторы, обучающие ПО, медицинские системы.

Свою популярность библиотека получила не только из-за кросс-платформенности, но и из-за возможности использования в проектах на различных языках программирования. И самое главное, OpenGL поддерживается производителями видеокарт, благодаря чему библиотека получает аппаратное ускорение видеокарт. Когда я только начинал работать с OpenGL, у меня возник вопрос: Как установить OpenGL? Где взять дистрибутив? Ответ прост: OpenGL устанавливается вместе с драйверами видеокарты, так как и список расширений и различные константы разнятся в зависимости от видеокарты (правда, Windows может иметь встроенный OpenGL старой версии без поддержки аппаратного обеспечения).

Для использования OpenGL, конечно, необходимо иметь библиотеку для линковки (gl.lib, glu.lib) и заголовочный файлы. Они входят в Visual Studio, но и их не трудно найти в Интернете.

Какие именно возможности вам предоставит OpenGL?

OpenGL предоставляет средства для рендера 3D сцены. OpenGL также позволяет гибко настраивать отрисовку. OpenGL поддерживает аппаратное ускорение, так как большинство команд выполняется на видеокарте.

Какими знаниями необходимо обладать?

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

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

Позиционирование объектов — серьёзный вопрос, связанный с 3D сценами. Объекты позиционируются с помощью аффинных преобразований: перемещение, вращение и увеличение размера. С математической точки зрения эти преобразования записываются соответствующими матрицами. Если вы плохо разбираетесь в этом, то обязательно почитайте специализированную литературу, посвященную данному вопросу.

С чего начать?

Начать изучение я бы посоветовал с хорошей книги, при этом постоянно практикуясь. На русском языке не так много хороших книг, так как большинство из них уже устарели. Я бы посоветовал следующую книгу: «OpenGL. Руководство по программированию». При начальном обучении книга может показаться довольно сложной. Параллельно с ней можно изучать статьи с примерами http://nehe.gamedev.net (перевод статей на русский http://pmg.org.ru/nehe).

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

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

Об устаревших и современных методах и расширениях

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

Когда вы начнёте читать книгу, то обнаружите, что в первых примерах объекты (треугольники или квадраты) вы будете строить по точкам с помощью функции glVertex*, первое освещение вы будете включать, используя glLight, задавать цвет материала функцией glMaterialf. Многие из них не используются в современных проектах. Например, вершины объектов не задаются по одной, а передаются все вместе с помощью Vertex Buffer Object (VBO). Это намного быстрее, так как вершины необходимо передать на видеокарту и намного быстрее передать все сразу, чем по одной. Стандартное освещение тоже не используется, все реализуется в шейдерах. Другими словами, объекты всегда отрисовываются с помощью шейдеров. В шейдеры передаются все необходимые параметры: освещение, материалы, матрицы. И когда вы освоите азы, вам необходимо переключаться на изучение шейдеров (GLSL).

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

На будущее

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