How do I update the contents of a VertexArrayBuffer - opengl

Question

I have created a VAO with 2 vertex array buffers. The 1st buffer contains the coordinates of the verticies while the 2nd one contains 4 data values (type GLbyte) for each vertex.
/*
** Create a VAO and bind it
*/
glCreateVertexArrays(1, &vertex_array_object);
glBindVertexArray(vertex_array_object);
/*
** Create a buffer and initilise it
*/
glCreateBuffers(1, &vertex_buffer);
glNamedBufferStorage(vertex_buffer, sizeof(verticies), verticies, 0);
/*
** Bind the buffer to the VAO
*/
glVertexArrayVertexBuffer(vertex_array_object, 0, vertex_buffer, 0, sizeof(float)*3);
/*
** Specify the data format,
*/
glVertexArrayAttribFormat(vertex_array_object,0, 3, GL_FLOAT, GL_FALSE, 0);
/*
** Specify the vertex buffer binding for this attribute
*/
glVertexArrayAttribBinding(vertex_array_object,0,0);
/*
** Enable the attribute
*/
glEnableVertexArrayAttrib(vertex_array_object,0);
/*
** Now repeat for another buffer to hold per vertex data
**
** Create and initilise it
*/
glCreateBuffers(1, &nvd_buffer);
glNamedBufferStorage(nvd_buffer, sizeof(vectors), vectors, 0);
/*
** Bind the buffer to the VAO
*/
glVertexArrayVertexBuffer(vertex_array_object, 1, nvd_buffer, 0, sizeof(GLbyte)*4);
/*
** Specify the data format,
*/
glVertexArrayAttribFormat(vertex_array_object, 1, 4, GL_BYTE, GL_FALSE, 0);
/*
** Specify the vertex buffer binding for this attribute
*/
glVertexArrayAttribBinding(vertex_array_object,1,1);
/*
** Enable the attribute
*/
glEnableVertexArrayAttrib(vertex_array_object,1);
This all works and my Vertex Shader can access the data in the 2nd buffer and pass it to the Geometry Shader where it's used to create additional points.
Later on I want to update the data in the 2nd buffer and I can't see how I can do that. I think I should be using
glNamedBufferSubData(....)
but I can't work out how to get the buffer that I need to feed into this function from the VAO. I know I could store the original value assigned to "nvd_buffer" but is there a way to get this information directly from the VAO as I know the binding index I use to bind the buffer to the VAO
glVertexArrayVertexBuffer(vertex_array_object, 1, nvd_buffer, 0, sizeof(GLbyte)*4);

Answer 1

You should not want to ask a VAO which buffer objects are stored within it. There are a number of reasons for this.
When specifying the DSA functions for VAO queries, there was a... hiccup. The enumerators weren't actually specified to work for the DSA query functions correctly. That issue has since been resolved in the specification, but that doesn't mean any such fixes filtered out to implementations that implemented the broken spec language. So, there is some question as to whether any such queries will succeed.
You told OpenGL which buffer to use. Therefore, you already know the answer. There's no reason to ask a question to which you already know the answer. If you have chosen to forget the answer, you can just as easily choose not to forget it. So this is a problem you already have the tools to solve, and you shouldn't make OpenGL solve it for you.
You should not treat buffer objects as though they are owned by a VAO that uses them. They are their own resource and should be managed distinctly from any VAO(s) that use them. Indeed, most VAO usage (particularly with separate attribute formats) will attach different buffers to the VAO throughout the render loop. So in those cases, the linkage between a buffer and a VAO that uses it is entirely ephemeral.
Lifetime issues. If you delete the buffer object name when the VAO is not bound to the context, the buffer object will continue to exist until it is no longer attached to any VAOs. If you query the buffer object from the VAO, then you will effectively bring the name back to "life", but still in a way that will disappear when it is no longer used by such buffers. That can cause errors that are very hard to detect. So if you don't query names from OpenGL, this kind of error will be impossible.
All that having been said, the function you're looking for is glGetVertexArrayIndexediv. Since the documentation has not, as of this writing, been updated in accord with the bug fix I mentioned in item 1, it won't tell you the right enumerator to use. So the query looks like this:
GLuint buffer;
glGetVertexArrayIndexediv(vao, binding_index, GL_VERTEX_BINDING_BUFFER, reinterpret_cast<GLint*>(&buffer));
Where binding_index is the index you passed to glVertexArrayVertexBuffer.
However, that won't actually make your uploading code work. Oh yes, it will give you a valid buffer object name, but you can't upload to it. Why?
Because you told OpenGL that you would not. Right here:
glNamedBufferStorage(vertex_buffer, sizeof(verticies), verticies, 0);
The 0 there is the usage flag you gave to the immutable storage buffer you just created. With mutable buffers, the usage hint is only a hint; it doesn't constrain your ability to use it.
That is not the case with immutable storage buffers. If you do not specify that you will manipulate the data storage from the CPU in a certain way, then you cannot manipulate it in that way. So if you want to use glNamedBufferSubData on an immutable storage buffer, you must tell OpenGL you intend to do that by providing the appropriate flag. Specifically, GL_DYNAMIC_STORAGE_BIT.