¿Cuál es el papel de glBindVertexArrays vs glBindBuffer y cuál es su relación?

Desde una perspectiva de bajo nivel, puedes pensar en un array como si tuviera dos partes: {[14]]}

• Información sobre el tamaño, la forma y el tipo de la matriz (por ejemplo, números de coma flotante de 32 bits, que contienen filas de vectores con cuatro elementos cada uno).

• Los datos de la matriz, que es poco más que un gran blob de bytes.

A pesar de que el concepto de bajo nivel en su mayoría se ha mantenido igual, la forma en que se especifican los arrays ha cambiado varias veces año.

OpenGL 3.0 / ARB_vertex_array_object

Esta es la forma en que probablemente debería estar haciendo las cosas hoy. Es muy raro encontrar personas que no pueden ejecutar OpenGL 3.x y aún así tener dinero para gastar en su software.

Un objeto buffer en OpenGL es un gran blob de bits. Piense en el búfer "activo" como solo una variable global, y hay un montón de funciones que utilizan el búfer activo en lugar de usar un parámetro. Estas variables de estado globales son el lado feo de OpenGL (antes de acceso directo del Estado, que se trata a continuación).

GLuint buffer;

// Generate a name for a new buffer.
// e.g. buffer = 2
glGenBuffers(1, &buffer);

// Make the new buffer active, creating it if necessary.
// Kind of like:
// if (opengl->buffers[buffer] == null)
//     opengl->buffers[buffer] = new Buffer()
// opengl->current_array_buffer = opengl->buffers[buffer]
glBindBuffer(GL_ARRAY_BUFFER, buffer);

// Upload a bunch of data into the active array buffer
// Kind of like:
// opengl->current_array_buffer->data = new byte[sizeof(points)]
// memcpy(opengl->current_array_buffer->data, points, sizeof(points))
glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);

Ahora, el sombreador de vértices típico toma vértices como entrada, no una gran masa de bits. Por lo tanto, debe especificar cómo se decodifica el blob de bits (el búfer) en vértices. Ese es el trabajo de la matriz. Del mismo modo, hay una matriz "activa" que se puede pensar como una variable global:

GLuint array;
// Generate a name for a new array.
glGenVertexArrays(1, &array);
// Make the new array active, creating it if necessary.
glBindVertexArray(array);

// Make the buffer the active array buffer.
glBindBuffer(GL_ARRAY_BUFFER, buffer);
// Attach the active buffer to the active array,
// as an array of vectors with 4 floats each.
// Kind of like:
// opengl->current_vertex_array->attributes[attr] = {
//     type = GL_FLOAT,
//     size = 4,
//     data = opengl->current_array_buffer
// }
glVertexAttribPointer(attr, 4, GL_FLOAT, GL_FALSE, 0, 0);
// Enable the vertex attribute
glEnableVertexAttribArray(attr);

OpenGL 2.0 (la vieja manera)

En OpenGL 2.x, no había vértice matrices y los datos eran globales. Todavía tenías que llamar glVertexAttribPointer() y glEnableVertexAttribArray(), pero tenías que llamarlos cada vez que usabas un buffer. En OpenGL 3.x, sólo tienes que configurar la matriz una vez.

Volviendo a OpenGL 1.5, en realidad podría usar buffers, pero usó una función separada para enlazar cada tipo de datos. Por ejemplo, glVertexPointer() era para datos de vértices, y glNormalPointer() era para datos normales. Antes de OpenGL 1.5, no había búferes, pero podía usar punteros en su aplicación memoria.

OpenGL 4.3 / ARB_vertex_attrib_binding

En 4.3, o si tiene la extensión ARB_vertex_attrib_binding, puede especificar el formato del atributo y los datos del atributo por separado. Esto es bueno porque le permite cambiar fácilmente una matriz de vértices entre diferentes búferes.

GLuint array;
// Generate a name for a new array array.
glGenVertexArrays(1, &array);
// Make the new array active, creating it if necessary.
glBindVertexArray(array);

// Enable my attributes
glEnableVertexAttribArray(loc_attrib);
glEnableVertexAttribArray(normal_attrib);
glEnableVertexAttribArray(texcoord_attrib);
// Set up the formats for my attributes
glVertexAttribFormat(loc_attrib,      3, GL_FLOAT, GL_FALSE, 0);
glVertexAttribFormat(normal_attrib,   3, GL_FLOAT, GL_FALSE, 12);
glVertexAttribFormat(texcoord_attrib, 2, GL_FLOAT, GL_FALSE, 24);
// Make my attributes all use binding 0
glVertexAttribBinding(loc_attrib,      0);
glVertexAttribBinding(normal_attrib,   0);
glVertexAttribBinding(texcoord_attrib, 0);

// Quickly bind all attributes to use "buffer"
// This replaces several calls to glVertexAttribPointer()
// Note: you don't need to bind the buffer first!  Nice!
glBindVertexBuffer(0, buffer, 0, 32);

// Quickly bind all attributes to use "buffer2"
glBindVertexBuffer(0, buffer2, 0, 32);

OpenGL 4.5 / ARB_direct_state_access

En OpenGL 4.5, o si tiene la extensión ARB_direct_state_access, ya no necesita llamar a glBindBuffer() o glBindVertexArray() solo para establecer las cosas... usted especifica los arrays y buffers directamente. Solo necesita enlazar la matriz al final para dibujarla.

GLuint array;
// Generate a name for the array and create it.
// Note that glGenVertexArrays() won't work here.
glCreateVertexArrays(1, &array);
// Instead of binding it, we pass it to the functions below.

// Enable my attributes
glEnableVertexArrayAttrib(array, loc_attrib);
glEnableVertexArrayAttrib(array, normal_attrib);
glEnableVertexArrayAttrib(array, texcoord_attrib);
// Set up the formats for my attributes
glVertexArrayAttribFormat(array, loc_attrib,      3, GL_FLOAT, GL_FALSE, 0);
glVertexArrayAttribFormat(array, normal_attrib,   3, GL_FLOAT, GL_FALSE, 12);
glVertexArrayAttribFormat(array, texcoord_attrib, 2, GL_FLOAT, GL_FALSE, 24);
// Make my attributes all use binding 0
glVertexArrayAttribBinding(array, loc_attrib,      0);
glVertexArrayAttribBinding(array, normal_attrib,   0);
glVertexArrayAttribBinding(array, texcoord_attrib, 0);

// Quickly bind all attributes to use "buffer"
glVertexArrayVertexBuffer(array, 0, buffer, 0, 32);

// Quickly bind all attributes to use "buffer2"
glVertexArrayVertexBuffer(array, 0, buffer2, 0, 32);

// You still have to bind the array to draw.
glBindVertexArray(array);
glDrawArrays(...);

ARB_direct_state_access es bueno por muchas razones. Puede olvidarse de vincular matrices y búferes (excepto cuando dibuja) para no tener que pensar en variables globales ocultas que OpenGL está rastreando por usted. Puede olvidarse de la diferencia entre "generar un nombre para un objeto" y "crear un objeto" porque glCreateBuffer() y glCreateArray() hacen ambas cosas en el a la misma hora.

Vulkan

Vulkan va aún más lejos y te hace escribir código como el pseudocódigo que escribí arriba. Así que verás algo como:

// This defines part of a "vertex array", sort of
VkVertexInputAttributeDescription attrib[3];
attrib[0].location = 0; // Feed data into shader input #0
attrib[0].binding = 0;  // Get data from buffer bound to slot #0
attrib[0].format = VK_FORMAT_R32G32B32_SFLOAT;
attrib[0].offset = 0;
// repeat for attrib[1], attrib[2]