Reassign shader buffer value - opengl

Question

In this question about growing buffers, someone answers with the following code.
// Bind the old buffer to `GL_COPY_READ_BUFFER`
glBindBuffer (GL_COPY_READ_BUFFER, old_buffer);
// Allocate data for a new buffer
glGenBuffers (1, &new_buffer);
glBindBuffer (GL_COPY_WRITE_BUFFER, new_buffer);
glBufferData (GL_COPY_WRITE_BUFFER, ...);
// Copy `old_buffer_size`-bytes of data from `GL_COPY_READ_BUFFER`
// to `GL_COPY_WRITE_BUFFER` beginning at 0.
glCopyBufferSubData (GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, old_buffer_size);
This is my understanding of the above, in order to copy A to B:
Bind A
Generate B
Bind B
Write null contents to B at larger size
Copy A to B
My problem is that A is the original vertex buffer for the shader, but so is B, (since changing the size is the goal). In my code (C# opentk) the shader tells me the ID of the buffer that coincides with a named shader variable using GL.GetActiveAttrib, I can't find how to make it use a different buffer than the one it gives.
So I either have to reassign the shader to use B afterwards, or do a double copy:
Bind A
Generate B
Bind B
Write null contents to B at larger size
Copy A to B
Reassign shader to use B
Write null contents to A at larger size (size of B)
Copy B to A
Is it possible make it use a specific buffer or to avoid double copying?

Answer 1

Once you have set the size of the buffer with glBufferData this size becomes inmutable. That's why a copy to another bigger buffer B is needed.
The good news is that you can re-bind the buffer with a different target. This is what you can do in your buffer-manager (it seems you wrongly call it "shader". A shader is a program in the GPU). No need a second copy.
GL_COPY_READ_BUFFER and GL_COPY_WRITE_BUFFER targets are useful if you want to keep previous bindings. This is not your case, so the copy is simpler:
//The buffer must be bound before copying it
glBindBuffer(GL_ARRAY_BUFFER, oldBuf); //or GL_ELEMENT_ARRAY_BUFFER or whatever it was
//New buffer
glGenBuffers (1, &newBuf);
//GL_COPY_WRITE_BUFFER is needed because GL_ARRAY_BUFFER is in use by oldBuf
glBindBuffer (GL_COPY_WRITE_BUFFER, newBuf);
glBufferData (GL_COPY_WRITE_BUFFER, newSize, ...);
glCopyBufferSubData (GL_ARRAY_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, old_buffer_size);
Now the copy is done, buffer oldBuf can be safetely deleted.
Two things left to do:
a) Tell the buffer-manager to use 'newBuf' insted of 'oldBuf'
b) Before using this new buffer, re-bind it to the target you need
glBindBuffer(GL_ARRAY_BUFFER, newBuf);
Well, there's one more thing to do. When the VAO was bound and the association "attribute - buffer to read from" was established by glVertexAttribPointer it used the oldBuf buffer. But now you want another buffer. So you must bind that VAO again, bind the new buffer and use glVertexAttribPointer.
A better solution may be to have a big buffer, and use only part of it. Let's say you have a VBO for one million vertices. 1M x 3 floats x 4 bytes = 12M bytes. That isn't a size any not-too-old GPU can't handle.
If your data changes in size, but not beyond that 1M vertices, then the easiest way is to use glBufferSubData and upload new data, even it is just added data. No new buffer, no copy, no VAO state change.