OpenGL 4.6 без glBind: Direct State Access на C++23
Почти каждый, кто учил OpenGL, начинал с одного и того же ритуала: glGenBuffers, glBindBuffer, glBufferData. Чтобы изменить объект, его сначала нужно привязать. Так написаны самые известные учебники, потому что они рассчитаны на OpenGL 3.3.
В OpenGL 4.5 этот ритуал стал необязательным. В стандарт вошёл Direct State Access, сокращённо DSA: функции, которые получают объект прямо в аргументе и ничего не привязывают. В статье я соберу на DSA квадрат с текстурой и индексами и по дороге покажу схемами, что происходит внутри. Код написан на C++23: std::expected, std::print, std::mdspan и несколько диапазонов оказались здесь к месту.
Всё, что есть в статье, собрано компилятором MSVC из Visual Studio 2026 с флагом /W4 без предупреждений и запущено на OpenGL 4.6. Вот что рисует программа:
Привяжи, потом меняй
Напомню, как выглядит заполнение буфера вершин в стиле OpenGL 3.3:
GLuint vbo = 0; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
Посмотрите на последнюю строку. В вызове glBufferData нет переменной vbo. Функция получает константу GL_ARRAY_BUFFER, а это не буфер, а название гнезда в контексте OpenGL. Контекст хранит таблицу таких гнёзд, и в каждом гнезде записано имя одного объекта. Функция glBufferData заглядывает в гнездо GL_ARRAY_BUFFER и меняет тот буфер, имя которого там сейчас записано.
Получается, что строка кода не говорит, какой объект она изменит. Ответ зависит от того, какой glBindBuffer выполнился последним, а этот вызов может стоять в другой функции и в другом файле.
Пока программа состоит из одного main, такое неудобство незаметно. Оно становится ошибкой, когда появляются свои функции. Вот типичный случай с текстурами:
Программа привязала текстуру стены, чтобы настроить ей фильтрацию. Между привязкой и настройкой она вызвала loadIcon, а функция loadIcon внутри привязывает свою текстуру, потому что по-другому загрузить картинку в OpenGL 3.3 нельзя. После возврата в гнезде GL_TEXTURE_2D записана иконка, и настройка фильтрации достаётся иконке.
OpenGL об ошибке не сообщит: все три вызова правильные. Чтобы защититься, каждую такую функцию приходится писать по схеме «запомни, что было в гнезде, сделай своё, верни как было», то есть перед работой вызывать glGetIntegerv(GL_TEXTURE_BINDING_2D, …).
Есть и вторая известная ловушка. Гнездо GL_ELEMENT_ARRAY_BUFFER принадлежит не контексту, а привязанному сейчас VAO. Поэтому аккуратная на вид строка glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0), выполненная до glBindVertexArray(0), отцепляет буфер индексов от VAO, и glDrawElements потом рисует пустоту. Запомнить это правило можно, но вывести его из кода нельзя.
DSA: имя объекта первым аргументом
Идея Direct State Access помещается в одну строку: функция получает имя объекта первым аргументом и работает с этим объектом, а гнёзда не читает и не меняет.
Тот же буфер вершин на DSA:
GLuint vbo = 0; glCreateBuffers(1, &vbo); glNamedBufferStorage(vbo, sizeof(vertices), vertices, 0);
Вызова glBindBuffer нет, константы GL_ARRAY_BUFFER тоже нет. Буферу вообще не нужно знать, будет он хранить вершины, индексы или данные для шейдера: назначение появляется позже, когда буфер подключают к VAO.
Функция loadIcon из примера выше на DSA не трогает ни одного гнезда. Её можно вызвать в любом месте программы, и состояние контекста останется прежним.
glCreate вместо glGen
Первое отличие в коде — glCreateBuffers на месте glGenBuffers. Разница не только в названии.
Функция glGenBuffers выдаёт свободное имя, то есть число, и больше ничего не делает. Самого объекта ещё нет: OpenGL создаёт объект в момент первой привязки. В старом стиле это не мешало, потому что привязка всё равно шла следующей строкой.
DSA ничего не привязывает, поэтому объект должен существовать сразу. Функции семейства glCreate* выдают имя и тут же создают объект.
Смешивать два стиля нельзя. Я проверил: если получить имя через glGenBuffers и сразу передать это имя в glNamedBufferStorage, вызов завершается ошибкой GL_INVALID_OPERATION, и память буферу не выделяется. То же самое происходит с glGenTextures и glTextureParameteri.
У каждого вида объектов есть своя создающая функция: glCreateBuffers, glCreateVertexArrays, glCreateTextures, glCreateFramebuffers, glCreateRenderbuffers, glCreateSamplers.
Буфер: память выделяется один раз
Вторая строка — glNamedBufferStorage. Эта функция выделяет буферу память и заполняет память данными. Аргументов четыре: имя буфера, размер в байтах, указатель на данные и флаги.
От привычной glBufferData она отличается тем, что память неизменяемая по размеру. Повторный вызов glNamedBufferStorage для того же буфера даёт GL_INVALID_OPERATION. Буфер другого размера — это новый буфер.
Флаги в последнем аргументе говорят, что программа собирается делать с содержимым дальше. Ноль означает «ничего»: данные загружены один раз, и менять содержимое со стороны процессора нельзя. Вызов glNamedBufferSubData для такого буфера тоже даёт GL_INVALID_OPERATION. Чтобы обновлять данные, при создании нужен флаг GL_DYNAMIC_STORAGE_BIT, а чтобы отображать буфер в память программы через glMapNamedBufferRange — флаги GL_MAP_READ_BIT или GL_MAP_WRITE_BIT.
Вместо расплывчатой подсказки GL_STATIC_DRAW драйвер получает точное обещание и может выбрать для буфера подходящую память.
В программе статьи два буфера, вершины и индексы, и оба создаёт одна функция:
GLuint createBuffer(std::span<const std::byte> bytes) { GLuint buffer = 0; glCreateBuffers(1, &buffer); glNamedBufferStorage(buffer, static_cast<GLsizeiptr>(bytes.size()), bytes.data(), 0); return buffer; }
std::span<const std::byte> передаёт указатель и размер одной вещью, поэтому перепутать sizeof массива с sizeof элемента при вызове не получится:
const GLuint vertexBuffer = createBuffer(std::as_bytes(std::span(vertices))); const GLuint indexBuffer = createBuffer(std::as_bytes(std::span(indices)));
std::span и std::as_bytes появились ещё в C++20. Конструктор std::span(vertices) сам выводит из массива тип элемента и количество.
VAO: формат отдельно, буфер отдельно
В OpenGL 3.3 вершины описывает функция glVertexAttribPointer. Она делает два дела сразу: записывает формат атрибута и запоминает буфер, который в этот момент лежит в гнезде GL_ARRAY_BUFFER. Буфера в аргументах снова нет.
DSA разводит эти два дела по разным функциям, и устройство VAO становится видно в коде:
Внутри VAO лежат записи двух видов.
Точка привязки отвечает на вопрос «откуда брать байты». В ней записаны буфер, начало данных в буфере и шаг — расстояние в байтах от одной вершины до следующей.
Атрибут отвечает на вопрос «как понимать байты». В нём записаны количество чисел, тип чисел и смещение от начала вершины. Кроме того, атрибут хранит номер точки привязки, из которой он читает.
Отдельно в VAO есть одно место для буфера индексов.
Вершина в программе статьи состоит из позиции, текстурных координат и цвета:
struct Vertex { float position[2]; float uv[2]; float color[3]; };
Так четыре вершины лежат в буфере:
Сначала точка привязки и буфер индексов:
GLuint vao = 0; glCreateVertexArrays(1, &vao); glVertexArrayVertexBuffer(vao, 0, vertexBuffer, 0, sizeof(Vertex)); glVertexArrayElementBuffer(vao, indexBuffer);
Функция glVertexArrayVertexBuffer принимает пять аргументов: VAO, номер точки привязки, буфер, начало данных в буфере и шаг. Шаг равен sizeof(Vertex), то есть 28 байт.
Функция glVertexArrayElementBuffer подключает буфер индексов. Ловушки с glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0) здесь нет, потому что привязки нет.
Теперь атрибуты. Каждому атрибуту нужны три вызова: включить, описать формат, указать точку привязки. Три атрибута дают девять почти одинаковых строк, поэтому я описал раскладку вершины таблицей и прошёл по таблице циклом:
struct Attribute { GLint count; GLuint offset; }; constexpr std::array layout{ Attribute{ 2, offsetof(Vertex, position) }, Attribute{ 2, offsetof(Vertex, uv) }, Attribute{ 3, offsetof(Vertex, color) }, }; for (const auto [index, attribute] : std::views::enumerate(layout)) { const auto location = static_cast<GLuint>(index); glEnableVertexArrayAttrib(vao, location); glVertexArrayAttribFormat(vao, location, attribute.count, GL_FLOAT, GL_FALSE, attribute.offset); glVertexArrayAttribBinding(vao, location, 0); }
std::views::enumerate из C++23 выдаёт пары «номер, элемент», и отдельный счётчик не нужен. Номер элемента в таблице совпадает с location атрибута в шейдере.
Обратите внимание на последний аргумент glVertexArrayAttribFormat. Смещение передаётся обычным числом. В glVertexAttribPointer на этом месте стоял указатель, и число приходилось превращать в указатель записью (void*)offsetof(…).
Разделение формата и буфера даёт и практическую выгоду. Чтобы нарисовать тем же VAO другую модель с такой же раскладкой вершины, достаточно одного вызова glVertexArrayVertexBuffer с другим буфером: атрибуты заново описывать не надо.
Текстура без glActiveTexture
Картинку для текстуры программа создаёт сама, чтобы статье не понадобилась библиотека загрузки изображений. Это шахматная доска 64 на 64 пикселя:
constexpr int size = 64; constexpr int cell = 8; std::vector<std::uint32_t> pixels(size * size); const std::mdspan image(pixels.data(), size, size); const auto range = std::views::iota(0, size); for (const auto [y, x] : std::views::cartesian_product(range, range)) { const bool light = (x / cell + y / cell) % 2 == 0; image[y, x] = light ? 0xFFE8E8E8 : 0xFF505050; }
Здесь сразу три вещи из C++23. std::mdspan смотрит на одномерный std::vector как на двумерную таблицу и сам считает y * size + x. Запись image[y, x] с двумя индексами в квадратных скобках стала законной тоже в C++23. std::views::cartesian_product заменяет два вложенных цикла одним.
Теперь объект текстуры:
GLuint texture = 0; glCreateTextures(GL_TEXTURE_2D, 1, &texture); glTextureStorage2D(texture, 1, GL_RGBA8, size, size); glTextureSubImage2D(texture, 0, 0, 0, size, size, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data()); glTextureParameteri(texture, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTextureParameteri(texture, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
Функция glCreateTextures получает вид текстуры первым аргументом: вид задаётся при создании и потом не меняется. В остальных вызовах константы GL_TEXTURE_2D уже нет, везде стоит имя texture.
Работа с памятью устроена так же, как у буфера. glTextureStorage2D один раз выделяет память: второй аргумент — количество уровней детализации, третий — формат хранения, дальше ширина и высота. Повторный вызов даёт GL_INVALID_OPERATION. glTextureSubImage2D копирует пиксели в уже выделенную память.
Осталось передать текстуру шейдеру. В старом стиле для этого нужны два вызова и ещё одно скрытое состояние: glActiveTexture выбирает текстурный блок, а glBindTexture кладёт текстуру в выбранный блок. В DSA номер блока передаётся аргументом:
glBindTextureUnit(0, texture);
Шейдер находит текстуру по номеру блока, который записан в описании сэмплера:
layout(binding = 0) uniform sampler2D checker;
Номер блока стоит в двух местах, в вызове и в шейдере, и оба места видны глазами. Вызов glUniform1i для сэмплера не нужен.
Шейдеры: std::expected вместо молчаливой ошибки
Функции шейдеров и программ, glShaderSource, glCompileShader, glLinkProgram, с самого начала принимали имя объекта аргументом, так что менять в них нечего. Зато здесь пригодился C++23.
Обычная compileShader из учебника печатает ошибку и всё равно возвращает имя неработающего шейдера. В C++23 функция может вернуть либо результат, либо ошибку:
enum class ShaderStage : GLenum { Vertex = GL_VERTEX_SHADER, Fragment = GL_FRAGMENT_SHADER, }; std::expected<GLuint, std::string> compileShader(ShaderStage stage, const char* source) { const GLuint shader = glCreateShader(std::to_underlying(stage)); glShaderSource(shader, 1, &source, nullptr); glCompileShader(shader); GLint success = GL_FALSE; glGetShaderiv(shader, GL_COMPILE_STATUS, &success); if (!success) { std::string message(1024, ‘