Is it legal to update buffer bound via glBindBufferRange from CPU? - opengl

Question

I'm testing the following code in OpenGL.
glGenBuffers(1, &UBO);
glBindBuffer(GL_UNIFORM_BUFFER, UBO);
glBufferData(GL_UNIFORM_BUFFER, 4 * sizeof(float), nullptr, GL_STREAM_DRAW);
glBindBufferRange(GL_UNIFORM_BUFFER, 1, UBO, 0, 4 * sizeof(float));
while (1) {
glBindBuffer(GL_UNIFORM_BUFFER, UBO);
GLbitfield access = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
auto* ptr = glMapBufferRange(GL_UNIFORM_BUFFER, 0, 4 * sizeof(float), access);
float color[4] = {
static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
1.0
};
memcpy(ptr, &color[0], 4 * sizeof(float));
glUnmapBuffer(GL_UNIFORM_BUFFER);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
// <bind VAO>
// <bind shader>
// <submit draw>
}
//clean up stuff
On on NVidia & Windows and it's blazing fast (faster than per-shader uniform updates with glUniform4f(0, color[0], color[1], color[2], color[3]) or persistent UBO mapping)
However I'm concerned that I'm updating the buffer content on CPU for the buffer bound at the very beginning of my program with glBindBufferRange() to the GPU. Perhaps my code should look like this instead:
glGenBuffers(1, &UBO);
glBindBuffer(GL_UNIFORM_BUFFER, UBO);
glBufferData(GL_UNIFORM_BUFFER, 4 * sizeof(float), nullptr, GL_STREAM_DRAW);
//glBindBufferRange(GL_UNIFORM_BUFFER, 1, UBO, 0, 4 * sizeof(float)); //no more 1 time bindings, perhaps it's not legal???
while (1) {
glBindBufferRange(GL_UNIFORM_BUFFER, 1, 0, 0, 4 * sizeof(float)); //clean up binding
glBindBuffer(GL_UNIFORM_BUFFER, UBO);
GLbitfield access = GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT;
auto* ptr = glMapBufferRange(GL_UNIFORM_BUFFER, 0, 4 * sizeof(float), access);
float color[4] = {
static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
1.0
};
memcpy(ptr, &color[0], 4 * sizeof(float));
glUnmapBuffer(GL_UNIFORM_BUFFER);
glBindBuffer(GL_UNIFORM_BUFFER, 0);
glBindBufferRange(GL_UNIFORM_BUFFER, 1, UBO, 0, 4 * sizeof(float)); //reestablish binding again
// <bind VAO>
// <bind shader>
// <submit draw>
}
//clean up stuff
I know NVidia OpenGL drivers are very lenient to programmer mistakes and tend to forgive a lot of stuff, so I wonder if it's legal to update buffer contents (on CPU, like in my example) for the UBO buffer bound to certain index with glBindBufferRange() per OpenGL spec.

Answer 1

Broadly speaking, OpenGL does not allow one function to undo state set by another function unless manipulating that particular piece of state is the goal of that function. The contents of GPU-accessible memory and the binding of that memory for a purpose are different state. If you have bound a buffer range to a location in the context for a purpose, the only thing that can affect that binding is attempting to bind to that same location in the context for that purpose (or deleting the buffer).
Now the buffer itself may become temporarily unusable, such as the period when the bound buffer is (non-persistently) mapped. But that doesn't cause the buffer to become unbound from the context; you simply cannot do anything to use it during that period.
So there would be no point in re-binding the same range of the same buffer, simply because you modified its contents. Even the fact that you're invaliding the buffer in its entirety is something an implementation must deal with.