Hello OpenGL | SyntaxError

Введение

В этой небольшой статье мы попробуем разработать простейшее приложение с использованием OpenGL. Мы будем использовать современную версию OpenGL (3.2+, так называемая modern OpenGL). В качестве основного языка программирования мы будем использовать C++ привкусом C. Проект будет основан на CMake, поэтому можно использовать любую IDE поддерживающую CMake проекты нативно (например, VS CE, CLion и другие), либо, можно сгенерировать проект для вашей IDE, используя утилиту CMake. Основной целевой платформой будет Windows (Win 10, но проблем с другими современными версиями этой ОС, по идее, быть не должно). Исходный код можно найти на репозитории.

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

Лучший способ чему-то научиться – начать учить этому других (народная мудрость).

Disclaimer

еще одна статья об OpenGL;
с вероятностью 146% мною будут допущены те или иные ошибки, поэтому, конструктивная критика, правки и предложения приветствуются.

OpengGL

OpenGL (Open Graphics Library) — открытая кроссплатформенная графическая библиотека для написания графических приложений.

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

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

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

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

Примерный план

Инициализировать контекст отрисовки OpenGL;
Вывести треугольник.

Реализация

Обычно (для подключения большинства библиотек) достаточно подключить заголовочный файл библиотеки #include <gl.h> и добавить зависимость компоновщику opengl32.lib и, иногда, вызвать метод инициализации glInitialize(...) . Но исторически так сложилось, что процесс инициализации OpenGL библиотеки «несколько» усложнился…

Историческая справка

Из-за событий (таких как это письмо или ответ на него) началась кампания Microsoft против OpenGL в угоду их собственной проприетарной разработки DirectX. В 2003 году Microsoft покидает «Наблюдательный совет за архитектурой OpenGL (ARB OpenGL), а в 2005 году на SIGGRAPH они объявили о намерении удалить поддержку OpenGL из Windows Vista, оставляя лишь слой эмуляции поверх DirectX для обратной совместимости. В 2006 году члены Khronos Group (такие как NVIDIA, AMD) объявили о поддержке OpenGL в клиентских драйверах.

Результатом этих API «войн» ОС Windows поддерживает OpenGL только версии 1.1. А для использования последних возможностей OpenGL необходимо устанавливать драйверы от производителей видеоускорителей (NVIDIA, AMD или Intel).

Тоже самое относится и к заголовочным файлам OpenGL. Windows SDK содержит заголовочные файлы OpenGL только версии 1.1. А для использования современных возможностей OpenGL необходимо использовать заголовочные файлы предоставляемые Khronos Group.

[свернуть]

Для получения доступа к современным функциям OpenGL нам нужно получить указатели на эти функции во время выполнения программы используя функцию wglGetProcAddress() из библиотеки opengl32.dll версии 1.1. Этот процесс похож на процесс подключения динамической библиотеки с LoadLibrary() и GetProcAddress() . Обычно для получения функций OpenGL используются соответствующие библиотеки, такие как GLEW, GL3W, glLoadGen и другие. А для того, чтобы разобраться как эти библиотеки работуют мы не будем их использовать и реализуем весь необходимый функционал вручную.

Но прежде чем получить указатель на функцию OpenGL нужно создать OpenGL контекст отрисовки. А для этого, в свою очередь, нужно:

создать окно;
получить контекст устройства (Device Context, DC) с помощью GetDС();
выбрать формат пикселей контекста устройства (с аппаратным ускорением!) с помощью ChoosePixelFormat() и ассоциировать его с контекстом устройства (DC);
создать OpenGL контекст отрисовки с помощью wglCreateContext().

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

Выглядит все относительно просто, но есть небольшая загвоздка (собственно, как чаще всего и бывает): методы ChoosePixelFormat() и wglCreateContext() не расширяемые, иными словами, они не поддерживают новые возможности OpenGL. Например, метод ChoosePixelFormat() использует структуру PIXELFORMATDESCRIPTOR в которой нет поля, которое можно выставить, чтобы запросить мультисэмлинг (сглаживание), sRGB или floating-point формат фреймбуфера. А используя wglCreateContext() не получится указать OpenGL профиль или версию OpenGL.

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

Начнем с создания окна. Обычно, в подобных уроках, для создания окон используются специализированные библиотеки (например: SDL, SFML, GLFW и т.п.). Само собой мы пойдем своим путем разбираясь как делать все ручками и, за одно, поймем (надеемся) почему, обычно, так не делается и нам тоже не стоило.

Если кратко, то для создания окна необходимо:

описать основную оконную процедуру WndProc() для обработки оконных событий. На данный момент достаточно обработать событие уничтожения окна WM_DESTROY , по которому завершаем работу приложения;
зарегистрировать класс окна с помощью RegisterClassEx() , указав ранее описанную оконную процедуру в качестве обработчика оконных событий;
создать окно с помощью CreateWindow() ;
показать и обновить окно ShowWindow() и UpdateWindow() ;
создать очередь обработки оконных событий, используя GetMessage() , TranslateMessage() и DispatchMessage() .

Более подробно о работе с оконным API можно прочитать, например, здесь.

Если у вас уже был опыт работы с Window API, то код ниже вам должен быть, до боли, знаком. Для облегчения чтения программы разобъём код на несколько файлов:

// main.cpp

#include "main.hpp"
#include "window.cpp"

int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE prevInstance, LPWSTR cmdLine,
                      int cmdShow)
{
    // инициализируем контекст отрисовки
    auto[succeed, hwnd, dc] = InitRenderingContext(instance, cmdShow);
    
    if (!succeed)
        return appFail("InitRenderingContext failed.");

    // основной цикл приложения
    bool isRunning = true;

    while (isRunning)
    {
        // обработка оконных сообщений
        isRunning = ProcessEvents();

        // TODO: отрисовка
    }

    // завершаем работу приложения

    return 0;
}

// main.cpp

#include "main.hpp"

#include "window.cpp"

int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE prevInstance, LPWSTR cmdLine,

int cmdShow)

{

// инициализируем контекст отрисовки

auto[succeed, hwnd, dc] = InitRenderingContext(instance, cmdShow);

if (!succeed)

return appFail("InitRenderingContext failed.");

// основной цикл приложения

bool isRunning = true;

while (isRunning)

{

// обработка оконных сообщений

isRunning = ProcessEvents();

// TODO: отрисовка

}

// завершаем работу приложения

return 0;

}

// window.cpp

#include "shader.cpp"

const wchar_t windowClassName[] = L"HelloOpenGL";

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
    switch (message)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            break;

        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
    }

    return 0;
}

HWND CreateWnd(HINSTANCE instance, LPCWSTR wndClassName, LPCWSTR wndTitle) {
    return CreateWindowW(wndClassName, wndTitle, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
                         CW_USEDEFAULT, CW_USEDEFAULT, nullptr, nullptr, instance, nullptr);
}

std::tuple<bool, HWND, HDC> InitRenderingContext(HINSTANCE instance, int cmdShow) {
    // регистрируем класс окна
    WNDCLASSEXW wc   = {};

    wc.cbSize        = sizeof(WNDCLASSEXW);
    wc.style         = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    wc.lpfnWndProc   = WndProc;
    wc.cbClsExtra    = 0;
    wc.cbWndExtra    = 0;
    wc.hInstance     = instance;
    wc.hIcon         = nullptr;
    wc.hCursor       = LoadCursor(nullptr, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszMenuName  = nullptr;
    wc.lpszClassName = windowClassName;
    wc.hIconSm       = nullptr;

    if (!RegisterClassExW(&wc)) {
        return ircFail("RegisterClass failed");
    }

    // создаем основное окно
    HWND hWnd = CreateWnd(instance, windowClassName, L"Hello OpenGL");

    if (!hWnd) {
        return ircFail("CreateWindow failed");
    }

    ShowWindow(hWnd, cmdShow);
    UpdateWindow(hWnd);

    return 0;
}

bool ProcessEvents()
{
    MSG msg;

    while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
    {
        switch (msg.message)
        {
            case WM_QUIT:
                return false;
        }

        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }

    return true;
}

// window.cpp

#include "shader.cpp"

const wchar_t windowClassName[] = L"HelloOpenGL";

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {

switch (message)

{

case WM_DESTROY:

PostQuitMessage(0);

break;

default:

return DefWindowProc(hWnd, message, wParam, lParam);

}

return 0;

}

HWND CreateWnd(HINSTANCE instance, LPCWSTR wndClassName, LPCWSTR wndTitle) {

return CreateWindowW(wndClassName, wndTitle, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,

CW_USEDEFAULT, CW_USEDEFAULT, nullptr, nullptr, instance, nullptr);

}

std::tuple<bool, HWND, HDC> InitRenderingContext(HINSTANCE instance, int cmdShow) {

// регистрируем класс окна

WNDCLASSEXW wc = {};

wc.cbSize = sizeof(WNDCLASSEXW);

wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;

wc.lpfnWndProc = WndProc;

wc.cbClsExtra = 0;

wc.cbWndExtra = 0;

wc.hInstance = instance;

wc.hIcon = nullptr;

wc.hCursor = LoadCursor(nullptr, IDC_ARROW);

wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);

wc.lpszMenuName = nullptr;

wc.lpszClassName = windowClassName;

wc.hIconSm = nullptr;

if (!RegisterClassExW(&wc)) {

return ircFail("RegisterClass failed");

}

// создаем основное окно

HWND hWnd = CreateWnd(instance, windowClassName, L"Hello OpenGL");

if (!hWnd) {

return ircFail("CreateWindow failed");

}

ShowWindow(hWnd, cmdShow);

UpdateWindow(hWnd);

return 0;

}

bool ProcessEvents()

{

MSG msg;

while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))

{

switch (msg.message)

{

case WM_QUIT:

return false;

}

TranslateMessage(&msg);

DispatchMessage(&msg);

}

return true;

}

А чтобы это все можно было скомпилировать, необходимо указать в CMake, что мы хотим сборку под Win32. Сделать это можно путем добавления флага WIN32 команды add_executable :

cmake_minimum_required(VERSION 3.12)
project(HelloOpenGL)

set(CMAKE_CXX_STANDARD 20)

add_executable(HelloOpenGL WIN32 src/main.cpp)

cmake_minimum_required(VERSION 3.12)

project(HelloOpenGL)

set(CMAKE_CXX_STANDARD 20)

add_executable(HelloOpenGL WIN32 src/main.cpp)

Скомпилировав и запустив наш код мы должны увидеть простое пустое окно с заголовком «Hello OpenGL».

Наподобии такого:

Надеемся, что все так, тогда продолжаем.

Теперь нам нужно подключить заголовочные файлы OpenGL. Нам потребуются: <GL/gl.h> (идет в комплекте с Windows SDK) и "GL/glext.h" и "GL/wglext.h" (которые можно скачать в Khronos OpenGL реестре). А с недавних пор стал требоваться еще и <KHR/hkrplatform.h> (который можно скачать в Khronos EGL реестре). И подключаем заголовочные файлы с помощью CMake команды target_include_directories:

cmake_minimum_required(VERSION 3.12)
project(HelloOpenGL)

set(CMAKE_CXX_STANDARD 20)

add_executable(HelloOpenGL WIN32 src/main.cpp)

target_include_directories(HelloOpenGL PRIVATE thirdparty/include)

cmake_minimum_required(VERSION 3.12)

project(HelloOpenGL)

set(CMAKE_CXX_STANDARD 20)

add_executable(HelloOpenGL WIN32 src/main.cpp)

target_include_directories(HelloOpenGL PRIVATE thirdparty/include)

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

Теперь мы можем создать временное окно и получить контекст устройства:

// window.cpp

std::tuple<bool, HWND, HDC, HGLRC> CreateTempRenderingContext(HINSTANCE instance) {
    // создаем временное окно
    HWND tempWnd = CreateWnd(instance, windowClassName, L"Temp window");

    if (!tempWnd) {
        return ctcFail("Create temp window failed.");
    }

    HDC tempDC = GetDC(tempWnd);

    if (!tempDC) {
        return ctcFail("Get temp window device context failed.");
    }

// ...

// window.cpp

std::tuple<bool, HWND, HDC, HGLRC> CreateTempRenderingContext(HINSTANCE instance) {

// создаем временное окно

HWND tempWnd = CreateWnd(instance, windowClassName, L"Temp window");

if (!tempWnd) {

return ctcFail("Create temp window failed.");

}

HDC tempDC = GetDC(tempWnd);

if (!tempDC) {

return ctcFail("Get temp window device context failed.");

}

// ...

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

// window.cpp

// CreateTempRenderingContext ...

// ...

// выбираем формат пикселей устройства
PIXELFORMATDESCRIPTOR tempPfd = {};
tempPfd.nSize = sizeof(tempPfd);
tempPfd.nVersion = 1;
tempPfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
tempPfd.iPixelType = PFD_TYPE_RGBA;
tempPfd.cColorBits = 32;
tempPfd.cAlphaBits = 8;
tempPfd.cDepthBits = 24;

int tempPFDID = ChoosePixelFormat(tempDC, &tempPfd);

if (tempPFDID == 0) {
    return ctcFail("ChoosePixelFormat failed.");
}

if (SetPixelFormat(tempDC, tempPFDID, &tempPfd) == 0) {
    return ctcFail("SetPixelFormat failed.");
}

// ...

// window.cpp

// CreateTempRenderingContext ...

// ...

// выбираем формат пикселей устройства

PIXELFORMATDESCRIPTOR tempPfd = {};

tempPfd.nSize = sizeof(tempPfd);

tempPfd.nVersion = 1;

tempPfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;

tempPfd.iPixelType = PFD_TYPE_RGBA;

tempPfd.cColorBits = 32;

tempPfd.cAlphaBits = 8;

tempPfd.cDepthBits = 24;

int tempPFDID = ChoosePixelFormat(tempDC, &tempPfd);

if (tempPFDID == 0) {

return ctcFail("ChoosePixelFormat failed.");

}

if (SetPixelFormat(tempDC, tempPFDID, &tempPfd) == 0) {

return ctcFail("SetPixelFormat failed.");

}

// ...

И только теперь мы можем создать временный контекст отрисовки и назначить его текущим:

// window.cpp

// CreateTempRenderingContext ...

// ...

HGLRC tempRenderingContext = wglCreateContext(tempDC);

if (tempRenderingContext == nullptr) {
    return ctcFail("wglCreateContext failed.");
}

if (wglMakeCurrent(tempDC, tempRenderingContext) == 0) {
    return ctcFail("wglMakeCurrent failed.");
}

// ...

// window.cpp

// CreateTempRenderingContext ...

// ...

HGLRC tempRenderingContext = wglCreateContext(tempDC);

if (tempRenderingContext == nullptr) {

return ctcFail("wglCreateContext failed.");

}

if (wglMakeCurrent(tempDC, tempRenderingContext) == 0) {

return ctcFail("wglMakeCurrent failed.");

}

// ...

Следующий пункт нашего плана: получение указателей на современные функции OpenGL. Рассмотрим процесс получения указателей на примере функций wglChoosePixelFormatARB() и wglCreateContextAttribsARB() , которые необходимы нам для создания основного окна приложения и, соответственно, основного контекста отрисовки, поддерживающего современные возможности OpenGL.

Для получения указателя на функцию нужно найти соответствующий ей typedef (фактически сигнатуру функции) в заголовочных файлах OpenGL. Затем получить указатель на функцию по имени с помощью функции wglGetProcAddress() и откастить его к соответствующей сигнатуре функции. После чего проверить результат на успешность. gl_binding.cpp :

// gl_binding.cpp

#include <GL/gl.h>
#include <GL/glu.h>
#include "gl/glext.h"
#include "gl/wglext.h"

PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = nullptr;

bool InitBindings()
{
    wglChoosePixelFormatARB = reinterpret_cast<PFNWGLCHOOSEPIXELFORMATARBPROC>(
        wglGetProcAddress("wglChoosePixelFormatARB"));

    if (wglChoosePixelFormatARB == nullptr) {
        return fail("Getting wglGetProcAddress failed.");
    }

    return true;
}

// gl_binding.cpp

#include <GL/gl.h>

#include <GL/glu.h>

#include "gl/glext.h"

#include "gl/wglext.h"

PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB = nullptr;

bool InitBindings()

{

wglChoosePixelFormatARB = reinterpret_cast<PFNWGLCHOOSEPIXELFORMATARBPROC>(

wglGetProcAddress("wglChoosePixelFormatARB"));

if (wglChoosePixelFormatARB == nullptr) {

return fail("Getting wglGetProcAddress failed.");

}

return true;

}

Создаем временный контекст отрисовки и инициализируем OpenGL биндинги:

// window.cpp

// InitRenderingContext ...

// ...

// создаем временный контекст отрисовки
auto[succeed, tempWnd, tempDC, tempRenderingContext] = CreateTempRenderingContext(instance);

if (!InitGLBindings()) {
    return ircFail("Bindings initialization failed");
}

// ...

// window.cpp

// InitRenderingContext ...

// ...

// создаем временный контекст отрисовки

auto[succeed, tempWnd, tempDC, tempRenderingContext] = CreateTempRenderingContext(instance);

if (!InitGLBindings()) {

return ircFail("Bindings initialization failed");

}

// ...

И аналогично для wglCreateContextAttribsARB() :

// gl_binding.cpp

// InitBindings ...

// ...

wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(
        wglGetProcAddress("wglCreateContextAttribsARB"));

if (wglCreateContextAttribsARB == nullptr) {
    return fail("Getting wglGetProcAddress failed.");
}

// ...

// gl_binding.cpp

// InitBindings ...

// ...

wglCreateContextAttribsARB = reinterpret_cast<PFNWGLCREATECONTEXTATTRIBSARBPROC>(

wglGetProcAddress("wglCreateContextAttribsARB"));

if (wglCreateContextAttribsARB == nullptr) {

return fail("Getting wglGetProcAddress failed.");

}

// ...

И весь этот мучительно долгий, трудный и опасный (очень легко ошибиться) процесс нужно повторить для КАЖДОЙ используемой OpenGL функции, которая появилась позже OpenGL 1.1. Именно по этому, чаще всего, используются разные библиотеки-загрузчики, делающие всю «грязную» работу за вас.

Именование типов функций

Если хорошо приглядеться, к имени типа функции PFNWGLCHOOSEPIXELFORMATARBPROC можно разбить на осмысленные части: PFN — pointer function (указатель на функцию); — WGLCHOOSEPIXELFORMATARB — wglChoosePixelFormatARB название нашей функции (а ARB это сокращение Architecture Review Board или Наблюдательный совет за архитектурой OpenGL); PROC — procedure (процедура).

[свернуть]

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

Как уже было выше упомянуто функция wglChoosePixelFormatARB() принимает список пар параметров: ключ и значение. Код выбора формата и получения идентификатора формата пискелей контекста устройства с поддержкой мультисэмплинга будет выглядеть примерно так:

// window.cpp

// InitRenderingContext ... 

// ...

HDC dc = GetDC(hWnd);

const int pixelAttribs[] =
{
    WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,
    WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
    WGL_DOUBLE_BUFFER_ARB, GL_TRUE,
    WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
    WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
    WGL_COLOR_BITS_ARB, 32,
    WGL_ALPHA_BITS_ARB, 8,
    WGL_DEPTH_BITS_ARB, 24,
    WGL_STENCIL_BITS_ARB, 8,
    WGL_SAMPLE_BUFFERS_ARB, GL_TRUE,
    WGL_SAMPLES_ARB, 4,
    0
};

UINT numFormats;
int pixelFormatID;
BOOL status = wglChoosePixelFormatARB(dc, pixelAttribs, nullptr, 1, &pixelFormatID, &numFormats);

if (!status || numFormats == 0) {
    return ircFail("wglChoosePixelFormatARB() failed.");
}

// ...

// window.cpp

// InitRenderingContext ...

// ...

HDC dc = GetDC(hWnd);

const int pixelAttribs[] =

{

WGL_DRAW_TO_WINDOW_ARB, GL_TRUE,

WGL_SUPPORT_OPENGL_ARB, GL_TRUE,

WGL_DOUBLE_BUFFER_ARB, GL_TRUE,

WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,

WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,

WGL_COLOR_BITS_ARB, 32,

WGL_ALPHA_BITS_ARB, 8,

WGL_DEPTH_BITS_ARB, 24,

WGL_STENCIL_BITS_ARB, 8,

WGL_SAMPLE_BUFFERS_ARB, GL_TRUE,

WGL_SAMPLES_ARB, 4,

};

UINT numFormats;

int pixelFormatID;

BOOL status = wglChoosePixelFormatARB(dc, pixelAttribs, nullptr, 1, &pixelFormatID, &numFormats);

if (!status || numFormats == 0) {

return ircFail("wglChoosePixelFormatARB() failed.");

}

// ...

Хотя мы и получили идентификатор формата пикселей наше новое окно по прежнему требует вызова стандартной функции SetPixelFormat() с назначением старой версии дескриптора PIXELFORMATDESCRIPTOR . Благо, мы можем получить его из уже имеющегося идентификатора:

// window.cpp

// InitRenderingContext ...

// ...

PIXELFORMATDESCRIPTOR PFD;
DescribePixelFormat(dc, pixelFormatID, sizeof(PFD), &PFD);
SetPixelFormat(dc, pixelFormatID, &PFD);

// window.cpp

// InitRenderingContext ...

// ...

PIXELFORMATDESCRIPTOR PFD;

DescribePixelFormat(dc, pixelFormatID, sizeof(PFD), &PFD);

SetPixelFormat(dc, pixelFormatID, &PFD);

Теперь мы готовы создать настоящий контекст отрисовки OpenGL, для примера, указав основной профиль и версию OpenGL 4.5 (более подробно с профилями можно ознакомиться здесь):

// window.cpp

// InitRenderingContext ...

// ...

// версия OpenGL
const int major_min = 4;
const int minor_min = 5;
int  contextAttribs[] =
{
    WGL_CONTEXT_MAJOR_VERSION_ARB, major_min,
    WGL_CONTEXT_MINOR_VERSION_ARB, minor_min,
    WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
    0
};

HGLRC renderingContext = wglCreateContextAttribsARB(dc, nullptr, contextAttribs);
if (renderingContext == nullptr) {
    return ircFail("wglCreateContextAttribsARB failed.");
}

// ...

// window.cpp

// InitRenderingContext ...

// ...

// версия OpenGL

const int major_min = 4;

const int minor_min = 5;

int contextAttribs[] =

{

WGL_CONTEXT_MAJOR_VERSION_ARB, major_min,

WGL_CONTEXT_MINOR_VERSION_ARB, minor_min,

WGL_CONTEXT_PROFILE_MASK_ARB, WGL_CONTEXT_CORE_PROFILE_BIT_ARB,

};

HGLRC renderingContext = wglCreateContextAttribsARB(dc, nullptr, contextAttribs);

if (renderingContext == nullptr) {

return ircFail("wglCreateContextAttribsARB failed.");

}

// ...

Самое время избавиться от временного окна и всего, что с ним связано:

// window.cpp

// InitRenderingContext ...

// ...

// подчищаем за временным окно и временным контекстом отрисовки
wglMakeCurrent(nullptr, nullptr);
wglDeleteContext(tempRenderingContext);
ReleaseDC(tempWnd, tempDC);
DestroyWindow(tempWnd);

// ...

// window.cpp

// InitRenderingContext ...

// ...

// подчищаем за временным окно и временным контекстом отрисовки

wglMakeCurrent(nullptr, nullptr);

wglDeleteContext(tempRenderingContext);

ReleaseDC(tempWnd, tempDC);

DestroyWindow(tempWnd);

// ...

Для того, чтобы скомпилировать вышенаписанный код, необходимо прилинковать OpenGL:

// CMakeLists.txt

// ...

TARGET_LINK_LIBRARIES(HelloOpenGL opengl32)

// CMakeLists.txt

// ...

TARGET_LINK_LIBRARIES(HelloOpenGL opengl32)

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

Активируем текущий контекст отрисовки:

// window.cpp

// InitRenderingContext ...

// ...

// назначаем новый текущий контекст отрисовки
if (!wglMakeCurrent(dc, renderingContext)) {
    return ircFail("wglMakeCurrent failed.");
}

// ...

// window.cpp

// InitRenderingContext ...

// ...

// назначаем новый текущий контекст отрисовки

if (!wglMakeCurrent(dc, renderingContext)) {

return ircFail("wglMakeCurrent failed.");

}

// ...

Закончим реализацию текущего пункта плана заливкой экрана цветом используя OpenGL:

// main.cpp

// wWinMain ...

// ...

glEnable(GL_DEBUG_OUTPUT);
glEnable(GL_DOUBLEBUFFER);
glClearColor(0.129f, 0.586f, 0.949f, 1.0f); // rgb(33, 150, 243)
glClear(GL_COLOR_BUFFER_BIT);

SwapBuffers(dc);

// while () {...}

// main.cpp

// wWinMain ...

// ...

glEnable(GL_DEBUG_OUTPUT);

glEnable(GL_DOUBLEBUFFER);

glClearColor(0.129f, 0.586f, 0.949f, 1.0f); // rgb(33, 150, 243)

glClear(GL_COLOR_BUFFER_BIT);

SwapBuffers(dc);

// while () {...}

Команда glClearColor() задает цвет заливки в формате RGB, команда glClear() с параметром GL_COLOR_BUFFER_BIT очищает цветовой буфер, закрашивая каждый пиксель ранее заданным цветом. Последняя команда меняет местами текущий и фоновый буферы, тем самым, отображая, наши изменения. При создании контекста отрисовки мы указывали атрибут DOUBLE_BUFFER , который создает два буфера. Это своего рода оптимизация, позволяющая не отображать еще полностью не сформированную картинку. На одном буфере мы рисуем, а другой, в текущий момент, отображается, как только мы закончили рисование, то меняем буферы местами.

Запустив приложение, должно показаться окно, полностью залитое светло синем цветом. Наподобии такого:

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

Отрисовка треугольника

Следующим пунктом нашей программы является вывод треугольника на экран. Треугольник является одним из примитивов OpenGL, к которым так же относятся линии и точки. Треугольники являются, пожалуй, самыми часто-используемыми примитивами в 3D графике. Современная версия OpenGL использует программируемый пайплайн (конвейер — последовательность команд для вывода отображения на экран с возможностью вклиниться в этот процесс в точках расширения), по этому для отрисовки даже простого треугольника необходим (как минимум) один шейдер (мы будем использовать два). Думаем мало кто сегодня не слышал этот термин. Фактически, шейдеры это микропраграммы написанная на одном из шейдерных языков (например, как в нашем случаей, на GLSL) и выполняемые видеокартой (видеоускорителем). Существует несколько типов шейдеров, нас в первую очередь, будут интересовать вершинные (vertex shader) и фрагментные (fragment shader или пиксельные шейдеры — pixel shader) шейдеры. Вершинные шейдеры оперируют, как не трудно догадаться, с вершинами треугольников (координаты вершины в пространстве) и различными данными, связанными с этими вершинами: текстурными координатами, цветом вершин, векторами нормалями и бинормалями, расчетом освещения, перспективным преобразованием и т.д. и т.п. Фрагментные шейдеры, в свою очередь, работают с фрагментами растрового (уже растрированного) изображения и со связанными с пикселями данными: цветом, глубиной, текстурными координатами и т.д. Вершнинный шейдер вызывается для каждой вершины отрисовываемого объекта. При отрисовке одного треугольника программа вершинного шейдера будет выполнена 3 раза для каждой вершины треугольника соответственно. Фрагментный шейдер вызывается для каждого растрированного фрагмента (для упрощения можно считать пикселя) попадающего в треугольник. Таких фрагментов, даже для одного треугольника, много, соответственно и вызовов выполнения фрагментных шейдеров также много.

Начнем с самих шейдеров. Шейдеры это просто текстовые файлы (с неустоявшимся расширением) с кодом шейдера. Для вершинных шейдеров мы будем использовать расширение vert , а для фрагментных frag соответственно.

Наш наипростейший вершинный шейдер:

// simple_vertex_shader.vert

#version 450

layout(location = 0) in vec4 position;

void main()
{
    gl_Position = position;
}

// simple_vertex_shader.vert

#version 450

layout(location = 0) in vec4 position;

void main()

{

gl_Position = position;

}

Язык шейдеров GLSL своего рода урезанная и заточенная под написание шейдеров версия языка C со своими особенностями. В начале текста шейдера мы указываем версию шейдера. Далее описывается входящий параметр (модификатор in) с типом ( vec4 — вектор 4 — x, y, z, w): собственно данные обрабатываемой вершины. В результате своей работы вершинный шейдер должен, как минимум, вернуть итоговое положение вершины. Для этого используется зарезервированная переменная gl_Position . Так как у нас элементарный шейдер, то и никаких дополнительных действий с вершиной мы производить не будем — записываем в результат работы шейдера входящую вершину без каких-либо модификаций.

Наш наипростейший фрагментный шейдер выглядит так:

//simple_fragment_shader.frag

#version 450

out vec4 outputColor;

void main()
{
    outputColor = vec4(1f, 1f, 0f, 1f);
}

//simple_fragment_shader.frag

#version 450

out vec4 outputColor;

void main()

{

outputColor = vec4(1f, 1f, 0f, 1f);

}

В результате своей работы фрагментный шейдер должен вернуть цвет, обработанного фрагмента. Для реализации этого функционала используется переменная (с модификатором out) и уже знакомым типом vec4, который в данном случае, представляет из себя цвет в формате r g b a. Для создания цвета мы используем функцию vec4, передавая в неё, соответствующие значения цвета. В данном случае это желтый цвет.

Чтобы наша программа смогла найти шейдеры нужно добавить соответствующую команду CMake, чтобы при каждой компиляции файлы шейдеров автоматически копировались в выходную директорию:

// CMakeLists.txt

// ...

file(COPY data DESTINATION ${CMAKE_BINARY_DIR})

// CMakeLists.txt

// ...

file(COPY data DESTINATION ${CMAKE_BINARY_DIR})

Само-собой одних файлов шейдеров недостаточно. Необходимо создать соответствующий OpenGL объект программы шейдера. Алгоритм создания этой программы выглядит так:

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

Выглядит алгоритм слегка устрашающе. Начнем его реализаци с функции чтения содержимого файла шейдера:

// util.cpp

#include <fstream>
#include <sstream>
#include <iostream>

bool fail(const char *reason) {
    std::cerr << reason << std::endl;
    return false;
}

int appFail(const char *reason) {
    fail(reason);
    return -1;
}

std::tuple<bool, std::string> GetTextFileContent(const char *filePath) {
    std::ifstream inputStream(filePath);

    if (inputStream.is_open()) {
        std::stringstream stringBuffer;
        stringBuffer << inputStream.rdbuf();
        inputStream.close();

        return {true, stringBuffer.str()};
    }

    return {false, ""};
}

// util.cpp

#include <fstream>

#include <sstream>

#include <iostream>

bool fail(const char *reason) {

std::cerr << reason << std::endl;

return false;

}

int appFail(const char *reason) {

fail(reason);

return -1;

}

std::tuple<bool, std::string> GetTextFileContent(const char *filePath) {

std::ifstream inputStream(filePath);

if (inputStream.is_open()) {

std::stringstream stringBuffer;

stringBuffer << inputStream.rdbuf();

inputStream.close();

return {true, stringBuffer.str()};

}

return {false, ""};

}

Следующий шаг: создание и компиляция шейдера. Для этого нам потребуются следующие OpenGL функции: glCreateShader , glShaderSource , glCompileShader , glGetShaderiv (для получения информации о результате компиляции) , glDeleteShader и glGetShaderInfoLog (для получения ошибки, если скомпилировать шейдер не удалось). Но беда вся в том, что у нас нет этих функций(. И прежде чем ими воспользоваться, нужно найти указатели на них (помним, мы все еще не используем OpenGL загрузчик).

// gl_binding.cpp

// ...

PFNGLCREATESHADERPROC glCreateShader = nullptr;
PFNGLSHADERSOURCEPROC glShaderSource = nullptr;
PFNGLCOMPILESHADERPROC glCompileShader = nullptr;
PFNGLGETSHADERIVPROC glGetShaderiv = nullptr;
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = nullptr;
PFNGLDELETESHADERPROC glDeleteShader = nullptr;

// InitBindings ...

glCreateShader = reinterpret_cast<PFNGLCREATESHADERPROC>(wglGetProcAddress("glCreateShader"));

if (glCreateShader == nullptr) {
    return fail("glCreateShader failed.");
}

glShaderSource = reinterpret_cast<PFNGLSHADERSOURCEPROC>(wglGetProcAddress("glShaderSource"));

if (glShaderSource == nullptr) {
    return fail("glShaderSource failed.");
}

glCompileShader = reinterpret_cast<PFNGLCOMPILESHADERPROC>(wglGetProcAddress("glCompileShader"));

if (glCompileShader == nullptr) {
    return fail("glCompileShader failed.");
}

glGetShaderiv = reinterpret_cast<PFNGLGETSHADERIVPROC>(wglGetProcAddress("glGetShaderiv"));

if (glGetShaderiv == nullptr) {
    return fail("glGetShaderiv failed.");
}

glGetShaderInfoLog = reinterpret_cast<PFNGLGETSHADERINFOLOGPROC>(
        wglGetProcAddress("glGetShaderInfoLog"));

if (glGetShaderInfoLog == nullptr) {
    return fail("glGetShaderInfoLog failed.");
}

glDeleteShader = reinterpret_cast<PFNGLDELETESHADERPROC>(wglGetProcAddress("glDeleteShader"));

if (glDeleteShader == nullptr) {
    return fail("glDeleteShader failed.");
}

// ...

// gl_binding.cpp

// ...

PFNGLCREATESHADERPROC glCreateShader = nullptr;

PFNGLSHADERSOURCEPROC glShaderSource = nullptr;

PFNGLCOMPILESHADERPROC glCompileShader = nullptr;

PFNGLGETSHADERIVPROC glGetShaderiv = nullptr;

PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = nullptr;

PFNGLDELETESHADERPROC glDeleteShader = nullptr;

// InitBindings ...

glCreateShader = reinterpret_cast<PFNGLCREATESHADERPROC>(wglGetProcAddress("glCreateShader"));

if (glCreateShader == nullptr) {

return fail("glCreateShader failed.");

}

glShaderSource = reinterpret_cast<PFNGLSHADERSOURCEPROC>(wglGetProcAddress("glShaderSource"));

if (glShaderSource == nullptr) {

return fail("glShaderSource failed.");

}

glCompileShader = reinterpret_cast<PFNGLCOMPILESHADERPROC>(wglGetProcAddress("glCompileShader"));

if (glCompileShader == nullptr) {

return fail("glCompileShader failed.");

}

glGetShaderiv = reinterpret_cast<PFNGLGETSHADERIVPROC>(wglGetProcAddress("glGetShaderiv"));

if (glGetShaderiv == nullptr) {

return fail("glGetShaderiv failed.");

}

glGetShaderInfoLog = reinterpret_cast<PFNGLGETSHADERINFOLOGPROC>(

wglGetProcAddress("glGetShaderInfoLog"));

if (glGetShaderInfoLog == nullptr) {

return fail("glGetShaderInfoLog failed.");

}

glDeleteShader = reinterpret_cast<PFNGLDELETESHADERPROC>(wglGetProcAddress("glDeleteShader"));

if (glDeleteShader == nullptr) {

return fail("glDeleteShader failed.");

}

// ...

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

GLuint CreateShaderObject(GLenum shaderType, const char *filePath) {
    auto[succeed, fileContent] = GetTextFileContent(filePath);

    if (succeed) {
        auto shaderSource = fileContent.c_str();

        auto shader = glCreateShader(shaderType);

        if (shader) {
            glShaderSource(shader, 1, &shaderSource, nullptr);
            glCompileShader(shader);

            GLint status;
            glGetShaderiv(shader, GL_COMPILE_STATUS, &status);

            if (status != GL_FALSE) {
                return shader;
            } else {
                GLint infoLogLength;
                glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);

                auto infoLog = new GLchar[infoLogLength + 1];
                glGetShaderInfoLog(shader, infoLogLength, nullptr, infoLog);

                std::stringstream stringBuffer;
                stringBuffer << "Compile failure in ";

                switch (shaderType) {
                    case GL_VERTEX_SHADER  :
                        stringBuffer << "vertex";
                        break;
                    case GL_GEOMETRY_SHADER:
                        stringBuffer << "geometry";
                        break;
                    case GL_FRAGMENT_SHADER:
                        stringBuffer << "fragment";
                        break;
                    default:
                        stringBuffer << "unknown";
                        break;
                }

                stringBuffer << " shader:" << std::endl << std::string(infoLog) << std::endl;
                std::cerr << stringBuffer.str() << std::endl;

                delete[] infoLog;
                glDeleteShader(shader);
                return FALSE;
            }
        }
    }

    return FALSE;
}

GLuint CreateShaderObject(GLenum shaderType, const char *filePath) {

auto[succeed, fileContent] = GetTextFileContent(filePath);

if (succeed) {

auto shaderSource = fileContent.c_str();

auto shader = glCreateShader(shaderType);

if (shader) {

glShaderSource(shader, 1, &shaderSource, nullptr);

glCompileShader(shader);

GLint status;

glGetShaderiv(shader, GL_COMPILE_STATUS, &status);

if (status != GL_FALSE) {

return shader;

} else {

GLint infoLogLength;

glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);

auto infoLog = new GLchar[infoLogLength + 1];

glGetShaderInfoLog(shader, infoLogLength, nullptr, infoLog);

std::stringstream stringBuffer;

stringBuffer << "Compile failure in ";

switch (shaderType) {

case GL_VERTEX_SHADER :

stringBuffer << "vertex";

break;

case GL_GEOMETRY_SHADER:

stringBuffer << "geometry";

break;

case GL_FRAGMENT_SHADER:

stringBuffer << "fragment";

break;

default:

stringBuffer << "unknown";

break;

}

stringBuffer << " shader:" << std::endl << std::string(infoLog) << std::endl;

std::cerr << stringBuffer.str() << std::endl;

delete[] infoLog;

glDeleteShader(shader);

return FALSE;

}

return FALSE;

}

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

Создание объекта шейдерной программы выглядит похоже на создание объекта шейдера. Для реализации этой функции, в свою очередь, нам потребуются следующие OpenGL функции: glCreateProgram , glDeleteProgram , glAttachShader , glLinkProgramARB , glGetProgramiv , glGetProgramInfoLog и glDetachShader . Уже знакомым кодом получаем ссылки и на эти функции:

// gl_binding.cpp

// ...

PFNGLCREATEPROGRAMPROC glCreateProgram = nullptr;
PFNGLDELETEPROGRAMPROC glDeleteProgram = nullptr;
PFNGLATTACHSHADERPROC glAttachShader = nullptr;
PFNGLLINKPROGRAMARBPROC glLinkProgram = nullptr;
PFNGLGETPROGRAMIVPROC glGetProgramiv = nullptr;
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = nullptr;
PFNGLDETACHSHADERPROC glDetachShader = nullptr;

// InitBindings ...

// ...

glCreateProgram = reinterpret_cast<PFNGLCREATEPROGRAMPROC>(wglGetProcAddress("glCreateProgram"));

if (glCreateProgram == nullptr) {
    return fail("glCreateProgram failed.");
}

glDeleteProgram = reinterpret_cast<PFNGLDELETEPROGRAMPROC>(wglGetProcAddress("glDeleteProgram"));

if (glDeleteProgram == nullptr) {
    return fail("glDeleteProgram failed.");
}

glAttachShader = reinterpret_cast<PFNGLATTACHSHADERPROC>(wglGetProcAddress("glAttachShader"));

if (glAttachShader == nullptr) {
    return fail("glAttachShader failed.");
}

glLinkProgram = reinterpret_cast<PFNGLLINKPROGRAMARBPROC>(wglGetProcAddress("glLinkProgramARB"));

if (glLinkProgram == nullptr) {
    return fail("glLinkProgram failed.");
}

glGetProgramiv = reinterpret_cast<PFNGLGETPROGRAMIVPROC>(wglGetProcAddress("glGetProgramiv"));

if (glGetProgramiv == nullptr) {
    return fail("glGetProgramiv failed.");
}

glGetProgramInfoLog = reinterpret_cast<PFNGLGETPROGRAMINFOLOGPROC>(wglGetProcAddress("glGetProgramInfoLog"));

if (glGetProgramInfoLog == nullptr) {
    return fail("glGetProgramInfoLog failed.");
}

glDetachShader = reinterpret_cast<PFNGLDETACHSHADERPROC>(wglGetProcAddress("glDetachShader"));

if (glDetachShader == nullptr) {
    return fail("glDetachShader failed.");
}

// ...

// gl_binding.cpp

// ...

PFNGLCREATEPROGRAMPROC glCreateProgram = nullptr;

PFNGLDELETEPROGRAMPROC glDeleteProgram = nullptr;

PFNGLATTACHSHADERPROC glAttachShader = nullptr;

PFNGLLINKPROGRAMARBPROC glLinkProgram = nullptr;

PFNGLGETPROGRAMIVPROC glGetProgramiv = nullptr;

PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = nullptr;

PFNGLDETACHSHADERPROC glDetachShader = nullptr;

// InitBindings ...

// ...

glCreateProgram = reinterpret_cast<PFNGLCREATEPROGRAMPROC>(wglGetProcAddress("glCreateProgram"));

if (glCreateProgram == nullptr) {

return fail("glCreateProgram failed.");

}

glDeleteProgram = reinterpret_cast<PFNGLDELETEPROGRAMPROC>(wglGetProcAddress("glDeleteProgram"));

if (glDeleteProgram == nullptr) {

return fail("glDeleteProgram failed.");

}

glAttachShader = reinterpret_cast<PFNGLATTACHSHADERPROC>(wglGetProcAddress("glAttachShader"));

if (glAttachShader == nullptr) {

return fail("glAttachShader failed.");

}

glLinkProgram = reinterpret_cast<PFNGLLINKPROGRAMARBPROC>(wglGetProcAddress("glLinkProgramARB"));

if (glLinkProgram == nullptr) {

return fail("glLinkProgram failed.");

}

glGetProgramiv = reinterpret_cast<PFNGLGETPROGRAMIVPROC>(wglGetProcAddress("glGetProgramiv"));

if (glGetProgramiv == nullptr) {

return fail("glGetProgramiv failed.");

}

glGetProgramInfoLog = reinterpret_cast<PFNGLGETPROGRAMINFOLOGPROC>(wglGetProcAddress("glGetProgramInfoLog"));

if (glGetProgramInfoLog == nullptr) {

return fail("glGetProgramInfoLog failed.");

}

glDetachShader = reinterpret_cast<PFNGLDETACHSHADERPROC>(wglGetProcAddress("glDetachShader"));

if (glDetachShader == nullptr) {

return fail("glDetachShader failed.");

}

// ...

И реализация функции CreateShader :

// shader.cpp

// ...

GLuint CreateShader(const char *vertexShaderFilePath, const char *fragmentShaderFilePath) {
    auto vertexShader = CreateShaderObject(GL_VERTEX_SHADER, vertexShaderFilePath);
    auto fragmentShader = CreateShaderObject(GL_FRAGMENT_SHADER, fragmentShaderFilePath);

    if (vertexShader && fragmentShader) {
        auto shaderProgram = glCreateProgram();

        if (shaderProgram) {
            glAttachShader(shaderProgram, vertexShader);
            glAttachShader(shaderProgram, fragmentShader);

            glLinkProgram(shaderProgram);

            GLint status;
            glGetProgramiv(shaderProgram, GL_LINK_STATUS, &status);

            glDetachShader(shaderProgram, vertexShader);
            glDetachShader(shaderProgram, fragmentShader);

            glDeleteShader(vertexShader);
            glDeleteShader(fragmentShader);

            if (status != GL_FALSE) {
                return shaderProgram;
            } else {
                GLint infoLogLength;
                glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &infoLogLength);

                auto infoLog = new GLchar[infoLogLength + 1];
                glGetProgramInfoLog(shaderProgram, infoLogLength, nullptr, infoLog);

                std::stringstream stringBuffer;
                stringBuffer << "Linker failure: " << std::string(infoLog) << std::endl;
                std::cerr << stringBuffer.str() << std::endl;

                delete[] infoLog;

                glDeleteProgram(shaderProgram);
            }
        }
    }

    return FALSE;
}

// shader.cpp

// ...

GLuint CreateShader(const char *vertexShaderFilePath, const char *fragmentShaderFilePath) {

auto vertexShader = CreateShaderObject(GL_VERTEX_SHADER, vertexShaderFilePath);

auto fragmentShader = CreateShaderObject(GL_FRAGMENT_SHADER, fragmentShaderFilePath);

if (vertexShader && fragmentShader) {

auto shaderProgram = glCreateProgram();

if (shaderProgram) {

glAttachShader(shaderProgram, vertexShader);

glAttachShader(shaderProgram, fragmentShader);

glLinkProgram(shaderProgram);

GLint status;

glGetProgramiv(shaderProgram, GL_LINK_STATUS, &status);

glDetachShader(shaderProgram, vertexShader);

glDetachShader(shaderProgram, fragmentShader);

glDeleteShader(vertexShader);

glDeleteShader(fragmentShader);

if (status != GL_FALSE) {

return shaderProgram;

} else {

GLint infoLogLength;

glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &infoLogLength);

auto infoLog = new GLchar[infoLogLength + 1];

glGetProgramInfoLog(shaderProgram, infoLogLength, nullptr, infoLog);

std::stringstream stringBuffer;

stringBuffer << "Linker failure: " << std::string(infoLog) << std::endl;

std::cerr << stringBuffer.str() << std::endl;

delete[] infoLog;

glDeleteProgram(shaderProgram);

}

return FALSE;

}

Используя CreateShaderObject создаем шейдерные объекты для вершинного и фрагментного шейдеров. Далее создаем объект шейдерной программы, линкуем шейдерные объекты и подчищаем за собой:

// main.cpp

// winMain ...

// ...

auto shader = CreateShader(
    "data\\simple_vertex_shader.vert",
    "data\\simple_fragment_shader.frag");

// while () {...}

glDeleteProgram(shader);

// ...

// main.cpp

// winMain ...

// ...

auto shader = CreateShader(

"data\\simple_vertex_shader.vert",

"data\\simple_fragment_shader.frag");

// while () {...}

glDeleteProgram(shader);

// ...

Наконец-то мы подошли к долгожданной отрисовке треугольника.

Для отрисовки треугольника нам нужно указать три вершины (точки). Видеокарта не может напрямую работать с данными в оперативной памяти, по этому, чтобы, отрисовать треугольник, нам нужно загрузить необходимые данные (в данном случае три вершины) в видеопамять. В этом нелегком деле нам поможет Vertext Buffer Object (VBO) — это объект вершинного буфера в который мы можем загружать необходимую для отрисовки информацию. С каждой вершиной ассоциируются некоторые данные, такие как положение вершины, цвет, нормаль, текстурные координаты и любые другие данные необходимые для отрисовки. Загрузка данных из оперативной памяти в видеопамять довольно затратная операция и обычно должна осуществлятся как можно реже и как можно большим размером. Т.е. выгоднее один раз загрузить больше данных, чем несколько раз грузить по чуть-чуть. По этому и используются буферы.

Для того, чтобы воспользоваться данными из буфера нам нужно создать Vertext Array Object (VAO) . Так как в буфере могут лежать данные сразу для нескольких объектов (например для пары треугольников) и формат данных может отличаться, в зависимости от наших требований, то, чтобы объяснить OpenGL какую часть VBO буфера использовать и как интерпретировать данные буфера VAO объекты и используются. Грубо говоря VAO это «массив» вершинных атрибутов (т.е. некоторых данных, таких как цвет или положение вершины, ассоциированных с вершиной).

Алгоритм инициализации VBO и VAO для последующего использования при отрисовке:

запросить объект VBO буфера;
сделать буфер текущим;
загрузить данные в буфер;
деактивировать буфер;
запросить объект VAO;
сделать объект VAO текущим.

Для работы с VBO и VAO нам потребуются следующие функции: glGenBuffers , glBindBuffer , glBufferData , glDeleteBuffers , glGenVertexArrays , glBindVertexArray , glVertexAttribPointer , glDeleteVertexArrays . По этому сразу добавляем подключение всех выше перечисленных функций.

// gl_binding.cpp

// ...

PFNGLGENBUFFERSARBPROC glGenBuffers = nullptr;
PFNGLBINDBUFFERARBPROC glBindBuffer = nullptr;
PFNGLBUFFERDATAARBPROC glBufferData = nullptr;
PFNGLDELETEBUFFERSPROC glDeleteBuffers = nullptr;
PFNGLGENVERTEXARRAYSPROC glGenVertexArrays = nullptr;
PFNGLBINDVERTEXARRAYPROC glBindVertexArray = nullptr;
PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = nullptr;
PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays = nullptr;

// InitBindings

// ...

glGenBuffers = reinterpret_cast<PFNGLGENBUFFERSARBPROC>(wglGetProcAddress("glGenBuffersARB"));

if (glGenBuffers == nullptr) {
    return fail("glGenBuffers() failed.");
}

glBindBuffer = reinterpret_cast<PFNGLBINDBUFFERARBPROC>(wglGetProcAddress("glBindBufferARB"));

if (glBindBuffer == nullptr) {
    return fail("glBindBuffer() failed.");
}

glBufferData = reinterpret_cast<PFNGLBUFFERDATAARBPROC>(wglGetProcAddress("glBufferDataARB"));

if (glBufferData == nullptr) {
    return fail("glBufferData() failed.");
}

glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYSPROC>(wglGetProcAddress("glGenVertexArrays"));

if (glGenVertexArrays == nullptr) {
    return fail("glGenVertexArrays() failed.");
}

glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAYPROC>(wglGetProcAddress("glBindVertexArray"));

if (glBindVertexArray == nullptr) {
    return fail("glBindVertexArray() failed.");
}

glVertexAttribPointer = reinterpret_cast<PFNGLVERTEXATTRIBPOINTERPROC>(wglGetProcAddress("glVertexAttribPointer"));

if (glVertexAttribPointer == nullptr) {
    return fail("glVertexAttribPointer() failed.");
}

glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYSPROC >(
        wglGetProcAddress("glDeleteVertexArrays"));

if (glDeleteVertexArrays == nullptr) {
    return fail("glDeleteVertexArrays() failed.");
}

glUseProgram = reinterpret_cast<PFNGLUSEPROGRAMPROC>(wglGetProcAddress("glUseProgram"));

if (glUseProgram == nullptr) {
    return fail("glUseProgram() failed.");
}

// ...

// gl_binding.cpp

// ...

PFNGLGENBUFFERSARBPROC glGenBuffers = nullptr;

PFNGLBINDBUFFERARBPROC glBindBuffer = nullptr;

PFNGLBUFFERDATAARBPROC glBufferData = nullptr;

PFNGLDELETEBUFFERSPROC glDeleteBuffers = nullptr;

PFNGLGENVERTEXARRAYSPROC glGenVertexArrays = nullptr;

PFNGLBINDVERTEXARRAYPROC glBindVertexArray = nullptr;

PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = nullptr;

PFNGLDELETEVERTEXARRAYSPROC glDeleteVertexArrays = nullptr;

// InitBindings

// ...

glGenBuffers = reinterpret_cast<PFNGLGENBUFFERSARBPROC>(wglGetProcAddress("glGenBuffersARB"));

if (glGenBuffers == nullptr) {

return fail("glGenBuffers() failed.");

}

glBindBuffer = reinterpret_cast<PFNGLBINDBUFFERARBPROC>(wglGetProcAddress("glBindBufferARB"));

if (glBindBuffer == nullptr) {

return fail("glBindBuffer() failed.");

}

glBufferData = reinterpret_cast<PFNGLBUFFERDATAARBPROC>(wglGetProcAddress("glBufferDataARB"));

if (glBufferData == nullptr) {

return fail("glBufferData() failed.");

}

glGenVertexArrays = reinterpret_cast<PFNGLGENVERTEXARRAYSPROC>(wglGetProcAddress("glGenVertexArrays"));

if (glGenVertexArrays == nullptr) {

return fail("glGenVertexArrays() failed.");

}

glBindVertexArray = reinterpret_cast<PFNGLBINDVERTEXARRAYPROC>(wglGetProcAddress("glBindVertexArray"));

if (glBindVertexArray == nullptr) {

return fail("glBindVertexArray() failed.");

}

glVertexAttribPointer = reinterpret_cast<PFNGLVERTEXATTRIBPOINTERPROC>(wglGetProcAddress("glVertexAttribPointer"));

if (glVertexAttribPointer == nullptr) {

return fail("glVertexAttribPointer() failed.");

}

glDeleteVertexArrays = reinterpret_cast<PFNGLDELETEVERTEXARRAYSPROC >(

wglGetProcAddress("glDeleteVertexArrays"));

if (glDeleteVertexArrays == nullptr) {

return fail("glDeleteVertexArrays() failed.");

}

glUseProgram = reinterpret_cast<PFNGLUSEPROGRAMPROC>(wglGetProcAddress("glUseProgram"));

if (glUseProgram == nullptr) {

return fail("glUseProgram() failed.");

}

// ...

И инициализация VBO и VAO:

// main.cpp

// winMain ...

// CreateShader ...

const float vertexPositions[] = {
    0.0f,  1.0f, 0.0f, 1.0f,
    1.0f, -1.0f, 0.0f, 1.0f,
    -1.0f, -1.0f, 0.0f, 1.0f,
};

GLuint posBufferObject;
glGenBuffers(1, &posBufferObject);
glBindBuffer(GL_ARRAY_BUFFER, posBufferObject);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW);

GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, nullptr);
glBindBuffer(GL_ARRAY_BUFFER, 0); // unbind VBO
glBindVertexArray(0); // unbind VAO

// while() {...}

glDeleteVertexArrays(1, &vao);
glDeleteBuffers(1, &posBufferObject);

// ...

// main.cpp

// winMain ...

// CreateShader ...

const float vertexPositions[] = {

0.0f, 1.0f, 0.0f, 1.0f,

1.0f, -1.0f, 0.0f, 1.0f,

-1.0f, -1.0f, 0.0f, 1.0f,

};

GLuint posBufferObject;

glGenBuffers(1, &posBufferObject);

glBindBuffer(GL_ARRAY_BUFFER, posBufferObject);

glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STATIC_DRAW);

GLuint vao;

glGenVertexArrays(1, &vao);

glBindVertexArray(vao);

glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, nullptr);

glBindBuffer(GL_ARRAY_BUFFER, 0); // unbind VBO

glBindVertexArray(0); // unbind VAO

// while() {...}

glDeleteVertexArrays(1, &vao);

glDeleteBuffers(1, &posBufferObject);

// ...

Для отрисовки треугольника нам потребуются следующие функции: glUseProgram , glEnableVertexAttribArray , glDisableVertexAttribArray и glDrawArrays . Функция glDrawArrays уже объявлена в заголовочном файле gl.h и дополнительного поиска не требует. Находим остальные функции как обычно:

// gl_binding.cpp

// ...

PFNGLUSEPROGRAMPROC glUseProgram = nullptr;
PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = nullptr;
PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray = nullptr;

// InitBindings ...

// ...

glUseProgram = reinterpret_cast<PFNGLUSEPROGRAMPROC>(wglGetProcAddress("glUseProgram"));

if (glUseProgram == nullptr) {
    return fail("glUseProgram() failed.");
}

glEnableVertexAttribArray = reinterpret_cast<PFNGLENABLEVERTEXATTRIBARRAYPROC>(
        wglGetProcAddress("glEnableVertexAttribArray"));

if (glEnableVertexAttribArray == nullptr) {
    return fail("glEnableVertexAttribArray() failed.");
}

glDisableVertexAttribArray = reinterpret_cast<PFNGLDISABLEVERTEXATTRIBARRAYPROC>(
        wglGetProcAddress("glDisableVertexAttribArray"));

if (glDisableVertexAttribArray == nullptr) {
    return fail("glDisableVertexAttribArray() failed.");
}

// ...

// gl_binding.cpp

// ...

PFNGLUSEPROGRAMPROC glUseProgram = nullptr;

PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = nullptr;

PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray = nullptr;

// InitBindings ...

// ...

glUseProgram = reinterpret_cast<PFNGLUSEPROGRAMPROC>(wglGetProcAddress("glUseProgram"));

if (glUseProgram == nullptr) {

return fail("glUseProgram() failed.");

}

glEnableVertexAttribArray = reinterpret_cast<PFNGLENABLEVERTEXATTRIBARRAYPROC>(

wglGetProcAddress("glEnableVertexAttribArray"));

if (glEnableVertexAttribArray == nullptr) {

return fail("glEnableVertexAttribArray() failed.");

}

glDisableVertexAttribArray = reinterpret_cast<PFNGLDISABLEVERTEXATTRIBARRAYPROC>(

wglGetProcAddress("glDisableVertexAttribArray"));

if (glDisableVertexAttribArray == nullptr) {

return fail("glDisableVertexAttribArray() failed.");

}

// ...

Процесс отрисовки треугольника:

// main.cpp

// winMain

// ...

while (isRunning)
{
    // обработка оконных сообщений
    isRunning = ProcessEvents();

    glClear(GL_COLOR_BUFFER_BIT);

    glUseProgram(shaderProgram);

    glBindVertexArray(vao);
    glEnableVertexAttribArray(0);
    glDrawArrays(GL_TRIANGLES, 0, 3);

    glDisableVertexAttribArray(0);
    glBindVertexArray(0);
    glUseProgram(0);

    SwapBuffers(dc);
}

// ...

// main.cpp

// winMain

// ...

while (isRunning)

{

// обработка оконных сообщений

isRunning = ProcessEvents();

glClear(GL_COLOR_BUFFER_BIT);

glUseProgram(shaderProgram);

glBindVertexArray(vao);

glEnableVertexAttribArray(0);

glDrawArrays(GL_TRIANGLES, 0, 3);

glDisableVertexAttribArray(0);

glBindVertexArray(0);

glUseProgram(0);

SwapBuffers(dc);

}

// ...

Если все шло по плану, то при запуске приложения мы должны увидеть желтый треугольник на синем фоне:

Заключение

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

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

Введение

Disclaimer

OpengGL

Примерный план

Реализация

Отрисовка треугольника

Заключение

Добавить комментарий Отменить ответ