Библиотеки opengl и directx история и перспективы

Что лучше для BlueStacks: DirectX или OpenGL?

Достаточно часто можно встретить и вопросы по поводу использования одного из самых популярных эмуляторов Android-систем под названием BlueStacks. Какую платформу предпочесть в BlueStacks — OpenGL или DirectX? Увы, и тут однозначного ответа дать нельзя.

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

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

Впрочем, многое может зависеть и от того, какую конечную цель вы перед собой ставите и какой именно функционал каждой платформы будет использоваться в каждом конкретном случае (только графика, только звук или какие-то объединенные решения).

Массивы — это текстуры

Все данные, которые мы будем обрабатывать, мы будем хранить в виде текстур. Ведь что такое текстура? Это
изображение, то есть двумерный массив пикселей. (Если быть точным, то трёхмерный, учитывая три цветовых канала и
прозрачность.) По сути это матрица, а с ними нам и нужно работать.

Из этого следует важный вывод. Вершинный шейдер нам особо и не нужен. Однако без него конвейер работать не будет
и всё равно придётся какую-то заглушку ставить.

Использование текстур для хранения массивов накладывает серьёзные ограничения (которые становятся ещё более
серьёзными в урезанных ES-версиях OpenGL). Например, в OpenGL ES 2.0, который мы договорились использовать,
данные мы можем хранить максимум в виде четырёх байтов
(RGBA — красный зелёный, синий и прозрачность). Можно, конечно, выкрутиться, и как-то закодировать вещественное
число, но нужно помнить, что в шейдере эти байты будут обрабатываться независимо и придётся их декодировать
обратно. Впрочем, если мы решаем задачу цифровой обработки изображения, то это не проблема. Исходное изображение
очевидным образом используется как текстура.

У этой проблемы, конечно, есть решения. Одно из них — использовать расширения OpenGL. Как известно, у базового
OpenGL возможностей мало, но производители «железа» добавляют много новых. Все расширения зарегистрированы и
мы всегда можем проверить, поддерживает наше оборудование какое-то расширение или нет.

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

Впрочем, уже в OpenGL ES 3.0 (не говоря уж о «взрослых» OpenGL, без ES) есть поддержка чисел с плавающей точкой
в текстурах.

CMake

CMake — это инструмент, который с использованием заранее определенных сценариев может из коллекции файлов исходного кода сгенерировать файлы проектов/решений под выбранную пользователем IDE (например, для Visual Studio, Code::Blocks или Eclipse). Он позволит нам из исходного пакета файлов GLFW создать файл проекта под среду разработки Visual Studio 2019, а затем данный файл мы сможем использовать для компиляции библиотеки. Но сначала нам нужно его скачать, а затем установить.

После установки CMake у вас будет 2 варианта:

запустить CMake из командной строки;

запустить CMake через графический интерфейс.

Поскольку мы не стремимся всё усложнять, то остановимся на варианте с использованием графического интерфейса. Для работы с CMake нам потребуется указать папку с файлами исходного кода проекта (в нашем случае ) и папку назначения для бинарных файлов. Для папки исходного кода мы собираемся выбрать корневую папку загруженного исходного пакета GLFW, а для папки сборки мы создадим новый каталог :

После того, как мы прописали пути для исходной и целевой папок, нам нужно нажать кнопку , чтобы CMake смог просмотреть исходные файлы GLFW и выбрать необходимые параметры для сборки.

В следующем окне необходимо задать используемую версию Visual Studio. Т.к. работать мы будем в Visual Studio 2019, то выбираем опцию :

Далее CMake отобразит возможные варианты сборки библиотеки. Можно оставить значения по умолчанию и снова нажать кнопку , чтобы сохранить настройки:

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

Создание

Сперва узнаем, текстуры какого размера вообще поддерживаются.

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

Мой ноутбук выдал значение . Это значит, что я могу загружать текстуры размером 16384×16384.
Нам хватит с запасом.

С каждой текстурой связан некий объект, имеющий уникальный идентификатор (имя, если пользоваться
терминологией OpenGL). И перед началом работы с текстурой нужно этот объект создать.

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

Параметр 2 — это число создаваемых текстурных объектов. Текстуру будем использовать для
входа, а для выхода.

Ядра — это шейдеры

Программу для поэлементных вычислений над матрицами в GPGPU называют ядром. Не лишним будет ещё раз напомнить,
что ядра применяются к элементам матрицы независимо и параллельно. То есть, в идеале время обработки всей
матрицы будет равно времени работы одного ядра. (В жизни это, конечно, не так. На все элементы ядер не хватает,
потому приходится выполнять обработку блоками.)

И тут уже аналогия очевидна. Ядра — это фрагментные шейдеры. Мы можем запускать шейдеры с некоторыми параметрами,
делая их более универсальными, но надо помнить, что параметры будут одинаковыми для всех шейдеров на время
обработки.

Переносимость [ править ]

Запатентованный Direct3D официально реализован только на семьях Windows от Microsoft операционных систем, в том числе встроенных версий , используемых в Xbox семействе игровых консолей и Sega «s Dreamcast . Несколько в основном функциональных переопределений Direct3D API были сделаны третьими сторонами, такими как Wine , проект по переносу общих Windows API на Unix-подобные операционные системы, и Cedega , проприетарный форк Wine. Однако этот процесс все больше затрудняется из-за взаимозависимости DirectX от многих других проприетарных компонентов Windows, а также из-за того, что проприетарный характер Direct3D требует сложного процессаобратная инженерия .

OpenGL имеет реализации, доступные на многих платформах, включая Microsoft Windows, системы на основе Unix, такие как Mac OS X , Linux . Nintendo и Sony разработали свои собственные библиотеки, которые похожи, но не идентичны OpenGL. [ необходима цитата ] Подмножество OpenGL было выбрано в качестве основной графической библиотеки для Android , BlackBerry , iOS и Symbian в форме OpenGL ES .

Драйвер Microsoft OpenGL обеспечивает аппаратное ускорение в Windows Vista; поддержка была прекращена в Windows XP [ необходима цитата ] вскоре после того, как они не смогли предоставить низкоуровневую поддержку графического API Fahrenheit для слияния OpenGL и Direct3D в конце 1990-х. Аппаратное ускорение OpenGL в Windows достигается за счет того, что пользователи сначала устанавливают устанавливаемые клиентские драйверы (ICD), разработанные производителями графических процессоров . Эти ICD практически во всех случаях поставляются в комплекте со стандартным пакетом загрузки драйверов от поставщика оборудования (IHV), поэтому установки последних графических драйверов достаточно для обеспечения аппаратной поддержки OpenGL.

Совсем недавно проект Google почти Native Graphics Layer Engine ( ANGLE ) предоставляет средства для преобразования вызовов приложений OpenGL ES 2.0 в DirectX 9 . Это сделано для того, чтобы WebGL (вариант подмножества OpenGL для Интернета) мог работать в общей среде выполнения Direct3D, что означает меньшую вариативность между поставщиками.

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

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

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

Главное внимание здесь уделено COLLADA и glTF. Она будет полностью поддерживать форматы 1.4, 1.4.1, 1.5+, а также некоторые другие в качестве библиотеки для загрузки моделей в OpenGL.

Дизайн

Иллюстрация процесса графического конвейера

Спецификация OpenGL описывает абстрактный API для рисования 2D и 3D графики. Хотя API можно полностью реализовать программно, он предназначен для реализации в основном или полностью аппаратно .

API определяется как набор функций, которые могут быть вызваны клиентской программой, наряду с набором именованных целочисленных констант (например, константа GL_TEXTURE_2D, которая соответствует десятичному числу 3553). Хотя определения функций внешне похожи на определения языка программирования C , они не зависят от языка. Таким образом, OpenGL имеет множество языковых привязок , среди которых наиболее примечательными являются привязка JavaScript WebGL (API, основанный на OpenGL ES 2.0 , для 3D-рендеринга из веб-браузера ); C-связывания WGL , GLX и CGL ; привязка C, предоставляемая iOS ; и привязки Java и C, предоставляемые Android .

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

Разработка

OpenGL — это активно развивающийся API. Группа Khronos регулярно выпускает новые версии спецификаций OpenGL , каждая из которых расширяет API для поддержки различных новых функций. Детали каждой версии определяются консенсусом между членами Группы, включая производителей видеокарт, разработчиков операционных систем и общие технологические компании, такие как Mozilla и .

В дополнение к функциям, необходимым для основного API, поставщики графических процессоров (GPU) могут предоставлять дополнительные функции в виде расширений . Расширения могут вводить новые функции и новые константы, а также могут ослаблять или снимать ограничения на существующие функции OpenGL. Поставщики могут использовать расширения для предоставления пользовательских API без необходимости поддержки со стороны других поставщиков или Khronos Group в целом, что значительно увеличивает гибкость OpenGL. Все расширения собраны и определены в реестре OpenGL.

Каждое расширение связано с коротким идентификатором, основанным на названии компании, которая его разработала. Например, идентификатор Nvidia — это NV, который является частью имени расширения , константы и функции . Если несколько поставщиков соглашаются реализовать одни и те же функции с использованием одного и того же API, может быть выпущено общее расширение с использованием идентификатора EXT. В таких случаях также может случиться так, что Совет по анализу архитектуры Khronos Group даст расширению свое явное одобрение, и в этом случае используется идентификатор ARB.

Функции, представленные каждой новой версией OpenGL, обычно формируются из объединенных функций нескольких широко применяемых расширений, особенно расширений типа ARB или EXT.

Рендеринг объекта

Вывод всех объектов сцены на экран происходит в функции рендеринга между строками

	pDirectDevice->BeginScene();
	pDirectDevice->EndScene();

Заполним этот промежуток.Укажем, какие данные пересылать в поток данных устройства, также указываем размер данных, определяющий одну вершину:

SetStreamSource(0, pBufferVertex, 0, sizeof(CUSTOMVERTEX));
SetFVF(D3DFVF_CUSTOMVERTEX);				// задаем формат вершин

Выводим объект, для этого используем функцию вывода примитивов (примитив — любая геометрическая фигура).Передаем в качестве параметров такие значения:

DrawPrimitive(D3DPT_TRIANGLELIST,  // что рисовать
              0,                   // индекс первой вершины
              7                    // количество выводимых объектов
              );

Готово!!! (листинг программы heart.cpp)На экране результат: сердечко.

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

Ссылки по теме

Windows Presentation Foundation WPF

Основными элементами W7-Графики являются:a)
Desktop Window Manager

= DWMb)
Windows W7 Display Driver Model

= WVDDM или короче WDDM, поддерживаемые W7-Графическими картами.Работает так: 1.) Все окна и графические элементы (включая шрифты) в W7 — это Векторная Графика. 2.) Данные и команды Векторной Графики хранятся, управляются и позиционируются через DVM. 3.) DVM передает данные и команды WVDDM-драйверу.4.) Драйвер преобразует все в формат данных и команд DirectX и загружает это все в свою Графическую карту. 5.) Графический пайплайн на карте отрисовывает картинку автономно (без участия CPU) с максимальной скоростью в Back-Buffer.6.) как только Back-Buffer заполнен, Графическая карта переключает его как в состояние Front-Buffer для вывода на экран.

WPF

— это программная оболочка (Application Programming Interface API) для W7.С помощью WPF можно создавать как отдельные приложения, так и интерфейсные части других приложений или браузерные приложения.WPF содержит два API, которые дополняют друг друга и которые можно произвольно смешивать в одном приложении: можно писать часть на C# или XAML или смешано. WPF создан для замены Windows-Forms- и Active-Server-Page- систем.

Плюсы
: 1)
WPF генерирует только Векторную Графику (за исключением текстур и видео) как

Flash

. 2)
WPF прорисовывается через DirectX. Соответственно: Анимация, прозрачность, Anti-Aliasing намного быстрее, чем на Flash.
3)

WPF обладает богатым и хорошо организованным функционалом для Windows- и Web-
GUI

s. 4)
WPF везде предлагает единообразный интерфейс для Windows, Web-страниц и мобильных устройств.
5)
Expression Studio

могут не образованные (не информатики) интерфейс приложения или Web-страницы собрать самостоятельно.

Минусы
: 1)
WPF работает только под Windows (Исключение —

Silverlight

см ниже). 2)
Библиотека классов WPF глубоко структурирована и сложна в изучении. 3)
Использование WPF приводит к бесполезным графическим наворотам различного рода.Silverlight

Компиляция проекта

Теперь, зайдя в папку , среди всего прочего можно увидеть файл с именем , открываем его с помощью Visual Studio 2019:

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

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

Способ №1: Можно скопировать содержимое папки проекта GLFW в соответствующую папку вашей IDE или компилятора, а также скопировать полученный файл в соответствующую папку вашей IDE или компилятора. Данный способ вполне рабочий, но мы его не рекомендуем, так как новая установка IDE или компилятора приведет к тому, что вам заново придется подключать необходимые файлы.

Способ №2: Вы можете создать новую папку, которая будет содержать все заголовочные файлы и файлы из сторонних библиотек. На эту папку вы впоследствии сможете ссылаться из своей IDE или компилятора. Например, можно создать папку, в которой будут находиться папки и . В них мы будем хранить все наши библиотечные и подключаемые файлы, которые собираемся использовать для наших OpenGL-проектов. Получается, что все сторонние библиотеки будут организованы в одном месте (и их можно будет совместно использовать на нескольких компьютерах). Однако, каждый раз при создании нового проекта, мы должны будем указывать IDE соответствующие пути к этим папкам.

Как только необходимые файлы будут сохранены в выбранном вами месте, мы сможем приступить к созданию нашего первого OpenGL-GLFW-проекта.

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

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

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

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

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

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

Инициализация DirectX

Для начала необходимо подключить заголовочный файл.Теперь необходимо подключить библиотеку d3d9.lib , ее можно подключить в свойствах проекта или явно подключить с использованием команды препроцессора #pragma. Разницы никакой нет, используем второй способ:

#pragma comment(lib, "d3d9.lib")

Создадим функцию, в которой будут инициализироваться интерфейсы DirectX:

bool InitDirectX(void).

Создаем глобальные переменные:LPDIRECT3D9 pDirect3D — указатель на главный интерфейс. Это первый объект, который необходимо создать, только после этого можно получить доступ ко всем остальным интерфейсам.LPDIRECT3DDEVICE9 pDirectDevice — интерфейс устройства Direct3D.

Для удобства создадим функцию , в которой будем инициализировать устройства 3D.

bool InitDirectX(void)
{
	if((pDirect3D=Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
		return(false);
	D3DDISPLAYMODE stDisplay;
	if(FAILED(pDirect3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &stDisplay)))
		return(false);
	D3DPRESENT_PARAMETERS Direct3DParametr;
	ZeroMemory(&Direct3DParametr, sizeof(Direct3DParametr));
	Direct3DParametr.Windowed=TRUE;
	Direct3DParametr.SwapEffect=D3DSWAPEFFECT_DISCARD;
	Direct3DParametr.BackBufferFormat=stDisplay.Format;
	if(FAILED(pDirect3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, 
	          hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, &Direct3DParametr, &pDirectDevice)))
		return(false);
	return(true);
}

— создается основной указатель на интерфейс IDirect3D9. Всегда используется один макрос , указывающий на текущую версию SDK.

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

if(FAILED(…))
{	сбой	}
else
{	функция выполнена успешно	}
также можно использовать макрос SUCCEEDED, по такой схеме
if(SUCCEEDED(…))
{	функция выполнена успешно	}
else
{	сбой	}

Теперь нужно получить текущие параметры дисплея с помощью функции .Создаем структуру параметров представления и задаем значения:

— оконный режим работы приложения. — не использовать буфера обмена. — формат видеорежима заднего буфера устанавливаем равным текущему видеорежиму.

Создаем объект интерфейса . Все дальнейшие действия будут опираться на данный интерфейс устройства и его параметры.

— текущая видеокарта (обычно в системе установлена 1 видеокарта). — выбор способа обработки информации, с помощью видеокарты. — дескриптор главного окна. — способ обработки вершин (в данном случае аппаратно). Можно использовать значение — программная обработка вершин (при использовании старых видеокарт). — параметры видеорежима. — результат операции, указатель на только что созданный объект.

Фрагментный шейдер

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

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

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

Рассмотрим код шейдера.

Здесь задана средняя точность для всех вещественных переменных.

Сэмплер, связанный с нашей текстурой я назвал , хотя можно было назвать как угодно. Также здесь
снова объявлена varying-переменная . И, наконец, задан параметр . Значения всем uniform-переменным,
как уже было сказано, будут присвоены в самой программе. В шейдере же мы считаем их известными.

Сам шейдер тоже предельно прост. В первой строке функции с помощью встроенной функции
мы извлекаем цвет соответствующего текселя. Во второй, умножаем младший байт (R) на a, остальные (G, B, A) оставляем
неизменными.

Здесь нет , цвет фрагмента возвращается через встроенную переменную .

Код для вставки в программу.

Архитектура OpenGL

Функции OpenGL реализованы в модели клиент-сервер. Приложение выступает в роли клиента — оно вырабатывает команды, а сервер OpenGL интерпретирует и выполняет их. Сам сервер может находиться как на том же компьютере, на котором находится клиент, так и на другом.

GL обрабатывает и рисует в буфере кадра графические примитивы с учетом некоторого числа выбранных режимов. Каждый примитив — это точка, отрезок, многоугольник и т.д. Каждый режим может быть изменен независимо от других. Определение примитивов, выбор режимов и другие операции описываются с помощью команд в форме вызовов функций прикладной библиотеки.

Примитивы определяются набором из одной или более вершин (vertex). Вершина определяет точку, конец отрезка или угол многоугольника. С каждой вершиной ассоциируются некоторые данные (координаты, цвет, нормаль, текстурные координаты и т.д.), называемые атрибутами. В подавляющем большинстве случаев каждая вершина обрабатывается независимо от других.

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

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

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

Рисунок 3 – Функционирование конвейера OpenGL

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

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

Основные отличия DirectX и OpenGL

Что же касается основных отличий, не вдаваясь в технические аспекты функционирования, сразу же можно отметить, что платформа DirectX, являющая эксклюзивной разработкой корпорации Microsoft, предназначена исключительно для применения в Windows-системах и частично на Xbox, а OpenGL представляет свободно распространяемую кроссплатформенную технологию, применимую в других ОС (даже в мобильных). Лицензия GNU позволяет любому желающему вносить в компоненты этого API собственные изменения и дополнения, касающиеся ее усовершенствования с целью повышения производительности тех же видеокарт, в то время как улучшений DirectX приходится ждать только по мере выхода новых версий платформы. При этом даже с самыми новыми драйверами при использовании на старых версиях моста графические ускорители не выдают заявленных производителем показателей.

Direct3D Device

это важнейший Direct3D-Класс, который непосредственно управляет Графической Картой. Его главная функция — Device.Present , переключать BackBuffer Графической Карты на FrontBuffer и таким образом отображать прорисованную функцию на мониторе.Далее этот класс содержит Свойства/Функции как для Векторной Графики
(Viewport, Vertex Format, Transform) так и для Растровой Графики (Material, Texture, адресса и длины для Output-Buffer).При старте любой программы, использующей Direct3D, создается данный класс и резервиуются ресурсы и права доступа к Графической Карте.

Важные свойства	of Direct3D class «Device «
DeviceCaps	Возвращает структуру, представляющую возможности железа — используется для определения доступна ли та или иная фича для использования в текущем приложении
Viewport	Возвращает/Определяет прямоугольный регион для отрисовки на текущем устройстве
Material	Возвращает/Определяет материал для использования при прорисовке (рендере)
Lights	Возвращает коллекцию источников света, которые могут быть активированы при прорисовке (рендере)
RenderState	Возвращает колекцию состояний рендера, которые используются для контроля различных состояний Direct3D пайплайна.
VertexDeclaration	Возвращает/Определяет описание вертексных форматов используемых вертексным шейдером
VertexFormat	Возвращает/Определяет описание вертексных форматов, используемых в Fixed Vector Pipeline
VertexShader, PixelShader	Возвращает/Определяет the vertex/pixel shader to use for rendering

Важные методы	Direct3D class «Device «
BeginScene	Готовит устройство для прорисовки примитивов (простых форм) в кадре. BeginScene должна быть вызвана перед прорисовкой любых примитивов в кадре.
EndScene	Сигнал устройству, что все примитивы в кадре отрисованы. EndScene должна быть вызвана, когда все примитивы в кадре отрисованы.
DrawPrimitives	Прорисовывает примитивы.
Clear	Очищает окно перед прорисовкой следующего кадра.
Present	Отображает прорисованный буфер и готовит следующий для прорисовки. Present вызывается после EndScene и до следующей BeginScene (для следующего кадра).
GetTransform, SetTransform	Возвращает/Определяет мировые, экранныеи другие трансформации. Трансформации применяются для вертексных позиций и нормалей и/или текстурных координат.
GetTexture, SetTexture	Возвращает/Определяет текстуры связанные с данным текстурным состоянием.

Библиотека GLFW

GLFW (англ. «Graphics Library FrameWork») — это библиотека, написанная на языке Си, специально предназначенная для работы с OpenGL. Библиотека GLFW предоставит нам все необходимые инструменты, которые потребуются для рендеринга на экран различных объектов. Благодаря этому мы сможем создавать контексты OpenGL, определять параметры окна и обрабатывать пользовательский ввод, что вполне коррелирует с нашими целями.

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

Примечание: На момент написания данной статьи в качестве среды разработки мы будем использовать Microsoft Visual Studio 2019 (обратите внимание, что наши действия будут аналогичными и с более старыми версиями Visual Studio). Если же вы используете более старую версию Visual Studio (или вообще другую среду разработки), то можете быть спокойны, т.к

процесс установки и настройки GLFW аналогичен в большинстве IDE.