Как рендерить вне экрана в OpenGL?

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

Итак, очень простой метод закадрового рендеринга будет примерно таким. Я использую псевдокод C ++, поэтому он, скорее всего, будет содержать ошибки, но должен прояснить общий поток:

//Before swapping
std::vector<std::uint8_t> data(width*height*4);
glReadBuffer(GL_BACK);
glReadPixels(0,0,width,height,GL_BGRA,GL_UNSIGNED_BYTE,&data[0]);

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

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

По сути, FBO позволяет вам создавать нестандартный буфер кадра (например, буферы FRONT и BACK), которые позволяют рисовать в буфер памяти вместо экранных буферов. На практике вы можете рисовать либо в текстуре, либо в буфере рендеринга. Первый оптимален, когда вы хотите повторно использовать пиксели в самом OpenGL в качестве текстуры (например, наивная «камера безопасности» в игре), второй - если вы просто хотите визуализировать / считывать. При этом приведенный выше код стал бы чем-то вроде этого, снова псевдокодом, так что не убивайте меня, если я ошибся или забыл некоторые инструкции.

//Somewhere at initialization
GLuint fbo, render_buf;
glGenFramebuffers(1,&fbo);
glGenRenderbuffers(1,&render_buf);
glBindRenderbuffer(render_buf);
glRenderbufferStorage(GL_RENDERBUFFER, GL_BGRA8, width, height);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER​,fbo);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, render_buf);

//At deinit:
glDeleteFramebuffers(1,&fbo);
glDeleteRenderbuffers(1,&render_buf);

//Before drawing
glBindFramebuffer(GL_DRAW_FRAMEBUFFER​,fbo);
//after drawing
std::vector<std::uint8_t> data(width*height*4);
glReadBuffer(GL_COLOR_ATTACHMENT0);
glReadPixels(0,0,width,height,GL_BGRA,GL_UNSIGNED_BYTE,&data[0]);
// Return to onscreen rendering:
glBindFramebuffer(GL_DRAW_FRAMEBUFFER​,0);

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

Наконец, вы можете использовать объекты пиксельного буфера, чтобы сделать считанные пиксели асинхронными. Проблема в том, что glReadPixels блокируется до тех пор, пока данные пикселей не будут полностью переданы, что может привести к остановке вашего процессора. С PBO реализация может немедленно вернуться, поскольку она все равно контролирует буфер. Только при отображении буфера конвейер будет блокировать. Однако PBO можно оптимизировать для буферизации данных исключительно в ОЗУ, поэтому этот блок может занять намного меньше времени. Код считываемых пикселей будет примерно таким:

//Init:
GLuint pbo;
glGenBuffers(1,&pbo);
glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo);
glBufferData(GL_PIXEL_PACK_BUFFER, width*height*4, NULL, GL_DYNAMIC_READ);

//Deinit:
glDeleteBuffers(1,&pbo);

//Reading:
glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo);
glReadPixels(0,0,width,height,GL_BGRA,GL_UNSIGNED_BYTE,0); // 0 instead of a pointer, it is now an offset in the buffer.
//DO SOME OTHER STUFF (otherwise this is a waste of your time)
glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo); //Might not be necessary...
pixel_data = glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY);

Деталь в кепках обязательна. Если вы просто отправите glReadPixels в PBO, а затем glMapBuffer этого PBO, вы не получите ничего, кроме большого количества кода. Конечно, glReadPixels может вернуться немедленно, но теперь glMapBuffer остановится, потому что он должен безопасно отобразить данные из буфера чтения в PBO и в блок памяти в основной RAM.

Также обратите внимание, что я использую GL_BGRA повсюду, потому что многие видеокарты внутренне используют его как оптимальный формат рендеринга (или версию GL_BGR без альфа). Это должен быть самый быстрый формат для такой передачи пикселей. Я попытаюсь найти статью nvidia, которую прочитал об этом несколько месяцев назад.

При использовании OpenGL ES 2.0 GL_DRAW_FRAMEBUFFER может быть недоступен, вы должны просто использовать GL_FRAMEBUFFER в этом случае.

Я предполагаю, что создание фиктивного окна (вы не выполняете рендеринг в нем; оно существует только потому, что API требует его создания), в котором вы создаете свой основной контекст, является приемлемой стратегией реализации.

Вот ваши варианты:

Пиксельные буферы

Пиксельный буфер или pbuffer (который не является объектом пиксельного буфера) в первую очередь контекст OpenGL. Обычно вы создаете окно как обычно, а затем выбираете формат пикселей из _1 _ (форматы pbuffer надо брать отсюда). Затем вы вызываете wglCreatePbufferARB, сообщая ему HDC вашего окна и формат буфера пикселей, который вы хотите использовать. Да, и ширина / высота; вы можете запросить максимальную ширину / высоту реализации.

Фреймбуфер по умолчанию для pbuffer не отображается на экране, а максимальная ширина / высота - это то, что аппаратное обеспечение хочет позволить вам использовать. Таким образом, вы можете выполнить рендеринг и использовать glReadPixels для чтения из него.

Вам нужно будет поделиться своим контекстом с данным контекстом, если вы создали объекты в контексте окна. В противном случае вы можете использовать контекст pbuffer полностью отдельно. Только не разрушайте контекст окна.

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

Минусы таковы. Буферы не работают с основными контекстами OpenGL. Они могут работать для обеспечения совместимости, но нет возможности предоставить wglCreatePbufferARB информацию о версиях и профилях OpenGL.

Объекты Framebuffer

Объекты Framebuffer являются более "правильными" целями визуализации вне экрана, чем pbuffers. FBO находятся в контексте, а pbuffers предназначены для создания новых контекстов.

FBO - это просто контейнер для изображений, в которые вы выполняете рендеринг. Максимальные размеры, которые позволяет реализация, могут быть запрошены; вы можете предположить, что это GL_MAX_VIEWPORT_DIMS (перед проверкой убедитесь, что FBO привязан, поскольку он изменяется в зависимости от того, привязан ли FBO).

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

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

Единственный реальный недостаток - это более узкий диапазон оборудования, которое их поддерживает. В общем, все, что AMD или NVIDIA делают и которые они все еще поддерживают (прямо сейчас GeForce 6xxx или лучше [обратите внимание на количество x] и любая карта Radeon HD), будет иметь доступ к ARB_framebuffer_object или OpenGL 3.0+ (где это основная функция ). Старые драйверы могут иметь только поддержку EXT_framebuffer_object (которая имеет несколько отличий). Аппаратное обеспечение Intel - это удача; даже если они заявляют о поддержке 3.x или 4.x, все равно может произойти сбой из-за ошибок драйвера.

Если вам нужно отрендерить что-то, что превышает максимальный размер FBO вашей реализации GL, _ 1_ работает очень хорошо:

Библиотека TR (Tile Rendering) - это служебная библиотека OpenGL для выполнения мозаичного рендеринга. Тайловый рендеринг - это метод создания больших изображений по частям (тайлам).

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

Самый простой способ - использовать так называемые объекты буфера кадра (FBO). Вам все равно придется создать окно для создания контекста opengl (но это окно можно скрыть).

Самый простой способ достичь вашей цели - использовать FBO для рендеринга вне экрана. И вам не нужно выполнять рендеринг в текстуру, а затем получать тексимаж. Просто выполните рендеринг в буфер и используйте функцию glReadPixels. Эта ссылка будет полезна. См. Примеры объектов Framebuffer