Основы VBO в OpenGL. Часть первая, первый квадрат

1. Часть первая, первый квадрат
2. Часть вторая, добавляем атрибуты
3. Часть третья, индексный буфер
4. Часть четвертая, динамика
5. Часть пятая, дополнительные возможности
6. Часть шестая, VAO
7. Ссылки по теме

Я уже многократно упоминал о VBO, которое даже входит в название моего движка, потому я решил здесь опубликовать свою старую ознакомительную статью об этом самом VBO.

VBO (Vertex Buffer Objects) – технология, позволяющая хранить координаты вершин совместно с их атрибутами в видеопамяти.

В отличии от использования блока glBegin/glEnd, при котором на каждом кадре вся геометрия передается GPU по очень медленной шине PCIEx, при использовании VBO все геометрия загружается в видеопамять только один раз, на этапе инициализации, после чего мы просто ссылаемся на эти данные. Это во-первых позволят существенно разгрузить шину для более важных задач, во-вторых - это приводит к существенному повышению производительности, так как GPU может незамедлительно приступать к рендерингу, не дожидаясь пока будут получены данные от CPU. Ну и пропускная способность видеопамяти в десятки раз выше пропускной способности PCIEx (4Гб/сек против 148Гб/сек), благодаря чему все операции копирования в видеопамяти происходят существенно быстрее чем при загрузке данных со стороны CPU. Используя приведенные выше особенности можно существенно повысить как производительность так и гибкость рендера, но обо всем по-порядку.

Работа с VBO сводится к нескольким этапам –

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

Рассмотрим поэтапно данный процесс. Этап первый – создание буфера VBO

Листинг 1:

1 2 3 4 5 6 7

var vId: Cardinal; begin glGenBuffers( 1, @vId ); glBindBuffer(GL_ARRAY_BUFFER, vId ); glBufferData(GL_ARRAY_BUFFER, sizeof(GLFLoat)*3*Count, @VertexBuffer[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,0); end;

Разберем этот код – в первую очередь для работы с VBO нам нужно выделить переменную в которой будет храниться идентификатор нашего буферного объекта, в качестве такой переменной у нас используется vId: Cardinal, как вариант можно использовать тип данных OpenGL GLUInt, что по сути одно и то же. Далее нам нужно попросить OpenGL выдать нам свободный идентификатор, делается это в строке (3) командой glGenBuffers( 1, @vId ). Первый параметр указывает на количество буферов которые мы хотим сгенерировать, в нашем случае нужен лишь один буфер, о чем мы и сообщили.

Теперь у нас есть идентификатор на пока что пустой буфер объекта, следовательно самое время его чем-то заполнить, но прежде чем заполнять – нужно сделать данный буфер активным, делается это командой (4) glBindBuffer(GL_ARRAY_BUFFER, vId ). В качестве последнего параметра выступает наш идентификатор, а в качестве первого – специальная константа, говорящая OpenGL что данный буфер будет использоваться для хранения вершинных атрибутов.

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

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

TVertex = record

   X,Y,Z: single;

End;

Таким образом, одна вершина будет у нас занимать в памяти 3 координаты*4байта на каждую=12 байт. Соответственно, если у нас 100 вершин, то это число еще нужно умножить на 100, или в общем виде – на Count. Сам же буфер у нас будет объявлен как обычный одномерный массив типа TVertex:

Var VertexBuffer: Array of TVertex;

…..

Setlength(VertexBuffer, Count);

Указатель на данный массив и выступает у нас в качестве третьего параметра функции glBufferData.

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

GL_STATIC_DRAW            – данные будут очень редко обновляться

GL_DYNAMIC_DRAW       – данные будут обновляться, но не каждый кадр

GL_STREAM_DRAW          – данные будут обновляться каждый кадр.

Это позволяет компилятору более эффективно работать с данными буферами.

Теперь наши данные находятся в видеопамяти, и с чистой совестью мы можем удалять данные из оперативной памяти (если в них больше нет надобности). Так же можно освободить активный буфер, так как до тех пор, пока буфер VBO активен, все операции рисования будут пытаться работать с VBO. Активация следующего буфера автоматически отключает предыдущий. Для полной деактивации буфера VBO необходимо указать в качестве идентификатора буфера "0" (строка 6):

glBindBuffer(GL_ARRAY_BUFFER,0);

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

Листинг 2:

1 2 3 4 5 6 7

begin glEnableClientState( GL_VERTEX_ARRAY ); glBindBuffer( GL_ARRAY_BUFFER, vId ); glVertexPointer( 3, GL_FLOAT, 0, nil ); glDrawArrays(GL_TRIANGLES , 0, VertexCount); glDisableClientState(GL_VERTEX_ARRAY); end;

Рассмотрим данный код – первое что нам нужно сделать – переключить состояние OpenGL на использование вершинных буферов (иначе будут использована более старая и более медленная технология VBA), это делается вызовом команды glEnableClientState(GL_VERTEX_ARRAY). В качестве параметра этой команды выступает тип атрибута. Вышеперечисленным типам атрибутов соответствуют такие константы:

Вершинные координаты       -           GL_VERTEX_ARRAY

Нормали                                  -           GL_NORMAL_ARRAY

Текстурные координаты        -           GL_TEXTURE_COORD_ARRAY

Цвет вершины                         -           GL_COLOR_ARRAY

После того как мы указали OpenGL что мы сейчас будем передавать данные о координатах вершин, необходимо подключить соответствующий буфер, используя идентификатор, полученный на предыдущем этапе. Делается это так же командой glBindBuffer(GL_ARRAY_BUFFER, vId). 

После того, как нужный буфер сделан активным мы должны указать GPU что из этого буфера у нас будут браться координаты вершин (в одном буфере у нас могут содержаться несколько различных атрибутов), для этого у нас служит команда glVertexPointer( 3, GL_FLOAT, 0, nil ).

Первый параметр данной команды говорит GPU о том, сколько координат мы хотим передать, в нашем случае у каждой вершины у нас 3 координаты – X,Y,Z, потому мы и указываем первым параметром число 3. Второй параметр говорит GPU в каком виде у нас содержатся эти данные, вспоминаем нашу структуру TVertex, объявленную выше – там у нас данные имеют тип single, который эквивалентен типу GL_FLOAT, потому мы и указываем в качестве второго параметра тип GL_FLOAT. Третий параметр у нас задает расстояние между однотипными данными. Как я уже упоминал выше – в одном буфере у нас могут содержаться несколько вершинных атрибутов, все они расположены друг за другом, вот мы и должны указать сколько блоков памяти размером GL_FLOAT мы должны пропустить, чтоб добраться до интересующих нас данных. В нашем случае у нас всего 1 атрибут, потому мы указываем в качестве параметра 0, что говорит что координаты следуют друг за другом. Последний параметр так же необходим при помещении нескольких атрибутов в один буфер, и задает начальное смещение этих данных в буфере. В случае одного атрибута это смещение задается как nil. 

Более подробно о упаковке нескольких атрибутов в один буфер можно почитать в справке по команде glInterleavedArrays. Данная технология несколько устарела, потому я это пропущу. 

Итак, после того как мы сделали активным наш вершинный буфер и указали GPU где искать наши координаты вершин – самое время отрисовать их, для этого используется команда:

glDrawArrays(GL_TRIANGLES , 0, VertexCount);

Данная команда говорит GPU что нужно отрисовать VertexCount вершин, при этом 3 идущие друг за другом вершины формируют один треугольник, о чем говорит параметр GL_TRIANGLES. Вместо GL_TRIANGLES вы можете использовать любой стандартный тип полигона, к примеру GL_TRIANGLE_STRIP, GL_QUADS и прочие. Второй параметр позволяет начать рисование не с первого элемента массива, в нашем случае 0 означает что будут отрисованы все треугольники, начиная с самого первого.

После того как все треугольники нарисованы, необходимо восстановить состояние OpenGL, это делается функцией glDisableClientState(GL_VERTEX_ARRAY), в качестве которого выступает тип активного буфера.

Данный этап выполняется каждый раз, когда нужно отрендерить нашу геометрию.

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

Ну и третий этап - после того, как программа отработала, или после того, как какой-то из буферов стал нам не нужен нам нужно освободить занимаемую им видеопамять, делается это очень легко:

glBindBuffer( GL_ARRAY_BUFFER, 0 );          

glDeleteBuffers(1,@vId);

Тоесть мы вначале делаем текущий буфер неактивным, после чего командой glDeleteBuffers удаляем буфер с идентификатором vId.

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

Так же нам потребуется объявить некоторые глобальные переменные, в частности переменную vId (Vertex Id), массив координат вершин «Var VertexBuffer: Array of TVertex» и объявить новый тип данных «TVertex = record  X,Y,Z: single; End;»

Запишем все это:

Листинг 3:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

Type TVertex = record X,Y,Z: single; end; var vId:integer; VertexBuffer: Array of TVertex; Ready:Boolean=false; procedure VBOInit; var Count:integer; begin Count:=high(VertexBuffer)+1; glGenBuffers( 1, @vId ); glBindBuffer(GL_ARRAY_BUFFER, vId ); glBufferData(GL_ARRAY_BUFFER, sizeof(GLFLoat)*3*Count, @VertexBuffer[0], GL_STATIC_DRAW); glBindBuffer(GL_ARRAY_BUFFER,0); end; procedure VBODraw; var Count:integer; begin Count:=high(VertexBuffer)+1; glEnableClientState( GL_VERTEX_ARRAY ); glBindBuffer( GL_ARRAY_BUFFER, vId ); glVertexPointer( 3, GL_FLOAT, 0, nil ); glDrawArrays(GL_TRIANGLES , 0, Count); glDisableClientState(GL_VERTEX_ARRAY); end; procedure VBOFree; begin glBindBuffer( GL_ARRAY_BUFFER, 0 ); glDeleteBuffers(1,@vId); end;

Теперь осталось только заполнить буфер вершин нашими данными и отправить его на рисование. Я поместил инициализацию буфера в конструктор формы:

Листинг 4:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

procedure TForm1.FormCreate(Sender: TObject); begin Setlength(VertexBuffer,6);//Создаем буффер под 6 вершин //Создаем квадрат, состоящий из двух треугольников VertexBuffer[0].X:=-1; VertexBuffer[0].Y:=1; VertexBuffer[0].Z:=0; VertexBuffer[1].X:=-1; VertexBuffer[1].Y:=-1;VertexBuffer[1].Z:=0; VertexBuffer[2].X:= 1; VertexBuffer[2].Y:=1; VertexBuffer[2].Z:=0; VertexBuffer[3].X:= 1; VertexBuffer[3].Y:=1; VertexBuffer[3].Z:=0; VertexBuffer[4].X:=-1; VertexBuffer[4].Y:=-1;VertexBuffer[4].Z:=0; VertexBuffer[5].X:= 1; VertexBuffer[5].Y:=-1;VertexBuffer[5].Z:=0; //Инициализируем наш буфер VBOInit; Ready:=true; //ставим флаг что буфер готов к рендерингу end;

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

Сразу напишем код, удаляющий наш буфер после завершения работы, для этого в событии onClose пишем такой вот код:

Листинг 5:

1 2 3 4 5

procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin Ready:=false; VBOFree; end;

Для демок я использовал GLScene, чтоб заставить GLScene выполнить код OpenGL существует специальный компонент - GLDirectOpenGL, у которого есть событие onRender, вот туда мы и помещаем вызов нашей команды рисования. Важное замечание - в последних версиях GLScene изменился способ прямой работы с OpenGL, но дабы не привязываться к синтаксису одного движка я продолжу приводить код на чистом OpenGL.

Листинг 6:

1 2 3 4 5

procedure TForm1.GLDirectOpenGL1Render(Sender: TObject; var rci: TRenderContextInfo); begin if Ready then VBODraw; end;

Здесь мы просто проверяем готов ли наш буфер и если готов, то вызываем процедуру рисования.

При использовании GLScene требуется принудительная перерисовка вьюпорта, для этого, событии onProgress каденсера, нужно вызвать метод GLSceneViewer1.Invalidate:

Листинг 7:

1 2 3 4 5

procedure TForm1.GLCadencer1Progress(Sender: TObject; const deltaTime, newTime: Double); begin GLSceneViewer1.Invalidate; end;

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

Рис.1. Первый квадрат.

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

Бинарник с исходными кодами примера: Demo1