What's the best way to keep adding new points to glBufferData? - c++

Question

I am making an experiment with OpenGL to find what's the best/most efficient way to very frequently add new data to glBufferData.
To do this, I wrote a small 2D paint program and simply keep adding points when I move the mouse.
The whole function looks like this:
void addPoint(double x, double y)
{
glBindBuffer(GL_ARRAY_BUFFER, pointVertBuffObj);
if (arrayOfPointCapacity < numOfPoints + 1) {
U32 size = (arrayOfPointCapacity + 8) * sizeof(Point2);
Point2 *tmp = (Point2*)realloc(arrayOfPoints, size);
arrayOfPoints = tmp;
arrayOfPointCapacity += 8;
}
arrayOfPoints[numOfPoints].x = x,
arrayOfPoints[numOfPoints].y = y;
U32 offset = numOfPoints * sizeof(Point2);
glBufferData(GL_ARRAY_BUFFER, numOfPoints * sizeof(Point2), arrayOfPoints, GL_DYNAMIC_DRAW);
numOfPoints++;
}
Having to reset glBufferData with new data each time I add a point seems absolutely crazy. I thought about using glBufferData to allocate a large array of points and setting these points up with glBufferSubData. When the size of the buffer becomes too small, then I call glBufferData again increasing the size of the buffer, and copying back existing points to it.
Ideally, I would prefer to avoid storing the point data in the computer memory and keep everything in the GPU memory. But when I would resize the buffer, I would have to copy the data back from the buffer to the CPU, then resize the buffer, and finally copy the data back to the buffer from the CPU. All this, also seems inefficient.
Any idea? What's best practice?

Answer 1

When the size of the buffer becomes too small, then I call glBufferData again increasing the size of the buffer, and copying back existing points to it.
Not a bad idea. In fact that's the recommended way of doing these things. But don't make the chunks too small.
Ideally, I would prefer to avoid storing the point data in the computer memory and keep everything in the GPU memory.
That's not how OpenGL works. The contents of a buffer objects can be freely swapped between CPU and GPU memory as needed.
But when I would resize the buffer, I would have to copy the data back from the buffer to the CPU, then resize the buffer, and finally copy the data back to the buffer from the CPU. All this, also seems inefficient.
Correct. You want to avoid copies between OpenGL and the host program. That's why there is in OpenGL-3.1 and later the function glCopyBufferSubData to copy data between buffers. When you need to resize a buffer you can as well create a new buffer object and copy from the old to the new one^1.
[1]: maybe you can also do resizing copys within the same buffer object name, by exploiting name orphaning; but I'd first have to read the specs if this is actually defined, and then cross fingers that all implementations get this right.

Answer 2

I made a program for scientific graphing before, that could add new data points in real-time. What I did was create a fairly large fixed size buffer with flag GL_DYNAMIC_DRAW, and added individual points to it with glBufferSubData. Once it filled, I created a new buffer with flag GL_STATIC_DRAW and moved all the data there, then started filling the GL_DYNAMIC_DRAW buffer again from the beginning. So I ended up with a small number of static buffers, one dynamic buffer, and since they were all equal size (with monotonically increasing x coordinates) calculating which buffers to use to draw any given segment of the data was easy. And I never had to resize any of them, just keep track of how much of the dynamic buffer was used and only draw that many vertices from it.
I don't think I used glCopyBufferSubData as datenwolf suggests, I kept a copy in CPU memory of the data in the dynamic buffer, until I could flush it to a new static buffer. But GPU->GPU copy would be better. I still would allocate more chunk-sized buffers and avoid resizing.